From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mark yao Subject: Re: [v6 PATCH 6/6] drm/rockchip: cdn-dp: add cdn DP support for rk3399 Date: Fri, 22 Jul 2016 08:41:19 +0800 Message-ID: <57916BAF.10109@rock-chips.com> References: <1469106808-28297-1-git-send-email-zyw@rock-chips.com> <1469106808-28297-7-git-send-email-zyw@rock-chips.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1469106808-28297-7-git-send-email-zyw@rock-chips.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Chris Zhong , dianders@chromium.org, tfiga@chromium.org, heiko@sntech.de, yzq@rock-chips.com, groeck@chromium.org, myungjoo.ham@samsung.com, cw00.choi@samsung.com, wulf@rock-chips.com, marcheu@chromium.org Cc: linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-arm-kernel@lists.infradead.org List-Id: linux-rockchip.vger.kernel.org T24gMjAxNuW5tDA35pyIMjHml6UgMjE6MTMsIENocmlzIFpob25nIHdyb3RlOgo+IEFkZCBzdXBw b3J0IGZvciBjZG4gRFAgY29udHJvbGxlciB3aGljaCBpcyBlbWJlZGRlZCBpbiB0aGUgcmszMzk5 Cj4gU29Dcy4gVGhlIERQIGlzIGNvbXBsaWFudCB3aXRoIERpc3BsYXlQb3J0IFNwZWNpZmljYXRp b24sCj4gVmVyc2lvbiAxLjMsIFRoaXMgSVAgaXMgY29tcGF0aWJsZSB3aXRoIHRoZSByb2NrY2hp cCB0eXBlLWMgUEhZIElQLgo+IFRoZXJlIGlzIGEgdUNQVSBpbiBEUCBjb250cm9sbGVyLCBpdCBu ZWVkIGEgZmlybXdhcmUgdG8gd29yaywKPiBwbGVhc2UgcHV0IHRoZSBmaXJtd2FyZSBmaWxlIHRv IC9saWIvZmlybXdhcmUvY2RuL2RwdHguYmluLiBUaGUKPiB1Q1BVIGluIGNoYXJnZSBvZiBhdXgg Y29tbXVuaWNhdGlvbiBhbmQgbGluayB0cmFpbmluZywgdGhlIGhvc3QgdXNlCj4gbWFpbGJveCB0 byBjb21tdW5pY2F0ZSB3aXRoIHRoZSB1Y3B1Lgo+IFRoZSBkY2xrIHBpbl9wb2wgb2Ygdm9wIG11 c3Qgbm90IGJlIGludmVydCBmb3IgRFAuCj4KPiBTaWduZWQtb2ZmLWJ5OiBDaHJpcyBaaG9uZyA8 enl3QHJvY2stY2hpcHMuY29tPgo+IFJldmlld2VkLWJ5OiBTZWFuIFBhdWwgPHNlYW5wYXVsQGNo cm9taXVtLm9yZz4KClNlYW4gUGF1bCBhbHJlYWR5IGRvIGEgZ29vZCByZXZpZXcsIEkgdGhpbmsg aXQncyByZWFkeSB0byBiZSBtZXJnZWQsIHNvCgpBY2tlZC1ieTogTWFyayBZYW8gPG1hcmsueWFv QHJvY2stY2hpcHMuY29tPgoKCj4gLS0tCj4KPiBDaGFuZ2VzIGluIHY2Ogo+IC0gYWRkIGEgcG9y dCBzdHJ1Y3QKPiAtIHNlbGVjdCBTTkRfU09DX0hETUlfQ09ERUMKPiAtIGZvcmNlIHJlc2V0IHRo ZSBwaHkgd2hlbiBocGQgZGV0ZWN0ZWQKPgo+IENoYW5nZXMgaW4gdjU6Cj4gLSBhbHBoYWJldGlj YWwgb3JkZXIKPiAtIGRvIG5vdCB1c2UgbG9uZywgdXNlIHUzMiBvciB1NjQKPiAtIHJldHVybiBN T0RFX0NMT0NLX0hJR0ggd2hlbiByZXF1ZXN0ZWQgPiBhY3R1YWwKPiAtIE9wdGltaXplZCBDb2Rp bmcgU3R5bGUKPiAtIGFkZCBhIGZvcm11bGEgdG8gZ2V0IGJldHRlciB0dSBzaXplIGFuZCBzeW1i b2wgdmFsdWUuCj4gLSBtb2RpZnkgYWNjb3JkaW5nIHRvIFNlYW4gUGF1bCdzIGNvbW1lbnRzCj4g LSBmaXhlZCB0aGUgZndfd2FpdCBhbHdheXMgMAo+Cj4gQ2hhbmdlcyBpbiB2NDoKPiAtIHVzZSBw aHkgZnJhbWV3b3JrIHRvIGNvbnRyb2wgRFAgcGh5Cj4gLSBzdXBwb3J0IDIgcGh5cwo+Cj4gQ2hh bmdlcyBpbiB2MzoKPiAtIHVzZSBFWFRDT05fRElTUF9EUCBhbmQgRVhUQ09OX0RJU1BfRFBfQUxU IGNhYmxlIHRvIGdldCBkcCBwb3J0IHN0YXRlLgo+IC0gcmVzZXQgc3BkaWYgYmVmb3JlIGNvbmZp ZyBpdAo+IC0gbW9kaWZ5IHRoZSBmaXJtd2FyZSBjbGsgdG8gMTAwTWh6Cj4gLSByZXRyeSBsb2Fk IGZpcm13YXJlIGlmIGZ3IGZpbGUgaXMgcmVxdWVzdGVkIHRvbyBlYXJseQo+Cj4gQ2hhbmdlcyBp biB2MjoKPiAtIEFscGhhYmV0aWMgb3JkZXIKPiAtIHJlbW92ZSBleGNlc3MgZXJyb3IgbWVzc2Fn ZQo+IC0gdXNlIGRlZmluZSBjbGtfcmF0ZQo+IC0gY2hlY2sgYWxsIHJldHVybiB2YWx1ZQo+IC0g cmVtb3ZlIGRldl9zZXRfbmFtZShkcC0+ZGV2LCAiY2RuLWRwIik7Cj4gLSB1c2Ugc2NoZWR1bGVf ZGVsYXllZF93b3JrCj4gLSByZW1vdmUgbmV2ZXItY2FsbGVkIGZ1bmN0aW9ucwo+IC0gcmVtb3Zl IHNvbWUgdW5uZWNlc3NhcnkgKCkKPgo+IENoYW5nZXMgaW4gdjE6Cj4gLSB1c2UgZXh0Y29uIEFQ SQo+IC0gdXNlIGhkbWktY29kZWMgZm9yIHRoZSBEUCBBc29jCj4gLSBkbyBub3QgaW5pdGlhbGl6 ZSB0aGUgInJldCIKPiAtIHByaW50ayBhIGVyciBsb2cgd2hlbiBkcm1fb2ZfZW5jb2Rlcl9hY3Rp dmVfZW5kcG9pbnRfaWQKPiAtIG1vZGlmeSB0aGUgZGNsayBwaW5fcG9sIHRvIGEgc2luZ2xlIGxp bmUKPgo+ICAgZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL0tjb25maWcgICAgICAgICAgICB8ICAx MCArCj4gICBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvTWFrZWZpbGUgICAgICAgICAgIHwgICAx ICsKPiAgIGRyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9jZG4tZHAtY29yZS5jICAgICAgfCA4Njgg KysrKysrKysrKysrKysrKysrKysrKysrKysKPiAgIGRyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9j ZG4tZHAtY29yZS5oICAgICAgfCAxMDIgKysrKwo+ICAgZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlw L2Nkbi1kcC1yZWcuYyAgICAgICB8IDkwNCArKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4g ICBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvY2RuLWRwLXJlZy5oICAgICAgIHwgNDc5ICsrKysr KysrKysrKysrKwo+ICAgZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV92b3Au YyB8ICAxMyArLQo+ICAgZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV92b3Au aCB8ICAgOSArCj4gICBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfdm9wX3JlZy5j IHwgICAyICsKPiAgIDkgZmlsZXMgY2hhbmdlZCwgMjM4NSBpbnNlcnRpb25zKCspLCAzIGRlbGV0 aW9ucygtKQo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9j ZG4tZHAtY29yZS5jCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3JvY2tj aGlwL2Nkbi1kcC1jb3JlLmgKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0v cm9ja2NoaXAvY2RuLWRwLXJlZy5jCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUv ZHJtL3JvY2tjaGlwL2Nkbi1kcC1yZWcuaAo+Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9yb2NrY2hpcC9LY29uZmlnIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL0tjb25maWcKPiBp bmRleCBkMzBiZGMzLi4yMGFhYWZlIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yb2Nr Y2hpcC9LY29uZmlnCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL0tjb25maWcKPiBA QCAtMjUsNiArMjUsMTYgQEAgY29uZmlnIFJPQ0tDSElQX0FOQUxPR0lYX0RQCj4gICAJICBmb3Ig dGhlIEFuYWxvZ2l4IENvcmUgRFAgZHJpdmVyLiBJZiB5b3Ugd2FudCB0byBlbmFibGUgRFAKPiAg IAkgIG9uIFJLMzI4OCBiYXNlZCBTb0MsIHlvdSBzaG91bGQgc2VsZXQgdGhpcyBvcHRpb24uCj4g ICAKPiArY29uZmlnIFJPQ0tDSElQX0NETl9EUAo+ICsgICAgICAgIHRyaXN0YXRlICJSb2NrY2hp cCBjZG4gRFAiCj4gKyAgICAgICAgZGVwZW5kcyBvbiBEUk1fUk9DS0NISVAKPiArCXNlbGVjdCBT TkRfU09DX0hETUlfQ09ERUMgaWYgU05EX1NPQwo+ICsgICAgICAgIGhlbHAKPiArCSAgVGhpcyBz ZWxlY3RzIHN1cHBvcnQgZm9yIFJvY2tjaGlwIFNvQyBzcGVjaWZpYyBleHRlbnNpb25zCj4gKwkg IGZvciB0aGUgY2RuIERQIGRyaXZlci4gSWYgeW91IHdhbnQgdG8gZW5hYmxlIERwIG9uCj4gKwkg IFJLMzM5OSBiYXNlZCBTb0MsIHlvdSBzaG91bGQgc2VsZWN0IHRoaXMKPiArCSAgb3B0aW9uLgo+ ICsKPiAgIGNvbmZpZyBST0NLQ0hJUF9EV19IRE1JCj4gICAgICAgICAgIHRyaXN0YXRlICJSb2Nr Y2hpcCBzcGVjaWZpYyBleHRlbnNpb25zIGZvciBTeW5vcHN5cyBEVyBIRE1JIgo+ICAgICAgICAg ICBkZXBlbmRzIG9uIERSTV9ST0NLQ0hJUAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v cm9ja2NoaXAvTWFrZWZpbGUgYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvTWFrZWZpbGUKPiBp bmRleCAwNWQwNzEzLi5hYmRlY2Q1IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yb2Nr Y2hpcC9NYWtlZmlsZQo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9NYWtlZmlsZQo+ IEBAIC03LDYgKzcsNyBAQCByb2NrY2hpcGRybS15IDo9IHJvY2tjaGlwX2RybV9kcnYubyByb2Nr Y2hpcF9kcm1fZmIubyBcCj4gICByb2NrY2hpcGRybS0kKENPTkZJR19EUk1fRkJERVZfRU1VTEFU SU9OKSArPSByb2NrY2hpcF9kcm1fZmJkZXYubwo+ICAgCj4gICBvYmotJChDT05GSUdfUk9DS0NI SVBfQU5BTE9HSVhfRFApICs9IGFuYWxvZ2l4X2RwLXJvY2tjaGlwLm8KPiArb2JqLSQoQ09ORklH X1JPQ0tDSElQX0NETl9EUCkgKz0gY2RuLWRwLWNvcmUubyBjZG4tZHAtcmVnLm8KPiAgIG9iai0k KENPTkZJR19ST0NLQ0hJUF9EV19IRE1JKSArPSBkd19oZG1pLXJvY2tjaGlwLm8KPiAgIG9iai0k KENPTkZJR19ST0NLQ0hJUF9EV19NSVBJX0RTSSkgKz0gZHctbWlwaS1kc2kubwo+ICAgb2JqLSQo Q09ORklHX1JPQ0tDSElQX0lOTk9fSERNSSkgKz0gaW5ub19oZG1pLm8KPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL2Nkbi1kcC1jb3JlLmMgYi9kcml2ZXJzL2dwdS9kcm0v cm9ja2NoaXAvY2RuLWRwLWNvcmUuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAw MDAwMC4uMjA5YTdlZgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcm9j a2NoaXAvY2RuLWRwLWNvcmUuYwo+IEBAIC0wLDAgKzEsODY4IEBACj4gKy8qCj4gKyAqIENvcHly aWdodCAoQykgRnV6aG91IFJvY2tjaGlwIEVsZWN0cm9uaWNzIENvLkx0ZAo+ICsgKiBBdXRob3I6 IENocmlzIFpob25nIDx6eXdAcm9jay1jaGlwcy5jb20+Cj4gKyAqCj4gKyAqIFRoaXMgc29mdHdh cmUgaXMgbGljZW5zZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMK PiArICogTGljZW5zZSB2ZXJzaW9uIDIsIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uLCBhbmQKPiArICogbWF5IGJlIGNvcGllZCwgZGlzdHJpYnV0ZWQsIGFuZCBt b2RpZmllZCB1bmRlciB0aG9zZSB0ZXJtcy4KPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4gKyAqIGJ1dCBX SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m Cj4gKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9T RS4gIFNlZSB0aGUKPiArICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0 YWlscy4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8ZHJtL2RybVAuaD4KPiArI2luY2x1ZGUgPGRy bS9kcm1fYXRvbWljX2hlbHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5o Pgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9kcF9oZWxwZXIuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1f ZWRpZC5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9vZi5oPgo+ICsKPiArI2luY2x1ZGUgPGxpbnV4 L2Nsay5oPgo+ICsjaW5jbHVkZSA8bGludXgvY29tcG9uZW50Lmg+Cj4gKyNpbmNsdWRlIDxsaW51 eC9leHRjb24uaD4KPiArI2luY2x1ZGUgPGxpbnV4L2Zpcm13YXJlLmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9yZWdtYXAuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3Jlc2V0Lmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9tZmQvc3lzY29uLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9waHkvcGh5Lmg+Cj4gKwo+ICsj aW5jbHVkZSA8c291bmQvaGRtaS1jb2RlYy5oPgo+ICsKPiArI2luY2x1ZGUgImNkbi1kcC1jb3Jl LmgiCj4gKyNpbmNsdWRlICJjZG4tZHAtcmVnLmgiCj4gKyNpbmNsdWRlICJyb2NrY2hpcF9kcm1f dm9wLmgiCj4gKwo+ICsjZGVmaW5lIGNvbm5lY3Rvcl90b19kcChjKSBcCj4gKwkJY29udGFpbmVy X29mKGMsIHN0cnVjdCBjZG5fZHBfZGV2aWNlLCBjb25uZWN0b3IpCj4gKwo+ICsjZGVmaW5lIGVu Y29kZXJfdG9fZHAoYykgXAo+ICsJCWNvbnRhaW5lcl9vZihjLCBzdHJ1Y3QgY2RuX2RwX2Rldmlj ZSwgZW5jb2RlcikKPiArCj4gKy8qIGRwIGdyZiByZWdpc3RlciBvZmZzZXQgKi8KPiArI2RlZmlu ZSBEUF9WT1BfU0VMCQkweDYyMjQKPiArI2RlZmluZSBEUF9TRUxfVk9QX0xJVAkJQklUKDEyKQo+ ICsjZGVmaW5lIE1BWF9GV19XQUlUX1NFQ1MJNjQKPiArI2RlZmluZSBDRE5fRFBfRklSTVdBUkUJ CSJyb2NrY2hpcC9kcHR4LmJpbiIKPiArCj4gK3N0cnVjdCBjZG5fZHBfZGF0YSB7Cj4gKwl1OCBt YXhfcGh5Owo+ICt9Owo+ICsKPiArc3RydWN0IGNkbl9kcF9kYXRhIHJrMzM5OV9jZG5fZHAgPSB7 Cj4gKwkubWF4X3BoeSA9IDIsCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2Rl dmljZV9pZCBjZG5fZHBfZHRfaWRzW10gPSB7Cj4gKwl7IC5jb21wYXRpYmxlID0gInJvY2tjaGlw LHJrMzM5OS1jZG4tZHAiLAo+ICsJCS5kYXRhID0gKHZvaWQgKikmcmszMzk5X2Nkbl9kcCB9LAoK YWxpZ24gdGhlIC5kYXRhPwoKCj4gKwl7fQo+ICt9Owo+ICsKPiArTU9EVUxFX0RFVklDRV9UQUJM RShvZiwgY2RuX2RwX2R0X2lkcyk7Cj4gKwo+ICtzdGF0aWMgaW50IGNkbl9kcF9jbGtfZW5hYmxl KHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCkKPiArewo+ICsJaW50IHJldDsKPiArCXUzMiByYXRl Owo+ICsKPiArCXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShkcC0+cGNsayk7Cj4gKwlpZiAocmV0 IDwgMCkgewo+ICsJCWRldl9lcnIoZHAtPmRldiwgImNhbm5vdCBlbmFibGUgZHAgcGNsayAlZFxu IiwgcmV0KTsKPiArCQlnb3RvIGVycl9wY2xrOwo+ICsJfQo+ICsKPiArCXJldCA9IGNsa19wcmVw YXJlX2VuYWJsZShkcC0+Y29yZV9jbGspOwo+ICsJaWYgKHJldCA8IDApIHsKPiArCQlkZXZfZXJy KGRwLT5kZXYsICJjYW5ub3QgZW5hYmxlIGNvcmVfY2xrICVkXG4iLCByZXQpOwo+ICsJCWdvdG8g ZXJyX2NvcmVfY2xrOwo+ICsJfQo+ICsKPiArCXJhdGUgPSBjbGtfZ2V0X3JhdGUoZHAtPmNvcmVf Y2xrKTsKPiArCWlmIChyYXRlIDwgMCkgewo+ICsJCWRldl9lcnIoZHAtPmRldiwgImdldCBjbGsg cmF0ZSBmYWlsZWQ6ICVkXG4iLCByYXRlKTsKPiArCQlnb3RvIGVycl9zZXRfcmF0ZTsKPiArCX0K PiArCj4gKwljZG5fZHBfc2V0X2Z3X2NsayhkcCwgcmF0ZSk7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4g Kwo+ICtlcnJfc2V0X3JhdGU6Cj4gKwljbGtfZGlzYWJsZV91bnByZXBhcmUoZHAtPmNvcmVfY2xr KTsKPiArZXJyX2NvcmVfY2xrOgo+ICsJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGRwLT5wY2xrKTsK PiArZXJyX3BjbGs6Cj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgZW51bSBkcm1f Y29ubmVjdG9yX3N0YXR1cwo+ICtjZG5fZHBfY29ubmVjdG9yX2RldGVjdChzdHJ1Y3QgZHJtX2Nv bm5lY3RvciAqY29ubmVjdG9yLCBib29sIGZvcmNlKQo+ICt7Cj4gKwlzdHJ1Y3QgY2RuX2RwX2Rl dmljZSAqZHAgPSBjb25uZWN0b3JfdG9fZHAoY29ubmVjdG9yKTsKPiArCj4gKwlyZXR1cm4gZHAt PmhwZF9zdGF0dXM7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIGNkbl9kcF9jb25uZWN0b3JfZGVz dHJveShzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQo+ICt7Cj4gKwlkcm1fY29ubmVj dG9yX3VucmVnaXN0ZXIoY29ubmVjdG9yKTsKPiArCWRybV9jb25uZWN0b3JfY2xlYW51cChjb25u ZWN0b3IpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0IGRybV9jb25uZWN0b3JfZnVuY3MgY2Ru X2RwX2F0b21pY19jb25uZWN0b3JfZnVuY3MgPSB7Cj4gKwkuZHBtcyA9IGRybV9hdG9taWNfaGVs cGVyX2Nvbm5lY3Rvcl9kcG1zLAo+ICsJLmRldGVjdCA9IGNkbl9kcF9jb25uZWN0b3JfZGV0ZWN0 LAo+ICsJLmRlc3Ryb3kgPSBjZG5fZHBfY29ubmVjdG9yX2Rlc3Ryb3ksCj4gKwkuZmlsbF9tb2Rl cyA9IGRybV9oZWxwZXJfcHJvYmVfc2luZ2xlX2Nvbm5lY3Rvcl9tb2RlcywKPiArCS5yZXNldCA9 IGRybV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9yZXNldCwKPiArCS5hdG9taWNfZHVwbGljYXRl X3N0YXRlID0gZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX2R1cGxpY2F0ZV9zdGF0ZSwKPiAr CS5hdG9taWNfZGVzdHJveV9zdGF0ZSA9IGRybV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9kZXN0 cm95X3N0YXRlLAo+ICt9Owo+ICsKPiArc3RhdGljIGludCBjZG5fZHBfY29ubmVjdG9yX2dldF9t b2RlcyhzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQo+ICt7Cj4gKwlzdHJ1Y3QgY2Ru X2RwX2RldmljZSAqZHAgPSBjb25uZWN0b3JfdG9fZHAoY29ubmVjdG9yKTsKPiArCXN0cnVjdCBl ZGlkICplZGlkOwo+ICsJaW50IHJldCA9IDA7Cj4gKwo+ICsJZWRpZCA9IGRybV9kb19nZXRfZWRp ZChjb25uZWN0b3IsIGNkbl9kcF9nZXRfZWRpZF9ibG9jaywgZHApOwo+ICsJaWYgKGVkaWQpIHsK PiArCQlkZXZfZGJnKGRwLT5kZXYsICJnb3QgZWRpZDogd2lkdGhbJWRdIHggaGVpZ2h0WyVkXVxu IiwKPiArCQkJZWRpZC0+d2lkdGhfY20sIGVkaWQtPmhlaWdodF9jbSk7Cj4gKwo+ICsJCWRwLT5z aW5rX2hhc19hdWRpbyA9IGRybV9kZXRlY3RfbW9uaXRvcl9hdWRpbyhlZGlkKTsKPiArCQlyZXQg PSBkcm1fYWRkX2VkaWRfbW9kZXMoY29ubmVjdG9yLCBlZGlkKTsKPiArCQlpZiAocmV0KSB7Cj4g KwkJCWRybV9tb2RlX2Nvbm5lY3Rvcl91cGRhdGVfZWRpZF9wcm9wZXJ0eShjb25uZWN0b3IsCj4g KwkJCQkJCQkJZWRpZCk7Cj4gKwkJCWRybV9lZGlkX3RvX2VsZChjb25uZWN0b3IsIGVkaWQpOwo+ ICsJCX0KPiArCQlrZnJlZShlZGlkKTsKPiArCX0gZWxzZSB7Cj4gKwkJZGV2X3dhcm4oZHAtPmRl diwgImZhaWxlZCB0byBnZXQgZWRpZFxuIik7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiAr fQo+ICsKPiArc3RhdGljIHN0cnVjdCBkcm1fZW5jb2RlciAqCj4gKwljZG5fZHBfY29ubmVjdG9y X2Jlc3RfZW5jb2RlcihzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQo+ICt7Cj4gKwlz dHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAgPSBjb25uZWN0b3JfdG9fZHAoY29ubmVjdG9yKTsKPiAr Cj4gKwlyZXR1cm4gJmRwLT5lbmNvZGVyOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGNkbl9kcF9j b25uZWN0b3JfbW9kZV92YWxpZChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLAo+ICsJ CQkJICAgICAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlKQo+ICt7Cj4gKwlzdHJ1Y3Qg Y2RuX2RwX2RldmljZSAqZHAgPSBjb25uZWN0b3JfdG9fZHAoY29ubmVjdG9yKTsKPiArCXN0cnVj dCBkcm1fZGlzcGxheV9pbmZvICpkaXNwbGF5X2luZm8gPSAmZHAtPmNvbm5lY3Rvci5kaXNwbGF5 X2luZm87Cj4gKwl1MzIgcmVxdWVzdGVkID0gbW9kZS0+Y2xvY2sgKiBkaXNwbGF5X2luZm8tPmJw YyAqIDMgLyAxMDAwOwo+ICsJdTMyIHNpbmtfbWF4LCBzb3VyY2VfbWF4LCByYXRlOwo+ICsJdTgg bGFuZXMsIGk7Cj4gKwl1MzIgYWN0dWFsOwo+ICsKPiArCS8qIGZpbmQgdGhlIHJ1bm5pbmcgcG9y dCAqLwo+ICsJZm9yIChpID0gMDsgaSA8IGRwLT5wb3J0czsgaSsrKSB7Cj4gKwkJaWYgKGRwLT5w b3J0W2ldLT5waHlfc3RhdHVzID09IDEpIHsKPiArCQkJc291cmNlX21heCA9IGRwLT5wb3J0W2ld LT5jYXBfbGFuZXM7Cj4gKwkJCWJyZWFrOwo+ICsJCX0KPiArCX0KPiArCj4gKwlzaW5rX21heCA9 IGRybV9kcF9tYXhfbGFuZV9jb3VudChkcC0+ZHBjZCk7Cj4gKwlsYW5lcyA9IG1pbihzb3VyY2Vf bWF4LCBzaW5rX21heCk7Cj4gKwo+ICsJc291cmNlX21heCA9IGRybV9kcF9id19jb2RlX3RvX2xp bmtfcmF0ZShDRE5fRFBfTUFYX0xJTktfUkFURSk7Cj4gKwlzaW5rX21heCA9IGRybV9kcF9tYXhf bGlua19yYXRlKGRwLT5kcGNkKTsKPiArCXJhdGUgPSBtaW4oc291cmNlX21heCwgc2lua19tYXgp Owo+ICsKPiArCWFjdHVhbCA9IHJhdGUgKiBsYW5lcyAvIDEwMDsKPiArCj4gKwkvKiBlZmZpY2ll bmN5IGlzIGFib3V0IDAuOCAqLwo+ICsJYWN0dWFsID0gYWN0dWFsICogOCAvIDEwOwo+ICsKPiAr CWlmIChyZXF1ZXN0ZWQgPiBhY3R1YWwpIHsKPiArCQlkZXZfZGJnKGRwLT5kZXYsICJyZXF1ZXN0 ZWQ9JWQsIGFjdHVhbD0lZCwgY2xvY2s9JWRcbiIsCj4gKwkJCXJlcXVlc3RlZCwgYWN0dWFsLCBt b2RlLT5jbG9jayk7Cj4gKwkJcmV0dXJuIE1PREVfQ0xPQ0tfSElHSDsKPiArCX0KPiArCj4gKwly ZXR1cm4gTU9ERV9PSzsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCBkcm1fY29ubmVjdG9yX2hl bHBlcl9mdW5jcyBjZG5fZHBfY29ubmVjdG9yX2hlbHBlcl9mdW5jcyA9IHsKPiArCS5nZXRfbW9k ZXMgPSBjZG5fZHBfY29ubmVjdG9yX2dldF9tb2RlcywKPiArCS5iZXN0X2VuY29kZXIgPSBjZG5f ZHBfY29ubmVjdG9yX2Jlc3RfZW5jb2RlciwKPiArCS5tb2RlX3ZhbGlkID0gY2RuX2RwX2Nvbm5l Y3Rvcl9tb2RlX3ZhbGlkLAo+ICt9Owo+ICsKPiArc3RhdGljIHZvaWQgY2RuX2RwX2NvbW1pdChz dHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIpCj4gK3sKPiArCXN0cnVjdCBjZG5fZHBfZGV2aWNl ICpkcCA9IGVuY29kZXJfdG9fZHAoZW5jb2Rlcik7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9 IGNkbl9kcF90cmFpbmluZ19zdGFydChkcCk7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJZGV2X2Vycihk cC0+ZGV2LCAibGluayB0cmFpbmluZyBmYWlsZWQ6ICVkXG4iLCByZXQpOwo+ICsJCXJldHVybjsK PiArCX0KPiArCj4gKwlyZXQgPSBjZG5fZHBfZ2V0X3RyYWluaW5nX3N0YXR1cyhkcCk7Cj4gKwlp ZiAocmV0KSB7Cj4gKwkJZGV2X2VycihkcC0+ZGV2LCAiZ2V0IGxpbmsgdHJhaW5pbmcgc3RhdHVz IGZhaWxlZDogJWRcbiIsIHJldCk7Cj4gKwkJcmV0dXJuOwo+ICsJfQo+ICsKPiArCWRldl9pbmZv KGRwLT5kZXYsICJyYXRlOiVkLCBsYW5lczolZFxuIiwKPiArCQkgZHAtPmxpbmsucmF0ZSwgZHAt PmxpbmsubnVtX2xhbmVzKTsKPiArCj4gKwlpZiAoY2RuX2RwX3NldF92aWRlb19zdGF0dXMoZHAs IENPTlRST0xfVklERU9fSURMRSkpCj4gKwkJcmV0dXJuOwo+ICsKPiArCWlmIChjZG5fZHBfY29u ZmlnX3ZpZGVvKGRwKSkgewo+ICsJCWRldl9lcnIoZHAtPmRldiwgInVuYWJsZSB0byBjb25maWcg dmlkZW9cbiIpOwo+ICsJCXJldHVybjsKPiArCX0KPiArCj4gKwlpZiAoY2RuX2RwX3NldF92aWRl b19zdGF0dXMoZHAsIENPTlRST0xfVklERU9fVkFMSUQpKQo+ICsJCXJldHVybjsKPiArCj4gKwlk cC0+ZHBtc19tb2RlID0gRFJNX01PREVfRFBNU19PTjsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQg Y2RuX2RwX2VuY29kZXJfbW9kZV9zZXQoc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyLAo+ICsJ CQkJICAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlLAo+ICsJCQkJICAgIHN0cnVjdCBk cm1fZGlzcGxheV9tb2RlICphZGp1c3RlZCkKPiArewo+ICsJc3RydWN0IGNkbl9kcF9kZXZpY2Ug KmRwID0gZW5jb2Rlcl90b19kcChlbmNvZGVyKTsKPiArCXN0cnVjdCBkcm1fZGlzcGxheV9pbmZv ICpkaXNwbGF5X2luZm8gPSAmZHAtPmNvbm5lY3Rvci5kaXNwbGF5X2luZm87Cj4gKwlzdHJ1Y3Qg cm9ja2NoaXBfY3J0Y19zdGF0ZSAqc3RhdGU7Cj4gKwlzdHJ1Y3QgdmlkZW9faW5mbyAqdmlkZW8g PSAmZHAtPnZpZGVvX2luZm87Cj4gKwlpbnQgcmV0LCB2YWw7Cj4gKwo+ICsJc3dpdGNoIChkaXNw bGF5X2luZm8tPmJwYykgewo+ICsJY2FzZSAxNjoKPiArCWNhc2UgMTI6Cj4gKwljYXNlIDEwOgo+ ICsJCXZpZGVvLT5jb2xvcl9kZXB0aCA9IDEwOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSA2Ogo+ICsJ CXZpZGVvLT5jb2xvcl9kZXB0aCA9IDY7Cj4gKwkJYnJlYWs7Cj4gKwlkZWZhdWx0Ogo+ICsJCXZp ZGVvLT5jb2xvcl9kZXB0aCA9IDg7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwo+ICsJdmlkZW8tPmNv bG9yX2ZtdCA9IFBYTF9SR0I7Cj4gKwo+ICsJdmlkZW8tPnZfc3luY19wb2xhcml0eSA9ICEhKG1v ZGUtPmZsYWdzICYgRFJNX01PREVfRkxBR19OVlNZTkMpOwo+ICsJdmlkZW8tPmhfc3luY19wb2xh cml0eSA9ICEhKG1vZGUtPmZsYWdzICYgRFJNX01PREVfRkxBR19OSFNZTkMpOwo+ICsKPiArCXJl dCA9IGRybV9vZl9lbmNvZGVyX2FjdGl2ZV9lbmRwb2ludF9pZChkcC0+ZGV2LT5vZl9ub2RlLCBl bmNvZGVyKTsKPiArCWlmIChyZXQgPCAwKSB7Cj4gKwkJZGV2X2VycihkcC0+ZGV2LCAiQ291bGQg bm90IGdldCB2b3AgaWQsICVkIiwgcmV0KTsKPiArCQlyZXR1cm47Cj4gKwl9Cj4gKwo+ICsJZGV2 X2RiZyhkcC0+ZGV2LCAidm9wICVzIG91dHB1dCB0byBjZG4tZHBcbiIsIChyZXQpID8gIkxJVCIg OiAiQklHIik7Cj4gKwlzdGF0ZSA9IHRvX3JvY2tjaGlwX2NydGNfc3RhdGUoZW5jb2Rlci0+Y3J0 Yy0+c3RhdGUpOwo+ICsJaWYgKHJldCkgewo+ICsJCXZhbCA9IERQX1NFTF9WT1BfTElUIHwgKERQ X1NFTF9WT1BfTElUIDw8IDE2KTsKPiArCQlzdGF0ZS0+b3V0cHV0X21vZGUgPSBST0NLQ0hJUF9P VVRfTU9ERV9QODg4Owo+ICsJfSBlbHNlIHsKPiArCQl2YWwgPSBEUF9TRUxfVk9QX0xJVCA8PCAx NjsKPiArCQlzdGF0ZS0+b3V0cHV0X21vZGUgPSBST0NLQ0hJUF9PVVRfTU9ERV9BQUFBOwo+ICsJ fQo+ICsJcmV0ID0gcmVnbWFwX3dyaXRlKGRwLT5ncmYsIERQX1ZPUF9TRUwsIHZhbCk7Cj4gKwlp ZiAocmV0ICE9IDApCj4gKwkJZGV2X2VycihkcC0+ZGV2LCAiQ291bGQgbm90IHdyaXRlIHRvIEdS RjogJWRcbiIsIHJldCk7Cj4gKwo+ICsJbWVtY3B5KCZkcC0+bW9kZSwgYWRqdXN0ZWQsIHNpemVv ZigqbW9kZSkpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBjZG5fZHBfZW5jb2Rlcl9lbmFibGUo c3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyKQo+ICt7Cj4gKwlzdHJ1Y3QgY2RuX2RwX2Rldmlj ZSAqZHAgPSBlbmNvZGVyX3RvX2RwKGVuY29kZXIpOwo+ICsKPiArCWlmIChkcC0+ZHBtc19tb2Rl ICE9IERSTV9NT0RFX0RQTVNfT04pCj4gKwkJY2RuX2RwX2NvbW1pdChlbmNvZGVyKTsKPiArfQo+ ICsKPiArc3RhdGljIHZvaWQgY2RuX2RwX2VuY29kZXJfZGlzYWJsZShzdHJ1Y3QgZHJtX2VuY29k ZXIgKmVuY29kZXIpCj4gK3sKPiArCXN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCA9IGVuY29kZXJf dG9fZHAoZW5jb2Rlcik7Cj4gKwo+ICsJaWYgKGRwLT5kcG1zX21vZGUgIT0gRFJNX01PREVfRFBN U19PRkYpIHsKPiArCQljZG5fZHBfc2V0X3ZpZGVvX3N0YXR1cyhkcCwgQ09OVFJPTF9WSURFT19J RExFKTsKPiArCQlkcC0+ZHBtc19tb2RlID0gRFJNX01PREVfRFBNU19PRkY7Cj4gKwl9Cj4gK30K PiArCj4gK3N0YXRpYyBpbnQKPiArY2RuX2RwX2VuY29kZXJfYXRvbWljX2NoZWNrKHN0cnVjdCBk cm1fZW5jb2RlciAqZW5jb2RlciwKPiArCQkJICAgIHN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqY3J0 Y19zdGF0ZSwKPiArCQkJICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRl KQo+ICt7Cj4gKwlzdHJ1Y3Qgcm9ja2NoaXBfY3J0Y19zdGF0ZSAqcyA9IHRvX3JvY2tjaGlwX2Ny dGNfc3RhdGUoY3J0Y19zdGF0ZSk7Cj4gKwo+ICsJcy0+b3V0cHV0X21vZGUgPSBST0NLQ0hJUF9P VVRfTU9ERV9BQUFBOwo+ICsJcy0+b3V0cHV0X3R5cGUgPSBEUk1fTU9ERV9DT05ORUNUT1JfRGlz cGxheVBvcnQ7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgZHJt X2VuY29kZXJfaGVscGVyX2Z1bmNzIGNkbl9kcF9lbmNvZGVyX2hlbHBlcl9mdW5jcyA9IHsKPiAr CS5tb2RlX3NldCA9IGNkbl9kcF9lbmNvZGVyX21vZGVfc2V0LAo+ICsJLmVuYWJsZSA9IGNkbl9k cF9lbmNvZGVyX2VuYWJsZSwKPiArCS5kaXNhYmxlID0gY2RuX2RwX2VuY29kZXJfZGlzYWJsZSwK PiArCS5hdG9taWNfY2hlY2sgPSBjZG5fZHBfZW5jb2Rlcl9hdG9taWNfY2hlY2ssCj4gK307Cj4g Kwo+ICtzdGF0aWMgc3RydWN0IGRybV9lbmNvZGVyX2Z1bmNzIGNkbl9kcF9lbmNvZGVyX2Z1bmNz ID0gewo+ICsJLmRlc3Ryb3kgPSBkcm1fZW5jb2Rlcl9jbGVhbnVwLAo+ICt9Owo+ICsKPiArc3Rh dGljIGludCBjZG5fZHBfZmlybXdhcmVfaW5pdChzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHApCj4g K3sKPiArCWludCByZXQ7Cj4gKwljb25zdCB1MzIgKmlyYW1fZGF0YSwgKmRyYW1fZGF0YTsKPiAr CWNvbnN0IHN0cnVjdCBmaXJtd2FyZSAqZncgPSBkcC0+Znc7Cj4gKwljb25zdCBzdHJ1Y3QgY2Ru X2Zpcm13YXJlX2hlYWRlciAqaGRyOwo+ICsKPiArCWhkciA9IChzdHJ1Y3QgY2RuX2Zpcm13YXJl X2hlYWRlciAqKWZ3LT5kYXRhOwo+ICsJaWYgKGZ3LT5zaXplICE9IGxlMzJfdG9fY3B1KGhkci0+ c2l6ZV9ieXRlcykpIHsKPiArCQlkZXZfZXJyKGRwLT5kZXYsICJmaXJtd2FyZSBpcyBpbnZhbGlk XG4iKTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwlpcmFtX2RhdGEgPSAoY29u c3QgdTMyICopKGZ3LT5kYXRhICsgaGRyLT5oZWFkZXJfc2l6ZSk7Cj4gKwlkcmFtX2RhdGEgPSAo Y29uc3QgdTMyICopKGZ3LT5kYXRhICsgaGRyLT5oZWFkZXJfc2l6ZSArIGhkci0+aXJhbV9zaXpl KTsKPiArCj4gKwlyZXQgPSBjZG5fZHBfbG9hZF9maXJtd2FyZShkcCwgaXJhbV9kYXRhLCBoZHIt PmlyYW1fc2l6ZSwKPiArCQkJCSAgIGRyYW1fZGF0YSwgaGRyLT5kcmFtX3NpemUpOwo+ICsJaWYg KHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCWRwLT5md19sb2FkZWQgPSAxOwo+ICsKPiAr CXJldCA9IGNkbl9kcF9hY3RpdmUoZHAsIHRydWUpOwo+ICsJaWYgKHJldCkgewo+ICsJCWRldl9l cnIoZHAtPmRldiwgImFjdGl2ZSB1Y3B1IGZhaWxlZDogJWRcbiIsIHJldCk7Cj4gKwkJcmV0dXJu IHJldDsKPiArCX0KPiArCj4gKwlyZXR1cm4gY2RuX2RwX2V2ZW50X2NvbmZpZyhkcCk7Cj4gK30K PiArCj4gK3N0YXRpYyBpbnQgY2RuX2RwX2luaXQoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwKQo+ ICt7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBkcC0+ZGV2Owo+ICsJc3RydWN0IGRldmljZV9u b2RlICpucCA9IGRldi0+b2Zfbm9kZTsKPiArCXN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYg PSB0b19wbGF0Zm9ybV9kZXZpY2UoZGV2KTsKPiArCXN0cnVjdCByZXNvdXJjZSAqcmVzOwo+ICsJ aW50IHJldDsKPiArCj4gKwlkcC0+Z3JmID0gc3lzY29uX3JlZ21hcF9sb29rdXBfYnlfcGhhbmRs ZShucCwgInJvY2tjaGlwLGdyZiIpOwo+ICsJaWYgKElTX0VSUihkcC0+Z3JmKSkgewo+ICsJCWRl dl9lcnIoZGV2LCAiY2RuLWRwIG5lZWRzIHJvY2tjaGlwLGdyZiBwcm9wZXJ0eVxuIik7Cj4gKwkJ cmV0dXJuIFBUUl9FUlIoZHAtPmdyZik7Cj4gKwl9Cj4gKwo+ICsJcmVzID0gcGxhdGZvcm1fZ2V0 X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsKPiArCWRwLT5yZWdzID0gZGV2bV9p b3JlbWFwX3Jlc291cmNlKGRldiwgcmVzKTsKPiArCWlmIChJU19FUlIoZHAtPnJlZ3MpKSB7Cj4g KwkJZGV2X2VycihkZXYsICJpb3JlbWFwIHJlZyBmYWlsZWRcbiIpOwo+ICsJCXJldHVybiBQVFJf RVJSKGRwLT5yZWdzKTsKPiArCX0KPiArCj4gKwlkcC0+Y29yZV9jbGsgPSBkZXZtX2Nsa19nZXQo ZGV2LCAiY29yZS1jbGsiKTsKPiArCWlmIChJU19FUlIoZHAtPmNvcmVfY2xrKSkgewo+ICsJCWRl dl9lcnIoZGV2LCAiY2Fubm90IGdldCBjb3JlX2Nsa19kcFxuIik7Cj4gKwkJcmV0dXJuIFBUUl9F UlIoZHAtPmNvcmVfY2xrKTsKPiArCX0KPiArCj4gKwlkcC0+cGNsayA9IGRldm1fY2xrX2dldChk ZXYsICJwY2xrIik7Cj4gKwlpZiAoSVNfRVJSKGRwLT5wY2xrKSkgewo+ICsJCWRldl9lcnIoZGV2 LCAiY2Fubm90IGdldCBwY2xrXG4iKTsKPiArCQlyZXR1cm4gUFRSX0VSUihkcC0+cGNsayk7Cj4g Kwl9Cj4gKwo+ICsJZHAtPnNwZGlmX2NsayA9IGRldm1fY2xrX2dldChkZXYsICJzcGRpZiIpOwo+ ICsJaWYgKElTX0VSUihkcC0+c3BkaWZfY2xrKSkgewo+ICsJCWRldl9lcnIoZGV2LCAiY2Fubm90 IGdldCBzcGRpZl9jbGtcbiIpOwo+ICsJCXJldHVybiBQVFJfRVJSKGRwLT5zcGRpZl9jbGspOwo+ ICsJfQo+ICsKPiArCWRwLT5zcGRpZl9yc3QgPSBkZXZtX3Jlc2V0X2NvbnRyb2xfZ2V0KGRldiwg InNwZGlmIik7Cj4gKwlpZiAoSVNfRVJSKGRwLT5zcGRpZl9yc3QpKSB7Cj4gKwkJZGV2X2Vycihk ZXYsICJubyBzcGRpZiByZXNldCBjb250cm9sIGZvdW5kXG4iKTsKPiArCQlyZXR1cm4gUFRSX0VS UihkcC0+c3BkaWZfcnN0KTsKPiArCX0KPiArCj4gKwlkcC0+ZHBtc19tb2RlID0gRFJNX01PREVf RFBNU19PRkY7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX2Nsa19lbmFibGUoZHApOwo+ICsJaWYgKHJl dCA8IDApCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwljZG5fZHBfY2xvY2tfcmVzZXQoZHApOwo+ ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGNkbl9kcF9hdWRpb19od19w YXJhbXMoc3RydWN0IGRldmljZSAqZGV2LAo+ICsJCQkJICBzdHJ1Y3QgaGRtaV9jb2RlY19kYWlm bXQgKmRhaWZtdCwKPiArCQkJCSAgc3RydWN0IGhkbWlfY29kZWNfcGFyYW1zICpwYXJhbXMpCj4g K3sKPiArCXN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ ICsJc3RydWN0IGF1ZGlvX2luZm8gYXVkaW8gPSB7Cj4gKwkJLnNhbXBsZV93aWR0aCA9IHBhcmFt cy0+c2FtcGxlX3dpZHRoLAo+ICsJCS5zYW1wbGVfcmF0ZSA9IHBhcmFtcy0+c2FtcGxlX3JhdGUs Cj4gKwkJLmNoYW5uZWxzID0gcGFyYW1zLT5jaGFubmVscywKPiArCX07Cj4gKwlpbnQgcmV0Owo+ ICsKPiArCWlmICghZHAtPmVuY29kZXIuY3J0YykKPiArCQlyZXR1cm4gLUVOT0RFVjsKPiArCj4g Kwlzd2l0Y2ggKGRhaWZtdC0+Zm10KSB7Cj4gKwljYXNlIEhETUlfSTJTOgo+ICsJCWF1ZGlvLmZv cm1hdCA9IEFGTVRfSTJTOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBIRE1JX1NQRElGOgo+ICsJCWF1 ZGlvLmZvcm1hdCA9IEFGTVRfU1BESUY7Cj4gKwkJYnJlYWs7Cj4gKwlkZWZhdWx0Ogo+ICsJCWRl dl9lcnIoZGV2LCAiJXM6IEludmFsaWQgZm9ybWF0ICVkXG4iLCBfX2Z1bmNfXywgZGFpZm10LT5m bXQpOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsKPiArCXJldCA9IGNkbl9kcF9hdWRp b19jb25maWdfc2V0KGRwLCAmYXVkaW8pOwo+ICsJaWYgKCFyZXQpCj4gKwkJZHAtPmF1ZGlvX2lu Zm8gPSBhdWRpbzsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBj ZG5fZHBfYXVkaW9fc2h1dGRvd24oc3RydWN0IGRldmljZSAqZGV2KQo+ICt7Cj4gKwlzdHJ1Y3Qg Y2RuX2RwX2RldmljZSAqZHAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCWludCByZXQgPSBj ZG5fZHBfYXVkaW9fc3RvcChkcCwgJmRwLT5hdWRpb19pbmZvKTsKPiArCj4gKwlpZiAoIXJldCkK PiArCQlkcC0+YXVkaW9faW5mby5mb3JtYXQgPSBBRk1UX1VOVVNFRDsKPiArfQo+ICsKPiArc3Rh dGljIGludCBjZG5fZHBfYXVkaW9fZGlnaXRhbF9tdXRlKHN0cnVjdCBkZXZpY2UgKmRldiwgYm9v bCBlbmFibGUpCj4gK3sKPiArCXN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCA9IGRldl9nZXRfZHJ2 ZGF0YShkZXYpOwo+ICsKPiArCXJldHVybiBjZG5fZHBfYXVkaW9fbXV0ZShkcCwgZW5hYmxlKTsK PiArfQo+ICsKPiArc3RhdGljIGludCBjZG5fZHBfYXVkaW9fZ2V0X2VsZChzdHJ1Y3QgZGV2aWNl ICpkZXYsIHVpbnQ4X3QgKmJ1Ziwgc2l6ZV90IGxlbikKPiArewo+ICsJc3RydWN0IGNkbl9kcF9k ZXZpY2UgKmRwID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gKwlzdHJ1Y3QgZHJtX21vZGVfY29u ZmlnICpjb25maWcgPSAmZHAtPmVuY29kZXIuZGV2LT5tb2RlX2NvbmZpZzsKPiArCXN0cnVjdCBk cm1fY29ubmVjdG9yICpjb25uZWN0b3I7Cj4gKwlpbnQgcmV0ID0gLUVOT0RFVjsKPiArCj4gKwlt dXRleF9sb2NrKCZjb25maWctPm11dGV4KTsKPiArCWxpc3RfZm9yX2VhY2hfZW50cnkoY29ubmVj dG9yLCAmY29uZmlnLT5jb25uZWN0b3JfbGlzdCwgaGVhZCkgewo+ICsJCWlmICgmZHAtPmVuY29k ZXIgPT0gY29ubmVjdG9yLT5lbmNvZGVyKSB7Cj4gKwkJCW1lbWNweShidWYsIGNvbm5lY3Rvci0+ ZWxkLAo+ICsJCQkgICAgICAgbWluKHNpemVvZihjb25uZWN0b3ItPmVsZCksIGxlbikpOwo+ICsJ CQlyZXQgPSAwOwo+ICsJCX0KPiArCX0KPiArCW11dGV4X3VubG9jaygmY29uZmlnLT5tdXRleCk7 Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBoZG1p X2NvZGVjX29wcyBhdWRpb19jb2RlY19vcHMgPSB7Cj4gKwkuaHdfcGFyYW1zID0gY2RuX2RwX2F1 ZGlvX2h3X3BhcmFtcywKPiArCS5hdWRpb19zaHV0ZG93biA9IGNkbl9kcF9hdWRpb19zaHV0ZG93 biwKPiArCS5kaWdpdGFsX211dGUgPSBjZG5fZHBfYXVkaW9fZGlnaXRhbF9tdXRlLAo+ICsJLmdl dF9lbGQgPSBjZG5fZHBfYXVkaW9fZ2V0X2VsZCwKPiArfTsKPiArCj4gK3N0YXRpYyBpbnQgY2Ru X2RwX2F1ZGlvX2NvZGVjX2luaXQoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLAo+ICsJCQkJICAg c3RydWN0IGRldmljZSAqZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgaGRtaV9jb2RlY19wZGF0YSBjb2Rl Y19kYXRhID0gewo+ICsJCS5pMnMgPSAxLAo+ICsJCS5zcGRpZiA9IDEsCj4gKwkJLm9wcyA9ICZh dWRpb19jb2RlY19vcHMsCj4gKwkJLm1heF9pMnNfY2hhbm5lbHMgPSA4LAo+ICsJfTsKPiArCj4g KwlkcC0+YXVkaW9fcGRldiA9IHBsYXRmb3JtX2RldmljZV9yZWdpc3Rlcl9kYXRhKAo+ICsJCQkg ZGV2LCBIRE1JX0NPREVDX0RSVl9OQU1FLCBQTEFURk9STV9ERVZJRF9BVVRPLAo+ICsJCQkgJmNv ZGVjX2RhdGEsIHNpemVvZihjb2RlY19kYXRhKSk7Cj4gKwo+ICsJcmV0dXJuIFBUUl9FUlJfT1Jf WkVSTyhkcC0+YXVkaW9fcGRldik7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgY2RuX2RwX2dldF9j YXBfbGFuZXMoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLAo+ICsJCQkJc3RydWN0IGV4dGNvbl9k ZXYgKmVkZXYpCj4gK3sKPiArCWJvb2wgZGZwLCBkcHR4Owo+ICsJdTggbGFuZXM7Cj4gKwo+ICsJ ZGZwID0gZXh0Y29uX2dldF9jYWJsZV9zdGF0ZV8oZWRldiwgRVhUQ09OX1VTQl9IT1NUKTsKPiAr CWRwdHggPSBleHRjb25fZ2V0X2NhYmxlX3N0YXRlXyhlZGV2LCBFWFRDT05fRElTUF9EUCk7Cj4g Kwo+ICsJaWYgKGRmcCAmJiBkcHR4KQo+ICsJCWxhbmVzID0gMjsKPiArCWVsc2UgaWYgKGRwdHgp Cj4gKwkJbGFuZXMgPSA0Owo+ICsJZWxzZQo+ICsJCWxhbmVzID0gMDsKPiArCj4gKwlyZXR1cm4g bGFuZXM7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgY2RuX2RwX3BoeV9wb3dlcl9jdHJsKHN0cnVj dCBjZG5fZHBfZGV2aWNlICpkcCwKPiArCQkJCSBzdHJ1Y3QgY2RuX2RwX3BvcnQgKnBvcnQsIGJv b2wgZW5hYmxlKQo+ICt7Cj4gKwlzdHJ1Y3QgcGh5ICpwaHkgPSBwb3J0LT5waHk7Cj4gKwlpbnQg cmV0Owo+ICsJaW50IGNvdW50ID0gMDsKPiArCj4gKwl3aGlsZSAocGh5LT5wb3dlcl9jb3VudCA+ IDApIHsKPiArCQlyZXQgPSBwaHlfcG93ZXJfb2ZmKHBoeSk7Cj4gKwkJaWYgKHJldCkKPiArCQkJ cmV0dXJuIHJldDsKPiArCQljb3VudCsrOwo+ICsJfQo+ICsKPiArCWNvdW50ID0gZW5hYmxlID8g Y291bnQgKyAxIDogY291bnQgLSAxOwo+ICsJd2hpbGUgKGNvdW50LS0gPiAwKSB7Cj4gKwkJcmV0 ID0gcGh5X3Bvd2VyX29uKHBoeSk7Cj4gKwkJaWYgKHJldCkKPiArCQkJcmV0dXJuIHJldDsKPiAr CX0KPiArCj4gKwlwb3J0LT5waHlfc3RhdHVzID0gZW5hYmxlOwo+ICsJcmV0dXJuIDA7Cj4gK30K PiArCj4gK3N0YXRpYyBpbnQgY2RuX2RwX3BkX2V2ZW50KHN0cnVjdCBub3RpZmllcl9ibG9jayAq bmIsCj4gKwkJCSAgIHVuc2lnbmVkIGxvbmcgZXZlbnQsIHZvaWQgKnByaXYpCj4gK3sKPiArCXN0 cnVjdCBjZG5fZHBfcG9ydCAqcG9ydDsKPiArCj4gKwlwb3J0ID0gY29udGFpbmVyX29mKG5iLCBz dHJ1Y3QgY2RuX2RwX3BvcnQsIGV2ZW50X25iKTsKPiArCj4gKwlzY2hlZHVsZV9kZWxheWVkX3dv cmsoJnBvcnQtPmV2ZW50X3dxLCAwKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3Rh dGljIHZvaWQgY2RuX2RwX3BkX2V2ZW50X3dxKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKPiAr ewo+ICsJc3RydWN0IGNkbl9kcF9wb3J0ICpwb3J0ID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVj dCBjZG5fZHBfcG9ydCwKPiArCQkJCQkJZXZlbnRfd3Eud29yayk7Cj4gKwlzdHJ1Y3QgY2RuX2Rw X2RldmljZSAqZHAgPSBwb3J0LT5kcDsKPiArCXU4IG5ld19jYXBfbGFuZXM7Cj4gKwlpbnQgcmV0 Owo+ICsJdTggaTsKPiArCj4gKwluZXdfY2FwX2xhbmVzID0gY2RuX2RwX2dldF9jYXBfbGFuZXMo ZHAsIHBvcnQtPmV4dGNvbik7Cj4gKwo+ICsJaWYgKG5ld19jYXBfbGFuZXMgPT0gcG9ydC0+Y2Fw X2xhbmVzKSB7Cj4gKwkJZGV2X2VycihkcC0+ZGV2LCAibGFuZXMgY291bnQgZG9lcyBub3QgY2hh bmdlOiAlZFxuIiwKPiArCQkJbmV3X2NhcF9sYW5lcyk7Cj4gKwkJcmV0dXJuOwo+ICsJfQo+ICsK PiArCWlmICghbmV3X2NhcF9sYW5lcykgewo+ICsJCXJldCA9IGNkbl9kcF9waHlfcG93ZXJfY3Ry bChkcCwgcG9ydCwgMCk7Cj4gKwkJaWYgKHJldCkgewo+ICsJCQlkZXZfZXJyKGRwLT5kZXYsICJw aHkgcG93ZXIgb2ZmIGZhaWxlZDogJWQiLCByZXQpOwo+ICsJCQlyZXR1cm47Cj4gKwkJfQo+ICsJ CXBvcnQtPnBoeV9zdGF0dXMgPSAwOwo+ICsJCXBvcnQtPmNhcF9sYW5lcyA9IG5ld19jYXBfbGFu ZXM7Cj4gKwkJZm9yIChpID0gMDsgaSA8IGRwLT5wb3J0czsgaSsrKSB7Cj4gKwkJCWlmIChkcC0+ cG9ydFtpXS0+cGh5X3N0YXR1cyA9PSAxKQo+ICsJCQkJcmV0dXJuOwo+ICsJCX0KPiArCj4gKwkJ ZHAtPmhwZF9zdGF0dXMgPSBjb25uZWN0b3Jfc3RhdHVzX2Rpc2Nvbm5lY3RlZDsKPiArCQlkcm1f aGVscGVyX2hwZF9pcnFfZXZlbnQoZHAtPmRybV9kZXYpOwo+ICsJCXJldHVybjsKPiArCX0KPiAr Cj4gKwkvKiBpZiBvdGhlciBwaHkgaXMgcnVubmluZywgZG8gbm90IHRvdWNoIHRoZSBocGRfc3Rh dHVzLCBhbmQgcmV0dXJuICovCj4gKwlmb3IgKGkgPSAwOyBpIDwgZHAtPnBvcnRzOyBpKyspIHsK PiArCQlpZiAoZHAtPnBvcnRbaV0tPnBoeV9zdGF0dXMgPT0gMSkgewo+ICsJCQlkZXZfd2Fybihk cC0+ZGV2LCAiYnVzeSwgcGh5WyVkXSBpcyBydW5uaW5nIiwKPiArCQkJCSBkcC0+cG9ydFtpXS0+ aWQpOwo+ICsJCQlyZXR1cm47Cj4gKwkJfQo+ICsJfQo+ICsKPiArCWlmICghZHAtPmZ3X2xvYWRl ZCkgewo+ICsJCXJldCA9IHJlcXVlc3RfZmlybXdhcmUoJmRwLT5mdywgQ0ROX0RQX0ZJUk1XQVJF LCBkcC0+ZGV2KTsKPiArCQlpZiAocmV0ID09IC1FTk9FTlQgJiYgZHAtPmZ3X3dhaXQgPD0gTUFY X0ZXX1dBSVRfU0VDUykgewo+ICsJCQl1bnNpZ25lZCBsb25nIHRpbWUgPSBtc2Vjc190b19qaWZm aWVzKGRwLT5md193YWl0ICogSFopOwo+ICsKPiArCQkJLyoKPiArCQkJICogSWYgY2FuIG5vdCBm aW5kIHRoZSBmaWxlLCByZXRyeSB0byBsb2FkIHRoZSBmaXJtd2FyZQo+ICsJCQkgKiBpbiAxIHNl Y29uZCwgaWYgc3RpbGwgZmFpbGVkIGFmdGVyIDEgbWludXRlLCBnaXZlIHVwLgo+ICsJCQkgKi8K PiArCQkJc2NoZWR1bGVfZGVsYXllZF93b3JrKCZwb3J0LT5ldmVudF93cSwgdGltZSk7Cj4gKwkJ CWRldl93YXJuKGRwLT5kZXYsICJyZXRyeSB0byByZXF1ZXN0IGZpcm13YXJlIGluICVkU1xuIiwK PiArCQkJCSBkcC0+Zndfd2FpdCk7Cj4gKwkJCWRwLT5md193YWl0ICo9IDI7Cj4gKwkJCXJldHVy bjsKPiArCQl9IGVsc2UgaWYgKHJldCkgewo+ICsJCQlkZXZfZXJyKGRwLT5kZXYsICJmYWlsZWQg dG8gcmVxdWVzdCBmaXJtd2FyZTogJWRcbiIsCj4gKwkJCQlyZXQpOwo+ICsJCQlyZXR1cm47Cj4g KwkJfQo+ICsJfQo+ICsKPiArCXJldCA9IGNkbl9kcF9waHlfcG93ZXJfY3RybChkcCwgcG9ydCwg MSk7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJaWYgKCFkcC0+ZndfbG9hZGVkKQo+ICsJCQlyZWxlYXNl X2Zpcm13YXJlKGRwLT5mdyk7Cj4gKwkJZGV2X2VycihkcC0+ZGV2LCAicGh5IHBvd2VyIG9uIGZh aWxlZDogJWRcbiIsIHJldCk7Cj4gKwkJcmV0dXJuOwo+ICsJfQo+ICsKPiArCWlmICghZHAtPmZ3 X2xvYWRlZCkgewo+ICsJCXJldCA9IGNkbl9kcF9maXJtd2FyZV9pbml0KGRwKTsKPiArCQlyZWxl YXNlX2Zpcm13YXJlKGRwLT5mdyk7Cj4gKwkJaWYgKHJldCkgewo+ICsJCQlkZXZfZXJyKGRwLT5k ZXYsICJmaXJtd2FyZSBpbml0IGZhaWxlZDogJWQiLCByZXQpOwo+ICsJCQlnb3RvIGVycl9maXJt d2FyZTsKPiArCQl9Cj4gKwl9Cj4gKwo+ICsJLyogcmVhZCBocGQgc3RhdHVzIGZhaWxlZCwgb3Ig dGhlIGhwZCBkb2VzIG5vdCBleGlzdC4gKi8KPiArCXJldCA9IGNkbl9kcF9nZXRfaHBkX3N0YXR1 cyhkcCk7Cj4gKwlpZiAocmV0IDw9IDApIHsKPiArCQlkZXZfZXJyKGRwLT5kZXYsICJnZXQgaHBk IGZhaWxlZDogJWQiLCByZXQpOwo+ICsJCWdvdG8gZXJyX2Zpcm13YXJlOwo+ICsJfQo+ICsKPiAr CXJldCA9IGNkbl9kcF9zZXRfaG9zdF9jYXAoZHAsIG5ld19jYXBfbGFuZXMpOwo+ICsJaWYgKHJl dCkgewo+ICsJCWRldl9lcnIoZHAtPmRldiwgInNldCBob3N0IGNhcGFiaWxpdGllcyBmYWlsZWQ6 ICVkXG4iLCByZXQpOwo+ICsJCWdvdG8gZXJyX2Zpcm13YXJlOwo+ICsJfQo+ICsKPiArCS8qCj4g KwkgKiBOYXRpdmUgcmVhZCB3aXRoIHJldHJ5IGZvciBsaW5rIHN0YXR1cyBhbmQgcmVjZWl2ZXIg Y2FwYWJpbGl0eSByZWFkcwo+ICsJICogZm9yIGNhc2VzIHdoZXJlIHRoZSBzaW5rIG1heSBzdGls bCBiZSBhc2xlZXAuCj4gKwkgKgo+ICsJICogU2lua3MgYXJlICpzdXBwb3NlZCogdG8gY29tZSB1 cCB3aXRoaW4gMW1zIGZyb20gYW4gb2ZmIHN0YXRlLCBidXQKPiArCSAqIHdlJ3JlIGFsc28gc3Vw cG9zZWQgdG8gcmV0cnkgMyB0aW1lcyBwZXIgdGhlIHNwZWMuCj4gKwkgKi8KPiArCWZvciAoaSA9 IDA7IGkgPCAzOyBpKyspIHsKPiArCQlyZXQgPSBjZG5fZHBfZHBjZF9yZWFkKGRwLCAweDAwMCwg ZHAtPmRwY2QsCj4gKwkJCQkgICAgICAgRFBfUkVDRUlWRVJfQ0FQX1NJWkUpOwo+ICsJCWlmICgh cmV0KSB7Cj4gKwkJCXBvcnQtPmNhcF9sYW5lcyA9IG5ld19jYXBfbGFuZXM7Cj4gKwkJCWRwLT5o cGRfc3RhdHVzID0gY29ubmVjdG9yX3N0YXR1c19jb25uZWN0ZWQ7Cj4gKwkJCWRybV9oZWxwZXJf aHBkX2lycV9ldmVudChkcC0+ZHJtX2Rldik7Cj4gKwkJCXJldHVybjsKPiArCQl9Cj4gKwkJdXNs ZWVwX3JhbmdlKDEwMDAsIDEwNTApOwo+ICsJfQo+ICsKPiArCWRldl9lcnIoZHAtPmRldiwgImdl dCBkcGNkIGZhaWxlZDogJWQiLCByZXQpOwo+ICsKPiArZXJyX2Zpcm13YXJlOgo+ICsJcmV0ID0g Y2RuX2RwX3BoeV9wb3dlcl9jdHJsKGRwLCBwb3J0LCAwKTsKPiArCWlmIChyZXQpCj4gKwkJZGV2 X2VycihkcC0+ZGV2LCAicGh5IHBvd2VyIG9mZiBmYWlsZWQ6ICVkIiwgcmV0KTsKPiArfQo+ICsK PiArc3RhdGljIGludCBjZG5fZHBfYmluZChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZp Y2UgKm1hc3RlciwKPiArCQkgICAgICAgdm9pZCAqZGF0YSkKPiArewo+ICsJc3RydWN0IGNkbl9k cF9kZXZpY2UgKmRwID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gKwlzdHJ1Y3QgZHJtX2VuY29k ZXIgKmVuY29kZXI7Cj4gKwlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yOwo+ICsJc3Ry dWN0IGNkbl9kcF9wb3J0ICpwb3J0Owo+ICsJc3RydWN0IGRybV9kZXZpY2UgKmRybV9kZXYgPSBk YXRhOwo+ICsJaW50IHJldCwgaTsKPiArCj4gKwlyZXQgPSBjZG5fZHBfaW5pdChkcCk7Cj4gKwlp ZiAocmV0IDwgMCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCWRwLT5kcm1fZGV2ID0gZHJtX2Rl djsKPiArCWRwLT5ocGRfc3RhdHVzID0gY29ubmVjdG9yX3N0YXR1c19kaXNjb25uZWN0ZWQ7Cj4g KwlkcC0+Zndfd2FpdCA9IDE7Cj4gKwo+ICsJZW5jb2RlciA9ICZkcC0+ZW5jb2RlcjsKPiArCj4g KwllbmNvZGVyLT5wb3NzaWJsZV9jcnRjcyA9IGRybV9vZl9maW5kX3Bvc3NpYmxlX2NydGNzKGRy bV9kZXYsCj4gKwkJCQkJCQkgICAgIGRldi0+b2Zfbm9kZSk7Cj4gKwlEUk1fREVCVUdfS01TKCJw b3NzaWJsZV9jcnRjcyA9IDB4JXhcbiIsIGVuY29kZXItPnBvc3NpYmxlX2NydGNzKTsKPiArCj4g KwlyZXQgPSBkcm1fZW5jb2Rlcl9pbml0KGRybV9kZXYsIGVuY29kZXIsICZjZG5fZHBfZW5jb2Rl cl9mdW5jcywKPiArCQkJICAgICAgIERSTV9NT0RFX0VOQ09ERVJfVE1EUywgTlVMTCk7Cj4gKwlp ZiAocmV0KSB7Cj4gKwkJRFJNX0VSUk9SKCJmYWlsZWQgdG8gaW5pdGlhbGl6ZSBlbmNvZGVyIHdp dGggZHJtXG4iKTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsKPiArCWRybV9lbmNvZGVyX2hl bHBlcl9hZGQoZW5jb2RlciwgJmNkbl9kcF9lbmNvZGVyX2hlbHBlcl9mdW5jcyk7Cj4gKwo+ICsJ Y29ubmVjdG9yID0gJmRwLT5jb25uZWN0b3I7Cj4gKwljb25uZWN0b3ItPnBvbGxlZCA9IERSTV9D T05ORUNUT1JfUE9MTF9IUEQ7Cj4gKwljb25uZWN0b3ItPmRwbXMgPSBEUk1fTU9ERV9EUE1TX09G RjsKPiArCj4gKwlyZXQgPSBkcm1fY29ubmVjdG9yX2luaXQoZHJtX2RldiwgY29ubmVjdG9yLAo+ ICsJCQkJICZjZG5fZHBfYXRvbWljX2Nvbm5lY3Rvcl9mdW5jcywKPiArCQkJCSBEUk1fTU9ERV9D T05ORUNUT1JfRGlzcGxheVBvcnQpOwo+ICsJaWYgKHJldCkgewo+ICsJCURSTV9FUlJPUigiZmFp bGVkIHRvIGluaXRpYWxpemUgY29ubmVjdG9yIHdpdGggZHJtXG4iKTsKPiArCQlnb3RvIGVycl9m cmVlX2VuY29kZXI7Cj4gKwl9Cj4gKwo+ICsJZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfYWRkKGNvbm5l Y3RvciwgJmNkbl9kcF9jb25uZWN0b3JfaGVscGVyX2Z1bmNzKTsKPiArCj4gKwlyZXQgPSBkcm1f bW9kZV9jb25uZWN0b3JfYXR0YWNoX2VuY29kZXIoY29ubmVjdG9yLCBlbmNvZGVyKTsKPiArCWlm IChyZXQpIHsKPiArCQlEUk1fRVJST1IoImZhaWxlZCB0byBhdHRhY2ggY29ubmVjdG9yIGFuZCBl bmNvZGVyXG4iKTsKPiArCQlnb3RvIGVycl9mcmVlX2Nvbm5lY3RvcjsKPiArCX0KPiArCj4gKwlj ZG5fZHBfYXVkaW9fY29kZWNfaW5pdChkcCwgZGV2KTsKPiArCj4gKwo+ICsJZm9yIChpID0gMDsg aSA8IGRwLT5wb3J0czsgaSsrKSB7Cj4gKwkJcG9ydCA9IGRwLT5wb3J0W2ldOwo+ICsKPiArCQlw b3J0LT5ldmVudF9uYi5ub3RpZmllcl9jYWxsID0gY2RuX2RwX3BkX2V2ZW50Owo+ICsJCUlOSVRf REVMQVlFRF9XT1JLKCZwb3J0LT5ldmVudF93cSwgY2RuX2RwX3BkX2V2ZW50X3dxKTsKPiArCQly ZXQgPSBleHRjb25fcmVnaXN0ZXJfbm90aWZpZXIocG9ydC0+ZXh0Y29uLCBFWFRDT05fRElTUF9E UCwKPiArCQkJCQkgICAgICAgJnBvcnQtPmV2ZW50X25iKTsKPiArCQlpZiAocmV0KSB7Cj4gKwkJ CWRldl9lcnIoZGV2LCAicmVnaXRzdGVyIEVYVENPTl9ESVNQX0RQIG5vdGlmaWVyIGVyclxuIik7 Cj4gKwkJCXJldHVybiByZXQ7Cj4gKwkJfQo+ICsKPiArCQlpZiAoZXh0Y29uX2dldF9jYWJsZV9z dGF0ZV8ocG9ydC0+ZXh0Y29uLCBFWFRDT05fRElTUF9EUCkpCj4gKwkJCXNjaGVkdWxlX2RlbGF5 ZWRfd29yaygmcG9ydC0+ZXZlbnRfd3EsIDApOwo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICsK PiArZXJyX2ZyZWVfY29ubmVjdG9yOgo+ICsJZHJtX2Nvbm5lY3Rvcl9jbGVhbnVwKGNvbm5lY3Rv cik7Cj4gK2Vycl9mcmVlX2VuY29kZXI6Cj4gKwlkcm1fZW5jb2Rlcl9jbGVhbnVwKGVuY29kZXIp Owo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgY2RuX2RwX3VuYmluZChz dHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2UgKm1hc3Rlciwgdm9pZCAqZGF0YSkKPiAr ewo+ICsJc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4g KwlzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIgPSAmZHAtPmVuY29kZXI7Cj4gKwlzdHJ1Y3Qg ZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yID0gJmRwLT5jb25uZWN0b3I7Cj4gKwlzdHJ1Y3QgY2Ru X2RwX3BvcnQgKnBvcnQ7Cj4gKwlpbnQgaTsKPiArCj4gKwlwbGF0Zm9ybV9kZXZpY2VfdW5yZWdp c3RlcihkcC0+YXVkaW9fcGRldik7Cj4gKwljZG5fZHBfZW5jb2Rlcl9kaXNhYmxlKGVuY29kZXIp Owo+ICsJZW5jb2Rlci0+ZnVuY3MtPmRlc3Ryb3koZW5jb2Rlcik7Cj4gKwljb25uZWN0b3ItPmZ1 bmNzLT5kZXN0cm95KGNvbm5lY3Rvcik7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IGRwLT5wb3J0 czsgaSsrKSB7Cj4gKwkJcG9ydCA9IGRwLT5wb3J0W2ldOwo+ICsJCWV4dGNvbl91bnJlZ2lzdGVy X25vdGlmaWVyKHBvcnQtPmV4dGNvbiwgRVhUQ09OX0RJU1BfRFAsCj4gKwkJCQkJICAgJnBvcnQt PmV2ZW50X25iKTsKPiArCX0KPiArfQo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBjb21wb25l bnRfb3BzIGNkbl9kcF9jb21wb25lbnRfb3BzID0gewo+ICsJLmJpbmQgPSBjZG5fZHBfYmluZCwK PiArCS51bmJpbmQgPSBjZG5fZHBfdW5iaW5kLAo+ICt9Owo+ICsKPiArc3RhdGljIGludCBjZG5f ZHBfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiArewo+ICsJc3RydWN0IGRl dmljZSAqZGV2ID0gJnBkZXYtPmRldjsKPiArCWNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgKm1h dGNoOwo+ICsJc3RydWN0IGNkbl9kcF9kYXRhICpkcF9kYXRhOwo+ICsJc3RydWN0IGNkbl9kcF9w b3J0ICpwb3J0Owo+ICsJc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwOwo+ICsJc3RydWN0IGV4dGNv bl9kZXYgKmV4dGNvbjsKPiArCXN0cnVjdCBwaHkgKnBoeTsKPiArCWludCBpOwo+ICsKPiArCWRw ID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpkcCksIEdGUF9LRVJORUwpOwo+ICsJaWYgKCFk cCkKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCWRwLT5kZXYgPSBkZXY7Cj4gKwo+ICsJbWF0Y2gg PSBvZl9tYXRjaF9ub2RlKGNkbl9kcF9kdF9pZHMsIHBkZXYtPmRldi5vZl9ub2RlKTsKPiArCWRw X2RhdGEgPSAoc3RydWN0IGNkbl9kcF9kYXRhICopbWF0Y2gtPmRhdGE7Cj4gKwo+ICsJZm9yIChp ID0gMDsgaSA8IGRwX2RhdGEtPm1heF9waHk7IGkrKykgewo+ICsJCWV4dGNvbiA9IGV4dGNvbl9n ZXRfZWRldl9ieV9waGFuZGxlKGRldiwgaSk7Cj4gKwkJcGh5ID0gZGV2bV9vZl9waHlfZ2V0X2J5 X2luZGV4KGRldiwgZGV2LT5vZl9ub2RlLCBpKTsKPiArCj4gKwkJaWYgKFBUUl9FUlIoZXh0Y29u KSA9PSAtRVBST0JFX0RFRkVSIHx8Cj4gKwkJICAgIFBUUl9FUlIocGh5KSA9PSAtRVBST0JFX0RF RkVSKQo+ICsJCQlyZXR1cm4gLUVQUk9CRV9ERUZFUjsKPiArCj4gKwkJaWYgKElTX0VSUihleHRj b24pIHx8IElTX0VSUihwaHkpKQo+ICsJCQljb250aW51ZTsKPiArCj4gKwkJcG9ydCA9IGRldm1f a3phbGxvYyhkZXYsIHNpemVvZigqcG9ydCksIEdGUF9LRVJORUwpOwo+ICsJCWlmICghZHApCj4g KwkJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCQlwb3J0LT5leHRjb24gPSBleHRjb247Cj4gKwkJ cG9ydC0+cGh5ID0gcGh5Owo+ICsJCXBvcnQtPmRwID0gZHA7Cj4gKwkJcG9ydC0+aWQgPSBpOwo+ ICsJCWRwLT5wb3J0W2RwLT5wb3J0cysrXSA9IHBvcnQ7Cj4gKwl9Cj4gKwo+ICsJaWYgKCFkcC0+ cG9ydHMpIHsKPiArCQlkZXZfZXJyKGRldiwgIm1pc3NpbmcgZXh0Y29uIG9yIHBoeVxuIik7Cj4g KwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJZGV2X3NldF9kcnZkYXRhKGRldiwgZHAp Owo+ICsKPiArCXJldHVybiBjb21wb25lbnRfYWRkKGRldiwgJmNkbl9kcF9jb21wb25lbnRfb3Bz KTsKPiArfQo+ICsKPiArc3RhdGljIGludCBjZG5fZHBfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9k ZXZpY2UgKnBkZXYpCj4gK3sKPiArCWNvbXBvbmVudF9kZWwoJnBkZXYtPmRldiwgJmNkbl9kcF9j b21wb25lbnRfb3BzKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVj dCBwbGF0Zm9ybV9kcml2ZXIgY2RuX2RwX2RyaXZlciA9IHsKPiArCS5wcm9iZSA9IGNkbl9kcF9w cm9iZSwKPiArCS5yZW1vdmUgPSBjZG5fZHBfcmVtb3ZlLAo+ICsJLmRyaXZlciA9IHsKPiArCQkg ICAubmFtZSA9ICJjZG4tZHAiLAo+ICsJCSAgIC5vd25lciA9IFRISVNfTU9EVUxFLAo+ICsJCSAg IC5vZl9tYXRjaF90YWJsZSA9IG9mX21hdGNoX3B0cihjZG5fZHBfZHRfaWRzKSwKPiArCX0sCj4g K307Cj4gKwo+ICttb2R1bGVfcGxhdGZvcm1fZHJpdmVyKGNkbl9kcF9kcml2ZXIpOwo+ICsKPiAr TU9EVUxFX0FVVEhPUigiQ2hyaXMgWmhvbmcgPHp5d0Byb2NrLWNoaXBzLmNvbT4iKTsKPiArTU9E VUxFX0RFU0NSSVBUSU9OKCJjZG4gRFAgRHJpdmVyIik7Cj4gK01PRFVMRV9MSUNFTlNFKCJHUEwg djIiKTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL2Nkbi1kcC1jb3Jl LmggYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvY2RuLWRwLWNvcmUuaAo+IG5ldyBmaWxlIG1v ZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uNmViN2I3Mgo+IC0tLSAvZGV2L251bGwKPiArKysg Yi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvY2RuLWRwLWNvcmUuaAo+IEBAIC0wLDAgKzEsMTAy IEBACj4gKy8qCj4gKyAqIENvcHlyaWdodCAoQykgMjAxNiBDaHJpcyBaaG9uZyA8enl3QHJvY2st Y2hpcHMuY29tPgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTYgUk9DS0NISVAsIEluYy4KPiArICoK PiArICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRl IGl0IGFuZC9vciBtb2RpZnkKPiArICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKPiArICogdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZS4KPiArICoKPiAr ICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBi ZSB1c2VmdWwsCj4gKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRo ZSBpbXBsaWVkIHdhcnJhbnR5IG9mCj4gKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKPiArICogR05VIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KPiArICovCj4gKwo+ICsjaWZuZGVmIF9DRE5fRFBf Q09SRV9ICj4gKyNkZWZpbmUgX0NETl9EUF9DT1JFX0gKPiArCj4gKyNpbmNsdWRlIDxkcm0vZHJt UC5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJt L2RybV9kcF9oZWxwZXIuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1fcGFuZWwuaD4KPiArI2luY2x1 ZGUgInJvY2tjaGlwX2RybV9kcnYuaCIKPiArCj4gKyNkZWZpbmUgTUFYX1BIWQkJMgo+ICsKPiAr ZW51bSBhdWRpb19mb3JtYXQgewo+ICsJQUZNVF9JMlMgPSAwLAo+ICsJQUZNVF9TUERJRiA9IDEs Cj4gKwlBRk1UX1VOVVNFRCwKPiArfTsKPiArCj4gK3N0cnVjdCBhdWRpb19pbmZvIHsKPiArCWVu dW0gYXVkaW9fZm9ybWF0IGZvcm1hdDsKPiArCWludCBzYW1wbGVfcmF0ZTsKPiArCWludCBjaGFu bmVsczsKPiArCWludCBzYW1wbGVfd2lkdGg7Cj4gK307Cj4gKwo+ICtlbnVtIHZpY19weGxfZW5j b2RpbmdfZm9ybWF0IHsKPiArCVBYTF9SR0IgPSAweDEsCj4gKwlZQ0JDUl80XzRfNCA9IDB4MiwK PiArCVlDQkNSXzRfMl8yID0gMHg0LAo+ICsJWUNCQ1JfNF8yXzAgPSAweDgsCj4gKwlZX09OTFkg PSAweDEwLAo+ICt9Owo+ICsKPiArc3RydWN0IHZpZGVvX2luZm8gewo+ICsJYm9vbCBoX3N5bmNf cG9sYXJpdHk7Cj4gKwlib29sIHZfc3luY19wb2xhcml0eTsKPiArCWJvb2wgaW50ZXJsYWNlZDsK PiArCWludCBjb2xvcl9kZXB0aDsKPiArCWVudW0gdmljX3B4bF9lbmNvZGluZ19mb3JtYXQgY29s b3JfZm10Owo+ICt9Owo+ICsKPiArc3RydWN0IGNkbl9maXJtd2FyZV9oZWFkZXIgewo+ICsJdTMy IHNpemVfYnl0ZXM7IC8qIHNpemUgb2YgdGhlIGVudGlyZSBoZWFkZXIraW1hZ2UocykgaW4gYnl0 ZXMgKi8KPiArCXUzMiBoZWFkZXJfc2l6ZTsgLyogc2l6ZSBvZiBqdXN0IHRoZSBoZWFkZXIgaW4g Ynl0ZXMgKi8KPiArCXUzMiBpcmFtX3NpemU7IC8qIHNpemUgb2YgaXJhbSAqLwo+ICsJdTMyIGRy YW1fc2l6ZTsgLyogc2l6ZSBvZiBkcmFtICovCj4gK307Cj4gKwo+ICtzdHJ1Y3QgY2RuX2RwX3Bv cnQgewo+ICsJc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwOwo+ICsJc3RydWN0IG5vdGlmaWVyX2Js b2NrIGV2ZW50X25iOwo+ICsJc3RydWN0IGRlbGF5ZWRfd29yayBldmVudF93cTsKPiArCXN0cnVj dCBleHRjb25fZGV2ICpleHRjb247Cj4gKwlzdHJ1Y3QgcGh5ICpwaHk7Cj4gKwl1OCBjYXBfbGFu ZXM7Cj4gKwlib29sIHBoeV9zdGF0dXM7Cj4gKwl1OCBpZDsKPiArfTsKPiArCj4gK3N0cnVjdCBj ZG5fZHBfZGV2aWNlIHsKPiArCXN0cnVjdCBkZXZpY2UgKmRldjsKPiArCXN0cnVjdCBkcm1fZGV2 aWNlICpkcm1fZGV2Owo+ICsJc3RydWN0IGRybV9jb25uZWN0b3IgY29ubmVjdG9yOwo+ICsJc3Ry dWN0IGRybV9lbmNvZGVyIGVuY29kZXI7Cj4gKwlzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSBtb2Rl Owo+ICsJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqYXVkaW9fcGRldjsKPiArCj4gKwljb25zdCBz dHJ1Y3QgZmlybXdhcmUgKmZ3OwkvKiBjZG4gZHAgZmlybXdhcmUgKi8KPiArCXVuc2lnbmVkIGlu dCBmd192ZXJzaW9uOwkvKiBjZG4gZncgdmVyc2lvbiAqLwo+ICsJdTMyIGZ3X3dhaXQ7Cj4gKwli b29sIGZ3X2xvYWRlZDsKPiArCXZvaWQgX19pb21lbSAqcmVnczsKPiArCXN0cnVjdCByZWdtYXAg KmdyZjsKPiArCXN0cnVjdCBjbGsgKmNvcmVfY2xrOwo+ICsJc3RydWN0IGNsayAqcGNsazsKPiAr CXN0cnVjdCBjbGsgKnNwZGlmX2NsazsKPiArCXN0cnVjdCByZXNldF9jb250cm9sICpzcGRpZl9y c3Q7Cj4gKwlzdHJ1Y3QgYXVkaW9faW5mbyBhdWRpb19pbmZvOwo+ICsJc3RydWN0IHZpZGVvX2lu Zm8gdmlkZW9faW5mbzsKPiArCXN0cnVjdCBkcm1fZHBfbGluayBsaW5rOwo+ICsJc3RydWN0IGNk bl9kcF9wb3J0ICpwb3J0W01BWF9QSFldOwo+ICsJdTggcG9ydHM7Cj4gKwo+ICsJdTggZHBjZFtE UF9SRUNFSVZFUl9DQVBfU0laRV07Cj4gKwllbnVtIGRybV9jb25uZWN0b3Jfc3RhdHVzIGhwZF9z dGF0dXM7Cj4gKwlpbnQgZHBtc19tb2RlOwo+ICsJYm9vbCBzaW5rX2hhc19hdWRpbzsKPiArfTsK PiArI2VuZGlmICAvKiBfQ0ROX0RQX0NPUkVfSCAqLwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vcm9ja2NoaXAvY2RuLWRwLXJlZy5jIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL2Nk bi1kcC1yZWcuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uYTIyNGE2 Ygo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvY2RuLWRw LXJlZy5jCj4gQEAgLTAsMCArMSw5MDQgQEAKPiArLyoKPiArICogQ29weXJpZ2h0IChDKSBGdXpo b3UgUm9ja2NoaXAgRWxlY3Ryb25pY3MgQ28uTHRkCj4gKyAqIEF1dGhvcjogQ2hyaXMgWmhvbmcg PHp5d0Byb2NrLWNoaXBzLmNvbT4KPiArICoKPiArICogVGhpcyBzb2Z0d2FyZSBpcyBsaWNlbnNl ZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYwo+ICsgKiBMaWNlbnNl IHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24s IGFuZAo+ICsgKiBtYXkgYmUgY29waWVkLCBkaXN0cmlidXRlZCwgYW5kIG1vZGlmaWVkIHVuZGVy IHRob3NlIHRlcm1zLgo+ICsgKgo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4g dGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKPiArICogYnV0IFdJVEhPVVQgQU5ZIFdB UlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKPiArICogTUVSQ0hB TlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQo+ ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+ICsgKi8K PiArCj4gKyNpbmNsdWRlIDxsaW51eC9jbGsuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2RldmljZS5o Pgo+ICsjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2lvLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9pb3BvbGwuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3Jlc2V0Lmg+Cj4g Kwo+ICsjaW5jbHVkZSAiY2RuLWRwLWNvcmUuaCIKPiArI2luY2x1ZGUgImNkbi1kcC1yZWcuaCIK PiArCj4gKyNkZWZpbmUgQ0ROX0RQX1NQRElGX0NMSwkJMjAwMDAwMDAwCj4gKyNkZWZpbmUgRldf QUxJVkVfVElNRU9VVF9VUwkJMTAwMDAwMAo+ICsjZGVmaW5lIE1BSUxCT1hfUkVUUllfVVMJCTEw MDAKPiArI2RlZmluZSBNQUlMQk9YX1RJTUVPVVRfVVMJCTUwMDAwMDAKPiArI2RlZmluZSBMSU5L X1RSQUlOSU5HX1JFVFJZX01TCQkyMAo+ICsjZGVmaW5lIExJTktfVFJBSU5JTkdfVElNRU9VVF9N Uwk1MDAKPiArCj4gK3ZvaWQgY2RuX2RwX3NldF9md19jbGsoc3RydWN0IGNkbl9kcF9kZXZpY2Ug KmRwLCB1MzIgY2xrKQo+ICt7Cj4gKwl3cml0ZWwoY2xrIC8gMTAwMDAwMCwgZHAtPnJlZ3MgKyBT V19DTEtfSCk7Cj4gK30KPiArCj4gK3ZvaWQgY2RuX2RwX2Nsb2NrX3Jlc2V0KHN0cnVjdCBjZG5f ZHBfZGV2aWNlICpkcCkKPiArewo+ICsJdTMyIHZhbDsKPiArCj4gKwl2YWwgPSBEUFRYX0ZSTVJf REFUQV9DTEtfUlNUTl9FTiB8Cj4gKwkgICAgICBEUFRYX0ZSTVJfREFUQV9DTEtfRU4gfAo+ICsJ ICAgICAgRFBUWF9QSFlfREFUQV9SU1ROX0VOIHwKPiArCSAgICAgIERQVFhfUEhZX0RBVEFfQ0xL X0VOIHwKPiArCSAgICAgIERQVFhfUEhZX0NIQVJfUlNUTl9FTiB8Cj4gKwkgICAgICBEUFRYX1BI WV9DSEFSX0NMS19FTiB8Cj4gKwkgICAgICBTT1VSQ0VfQVVYX1NZU19DTEtfUlNUTl9FTiB8Cj4g KwkgICAgICBTT1VSQ0VfQVVYX1NZU19DTEtfRU4gfAo+ICsJICAgICAgRFBUWF9TWVNfQ0xLX1JT VE5fRU4gfAo+ICsJICAgICAgRFBUWF9TWVNfQ0xLX0VOIHwKPiArCSAgICAgIENGR19EUFRYX1ZJ Rl9DTEtfUlNUTl9FTiB8Cj4gKwkgICAgICBDRkdfRFBUWF9WSUZfQ0xLX0VOOwo+ICsJd3JpdGVs KHZhbCwgZHAtPnJlZ3MgKyBTT1VSQ0VfRFBUWF9DQVIpOwo+ICsKPiArCXZhbCA9IFNPVVJDRV9Q SFlfUlNUTl9FTiB8IFNPVVJDRV9QSFlfQ0xLX0VOOwo+ICsJd3JpdGVsKHZhbCwgZHAtPnJlZ3Mg KyBTT1VSQ0VfUEhZX0NBUik7Cj4gKwo+ICsJdmFsID0gU09VUkNFX1BLVF9TWVNfUlNUTl9FTiB8 Cj4gKwkgICAgICBTT1VSQ0VfUEtUX1NZU19DTEtfRU4gfAo+ICsJICAgICAgU09VUkNFX1BLVF9E QVRBX1JTVE5fRU4gfAo+ICsJICAgICAgU09VUkNFX1BLVF9EQVRBX0NMS19FTjsKPiArCXdyaXRl bCh2YWwsIGRwLT5yZWdzICsgU09VUkNFX1BLVF9DQVIpOwo+ICsKPiArCXZhbCA9IFNQRElGX0NE Ul9DTEtfUlNUTl9FTiB8Cj4gKwkgICAgICBTUERJRl9DRFJfQ0xLX0VOIHwKPiArCSAgICAgIFNP VVJDRV9BSUZfU1lTX1JTVE5fRU4gfAo+ICsJICAgICAgU09VUkNFX0FJRl9TWVNfQ0xLX0VOIHwK PiArCSAgICAgIFNPVVJDRV9BSUZfQ0xLX1JTVE5fRU4gfAo+ICsJICAgICAgU09VUkNFX0FJRl9D TEtfRU47Cj4gKwl3cml0ZWwodmFsLCBkcC0+cmVncyArIFNPVVJDRV9BSUZfQ0FSKTsKPiArCj4g Kwl2YWwgPSBTT1VSQ0VfQ0lQSEVSX1NZU1RFTV9DTEtfUlNUTl9FTiB8Cj4gKwkgICAgICBTT1VS Q0VfQ0lQSEVSX1NZU19DTEtfRU4gfAo+ICsJICAgICAgU09VUkNFX0NJUEhFUl9DSEFSX0NMS19S U1ROX0VOIHwKPiArCSAgICAgIFNPVVJDRV9DSVBIRVJfQ0hBUl9DTEtfRU47Cj4gKwl3cml0ZWwo dmFsLCBkcC0+cmVncyArIFNPVVJDRV9DSVBIRVJfQ0FSKTsKPiArCj4gKwl2YWwgPSBTT1VSQ0Vf Q1JZUFRPX1NZU19DTEtfUlNUTl9FTiB8Cj4gKwkgICAgICBTT1VSQ0VfQ1JZUFRPX1NZU19DTEtf RU47Cj4gKwl3cml0ZWwodmFsLCBkcC0+cmVncyArIFNPVVJDRV9DUllQVE9fQ0FSKTsKPiArCj4g Kwl2YWwgPSB+KE1BSUxCT1hfSU5UX01BU0tfQklUIHwgUElGX0lOVF9NQVNLX0JJVCkgJiBBTExf SU5UX01BU0s7Cj4gKwl3cml0ZWwodmFsLCBkcC0+cmVncyArIEFQQl9JTlRfTUFTSyk7Cj4gK30K PiArCj4gK3N0YXRpYyBpbnQgY2RuX2RwX21haWxib3hfcmVhZChzdHJ1Y3QgY2RuX2RwX2Rldmlj ZSAqZHApCj4gK3sKPiArCWludCB2YWwsIHJldDsKPiArCj4gKwlpZiAoIWRwLT5md19sb2FkZWQp Cj4gKwkJcmV0dXJuIC1FUEVSTTsKPiArCj4gKwlyZXQgPSByZWFkeF9wb2xsX3RpbWVvdXQocmVh ZGwsIGRwLT5yZWdzICsgTUFJTEJPWF9FTVBUWV9BRERSLAo+ICsJCQkJIHZhbCwgIXZhbCwgTUFJ TEJPWF9SRVRSWV9VUywKPiArCQkJCSBNQUlMQk9YX1RJTUVPVVRfVVMpOwo+ICsJaWYgKHJldCA8 IDApIHsKPiArCQlkZXZfZXJyKGRwLT5kZXYsICJmYWlsZWQgdG8gcmVhZCBtYWlsYm94LCBrZWVw IGFsaXZlID0gJXhcbiIsCj4gKwkJCXJlYWRsKGRwLT5yZWdzICsgS0VFUF9BTElWRSkpOwo+ICsJ CXJldHVybiByZXQ7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIHJlYWRsKGRwLT5yZWdzICsgTUFJTEJP WDBfUkRfREFUQSkgJiAweGZmOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGNkcF9kcF9tYWlsYm94 X3dyaXRlKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgdTggdmFsKQo+ICt7Cj4gKwlpbnQgcmV0 LCBmdWxsOwo+ICsKPiArCWlmICghZHAtPmZ3X2xvYWRlZCkKPiArCQlyZXR1cm4gLUVQRVJNOwo+ ICsKPiArCXJldCA9IHJlYWR4X3BvbGxfdGltZW91dChyZWFkbCwgZHAtPnJlZ3MgKyBNQUlMQk9Y X0ZVTExfQUREUiwKPiArCQkJCSBmdWxsLCAhZnVsbCwgTUFJTEJPWF9SRVRSWV9VUywKPiArCQkJ CSBNQUlMQk9YX1RJTUVPVVRfVVMpOwo+ICsJaWYgKHJldCA8IDApIHsKPiArCQlkZXZfZXJyKGRw LT5kZXYsICJtYWlsYm94IGlzIGZ1bGwsIGtlZXAgYWxpdmUgPSAleFxuIiwKPiArCQkJcmVhZGwo ZHAtPnJlZ3MgKyBLRUVQX0FMSVZFKSk7Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0KPiArCj4gKwl3 cml0ZWwodmFsLCBkcC0+cmVncyArIE1BSUxCT1gwX1dSX0RBVEEpOwo+ICsKPiArCXJldHVybiAw Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGNkbl9kcF9tYWlsYm94X3ZhbGlkYXRlX3JlY2VpdmUo c3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLAo+ICsJCQkJCSAgIHU4IG1vZHVsZV9pZCwgdTggb3Bj b2RlLAo+ICsJCQkJCSAgIHU4IHJlcV9zaXplKQo+ICt7Cj4gKwl1MzIgbWJveF9zaXplLCBpOwo+ ICsJdTggaGVhZGVyWzRdOwo+ICsJaW50IHJldDsKPiArCj4gKwkvKiByZWFkIHRoZSBoZWFkZXIg b2YgdGhlIG1lc3NhZ2UgKi8KPiArCWZvciAoaSA9IDA7IGkgPCA0OyBpKyspICB7Cj4gKwkJcmV0 ID0gY2RuX2RwX21haWxib3hfcmVhZChkcCk7Cj4gKwkJaWYgKHJldCA8IDApCj4gKwkJCXJldHVy biByZXQ7Cj4gKwo+ICsJCWhlYWRlcltpXSA9IHJldDsKPiArCX0KPiArCj4gKwltYm94X3NpemUg PSAoaGVhZGVyWzJdIDw8IDgpIHwgaGVhZGVyWzNdOwo+ICsKPiArCWlmIChvcGNvZGUgIT0gaGVh ZGVyWzBdIHx8IG1vZHVsZV9pZCAhPSBoZWFkZXJbMV0gfHwKPiArCSAgICByZXFfc2l6ZSAhPSBt Ym94X3NpemUpIHsKPiArCQlkZXZfZXJyKGRwLT5kZXYsICJtYWlsYm94IHZhbGlkYXRlIGZhaWxl ZCIpOwo+ICsKPiArCQkvKgo+ICsJCSAqIElmIHRoZSBtZXNzYWdlIGluIG1haWxib3ggaXMgbm90 IHdoYXQgd2Ugd2FudCwgd2UgbmVlZCB0bwo+ICsJCSAqIGNsZWFyIHRoZSBtYWlsYm94IGJ5IHJl YWQuCj4gKwkJICovCj4gKwkJZm9yIChpID0gMDsgaSA8IG1ib3hfc2l6ZTsgaSsrKQo+ICsJCQlp ZiAoY2RuX2RwX21haWxib3hfcmVhZChkcCkgPCAwKQo+ICsJCQkJYnJlYWs7Cj4gKwo+ICsJCXJl dHVybiAtRUlOVkFMOwo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMg aW50IGNkbl9kcF9tYWlsYm94X3JlYWRfcmVjZWl2ZShzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAs Cj4gKwkJCQkgICAgICAgdTggKmJ1ZmYsIHU4IGJ1ZmZfc2l6ZSkKPiArewo+ICsJdTMyIGk7Cj4g KwlpbnQgcmV0Owo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBidWZmX3NpemU7IGkrKykgewo+ICsJ CXJldCA9IGNkbl9kcF9tYWlsYm94X3JlYWQoZHApOwo+ICsJCWlmIChyZXQgPCAwKQo+ICsJCQly ZXR1cm4gcmV0Owo+ICsKPiArCQlidWZmW2ldID0gcmV0Owo+ICsJfQo+ICsKPiArCXJldHVybiAw Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGNkbl9kcF9tYWlsYm94X3NlbmQoc3RydWN0IGNkbl9k cF9kZXZpY2UgKmRwLCB1OCBtb2R1bGVfaWQsCj4gKwkJCSAgICAgICB1OCBvcGNvZGUsIHUxNiBz aXplLCB1OCAqbWVzc2FnZSkKPiArewo+ICsJdTggaGVhZGVyWzRdOwo+ICsJaW50IHJldCwgaTsK PiArCj4gKwloZWFkZXJbMF0gPSBvcGNvZGU7Cj4gKwloZWFkZXJbMV0gPSBtb2R1bGVfaWQ7Cj4g KwloZWFkZXJbMl0gPSAoc2l6ZSA+PiA4KSAmIDB4ZmY7Cj4gKwloZWFkZXJbM10gPSBzaXplICYg MHhmZjsKPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgNDsgaSsrKSB7Cj4gKwkJcmV0ID0gY2RwX2Rw X21haWxib3hfd3JpdGUoZHAsIGhlYWRlcltpXSk7Cj4gKwkJaWYgKHJldCkKPiArCQkJcmV0dXJu IHJldDsKPiArCX0KPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgc2l6ZTsgaSsrKSB7Cj4gKwkJcmV0 ID0gY2RwX2RwX21haWxib3hfd3JpdGUoZHAsIG1lc3NhZ2VbaV0pOwo+ICsJCWlmIChyZXQpIHsK PiArCQkJZGV2X2VycihkcC0+ZGV2LCAibWFpbGJveCBzZW5kIGZhaWxlZDogJWQiLCByZXQpOwo+ ICsJCQlyZXR1cm4gcmV0Owo+ICsJCX0KPiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsK PiArc3RhdGljIGludCBjZG5fZHBfcmVnX3dyaXRlKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwg dTE2IGFkZHIsIHUzMiB2YWwpCj4gK3sKPiArCXU4IG1zZ1s2XTsKPiArCj4gKwltc2dbMF0gPSAo YWRkciA+PiA4KSAmIDB4ZmY7Cj4gKwltc2dbMV0gPSBhZGRyICYgMHhmZjsKPiArCW1zZ1syXSA9 ICh2YWwgPj4gMjQpICYgMHhmZjsKPiArCW1zZ1szXSA9ICh2YWwgPj4gMTYpICYgMHhmZjsKPiAr CW1zZ1s0XSA9ICh2YWwgPj4gOCkgJiAweGZmOwo+ICsJbXNnWzVdID0gdmFsICYgMHhmZjsKPiAr CXJldHVybiBjZG5fZHBfbWFpbGJveF9zZW5kKGRwLCBNQl9NT0RVTEVfSURfRFBfVFgsIERQVFhf V1JJVEVfUkVHSVNURVIsCj4gKwkJCQkgICBzaXplb2YobXNnKSwgbXNnKTsKPiArfQo+ICsKPiAr aW50IGNkbl9kcF9kcGNkX3JlYWQoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLCB1MzIgYWRkciwg dTggKmRhdGEsIHUxNiBsZW4pCj4gK3sKPiArCXU4IG1zZ1s1XSwgcmVnWzVdOwo+ICsJaW50IHJl dDsKPiArCj4gKwltc2dbMF0gPSAobGVuID4+IDgpICYgMHhmZjsKPiArCW1zZ1sxXSA9IGxlbiAm IDB4ZmY7Cj4gKwltc2dbMl0gPSAoYWRkciA+PiAxNikgJiAweGZmOwo+ICsJbXNnWzNdID0gKGFk ZHIgPj4gOCkgJiAweGZmOwo+ICsJbXNnWzRdID0gYWRkciAmIDB4ZmY7Cj4gKwljZG5fZHBfbWFp bGJveF9zZW5kKGRwLCBNQl9NT0RVTEVfSURfRFBfVFgsIERQVFhfUkVBRF9EUENELAo+ICsJCQkg ICAgc2l6ZW9mKG1zZyksIG1zZyk7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX21haWxib3hfdmFsaWRh dGVfcmVjZWl2ZShkcCwgTUJfTU9EVUxFX0lEX0RQX1RYLAo+ICsJCQkJCSAgICAgIERQVFhfUkVB RF9EUENELAo+ICsJCQkJCSAgICAgIHNpemVvZihyZWcpICsgbGVuKTsKPiArCWlmIChyZXQpCj4g KwkJcmV0dXJuIHJldDsKPiArCj4gKwlyZXQgPSBjZG5fZHBfbWFpbGJveF9yZWFkX3JlY2VpdmUo ZHAsIHJlZywgc2l6ZW9mKHJlZykpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsK PiArCXJldHVybiBjZG5fZHBfbWFpbGJveF9yZWFkX3JlY2VpdmUoZHAsIGRhdGEsIGxlbik7Cj4g K30KPiArCj4gK2ludCBjZG5fZHBfZHBjZF93cml0ZShzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAs IHUzMiBhZGRyLCB1OCB2YWx1ZSkKPiArewo+ICsJdTggbXNnWzZdLCByZWdbNV07Cj4gKwlpbnQg cmV0Owo+ICsKPiArCW1zZ1swXSA9IDA7Cj4gKwltc2dbMV0gPSAxOwo+ICsJbXNnWzJdID0gKGFk ZHIgPj4gMTYpICYgMHhmZjsKPiArCW1zZ1szXSA9IChhZGRyID4+IDgpICYgMHhmZjsKPiArCW1z Z1s0XSA9IGFkZHIgJiAweGZmOwo+ICsJbXNnWzVdID0gdmFsdWU7Cj4gKwljZG5fZHBfbWFpbGJv eF9zZW5kKGRwLCBNQl9NT0RVTEVfSURfRFBfVFgsIERQVFhfV1JJVEVfRFBDRCwKPiArCQkJICAg IHNpemVvZihtc2cpLCBtc2cpOwo+ICsKPiArCXJldCA9IGNkbl9kcF9tYWlsYm94X3ZhbGlkYXRl X3JlY2VpdmUoZHAsIE1CX01PRFVMRV9JRF9EUF9UWCwKPiArCQkJCQkgICAgICBEUFRYX1dSSVRF X0RQQ0QsIHNpemVvZihyZWcpKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4g KwlyZXQgPSBjZG5fZHBfbWFpbGJveF9yZWFkX3JlY2VpdmUoZHAsIHJlZywgc2l6ZW9mKHJlZykp Owo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCWlmIChhZGRyICE9IChyZWdb Ml0gPDwgMTYgfCByZWdbM10gPDwgOCB8IHJlZ1s0XSkpIHsKPiArCQlkZXZfZXJyKGRwLT5kZXYs ICJ3cml0ZSBkcGNkIGZhaWxlZFxuIik7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK2ludCBjZG5fZHBfbG9hZF9maXJtd2FyZShzdHJ1Y3Qg Y2RuX2RwX2RldmljZSAqZHAsIGNvbnN0IHUzMiAqaV9tZW0sCj4gKwkJCSB1MzIgaV9zaXplLCBj b25zdCB1MzIgKmRfbWVtLCB1MzIgZF9zaXplKQo+ICt7Cj4gKwlpbnQgaSwgcmV0Owo+ICsJdTMy IHJlZzsKPiArCj4gKwkvKiByZXNldCB1Y3B1IGJlZm9yZSBsb2FkIGZpcm13YXJlKi8KPiArCXdy aXRlbChBUEJfSVJBTV9QQVRIIHwgQVBCX0RSQU1fUEFUSCB8IEFQQl9YVF9SRVNFVCwKPiArCSAg ICAgICBkcC0+cmVncyArIEFQQl9DVFJMKTsKPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgaV9zaXpl OyBpICs9IDQpCj4gKwkJd3JpdGVsKCppX21lbSsrLCBkcC0+cmVncyArIEFERFJfSU1FTSArIGkp Owo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBkX3NpemU7IGkgKz0gNCkKPiArCQl3cml0ZWwoKmRf bWVtKyssIGRwLT5yZWdzICsgQUREUl9ETUVNICsgaSk7Cj4gKwo+ICsJLyogdW4tcmVzZXQgdWNw dSAqLwo+ICsJd3JpdGVsKDAsIGRwLT5yZWdzICsgQVBCX0NUUkwpOwo+ICsKPiArCS8qIGNoZWNr IHRoZSBrZWVwIGFsaXZlIHJlZ2lzdGVyIHRvIG1ha2Ugc3VyZSBmdyB3b3JraW5nICovCj4gKwly ZXQgPSByZWFkeF9wb2xsX3RpbWVvdXQocmVhZGwsIGRwLT5yZWdzICsgS0VFUF9BTElWRSwKPiAr CQkJCSByZWcsIHJlZywgMjAwMCwgRldfQUxJVkVfVElNRU9VVF9VUyk7Cj4gKwlpZiAocmV0IDwg MCkgewo+ICsJCWRldl9lcnIoZHAtPmRldiwgImZhaWxlZCB0byBsb2FkZWQgdGhlIEZXIHJlZyA9 ICV4XG4iLCByZWcpOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsKPiArCXJlZyA9IHJl YWRsKGRwLT5yZWdzICsgVkVSX0wpICYgMHhmZjsKPiArCWRwLT5md192ZXJzaW9uID0gcmVnOwo+ ICsJcmVnID0gcmVhZGwoZHAtPnJlZ3MgKyBWRVJfSCkgJiAweGZmOwo+ICsJZHAtPmZ3X3ZlcnNp b24gfD0gcmVnIDw8IDg7Cj4gKwlyZWcgPSByZWFkbChkcC0+cmVncyArIFZFUl9MSUJfTF9BRERS KSAmIDB4ZmY7Cj4gKwlkcC0+ZndfdmVyc2lvbiB8PSByZWcgPDwgMTY7Cj4gKwlyZWcgPSByZWFk bChkcC0+cmVncyArIFZFUl9MSUJfSF9BRERSKSAmIDB4ZmY7Cj4gKwlkcC0+ZndfdmVyc2lvbiB8 PSByZWcgPDwgMjQ7Cj4gKwo+ICsJZGV2X2RiZyhkcC0+ZGV2LCAiZmlybXdhcmUgdmVyc2lvbjog JXhcbiIsIGRwLT5md192ZXJzaW9uKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiAraW50 IGNkbl9kcF9yZWdfd3JpdGVfYml0KHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgdTE2IGFkZHIs IHU4IHN0YXJ0X2JpdCwKPiArCQkJIHU4IGJpdHNfbm8sIHUzMiB2YWwpCj4gK3sKPiArCXU4IGZp ZWxkWzhdOwo+ICsKPiArCWZpZWxkWzBdID0gKGFkZHIgPj4gOCkgJiAweGZmOwo+ICsJZmllbGRb MV0gPSBhZGRyICYgMHhmZjsKPiArCWZpZWxkWzJdID0gc3RhcnRfYml0Owo+ICsJZmllbGRbM10g PSBiaXRzX25vOwo+ICsJZmllbGRbNF0gPSAodmFsID4+IDI0KSAmIDB4ZmY7Cj4gKwlmaWVsZFs1 XSA9ICh2YWwgPj4gMTYpICYgMHhmZjsKPiArCWZpZWxkWzZdID0gKHZhbCA+PiA4KSAmIDB4ZmY7 Cj4gKwlmaWVsZFs3XSA9IHZhbCAmIDB4ZmY7Cj4gKwo+ICsJcmV0dXJuIGNkbl9kcF9tYWlsYm94 X3NlbmQoZHAsIE1CX01PRFVMRV9JRF9EUF9UWCwgRFBUWF9XUklURV9GSUVMRCwKPiArCQkJCSAg IHNpemVvZihmaWVsZCksIGZpZWxkKTsKPiArfQo+ICsKPiAraW50IGNkbl9kcF9hY3RpdmUoc3Ry dWN0IGNkbl9kcF9kZXZpY2UgKmRwLCBib29sIGVuYWJsZSkKPiArewo+ICsJdTggYWN0aXZlID0g ZW5hYmxlID8gMSA6IDA7Cj4gKwl1OCByZXNwOwo+ICsJaW50IHJldDsKPiArCj4gKwkvKiBzZXQg ZmlybXdhcmUgc3RhdHVzLCAxOiBhY3RpdmU7IDA6IHN0YW5kYnkgKi8KPiArCXJldCA9IGNkbl9k cF9tYWlsYm94X3NlbmQoZHAsIE1CX01PRFVMRV9JRF9HRU5FUkFMLAo+ICsJCQkJICBHRU5FUkFM X01BSU5fQ09OVFJPTCwgc2l6ZW9mKGFjdGl2ZSksCj4gKwkJCQkgICZhY3RpdmUpOwo+ICsJaWYg KHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJldCA9IGNkbl9kcF9tYWlsYm94X3ZhbGlk YXRlX3JlY2VpdmUoZHAsIE1CX01PRFVMRV9JRF9HRU5FUkFMLAo+ICsJCQkJCSAgICAgIEdFTkVS QUxfTUFJTl9DT05UUk9MLAo+ICsJCQkJCSAgICAgIHNpemVvZihyZXNwKSk7Cj4gKwlpZiAocmV0 KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX21haWxib3hfcmVhZF9yZWNl aXZlKGRwLCAmcmVzcCwgc2l6ZW9mKHJlc3ApKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJl dDsKPiArCj4gKwlyZXR1cm4gcmVzcCA/IDAgOiAtRUlOVkFMOwo+ICt9Cj4gKwo+ICtpbnQgY2Ru X2RwX3NldF9ob3N0X2NhcChzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAsIHU4IGxhbmVzKQo+ICt7 Cj4gKwl1OCBtc2dbOF07Cj4gKwlpbnQgcmV0Owo+ICsKPiArCW1zZ1swXSA9IENETl9EUF9NQVhf TElOS19SQVRFOwo+ICsJbXNnWzFdID0gbGFuZXM7Cj4gKwltc2dbMl0gPSBWT0xUQUdFX0xFVkVM XzI7Cj4gKwltc2dbM10gPSBQUkVfRU1QSEFTSVNfTEVWRUxfMzsKPiArCW1zZ1s0XSA9IFBUUzEg fCBQVFMyIHwgUFRTMyB8IFBUUzQ7Cj4gKwltc2dbNV0gPSBGQVNUX0xUX05PVF9TVVBQT1JUOwo+ ICsJbXNnWzZdID0gTEFORV9NQVBQSU5HX05PUk1BTDsKPiArCW1zZ1s3XSA9IEVOSEFOQ0VEOwo+ ICsKPiArCXJldCA9IGNkbl9kcF9tYWlsYm94X3NlbmQoZHAsIE1CX01PRFVMRV9JRF9EUF9UWCwK PiArCQkJCSAgRFBUWF9TRVRfSE9TVF9DQVBBQklMSVRJRVMsCj4gKwkJCQkgIHNpemVvZihtc2cp LCBtc2cpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJldCA9IGNkbl9k cF9yZWdfd3JpdGUoZHAsIERQX0FVWF9TV0FQX0lOVkVSU0lPTl9DT05UUk9MLAo+ICsJCQkgICAg ICAgQVVYX0hPU1RfSU5WRVJUKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4g KwlyZXR1cm4gMDsKPiArfQo+ICsKPiAraW50IGNkbl9kcF9ldmVudF9jb25maWcoc3RydWN0IGNk bl9kcF9kZXZpY2UgKmRwKQo+ICt7Cj4gKwl1OCBtc2dbNV07Cj4gKwo+ICsJbWVtc2V0KG1zZywg MCwgc2l6ZW9mKG1zZykpOwo+ICsKPiArCW1zZ1swXSA9IERQVFhfRVZFTlRfRU5BQkxFX0hQRCB8 IERQVFhfRVZFTlRfRU5BQkxFX1RSQUlOSU5HOwo+ICsKPiArCXJldHVybiBjZG5fZHBfbWFpbGJv eF9zZW5kKGRwLCBNQl9NT0RVTEVfSURfRFBfVFgsIERQVFhfRU5BQkxFX0VWRU5ULAo+ICsJCQkJ ICAgc2l6ZW9mKG1zZyksIG1zZyk7Cj4gK30KPiArCj4gK3UzMiBjZG5fZHBfZ2V0X2V2ZW50KHN0 cnVjdCBjZG5fZHBfZGV2aWNlICpkcCkKPiArewo+ICsJcmV0dXJuIHJlYWRsKGRwLT5yZWdzICsg U1dfRVZFTlRTMCk7Cj4gK30KPiArCj4gK2ludCBjZG5fZHBfZ2V0X2hwZF9zdGF0dXMoc3RydWN0 IGNkbl9kcF9kZXZpY2UgKmRwKQo+ICt7Cj4gKwl1OCBzdGF0dXM7Cj4gKwlpbnQgcmV0Owo+ICsK PiArCXJldCA9IGNkbl9kcF9tYWlsYm94X3NlbmQoZHAsIE1CX01PRFVMRV9JRF9EUF9UWCwgRFBU WF9IUERfU1RBVEUsCj4gKwkJCQkgIDAsIE5VTEwpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4g cmV0Owo+ICsKPiArCXJldCA9IGNkbl9kcF9tYWlsYm94X3ZhbGlkYXRlX3JlY2VpdmUoZHAsIE1C X01PRFVMRV9JRF9EUF9UWCwKPiArCQkJCQkgICAgICBEUFRYX0hQRF9TVEFURSwgc2l6ZW9mKHN0 YXR1cykpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJldCA9IGNkbl9k cF9tYWlsYm94X3JlYWRfcmVjZWl2ZShkcCwgJnN0YXR1cywgc2l6ZW9mKHN0YXR1cykpOwo+ICsJ aWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJldHVybiBzdGF0dXM7Cj4gK30KPiAr Cj4gK2ludCBjZG5fZHBfZ2V0X2VkaWRfYmxvY2sodm9pZCAqZGF0YSwgdTggKmVkaWQsCj4gKwkJ CSAgdW5zaWduZWQgaW50IGJsb2NrLCBzaXplX3QgbGVuZ3RoKQo+ICt7Cj4gKwlzdHJ1Y3QgY2Ru X2RwX2RldmljZSAqZHAgPSBkYXRhOwo+ICsJdTggbXNnWzJdLCByZWdbMl07Cj4gKwlpbnQgcmV0 Owo+ICsKPiArCW1zZ1swXSA9IGJsb2NrIC8gMjsKPiArCW1zZ1sxXSA9IGJsb2NrICUgMjsKPiAr Cj4gKwlyZXQgPSBjZG5fZHBfbWFpbGJveF9zZW5kKGRwLCBNQl9NT0RVTEVfSURfRFBfVFgsIERQ VFhfR0VUX0VESUQsCj4gKwkJCQkgIHNpemVvZihtc2cpLCBtc2cpOwo+ICsJaWYgKHJldCkKPiAr CQlyZXR1cm4gcmV0Owo+ICsKPiArCXJldCA9IGNkbl9kcF9tYWlsYm94X3ZhbGlkYXRlX3JlY2Vp dmUoZHAsIE1CX01PRFVMRV9JRF9EUF9UWCwKPiArCQkJCQkgICAgICBEUFRYX0dFVF9FRElELAo+ ICsJCQkJCSAgICAgIHNpemVvZihyZWcpICsgbGVuZ3RoKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0 dXJuIHJldDsKPiArCj4gKwlyZXQgPSBjZG5fZHBfbWFpbGJveF9yZWFkX3JlY2VpdmUoZHAsIHJl Zywgc2l6ZW9mKHJlZykpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJl dCA9IGNkbl9kcF9tYWlsYm94X3JlYWRfcmVjZWl2ZShkcCwgZWRpZCwgbGVuZ3RoKTsKPiArCWlm IChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwlpZiAocmVnWzBdICE9IGxlbmd0aCB8fCBy ZWdbMV0gIT0gYmxvY2sgLyAyKSB7Cj4gKwkJZGV2X2VycihkcC0+ZGV2LCAiZWRpZCBibG9jayBz aXplIGVyclxuIik7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIDA7 Cj4gK30KPiArCj4gK2ludCBjZG5fZHBfdHJhaW5pbmdfc3RhcnQoc3RydWN0IGNkbl9kcF9kZXZp Y2UgKmRwKQo+ICt7Cj4gKwl1OCBtc2csIGV2ZW50WzJdOwo+ICsJdW5zaWduZWQgbG9uZyB0aW1l b3V0Owo+ICsJaW50IHJldDsKPiArCj4gKwltc2cgPSBMSU5LX1RSQUlOSU5HX1JVTjsKPiArCj4g KwkvKiBzdGFydCB0cmFpbmluZyAqLwo+ICsJcmV0ID0gY2RuX2RwX21haWxib3hfc2VuZChkcCwg TUJfTU9EVUxFX0lEX0RQX1RYLCBEUFRYX1RSQUlOSU5HX0NPTlRST0wsCj4gKwkJCQkgIHNpemVv Zihtc2cpLCAmbXNnKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwl0aW1l b3V0ID0gamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoTElOS19UUkFJTklOR19USU1FT1VUX01T KTsKPiArCXdoaWxlICh0aW1lX2JlZm9yZShqaWZmaWVzLCB0aW1lb3V0KSkgewo+ICsJCW1zbGVl cChMSU5LX1RSQUlOSU5HX1JFVFJZX01TKTsKPiArCQlyZXQgPSBjZG5fZHBfbWFpbGJveF9zZW5k KGRwLCBNQl9NT0RVTEVfSURfRFBfVFgsCj4gKwkJCQkJICBEUFRYX1JFQURfRVZFTlQsIDAsIE5V TEwpOwo+ICsJCWlmIChyZXQpCj4gKwkJCXJldHVybiByZXQ7Cj4gKwo+ICsJCXJldCA9IGNkbl9k cF9tYWlsYm94X3ZhbGlkYXRlX3JlY2VpdmUoZHAsIE1CX01PRFVMRV9JRF9EUF9UWCwKPiArCQkJ CQkJICAgICAgRFBUWF9SRUFEX0VWRU5ULAo+ICsJCQkJCQkgICAgICBzaXplb2YoZXZlbnQpKTsK PiArCQlpZiAocmV0KQo+ICsJCQlyZXR1cm4gcmV0Owo+ICsKPiArCQlyZXQgPSBjZG5fZHBfbWFp bGJveF9yZWFkX3JlY2VpdmUoZHAsIGV2ZW50LCBzaXplb2YoZXZlbnQpKTsKPiArCQlpZiAocmV0 KQo+ICsJCQlyZXR1cm4gcmV0Owo+ICsKPiArCQlpZiAoZXZlbnRbMV0gJiBFUV9QSEFTRV9GSU5J U0hFRCkKPiArCQkJcmV0dXJuIDA7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIC1FVElNRURPVVQ7Cj4g K30KPiArCj4gK2ludCBjZG5fZHBfZ2V0X3RyYWluaW5nX3N0YXR1cyhzdHJ1Y3QgY2RuX2RwX2Rl dmljZSAqZHApCj4gK3sKPiArCXU4IHN0YXR1c1sxMF07Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJl dCA9IGNkbl9kcF9tYWlsYm94X3NlbmQoZHAsIE1CX01PRFVMRV9JRF9EUF9UWCwgRFBUWF9SRUFE X0xJTktfU1RBVCwKPiArCQkJCSAgMCwgTlVMTCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiBy ZXQ7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX21haWxib3hfdmFsaWRhdGVfcmVjZWl2ZShkcCwgTUJf TU9EVUxFX0lEX0RQX1RYLAo+ICsJCQkJCSAgICAgIERQVFhfUkVBRF9MSU5LX1NUQVQsCj4gKwkJ CQkJICAgICAgc2l6ZW9mKHN0YXR1cykpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ ICsKPiArCXJldCA9IGNkbl9kcF9tYWlsYm94X3JlYWRfcmVjZWl2ZShkcCwgc3RhdHVzLCBzaXpl b2Yoc3RhdHVzKSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJZHAtPmxp bmsucmF0ZSA9IHN0YXR1c1swXTsKPiArCWRwLT5saW5rLm51bV9sYW5lcyA9IHN0YXR1c1sxXTsK PiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiAraW50IGNkbl9kcF9zZXRfdmlkZW9fc3RhdHVz KHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgaW50IGFjdGl2ZSkKPiArewo+ICsJdTggbXNnOwo+ ICsKPiArCW1zZyA9ICEhYWN0aXZlOwo+ICsKPiArCXJldHVybiBjZG5fZHBfbWFpbGJveF9zZW5k KGRwLCBNQl9NT0RVTEVfSURfRFBfVFgsIERQVFhfU0VUX1ZJREVPLAo+ICsJCQkJICAgc2l6ZW9m KG1zZyksICZtc2cpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGNkbl9kcF9nZXRfbXNhX21pc2Mo c3RydWN0IHZpZGVvX2luZm8gKnZpZGVvLAo+ICsJCQkgICAgICAgc3RydWN0IGRybV9kaXNwbGF5 X21vZGUgKm1vZGUpCj4gK3sKPiArCXU4IHZhbFsyXTsKPiArCXUzMiBtc2FfbWlzYzsKPiArCj4g Kwlzd2l0Y2ggKHZpZGVvLT5jb2xvcl9mbXQpIHsKPiArCWNhc2UgUFhMX1JHQjoKPiArCWNhc2Ug WV9PTkxZOgo+ICsJCXZhbFswXSA9IDA7Cj4gKwkJYnJlYWs7Cj4gKwkvKiBzZXQgWVVWIGRlZmF1 bHQgY29sb3Igc3BhY2UgY29udmVyc2lvbiB0byBCVDYwMSAqLwo+ICsJY2FzZSBZQ0JDUl80XzRf NDoKPiArCQl2YWxbMF0gPSA2ICsgQlRfNjAxICogODsKPiArCQlicmVhazsKPiArCWNhc2UgWUNC Q1JfNF8yXzI6Cj4gKwkJdmFsWzBdID0gNSArIEJUXzYwMSAqIDg7Cj4gKwkJYnJlYWs7Cj4gKwlj YXNlIFlDQkNSXzRfMl8wOgo+ICsJCXZhbFswXSA9IDU7Cj4gKwkJYnJlYWs7Cj4gKwl9Owo+ICsK PiArCXN3aXRjaCAodmlkZW8tPmNvbG9yX2RlcHRoKSB7Cj4gKwljYXNlIDY6Cj4gKwkJdmFsWzFd ID0gMDsKPiArCQlicmVhazsKPiArCWNhc2UgODoKPiArCQl2YWxbMV0gPSAxOwo+ICsJCWJyZWFr Owo+ICsJY2FzZSAxMDoKPiArCQl2YWxbMV0gPSAyOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSAxMjoK PiArCQl2YWxbMV0gPSAzOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSAxNjoKPiArCQl2YWxbMV0gPSA0 Owo+ICsJCWJyZWFrOwo+ICsJfTsKPiArCj4gKwltc2FfbWlzYyA9IDIgKiB2YWxbMF0gKyAzMiAq IHZhbFsxXSArCj4gKwkJICAgKCh2aWRlby0+Y29sb3JfZm10ID09IFlfT05MWSkgPyAoMSA8PCAx NCkgOiAwKTsKPiArCj4gKwlyZXR1cm4gbXNhX21pc2M7Cj4gK30KPiArCj4gK2ludCBjZG5fZHBf Y29uZmlnX3ZpZGVvKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCkKPiArewo+ICsJc3RydWN0IHZp ZGVvX2luZm8gKnZpZGVvID0gJmRwLT52aWRlb19pbmZvOwo+ICsJc3RydWN0IGRybV9kaXNwbGF5 X21vZGUgKm1vZGUgPSAmZHAtPm1vZGU7Cj4gKwl1NjQgc3ltYm9sOwo+ICsJdTMyIHZhbCwgbGlu a19yYXRlOwo+ICsJdTggYml0X3Blcl9waXg7Cj4gKwl1OCB0dV9zaXplX3JlZyA9IFRVX1NJWkU7 Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWJpdF9wZXJfcGl4ID0gKHZpZGVvLT5jb2xvcl9mbXQgPT0g WUNCQ1JfNF8yXzIpID8KPiArCQkgICAgICAodmlkZW8tPmNvbG9yX2RlcHRoICogMikgOiAodmlk ZW8tPmNvbG9yX2RlcHRoICogMyk7Cj4gKwo+ICsJbGlua19yYXRlID0gZHJtX2RwX2J3X2NvZGVf dG9fbGlua19yYXRlKGRwLT5saW5rLnJhdGUpOwo+ICsKPiArCXZhbCA9IFZJRl9CWVBBU1NfSU5U RVJMQUNFOwo+ICsJcmV0ID0gY2RuX2RwX3JlZ193cml0ZShkcCwgQk5EX0hTWU5DMlZTWU5DLCB2 YWwpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJldCA9IGNkbl9kcF9y ZWdfd3JpdGUoZHAsIEhTWU5DMlZTWU5DX1BPTF9DVFJMLCAwKTsKPiArCWlmIChyZXQpCj4gKwkJ cmV0dXJuIHJldDsKPiArCj4gKwkvKiBnZXQgYSBiZXN0IHR1X3NpemUgYW5kIHN5bWJvbCAqLwo+ ICsJZG8gewo+ICsJCXR1X3NpemVfcmVnICs9IDI7Cj4gKwkJc3ltYm9sID0gdHVfc2l6ZV9yZWcg KiBtb2RlLT5jbG9jayAqIGJpdF9wZXJfcGl4Owo+ICsJCXN5bWJvbCAvPSBkcC0+bGluay5udW1f bGFuZXMgKiBsaW5rX3JhdGUgKiA4Owo+ICsJfSB3aGlsZSAoKHN5bWJvbCA9PSAxKSB8fCAodHVf c2l6ZV9yZWcgLSBzeW1ib2wgPCA0KSk7Cj4gKwo+ICsJdmFsID0gc3ltYm9sICsgKHR1X3NpemVf cmVnIDw8IDgpOwo+ICsJcmV0ID0gY2RuX2RwX3JlZ193cml0ZShkcCwgRFBfRlJBTUVSX1RVLCB2 YWwpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCS8qIHNldCB0aGUgRklG TyBCdWZmZXIgc2l6ZSAqLwo+ICsJdmFsID0gKChtb2RlLT5jbG9jayAqIChzeW1ib2wgKyAxKSAv IDEwMDApICsgbGlua19yYXRlKTsKPiArCXZhbCAvPSAoZHAtPmxpbmsubnVtX2xhbmVzICogbGlu a19yYXRlKTsKPiArCXZhbCA9IDggKiAoc3ltYm9sICsgMSkgLyBiaXRfcGVyX3BpeCAtIHZhbDsK PiArCXZhbCArPSAyOwo+ICsJcmV0ID0gY2RuX2RwX3JlZ193cml0ZShkcCwgRFBfVkNfVEFCTEUo MTUpLCB2YWwpOwo+ICsKPiArCXN3aXRjaCAodmlkZW8tPmNvbG9yX2RlcHRoKSB7Cj4gKwljYXNl IDY6Cj4gKwkJdmFsID0gQkNTXzY7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIDg6Cj4gKwkJdmFsID0g QkNTXzg7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIDEwOgo+ICsJCXZhbCA9IEJDU18xMDsKPiArCQli cmVhazsKPiArCWNhc2UgMTI6Cj4gKwkJdmFsID0gQkNTXzEyOwo+ICsJCWJyZWFrOwo+ICsJY2Fz ZSAxNjoKPiArCQl2YWwgPSBCQ1NfMTY7Cj4gKwkJYnJlYWs7Cj4gKwl9Owo+ICsKPiArCXZhbCAr PSB2aWRlby0+Y29sb3JfZm10IDw8IDg7Cj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRlKGRwLCBE UF9GUkFNRVJfUFhMX1JFUFIsIHZhbCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4g Kwo+ICsJdmFsID0gdmlkZW8tPmhfc3luY19wb2xhcml0eSA/IERQX0ZSQU1FUl9TUF9IU1AgOiAw Owo+ICsJdmFsIHw9IHZpZGVvLT52X3N5bmNfcG9sYXJpdHkgPyBEUF9GUkFNRVJfU1BfVlNQIDog MDsKPiArCXJldCA9IGNkbl9kcF9yZWdfd3JpdGUoZHAsIERQX0ZSQU1FUl9TUCwgdmFsKTsKPiAr CWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwl2YWwgPSAobW9kZS0+aHN5bmNfc3Rh cnQgLSBtb2RlLT5oZGlzcGxheSkgPDwgMTY7Cj4gKwl2YWwgfD0gbW9kZS0+aHRvdGFsIC0gbW9k ZS0+aHN5bmNfZW5kOwo+ICsJcmV0ID0gY2RuX2RwX3JlZ193cml0ZShkcCwgRFBfRlJPTlRfQkFD S19QT1JDSCwgdmFsKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwl2YWwg PSBtb2RlLT5oZGlzcGxheSAqIGJpdF9wZXJfcGl4IC8gODsKPiArCXJldCA9IGNkbl9kcF9yZWdf d3JpdGUoZHAsIERQX0JZVEVfQ09VTlQsIHZhbCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiBy ZXQ7Cj4gKwo+ICsJdmFsID0gbW9kZS0+aHRvdGFsIHwgKChtb2RlLT5odG90YWwgLSBtb2RlLT5o c3luY19zdGFydCkgPDwgMTYpOwo+ICsJcmV0ID0gY2RuX2RwX3JlZ193cml0ZShkcCwgTVNBX0hP UklaT05UQUxfMCwgdmFsKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwl2 YWwgPSBtb2RlLT5oc3luY19lbmQgLSBtb2RlLT5oc3luY19zdGFydDsKPiArCXZhbCB8PSAobW9k ZS0+aGRpc3BsYXkgPDwgMTYpIHwgKHZpZGVvLT5oX3N5bmNfcG9sYXJpdHkgPDwgMTUpOwo+ICsJ cmV0ID0gY2RuX2RwX3JlZ193cml0ZShkcCwgTVNBX0hPUklaT05UQUxfMSwgdmFsKTsKPiArCWlm IChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwl2YWwgPSBtb2RlLT52dG90YWw7Cj4gKwl2 YWwgfD0gKChtb2RlLT52dG90YWwgLSBtb2RlLT52c3luY19zdGFydCkgPDwgMTYpOwo+ICsJcmV0 ID0gY2RuX2RwX3JlZ193cml0ZShkcCwgTVNBX1ZFUlRJQ0FMXzAsIHZhbCk7Cj4gKwlpZiAocmV0 KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJdmFsID0gbW9kZS0+dnN5bmNfZW5kIC0gbW9kZS0+ dnN5bmNfc3RhcnQ7Cj4gKwl2YWwgfD0gbW9kZS0+dmRpc3BsYXkgPDwgMTYgfCAodmlkZW8tPnZf c3luY19wb2xhcml0eSA8PCAxNSk7Cj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRlKGRwLCBNU0Ff VkVSVElDQUxfMSwgdmFsKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwl2 YWwgPSBjZG5fZHBfZ2V0X21zYV9taXNjKHZpZGVvLCBtb2RlKTsKPiArCXJldCA9IGNkbl9kcF9y ZWdfd3JpdGUoZHAsIE1TQV9NSVNDLCB2YWwpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0 Owo+ICsKPiArCXJldCA9IGNkbl9kcF9yZWdfd3JpdGUoZHAsIFNUUkVBTV9DT05GSUcsIDEpOwo+ ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXZhbCA9IG1vZGUtPmhzeW5jX2Vu ZCAtIG1vZGUtPmhzeW5jX3N0YXJ0Owo+ICsJdmFsIHw9IChtb2RlLT5oZGlzcGxheSA8PCAxNik7 Cj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRlKGRwLCBEUF9IT1JJWk9OVEFMLCB2YWwpOwo+ICsJ aWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXZhbCA9IG1vZGUtPnZ0b3RhbDsKPiAr CXZhbCAtPSAobW9kZS0+dnRvdGFsIC0gbW9kZS0+dmRpc3BsYXkpOwo+ICsJdmFsIHw9IChtb2Rl LT52dG90YWwgLSBtb2RlLT52c3luY19zdGFydCkgPDwgMTY7Cj4gKwlyZXQgPSBjZG5fZHBfcmVn X3dyaXRlKGRwLCBEUF9WRVJUSUNBTF8wLCB2YWwpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4g cmV0Owo+ICsKPiArCXZhbCA9IG1vZGUtPnZ0b3RhbDsKPiArCXJldCA9IGNkbl9kcF9yZWdfd3Jp dGUoZHAsIERQX1ZFUlRJQ0FMXzEsIHZhbCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7 Cj4gKwo+ICsJdmFsID0gIDA7Cj4gKwlyZXR1cm4gY2RuX2RwX3JlZ193cml0ZV9iaXQoZHAsIERQ X1ZCX0lELCAyLCAxLCB2YWwpOwo+ICt9Cj4gKwo+ICtpbnQgY2RuX2RwX2F1ZGlvX3N0b3Aoc3Ry dWN0IGNkbl9kcF9kZXZpY2UgKmRwLCBzdHJ1Y3QgYXVkaW9faW5mbyAqYXVkaW8pCj4gK3sKPiAr CXUzMiB2YWw7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IGNkbl9kcF9yZWdfd3JpdGUoZHAs IEFVRElPX1BBQ0tfQ09OVFJPTCwgMCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4g Kwo+ICsJdmFsID0gU1BESUZfQVZHX1NFTCB8IFNQRElGX0pJVFRFUl9CWVBBU1M7Cj4gKwl2YWwg fD0gU1BESUZfRklGT19NSURfUkFOR0UoMHhlMCk7Cj4gKwl2YWwgfD0gU1BESUZfSklUVEVSX1RI UlNIKDB4ZTApOwo+ICsJdmFsIHw9IFNQRElGX0pJVFRFUl9BVkdfV0lOKDcpOwo+ICsJd3JpdGVs KHZhbCwgZHAtPnJlZ3MgKyBTUERJRl9DVFJMX0FERFIpOwo+ICsKPiArCS8qIGNsZWFybiB0aGUg YXVkaW8gY29uZmlnIGFuZCByZXNldCAqLwo+ICsJd3JpdGVsKDAsIGRwLT5yZWdzICsgQVVESU9f U1JDX0NOVEwpOwo+ICsJd3JpdGVsKDAsIGRwLT5yZWdzICsgQVVESU9fU1JDX0NORkcpOwo+ICsJ d3JpdGVsKEFVRElPX1NXX1JTVCwgZHAtPnJlZ3MgKyBBVURJT19TUkNfQ05UTCk7Cj4gKwl3cml0 ZWwoMCwgZHAtPnJlZ3MgKyBBVURJT19TUkNfQ05UTCk7Cj4gKwo+ICsJLyogcmVzZXQgc21wbDJw Y2t0IGNvbXBvbmVudCAgKi8KPiArCXdyaXRlbCgwLCBkcC0+cmVncyArIFNNUEwyUEtUX0NOVEwp Owo+ICsJd3JpdGVsKEFVRElPX1NXX1JTVCwgZHAtPnJlZ3MgKyBTTVBMMlBLVF9DTlRMKTsKPiAr CXdyaXRlbCgwLCBkcC0+cmVncyArIFNNUEwyUEtUX0NOVEwpOwo+ICsKPiArCS8qIHJlc2V0IEZJ Rk8gKi8KPiArCXdyaXRlbChBVURJT19TV19SU1QsIGRwLT5yZWdzICsgRklGT19DTlRMKTsKPiAr CXdyaXRlbCgwLCBkcC0+cmVncyArIEZJRk9fQ05UTCk7Cj4gKwo+ICsJaWYgKGF1ZGlvLT5mb3Jt YXQgPT0gQUZNVF9TUERJRikKPiArCQljbGtfZGlzYWJsZV91bnByZXBhcmUoZHAtPnNwZGlmX2Ns ayk7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK2ludCBjZG5fZHBfYXVkaW9fbXV0ZShz dHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAsIGJvb2wgZW5hYmxlKQo+ICt7Cj4gKwlyZXR1cm4gY2Ru X2RwX3JlZ193cml0ZV9iaXQoZHAsIERQX1ZCX0lELCA0LCAxLCBlbmFibGUpOwo+ICt9Cj4gKwo+ ICtzdGF0aWMgdm9pZCBjZG5fZHBfYXVkaW9fY29uZmlnX2kycyhzdHJ1Y3QgY2RuX2RwX2Rldmlj ZSAqZHAsCj4gKwkJCQkgICAgc3RydWN0IGF1ZGlvX2luZm8gKmF1ZGlvKQo+ICt7Cj4gKwlpbnQg c3ViX3Bja3RfbnVtID0gMSwgaTJzX3BvcnRfZW5fdmFsID0gMHhmLCBpOwo+ICsJdTMyIHZhbDsK PiArCj4gKwlpZiAoYXVkaW8tPmNoYW5uZWxzID09IDIpIHsKPiArCQlpZiAoZHAtPmxpbmsubnVt X2xhbmVzID09IDEpCj4gKwkJCXN1Yl9wY2t0X251bSA9IDI7Cj4gKwkJZWxzZQo+ICsJCQlzdWJf cGNrdF9udW0gPSA0Owo+ICsKPiArCQlpMnNfcG9ydF9lbl92YWwgPSAxOwo+ICsJfSBlbHNlIGlm IChhdWRpby0+Y2hhbm5lbHMgPT0gNCkgewo+ICsJCWkyc19wb3J0X2VuX3ZhbCA9IDM7Cj4gKwl9 Cj4gKwo+ICsJd3JpdGVsKDB4MCwgZHAtPnJlZ3MgKyBTUERJRl9DVFJMX0FERFIpOwo+ICsKPiAr CXdyaXRlbChTWU5DX1dSX1RPX0NIX1pFUk8sIGRwLT5yZWdzICsgRklGT19DTlRMKTsKPiArCj4g Kwl2YWwgPSBNQVhfTlVNX0NIKGF1ZGlvLT5jaGFubmVscyk7Cj4gKwl2YWwgfD0gTlVNX09GX0ky U19QT1JUUyhhdWRpby0+Y2hhbm5lbHMpOwo+ICsJdmFsIHw9IEFVRElPX1RZUEVfTFBDTTsKPiAr CXZhbCB8PSBDRkdfU1VCX1BDS1RfTlVNKHN1Yl9wY2t0X251bSk7Cj4gKwl3cml0ZWwodmFsLCBk cC0+cmVncyArIFNNUEwyUEtUX0NORkcpOwo+ICsKPiArCWlmIChhdWRpby0+c2FtcGxlX3dpZHRo ID09IDE2KQo+ICsJCXZhbCA9IDA7Cj4gKwllbHNlIGlmIChhdWRpby0+c2FtcGxlX3dpZHRoID09 IDI0KQo+ICsJCXZhbCA9IDEgPDwgOTsKPiArCWVsc2UKPiArCQl2YWwgPSAyIDw8IDk7Cj4gKwo+ ICsJdmFsIHw9IEFVRElPX0NIX05VTShhdWRpby0+Y2hhbm5lbHMpOwo+ICsJdmFsIHw9IEkyU19E RUNfUE9SVF9FTihpMnNfcG9ydF9lbl92YWwpOwo+ICsJdmFsIHw9IFRSQU5TX1NNUExfV0lEVEhf MzI7Cj4gKwl3cml0ZWwodmFsLCBkcC0+cmVncyArIEFVRElPX1NSQ19DTkZHKTsKPiArCj4gKwlm b3IgKGkgPSAwOyBpIDwgKGF1ZGlvLT5jaGFubmVscyArIDEpIC8gMjsgaSsrKSB7Cj4gKwkJaWYg KGF1ZGlvLT5zYW1wbGVfd2lkdGggPT0gMTYpCj4gKwkJCXZhbCA9ICgweDA4IDw8IDgpIHwgKDB4 MDggPDwgMjApOwo+ICsJCWVsc2UgaWYgKGF1ZGlvLT5zYW1wbGVfd2lkdGggPT0gMjQpCj4gKwkJ CXZhbCA9ICgweDBiIDw8IDgpIHwgKDB4MGIgPDwgMjApOwo+ICsKPiArCQl2YWwgfD0gKCgyICog aSkgPDwgNCkgfCAoKDIgKiBpICsgMSkgPDwgMTYpOwo+ICsJCXdyaXRlbCh2YWwsIGRwLT5yZWdz ICsgU1RUU19CSVRfQ0goaSkpOwo+ICsJfQo+ICsKPiArCXN3aXRjaCAoYXVkaW8tPnNhbXBsZV9y YXRlKSB7Cj4gKwljYXNlIDMyMDAwOgo+ICsJCXZhbCA9IFNBTVBMSU5HX0ZSRVEoMykgfAo+ICsJ CSAgICAgIE9SSUdJTkFMX1NBTVBfRlJFUSgweGMpOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSA0NDEw MDoKPiArCQl2YWwgPSBTQU1QTElOR19GUkVRKDApIHwKPiArCQkgICAgICBPUklHSU5BTF9TQU1Q X0ZSRVEoMHhmKTsKPiArCQlicmVhazsKPiArCWNhc2UgNDgwMDA6Cj4gKwkJdmFsID0gU0FNUExJ TkdfRlJFUSgyKSB8Cj4gKwkJICAgICAgT1JJR0lOQUxfU0FNUF9GUkVRKDB4ZCk7Cj4gKwkJYnJl YWs7Cj4gKwljYXNlIDg4MjAwOgo+ICsJCXZhbCA9IFNBTVBMSU5HX0ZSRVEoOCkgfAo+ICsJCSAg ICAgIE9SSUdJTkFMX1NBTVBfRlJFUSgweDcpOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSA5NjAwMDoK PiArCQl2YWwgPSBTQU1QTElOR19GUkVRKDB4YSkgfAo+ICsJCSAgICAgIE9SSUdJTkFMX1NBTVBf RlJFUSg1KTsKPiArCQlicmVhazsKPiArCWNhc2UgMTc2NDAwOgo+ICsJCXZhbCA9IFNBTVBMSU5H X0ZSRVEoMHhjKSB8Cj4gKwkJICAgICAgT1JJR0lOQUxfU0FNUF9GUkVRKDMpOwo+ICsJCWJyZWFr Owo+ICsJY2FzZSAxOTIwMDA6Cj4gKwkJdmFsID0gU0FNUExJTkdfRlJFUSgweGUpIHwKPiArCQkg ICAgICBPUklHSU5BTF9TQU1QX0ZSRVEoMSk7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwl2YWwgfD0g NDsKPiArCXdyaXRlbCh2YWwsIGRwLT5yZWdzICsgQ09NX0NIX1NUVFNfQklUUyk7Cj4gKwo+ICsJ d3JpdGVsKFNNUEwyUEtUX0VOLCBkcC0+cmVncyArIFNNUEwyUEtUX0NOVEwpOwo+ICsJd3JpdGVs KEkyU19ERUNfU1RBUlQsIGRwLT5yZWdzICsgQVVESU9fU1JDX0NOVEwpOwo+ICt9Cj4gKwo+ICtz dGF0aWMgdm9pZCBjZG5fZHBfYXVkaW9fY29uZmlnX3NwZGlmKHN0cnVjdCBjZG5fZHBfZGV2aWNl ICpkcCkKPiArewo+ICsJdTMyIHZhbDsKPiArCj4gKwl2YWwgPSBTUERJRl9BVkdfU0VMIHwgU1BE SUZfSklUVEVSX0JZUEFTUzsKPiArCXZhbCB8PSBTUERJRl9GSUZPX01JRF9SQU5HRSgweGUwKTsK PiArCXZhbCB8PSBTUERJRl9KSVRURVJfVEhSU0goMHhlMCk7Cj4gKwl2YWwgfD0gU1BESUZfSklU VEVSX0FWR19XSU4oNyk7Cj4gKwl3cml0ZWwodmFsLCBkcC0+cmVncyArIFNQRElGX0NUUkxfQURE Uik7Cj4gKwo+ICsJd3JpdGVsKFNZTkNfV1JfVE9fQ0hfWkVSTywgZHAtPnJlZ3MgKyBGSUZPX0NO VEwpOwo+ICsKPiArCXZhbCA9IE1BWF9OVU1fQ0goMikgfCBBVURJT19UWVBFX0xQQ00gfCBDRkdf U1VCX1BDS1RfTlVNKDQpOwo+ICsJd3JpdGVsKHZhbCwgZHAtPnJlZ3MgKyBTTVBMMlBLVF9DTkZH KTsKPiArCXdyaXRlbChTTVBMMlBLVF9FTiwgZHAtPnJlZ3MgKyBTTVBMMlBLVF9DTlRMKTsKPiAr Cj4gKwl2YWwgPSBTUERJRl9FTkFCTEUgfCBTUERJRl9BVkdfU0VMIHwgU1BESUZfSklUVEVSX0JZ UEFTUzsKPiArCXZhbCB8PSBTUERJRl9GSUZPX01JRF9SQU5HRSgweGUwKTsKPiArCXZhbCB8PSBT UERJRl9KSVRURVJfVEhSU0goMHhlMCk7Cj4gKwl2YWwgfD0gU1BESUZfSklUVEVSX0FWR19XSU4o Nyk7Cj4gKwl3cml0ZWwodmFsLCBkcC0+cmVncyArIFNQRElGX0NUUkxfQUREUik7Cj4gKwo+ICsJ Y2xrX3ByZXBhcmVfZW5hYmxlKGRwLT5zcGRpZl9jbGspOwo+ICsJY2xrX3NldF9yYXRlKGRwLT5z cGRpZl9jbGssIENETl9EUF9TUERJRl9DTEspOwo+ICt9Cj4gKwo+ICtpbnQgY2RuX2RwX2F1ZGlv X2NvbmZpZ19zZXQoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLCBzdHJ1Y3QgYXVkaW9faW5mbyAq YXVkaW8pCj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ICsJLyogcmVzZXQgdGhlIHNwZGlmIGNsayBi ZWZvcmUgY29uZmlnICovCj4gKwlpZiAoYXVkaW8tPmZvcm1hdCA9PSBBRk1UX1NQRElGKSB7Cj4g KwkJcmVzZXRfY29udHJvbF9hc3NlcnQoZHAtPnNwZGlmX3JzdCk7Cj4gKwkJcmVzZXRfY29udHJv bF9kZWFzc2VydChkcC0+c3BkaWZfcnN0KTsKPiArCX0KPiArCj4gKwlyZXQgPSBjZG5fZHBfcmVn X3dyaXRlKGRwLCBDTV9MQU5FX0NUUkwsIExBTkVfUkVGX0NZQyk7Cj4gKwlpZiAocmV0KQo+ICsJ CXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX3JlZ193cml0ZShkcCwgQ01fQ1RSTCwg MCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJaWYgKGF1ZGlvLT5mb3Jt YXQgPT0gQUZNVF9JMlMpCj4gKwkJY2RuX2RwX2F1ZGlvX2NvbmZpZ19pMnMoZHAsIGF1ZGlvKTsK PiArCWVsc2UKPiArCQljZG5fZHBfYXVkaW9fY29uZmlnX3NwZGlmKGRwKTsKPiArCj4gKwlyZXR1 cm4gY2RuX2RwX3JlZ193cml0ZShkcCwgQVVESU9fUEFDS19DT05UUk9MLCBBVURJT19QQUNLX0VO KTsKPiArfQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvY2RuLWRwLXJl Zy5oIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL2Nkbi1kcC1yZWcuaAo+IG5ldyBmaWxlIG1v ZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uMWFmZmVlZAo+IC0tLSAvZGV2L251bGwKPiArKysg Yi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvY2RuLWRwLXJlZy5oCj4gQEAgLTAsMCArMSw0Nzkg QEAKPiArLyoKPiArICogQ29weXJpZ2h0IChDKSBGdXpob3UgUm9ja2NoaXAgRWxlY3Ryb25pY3Mg Q28uTHRkCj4gKyAqIEF1dGhvcjogQ2hyaXMgWmhvbmcgPHp5d0Byb2NrLWNoaXBzLmNvbT4KPiAr ICoKPiArICogVGhpcyBzb2Z0d2FyZSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhl IEdOVSBHZW5lcmFsIFB1YmxpYwo+ICsgKiBMaWNlbnNlIHZlcnNpb24gMiwgYXMgcHVibGlzaGVk IGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGFuZAo+ICsgKiBtYXkgYmUgY29waWVk LCBkaXN0cmlidXRlZCwgYW5kIG1vZGlmaWVkIHVuZGVyIHRob3NlIHRlcm1zLgo+ICsgKgo+ICsg KiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKPiArICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhl IGltcGxpZWQgd2FycmFudHkgb2YKPiArICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQo+ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMg TGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+ICsgKi8KPiArCj4gKyNpZm5kZWYgX0NETl9EUF9S RUdfSAo+ICsjZGVmaW5lIF9DRE5fRFBfUkVHX0gKPiArCj4gKyNpbmNsdWRlIDxsaW51eC9iaXRv cHMuaD4KPiArCj4gKyNkZWZpbmUgQUREUl9JTUVNCQkweDEwMDAwCj4gKyNkZWZpbmUgQUREUl9E TUVNCQkweDIwMDAwCj4gKwo+ICsvKiBBUEIgQ0ZHIGFkZHIgKi8KPiArI2RlZmluZSBBUEJfQ1RS TAkJCTAKPiArI2RlZmluZSBYVF9JTlRfQ1RSTAkJCTB4MDQKPiArI2RlZmluZSBNQUlMQk9YX0ZV TExfQUREUgkJMHgwOAo+ICsjZGVmaW5lIE1BSUxCT1hfRU1QVFlfQUREUgkJMHgwYwo+ICsjZGVm aW5lIE1BSUxCT1gwX1dSX0RBVEEJCTB4MTAKPiArI2RlZmluZSBNQUlMQk9YMF9SRF9EQVRBCQkw eDE0Cj4gKyNkZWZpbmUgS0VFUF9BTElWRQkJCTB4MTgKPiArI2RlZmluZSBWRVJfTAkJCQkweDFj Cj4gKyNkZWZpbmUgVkVSX0gJCQkJMHgyMAo+ICsjZGVmaW5lIFZFUl9MSUJfTF9BRERSCQkJMHgy NAo+ICsjZGVmaW5lIFZFUl9MSUJfSF9BRERSCQkJMHgyOAo+ICsjZGVmaW5lIFNXX0RFQlVHX0wJ CQkweDJjCj4gKyNkZWZpbmUgU1dfREVCVUdfSAkJCTB4MzAKPiArI2RlZmluZSBNQUlMQk9YX0lO VF9NQVNLCQkweDM0Cj4gKyNkZWZpbmUgTUFJTEJPWF9JTlRfU1RBVFVTCQkweDM4Cj4gKyNkZWZp bmUgU1dfQ0xLX0wJCQkweDNjCj4gKyNkZWZpbmUgU1dfQ0xLX0gJCQkweDQwCj4gKyNkZWZpbmUg U1dfRVZFTlRTMAkJCTB4NDQKPiArI2RlZmluZSBTV19FVkVOVFMxCQkJMHg0OAo+ICsjZGVmaW5l IFNXX0VWRU5UUzIJCQkweDRjCj4gKyNkZWZpbmUgU1dfRVZFTlRTMwkJCTB4NTAKPiArI2RlZmlu ZSBYVF9PQ0RfQ1RSTAkJCTB4NjAKPiArI2RlZmluZSBBUEJfSU5UX01BU0sJCQkweDZjCj4gKyNk ZWZpbmUgQVBCX1NUQVRVU19NQVNLCQkJMHg3MAo+ICsKPiArLyogYXVkaW8gZGVjb2RlciBhZGRy ICovCj4gKyNkZWZpbmUgQVVESU9fU1JDX0NOVEwJCQkweDMwMDAwCj4gKyNkZWZpbmUgQVVESU9f U1JDX0NORkcJCQkweDMwMDA0Cj4gKyNkZWZpbmUgQ09NX0NIX1NUVFNfQklUUwkJMHgzMDAwOAo+ ICsjZGVmaW5lIFNUVFNfQklUX0NIKHgpCQkJKDB4MzAwMGMgKyAoKHgpIDw8IDIpKQo+ICsjZGVm aW5lIFNQRElGX0NUUkxfQUREUgkJCTB4MzAwNGMKPiArI2RlZmluZSBTUERJRl9DSDFfQ1NfMzEw MF9BRERSCQkweDMwMDUwCj4gKyNkZWZpbmUgU1BESUZfQ0gxX0NTXzYzMzJfQUREUgkJMHgzMDA1 NAo+ICsjZGVmaW5lIFNQRElGX0NIMV9DU185NTY0X0FERFIJCTB4MzAwNTgKPiArI2RlZmluZSBT UERJRl9DSDFfQ1NfMTI3OTZfQUREUgkJMHgzMDA1Ywo+ICsjZGVmaW5lIFNQRElGX0NIMV9DU18x NTkxMjhfQUREUgkweDMwMDYwCj4gKyNkZWZpbmUgU1BESUZfQ0gxX0NTXzE5MTE2MF9BRERSCTB4 MzAwNjQKPiArI2RlZmluZSBTUERJRl9DSDJfQ1NfMzEwMF9BRERSCQkweDMwMDY4Cj4gKyNkZWZp bmUgU1BESUZfQ0gyX0NTXzYzMzJfQUREUgkJMHgzMDA2Ywo+ICsjZGVmaW5lIFNQRElGX0NIMl9D U185NTY0X0FERFIJCTB4MzAwNzAKPiArI2RlZmluZSBTUERJRl9DSDJfQ1NfMTI3OTZfQUREUgkJ MHgzMDA3NAo+ICsjZGVmaW5lIFNQRElGX0NIMl9DU18xNTkxMjhfQUREUgkweDMwMDc4Cj4gKyNk ZWZpbmUgU1BESUZfQ0gyX0NTXzE5MTE2MF9BRERSCTB4MzAwN2MKPiArI2RlZmluZSBTTVBMMlBL VF9DTlRMCQkJMHgzMDA4MAo+ICsjZGVmaW5lIFNNUEwyUEtUX0NORkcJCQkweDMwMDg0Cj4gKyNk ZWZpbmUgRklGT19DTlRMCQkJMHgzMDA4OAo+ICsjZGVmaW5lIEZJRk9fU1RUUwkJCTB4MzAwOGMK PiArCj4gKy8qIHNvdXJjZSBwaWYgYWRkciAqLwo+ICsjZGVmaW5lIFNPVVJDRV9QSUZfV1JfQURE UgkJMHgzMDgwMAo+ICsjZGVmaW5lIFNPVVJDRV9QSUZfV1JfUkVRCQkweDMwODA0Cj4gKyNkZWZp bmUgU09VUkNFX1BJRl9SRF9BRERSCQkweDMwODA4Cj4gKyNkZWZpbmUgU09VUkNFX1BJRl9SRF9S RVEJCTB4MzA4MGMKPiArI2RlZmluZSBTT1VSQ0VfUElGX0RBVEFfV1IJCTB4MzA4MTAKPiArI2Rl ZmluZSBTT1VSQ0VfUElGX0RBVEFfUkQJCTB4MzA4MTQKPiArI2RlZmluZSBTT1VSQ0VfUElGX0ZJ Rk8xX0ZMVVNICQkweDMwODE4Cj4gKyNkZWZpbmUgU09VUkNFX1BJRl9GSUZPMl9GTFVTSAkJMHgz MDgxYwo+ICsjZGVmaW5lIFNPVVJDRV9QSUZfU1RBVFVTCQkweDMwODIwCj4gKyNkZWZpbmUgU09V UkNFX1BJRl9JTlRFUlJVUFRfU09VUkNFCTB4MzA4MjQKPiArI2RlZmluZSBTT1VSQ0VfUElGX0lO VEVSUlVQVF9NQVNLCTB4MzA4MjgKPiArI2RlZmluZSBTT1VSQ0VfUElGX1BLVF9BTExPQ19SRUcJ MHgzMDgyYwo+ICsjZGVmaW5lIFNPVVJDRV9QSUZfUEtUX0FMTE9DX1dSX0VOCTB4MzA4MzAKPiAr I2RlZmluZSBTT1VSQ0VfUElGX1NXX1JFU0VUCQkweDMwODM0Cj4gKwo+ICsvKiBiZWxsb3cgcmVn aXN0ZXJzIG5lZWQgYWNjZXNzIGJ5IG1haWxib3ggKi8KPiArLyogc291cmNlIGNhciBhZGRyICov Cj4gKyNkZWZpbmUgU09VUkNFX0hEVFhfQ0FSCQkJMHgwOTAwCj4gKyNkZWZpbmUgU09VUkNFX0RQ VFhfQ0FSCQkJMHgwOTA0Cj4gKyNkZWZpbmUgU09VUkNFX1BIWV9DQVIJCQkweDA5MDgKPiArI2Rl ZmluZSBTT1VSQ0VfQ0VDX0NBUgkJCTB4MDkwYwo+ICsjZGVmaW5lIFNPVVJDRV9DQlVTX0NBUgkJ CTB4MDkxMAo+ICsjZGVmaW5lIFNPVVJDRV9QS1RfQ0FSCQkJMHgwOTE4Cj4gKyNkZWZpbmUgU09V UkNFX0FJRl9DQVIJCQkweDA5MWMKPiArI2RlZmluZSBTT1VSQ0VfQ0lQSEVSX0NBUgkJMHgwOTIw Cj4gKyNkZWZpbmUgU09VUkNFX0NSWVBUT19DQVIJCTB4MDkyNAo+ICsKPiArLyogY2xvY2sgbWV0 ZXJzIGFkZHIgKi8KPiArI2RlZmluZSBDTV9DVFJMCQkJCTB4MGEwMAo+ICsjZGVmaW5lIENNX0ky U19DVFJMCQkJMHgwYTA0Cj4gKyNkZWZpbmUgQ01fU1BESUZfQ1RSTAkJCTB4MGEwOAo+ICsjZGVm aW5lIENNX1ZJRF9DVFJMCQkJMHgwYTBjCj4gKyNkZWZpbmUgQ01fTEFORV9DVFJMCQkJMHgwYTEw Cj4gKyNkZWZpbmUgSTJTX05NX1NUQUJMRQkJCTB4MGExNAo+ICsjZGVmaW5lIEkyU19OQ1RTX1NU QUJMRQkJCTB4MGExOAo+ICsjZGVmaW5lIFNQRElGX05NX1NUQUJMRQkJCTB4MGExYwo+ICsjZGVm aW5lIFNQRElGX05DVFNfU1RBQkxFCQkweDBhMjAKPiArI2RlZmluZSBOTVZJRF9NRUFTX1NUQUJM RQkJMHgwYTI0Cj4gKyNkZWZpbmUgSTJTX01FQVMJCQkweDBhNDAKPiArI2RlZmluZSBTUERJRl9N RUFTCQkJMHgwYTgwCj4gKyNkZWZpbmUgTk1WSURfTUVBUwkJCTB4MGFjMAo+ICsKPiArLyogc291 cmNlIHZpZiBhZGRyICovCj4gKyNkZWZpbmUgQk5EX0hTWU5DMlZTWU5DCQkJMHgwYjAwCj4gKyNk ZWZpbmUgSFNZTkMyVlNZTkNfRjFfTDEJCTB4MGIwNAo+ICsjZGVmaW5lIEhTWU5DMlZTWU5DX0Yy X0wxCQkweDBiMDgKPiArI2RlZmluZSBIU1lOQzJWU1lOQ19TVEFUVVMJCTB4MGIwYwo+ICsjZGVm aW5lIEhTWU5DMlZTWU5DX1BPTF9DVFJMCQkweDBiMTAKPiArCj4gKy8qIGRwdHggcGh5IGFkZHIg Ki8KPiArI2RlZmluZSBEUF9UWF9QSFlfQ09ORklHX1JFRwkJMHgyMDAwCj4gKyNkZWZpbmUgRFBf VFhfUEhZX1NUQVRVU19SRUcJCTB4MjAwNAo+ICsjZGVmaW5lIERQX1RYX1BIWV9TV19SRVNFVAkJ MHgyMDA4Cj4gKyNkZWZpbmUgRFBfVFhfUEhZX1NDUkFNQkxFUl9TRUVECTB4MjAwYwo+ICsjZGVm aW5lIERQX1RYX1BIWV9UUkFJTklOR18wMV8wNAkweDIwMTAKPiArI2RlZmluZSBEUF9UWF9QSFlf VFJBSU5JTkdfMDVfMDgJMHgyMDE0Cj4gKyNkZWZpbmUgRFBfVFhfUEhZX1RSQUlOSU5HXzA5XzEw CTB4MjAxOAo+ICsjZGVmaW5lIFRFU1RfQ09SCQkJMHgyM2ZjCj4gKwo+ICsvKiBkcHR4IGhwZCBh ZGRyICovCj4gKyNkZWZpbmUgSFBEX0lSUV9ERVRfTUlOX1RJTUVSCQkweDIxMDAKPiArI2RlZmlu ZSBIUERfSVJRX0RFVF9NQVhfVElNRVIJCTB4MjEwNAo+ICsjZGVmaW5lIEhQRF9VTlBMR0VEX0RF VF9NSU5fVElNRVIJMHgyMTA4Cj4gKyNkZWZpbmUgSFBEX1NUQUJMRV9USU1FUgkJMHgyMTBjCj4g KyNkZWZpbmUgSFBEX0ZJTFRFUl9USU1FUgkJMHgyMTEwCj4gKyNkZWZpbmUgSFBEX0VWRU5UX01B U0sJCQkweDIxMWMKPiArI2RlZmluZSBIUERfRVZFTlRfREVUCQkJMHgyMTIwCj4gKwo+ICsvKiBk cHl4IGZyYW1lciBhZGRyICovCj4gKyNkZWZpbmUgRFBfRlJBTUVSX0dMT0JBTF9DT05GSUcJCTB4 MjIwMAo+ICsjZGVmaW5lIERQX1NXX1JFU0VUCQkJMHgyMjA0Cj4gKyNkZWZpbmUgRFBfRlJBTUVS X1RVCQkJMHgyMjA4Cj4gKyNkZWZpbmUgRFBfRlJBTUVSX1BYTF9SRVBSCQkweDIyMGMKPiArI2Rl ZmluZSBEUF9GUkFNRVJfU1AJCQkweDIyMTAKPiArI2RlZmluZSBBVURJT19QQUNLX0NPTlRST0wJ CTB4MjIxNAo+ICsjZGVmaW5lIERQX1ZDX1RBQkxFKHgpCQkJKDB4MjIxOCArICgoeCkgPDwgMikp Cj4gKyNkZWZpbmUgRFBfVkJfSUQJCQkweDIyNTgKPiArI2RlZmluZSBEUF9NVFBIX0xWUF9DT05U Uk9MCQkweDIyNWMKPiArI2RlZmluZSBEUF9NVFBIX1NZTUJPTF9WQUxVRVMJCTB4MjI2MAo+ICsj ZGVmaW5lIERQX01UUEhfRUNGX0NPTlRST0wJCTB4MjI2NAo+ICsjZGVmaW5lIERQX01UUEhfQUNU X0NPTlRST0wJCTB4MjI2OAo+ICsjZGVmaW5lIERQX01UUEhfU1RBVFVTCQkJMHgyMjZjCj4gKyNk ZWZpbmUgRFBfSU5URVJSVVBUX1NPVVJDRQkJMHgyMjcwCj4gKyNkZWZpbmUgRFBfSU5URVJSVVBU X01BU0sJCTB4MjI3NAo+ICsjZGVmaW5lIERQX0ZST05UX0JBQ0tfUE9SQ0gJCTB4MjI3OAo+ICsj ZGVmaW5lIERQX0JZVEVfQ09VTlQJCQkweDIyN2MKPiArCj4gKy8qIGRwdHggc3RyZWFtIGFkZHIg Ki8KPiArI2RlZmluZSBNU0FfSE9SSVpPTlRBTF8wCQkweDIyODAKPiArI2RlZmluZSBNU0FfSE9S SVpPTlRBTF8xCQkweDIyODQKPiArI2RlZmluZSBNU0FfVkVSVElDQUxfMAkJCTB4MjI4OAo+ICsj ZGVmaW5lIE1TQV9WRVJUSUNBTF8xCQkJMHgyMjhjCj4gKyNkZWZpbmUgTVNBX01JU0MJCQkweDIy OTAKPiArI2RlZmluZSBTVFJFQU1fQ09ORklHCQkJMHgyMjk0Cj4gKyNkZWZpbmUgQVVESU9fUEFD S19TVEFUVVMJCTB4MjI5OAo+ICsjZGVmaW5lIFZJRl9TVEFUVVMJCQkweDIyOWMKPiArI2RlZmlu ZSBQQ0tfU1RVRkZfU1RBVFVTXzAJCTB4MjJhMAo+ICsjZGVmaW5lIFBDS19TVFVGRl9TVEFUVVNf MQkJMHgyMmE0Cj4gKyNkZWZpbmUgSU5GT19QQUNLX1NUQVRVUwkJMHgyMmE4Cj4gKyNkZWZpbmUg UkFURV9HT1ZFUk5PUl9TVEFUVVMJCTB4MjJhYwo+ICsjZGVmaW5lIERQX0hPUklaT05UQUwJCQkw eDIyYjAKPiArI2RlZmluZSBEUF9WRVJUSUNBTF8wCQkJMHgyMmI0Cj4gKyNkZWZpbmUgRFBfVkVS VElDQUxfMQkJCTB4MjJiOAo+ICsjZGVmaW5lIERQX0JMT0NLX1NEUAkJCTB4MjJiYwo+ICsKPiAr LyogZHB0eCBnbGJsIGFkZHIgKi8KPiArI2RlZmluZSBEUFRYX0xBTkVfRU4JCQkweDIzMDAKPiAr I2RlZmluZSBEUFRYX0VOSE5DRAkJCTB4MjMwNAo+ICsjZGVmaW5lIERQVFhfSU5UX01BU0sJCQkw eDIzMDgKPiArI2RlZmluZSBEUFRYX0lOVF9TVEFUVVMJCQkweDIzMGMKPiArCj4gKy8qIGRwIGF1 eCBhZGRyICovCj4gKyNkZWZpbmUgRFBfQVVYX0hPU1RfQ09OVFJPTAkJMHgyODAwCj4gKyNkZWZp bmUgRFBfQVVYX0lOVEVSUlVQVF9TT1VSQ0UJCTB4MjgwNAo+ICsjZGVmaW5lIERQX0FVWF9JTlRF UlJVUFRfTUFTSwkJMHgyODA4Cj4gKyNkZWZpbmUgRFBfQVVYX1NXQVBfSU5WRVJTSU9OX0NPTlRS T0wJMHgyODBjCj4gKyNkZWZpbmUgRFBfQVVYX1NFTkRfTkFDS19UUkFOU0FDVElPTgkweDI4MTAK PiArI2RlZmluZSBEUF9BVVhfQ0xFQVJfUlgJCQkweDI4MTQKPiArI2RlZmluZSBEUF9BVVhfQ0xF QVJfVFgJCQkweDI4MTgKPiArI2RlZmluZSBEUF9BVVhfVElNRVJfU1RPUAkJMHgyODFjCj4gKyNk ZWZpbmUgRFBfQVVYX1RJTUVSX0NMRUFSCQkweDI4MjAKPiArI2RlZmluZSBEUF9BVVhfUkVTRVRf U1cJCQkweDI4MjQKPiArI2RlZmluZSBEUF9BVVhfRElWSURFXzJNCQkweDI4MjgKPiArI2RlZmlu ZSBEUF9BVVhfVFhfUFJFQUNIQVJHRV9MRU5HVEgJMHgyODJjCj4gKyNkZWZpbmUgRFBfQVVYX0ZS RVFVRU5DWV8xTV9NQVgJCTB4MjgzMAo+ICsjZGVmaW5lIERQX0FVWF9GUkVRVUVOQ1lfMU1fTUlO CQkweDI4MzQKPiArI2RlZmluZSBEUF9BVVhfUlhfUFJFX01JTgkJMHgyODM4Cj4gKyNkZWZpbmUg RFBfQVVYX1JYX1BSRV9NQVgJCTB4MjgzYwo+ICsjZGVmaW5lIERQX0FVWF9USU1FUl9QUkVTRVQJ CTB4Mjg0MAo+ICsjZGVmaW5lIERQX0FVWF9OQUNLX0ZPUk1BVAkJMHgyODQ0Cj4gKyNkZWZpbmUg RFBfQVVYX1RYX0RBVEEJCQkweDI4NDgKPiArI2RlZmluZSBEUF9BVVhfUlhfREFUQQkJCTB4Mjg0 Ywo+ICsjZGVmaW5lIERQX0FVWF9UWF9TVEFUVVMJCTB4Mjg1MAo+ICsjZGVmaW5lIERQX0FVWF9S WF9TVEFUVVMJCTB4Mjg1NAo+ICsjZGVmaW5lIERQX0FVWF9SWF9DWUNMRV9DT1VOVEVSCQkweDI4 NTgKPiArI2RlZmluZSBEUF9BVVhfTUFJTl9TVEFURVMJCTB4Mjg1Ywo+ICsjZGVmaW5lIERQX0FV WF9NQUlOX1RJTUVSCQkweDI4NjAKPiArI2RlZmluZSBEUF9BVVhfQUZFX09VVAkJCTB4Mjg2NAo+ ICsKPiArLyogY3J5cHRvIGFkZHIgKi8KPiArI2RlZmluZSBDUllQVE9fSERDUF9SRVZJU0lPTgkJ MHg1ODAwCj4gKyNkZWZpbmUgSERDUF9DUllQVE9fQ09ORklHCQkweDU4MDQKPiArI2RlZmluZSBD UllQVE9fSU5URVJSVVBUX1NPVVJDRQkJMHg1ODA4Cj4gKyNkZWZpbmUgQ1JZUFRPX0lOVEVSUlVQ VF9NQVNLCQkweDU4MGMKPiArI2RlZmluZSBDUllQVE8yMl9DT05GSUcJCQkweDU4MTgKPiArI2Rl ZmluZSBDUllQVE8yMl9TVEFUVVMJCQkweDU4MWMKPiArI2RlZmluZSBTSEFfMjU2X0RBVEFfSU4J CQkweDU4M2MKPiArI2RlZmluZSBTSEFfMjU2X0RBVEFfT1VUXyh4KQkJKDB4NTg1MCArICgoeCkg PDwgMikpCj4gKyNkZWZpbmUgQUVTXzMyX0tFWV8oeCkJCQkoMHg1ODcwICsgKCh4KSA8PCAyKSkK PiArI2RlZmluZSBBRVNfMzJfREFUQV9JTgkJCTB4NTg4MAo+ICsjZGVmaW5lIEFFU18zMl9EQVRB X09VVF8oeCkJCSgweDU4ODQgKyAoKHgpIDw8IDIpKQo+ICsjZGVmaW5lIENSWVBUTzE0X0NPTkZJ RwkJCTB4NThhMAo+ICsjZGVmaW5lIENSWVBUTzE0X1NUQVRVUwkJCTB4NThhNAo+ICsjZGVmaW5l IENSWVBUTzE0X1BSTk1fT1VUCQkweDU4YTgKPiArI2RlZmluZSBDUllQVE8xNF9LTV8wCQkJMHg1 OGFjCj4gKyNkZWZpbmUgQ1JZUFRPMTRfS01fMQkJCTB4NThiMAo+ICsjZGVmaW5lIENSWVBUTzE0 X0FOXzAJCQkweDU4YjQKPiArI2RlZmluZSBDUllQVE8xNF9BTl8xCQkJMHg1OGI4Cj4gKyNkZWZp bmUgQ1JZUFRPMTRfWU9VUl9LU1ZfMAkJMHg1OGJjCj4gKyNkZWZpbmUgQ1JZUFRPMTRfWU9VUl9L U1ZfMQkJMHg1OGMwCj4gKyNkZWZpbmUgQ1JZUFRPMTRfTUlfMAkJCTB4NThjNAo+ICsjZGVmaW5l IENSWVBUTzE0X01JXzEJCQkweDU4YzgKPiArI2RlZmluZSBDUllQVE8xNF9USV8wCQkJMHg1OGNj Cj4gKyNkZWZpbmUgQ1JZUFRPMTRfS0lfMAkJCTB4NThkMAo+ICsjZGVmaW5lIENSWVBUTzE0X0tJ XzEJCQkweDU4ZDQKPiArI2RlZmluZSBDUllQVE8xNF9CTE9DS1NfTlVNCQkweDU4ZDgKPiArI2Rl ZmluZSBDUllQVE8xNF9LRVlfTUVNX0RBVEFfMAkJMHg1OGRjCj4gKyNkZWZpbmUgQ1JZUFRPMTRf S0VZX01FTV9EQVRBXzEJCTB4NThlMAo+ICsjZGVmaW5lIENSWVBUTzE0X1NIQTFfTVNHX0RBVEEJ CTB4NThlNAo+ICsjZGVmaW5lIENSWVBUTzE0X1NIQTFfVl9WQUxVRV8oeCkJKDB4NThlOCArICgo eCkgPDwgMikpCj4gKyNkZWZpbmUgVFJOR19DVFJMCQkJMHg1OGZjCj4gKyNkZWZpbmUgVFJOR19E QVRBX1JEWQkJCTB4NTkwMAo+ICsjZGVmaW5lIFRSTkdfREFUQQkJCTB4NTkwNAo+ICsKPiArLyog Y2lwaGVyIGFkZHIgKi8KPiArI2RlZmluZSBIRENQX1JFVklTSU9OCQkJMHg2MDAwMAo+ICsjZGVm aW5lIElOVEVSUlVQVF9TT1VSQ0UJCTB4NjAwMDQKPiArI2RlZmluZSBJTlRFUlJVUFRfTUFTSwkJ CTB4NjAwMDgKPiArI2RlZmluZSBIRENQX0NJUEhFUl9DT05GSUcJCTB4NjAwMGMKPiArI2RlZmlu ZSBBRVNfMTI4X0tFWV8wCQkJMHg2MDAxMAo+ICsjZGVmaW5lIEFFU18xMjhfS0VZXzEJCQkweDYw MDE0Cj4gKyNkZWZpbmUgQUVTXzEyOF9LRVlfMgkJCTB4NjAwMTgKPiArI2RlZmluZSBBRVNfMTI4 X0tFWV8zCQkJMHg2MDAxYwo+ICsjZGVmaW5lIEFFU18xMjhfUkFORE9NXzAJCTB4NjAwMjAKPiAr I2RlZmluZSBBRVNfMTI4X1JBTkRPTV8xCQkweDYwMDI0Cj4gKyNkZWZpbmUgQ0lQSEVSMTRfS01f MAkJCTB4NjAwMjgKPiArI2RlZmluZSBDSVBIRVIxNF9LTV8xCQkJMHg2MDAyYwo+ICsjZGVmaW5l IENJUEhFUjE0X1NUQVRVUwkJCTB4NjAwMzAKPiArI2RlZmluZSBDSVBIRVIxNF9SSV9QSl9TVEFU VVMJCTB4NjAwMzQKPiArI2RlZmluZSBDSVBIRVJfTU9ERQkJCTB4NjAwMzgKPiArI2RlZmluZSBD SVBIRVIxNF9BTl8wCQkJMHg2MDAzYwo+ICsjZGVmaW5lIENJUEhFUjE0X0FOXzEJCQkweDYwMDQw Cj4gKyNkZWZpbmUgQ0lQSEVSMjJfQVVUSAkJCTB4NjAwNDQKPiArI2RlZmluZSBDSVBIRVIxNF9S MF9EUF9TVEFUVVMJCTB4NjAwNDgKPiArI2RlZmluZSBDSVBIRVIxNF9CT09UU1RSQVAJCTB4NjAw NGMKPiArCj4gKyNkZWZpbmUgRFBUWF9GUk1SX0RBVEFfQ0xLX1JTVE5fRU4JQklUKDExKQo+ICsj ZGVmaW5lIERQVFhfRlJNUl9EQVRBX0NMS19FTgkJQklUKDEwKQo+ICsjZGVmaW5lIERQVFhfUEhZ X0RBVEFfUlNUTl9FTgkJQklUKDkpCj4gKyNkZWZpbmUgRFBUWF9QSFlfREFUQV9DTEtfRU4JCUJJ VCg4KQo+ICsjZGVmaW5lIERQVFhfUEhZX0NIQVJfUlNUTl9FTgkJQklUKDcpCj4gKyNkZWZpbmUg RFBUWF9QSFlfQ0hBUl9DTEtfRU4JCUJJVCg2KQo+ICsjZGVmaW5lIFNPVVJDRV9BVVhfU1lTX0NM S19SU1ROX0VOCUJJVCg1KQo+ICsjZGVmaW5lIFNPVVJDRV9BVVhfU1lTX0NMS19FTgkJQklUKDQp Cj4gKyNkZWZpbmUgRFBUWF9TWVNfQ0xLX1JTVE5fRU4JCUJJVCgzKQo+ICsjZGVmaW5lIERQVFhf U1lTX0NMS19FTgkJCUJJVCgyKQo+ICsjZGVmaW5lIENGR19EUFRYX1ZJRl9DTEtfUlNUTl9FTglC SVQoMSkKPiArI2RlZmluZSBDRkdfRFBUWF9WSUZfQ0xLX0VOCQlCSVQoMCkKPiArCj4gKyNkZWZp bmUgU09VUkNFX1BIWV9SU1ROX0VOCQlCSVQoMSkKPiArI2RlZmluZSBTT1VSQ0VfUEhZX0NMS19F TgkJQklUKDApCj4gKwo+ICsjZGVmaW5lIFNPVVJDRV9QS1RfU1lTX1JTVE5fRU4JCUJJVCgzKQo+ ICsjZGVmaW5lIFNPVVJDRV9QS1RfU1lTX0NMS19FTgkJQklUKDIpCj4gKyNkZWZpbmUgU09VUkNF X1BLVF9EQVRBX1JTVE5fRU4JCUJJVCgxKQo+ICsjZGVmaW5lIFNPVVJDRV9QS1RfREFUQV9DTEtf RU4JCUJJVCgwKQo+ICsKPiArI2RlZmluZSBTUERJRl9DRFJfQ0xLX1JTVE5fRU4JCUJJVCg1KQo+ ICsjZGVmaW5lIFNQRElGX0NEUl9DTEtfRU4JCUJJVCg0KQo+ICsjZGVmaW5lIFNPVVJDRV9BSUZf U1lTX1JTVE5fRU4JCUJJVCgzKQo+ICsjZGVmaW5lIFNPVVJDRV9BSUZfU1lTX0NMS19FTgkJQklU KDIpCj4gKyNkZWZpbmUgU09VUkNFX0FJRl9DTEtfUlNUTl9FTgkJQklUKDEpCj4gKyNkZWZpbmUg U09VUkNFX0FJRl9DTEtfRU4JCUJJVCgwKQo+ICsKPiArI2RlZmluZSBTT1VSQ0VfQ0lQSEVSX1NZ U1RFTV9DTEtfUlNUTl9FTglCSVQoMykKPiArI2RlZmluZSBTT1VSQ0VfQ0lQSEVSX1NZU19DTEtf RU4JCUJJVCgyKQo+ICsjZGVmaW5lIFNPVVJDRV9DSVBIRVJfQ0hBUl9DTEtfUlNUTl9FTgkJQklU KDEpCj4gKyNkZWZpbmUgU09VUkNFX0NJUEhFUl9DSEFSX0NMS19FTgkJQklUKDApCj4gKwo+ICsj ZGVmaW5lIFNPVVJDRV9DUllQVE9fU1lTX0NMS19SU1ROX0VOCUJJVCgxKQo+ICsjZGVmaW5lIFNP VVJDRV9DUllQVE9fU1lTX0NMS19FTglCSVQoMCkKPiArCj4gKyNkZWZpbmUgQVBCX0lSQU1fUEFU SAkJCUJJVCgyKQo+ICsjZGVmaW5lIEFQQl9EUkFNX1BBVEgJCQlCSVQoMSkKPiArI2RlZmluZSBB UEJfWFRfUkVTRVQJCQlCSVQoMCkKPiArCj4gKyNkZWZpbmUgTUFJTEJPWF9JTlRfTUFTS19CSVQJ CUJJVCgxKQo+ICsjZGVmaW5lIFBJRl9JTlRfTUFTS19CSVQJCUJJVCgwKQo+ICsjZGVmaW5lIEFM TF9JTlRfTUFTSwkJCTMKPiArCj4gKy8qIG1haWxib3ggKi8KPiArI2RlZmluZSBNQl9PUENPREVf SUQJCQkwCj4gKyNkZWZpbmUgTUJfTU9EVUxFX0lECQkJMQo+ICsjZGVmaW5lIE1CX1NJWkVfTVNC X0lECQkJMgo+ICsjZGVmaW5lIE1CX1NJWkVfTFNCX0lECQkJMwo+ICsjZGVmaW5lIE1CX0RBVEFf SUQJCQk0Cj4gKwo+ICsjZGVmaW5lIE1CX01PRFVMRV9JRF9EUF9UWAkJMHgwMQo+ICsjZGVmaW5l IE1CX01PRFVMRV9JRF9IRENQX1RYCQkweDA3Cj4gKyNkZWZpbmUgTUJfTU9EVUxFX0lEX0hEQ1Bf UlgJCTB4MDgKPiArI2RlZmluZSBNQl9NT0RVTEVfSURfSERDUF9HRU5FUkFMCTB4MDkKPiArI2Rl ZmluZSBNQl9NT0RVTEVfSURfR0VORVJBTAkJMHgwYQo+ICsKPiArLyogZ2VuZXJhbCBvcGNvZGUg Ki8KPiArI2RlZmluZSBHRU5FUkFMX01BSU5fQ09OVFJPTCAgICAgICAgICAgIDB4MDEKPiArI2Rl ZmluZSBHRU5FUkFMX1RFU1RfRUNITyAgICAgICAgICAgICAgIDB4MDIKPiArI2RlZmluZSBHRU5F UkFMX0JVU19TRVRUSU5HUyAgICAgICAgICAgIDB4MDMKPiArI2RlZmluZSBHRU5FUkFMX1RFU1Rf QUNDRVNTICAgICAgICAgICAgIDB4MDQKPiArCj4gKyNkZWZpbmUgRFBUWF9TRVRfUE9XRVJfTU5H CQkJMHgwMAo+ICsjZGVmaW5lIERQVFhfU0VUX0hPU1RfQ0FQQUJJTElUSUVTCQkweDAxCj4gKyNk ZWZpbmUgRFBUWF9HRVRfRURJRAkJCQkweDAyCj4gKyNkZWZpbmUgRFBUWF9SRUFEX0RQQ0QJCQkJ MHgwMwo+ICsjZGVmaW5lIERQVFhfV1JJVEVfRFBDRAkJCQkweDA0Cj4gKyNkZWZpbmUgRFBUWF9F TkFCTEVfRVZFTlQJCQkweDA1Cj4gKyNkZWZpbmUgRFBUWF9XUklURV9SRUdJU1RFUgkJCTB4MDYK PiArI2RlZmluZSBEUFRYX1JFQURfUkVHSVNURVIJCQkweDA3Cj4gKyNkZWZpbmUgRFBUWF9XUklU RV9GSUVMRAkJCTB4MDgKPiArI2RlZmluZSBEUFRYX1RSQUlOSU5HX0NPTlRST0wJCQkweDA5Cj4g KyNkZWZpbmUgRFBUWF9SRUFEX0VWRU5UCQkJCTB4MGEKPiArI2RlZmluZSBEUFRYX1JFQURfTElO S19TVEFUCQkJMHgwYgo+ICsjZGVmaW5lIERQVFhfU0VUX1ZJREVPCQkJCTB4MGMKPiArI2RlZmlu ZSBEUFRYX1NFVF9BVURJTwkJCQkweDBkCj4gKyNkZWZpbmUgRFBUWF9HRVRfTEFTVF9BVVhfU1RB VVMJCQkweDBlCj4gKyNkZWZpbmUgRFBUWF9TRVRfTElOS19CUkVBS19QT0lOVAkJMHgwZgo+ICsj ZGVmaW5lIERQVFhfRk9SQ0VfTEFORVMJCQkweDEwCj4gKyNkZWZpbmUgRFBUWF9IUERfU1RBVEUJ CQkJMHgxMQo+ICsKPiArI2RlZmluZSBEUFRYX0VWRU5UX0VOQUJMRV9IUEQJCQlCSVQoMCkKPiAr I2RlZmluZSBEUFRYX0VWRU5UX0VOQUJMRV9UUkFJTklORwkJQklUKDEpCj4gKwo+ICsjZGVmaW5l IExJTktfVFJBSU5JTkdfTk9UX0FDVElWRQkJMAo+ICsjZGVmaW5lIExJTktfVFJBSU5JTkdfUlVO CQkJMQo+ICsjZGVmaW5lIExJTktfVFJBSU5JTkdfUkVTVEFSVAkJCTIKPiArCj4gKyNkZWZpbmUg Q09OVFJPTF9WSURFT19JRExFCQkJMAo+ICsjZGVmaW5lIENPTlRST0xfVklERU9fVkFMSUQJCQkx Cj4gKwo+ICsjZGVmaW5lIFZJRl9CWVBBU1NfSU5URVJMQUNFCQkJQklUKDEzKQo+ICsjZGVmaW5l IElOVEVSTEFDRV9GTVRfREVUCQkJQklUKDEyKQo+ICsjZGVmaW5lIElOVEVSTEFDRV9EVENUX1dJ TgkJCTB4MjAKPiArCj4gKyNkZWZpbmUgRFBfRlJBTUVSX1NQX0lOVEVSTEFDRV9FTgkJQklUKDIp Cj4gKyNkZWZpbmUgRFBfRlJBTUVSX1NQX0hTUAkJCUJJVCgxKQo+ICsjZGVmaW5lIERQX0ZSQU1F Ul9TUF9WU1AJCQlCSVQoMCkKPiArCj4gKy8qIGNhcGFiaWxpdHkgKi8KPiArI2RlZmluZSBBVVhf SE9TVF9JTlZFUlQJCQkJMwo+ICsjZGVmaW5lCUZBU1RfTFRfU1VQUE9SVAkJCQkxCj4gKyNkZWZp bmUgRkFTVF9MVF9OT1RfU1VQUE9SVAkJCTAKPiArI2RlZmluZSBMQU5FX01BUFBJTkdfTk9STUFM CQkJMHhlNAo+ICsjZGVmaW5lIExBTkVfTUFQUElOR19GTElQUEVECQkJMHgxYgo+ICsjZGVmaW5l IEVOSEFOQ0VECQkJCTEKPiArCj4gKyNkZWZpbmUJRlVMTF9MVF9TVEFSVEVECQkJCUJJVCgwKQo+ ICsjZGVmaW5lIEZBU0VfTFRfU1RBUlRFRAkJCQlCSVQoMSkKPiArI2RlZmluZSBDTEtfUkVDT1ZF UllfRklOSVNIRUQJCQlCSVQoMikKPiArI2RlZmluZSBFUV9QSEFTRV9GSU5JU0hFRAkJCUJJVCgz KQo+ICsjZGVmaW5lIEZBU0VfTFRfU1RBUlRfRklOSVNIRUQJCQlCSVQoNCkKPiArI2RlZmluZSBD TEtfUkVDT1ZFUllfRkFJTEVECQkJQklUKDUpCj4gKyNkZWZpbmUgRVFfUEhBU0VfRkFJTEVECQkJ CUJJVCg2KQo+ICsjZGVmaW5lIEZBU0VfTFRfRkFJTEVECQkJCUJJVCg3KQo+ICsKPiArI2RlZmlu ZSBEUFRYX0hQRF9FVkVOVAkJCQlCSVQoMCkKPiArI2RlZmluZSBEUFRYX1RSQUlOSU5HX0VWRU5U CQkJQklUKDEpCj4gKyNkZWZpbmUgSERDUF9UWF9TVEFUVVNfRVZFTlQJCQlCSVQoNCkKPiArI2Rl ZmluZSBIRENQMl9UWF9JU19LTV9TVE9SRURfRVZFTlQJCUJJVCg1KQo+ICsjZGVmaW5lIEhEQ1Ay X1RYX1NUT1JFX0tNX0VWRU5UCQkJQklUKDYpCj4gKyNkZWZpbmUgSERDUF9UWF9JU19SRUNFSVZF Ul9JRF9WQUxJRF9FVkVOVAlCSVQoNykKPiArCj4gKyNkZWZpbmUgVFVfU0laRQkJCQkJMzAKPiAr I2RlZmluZSBDRE5fRFBfTUFYX0xJTktfUkFURQkJCURQX0xJTktfQldfNV80Cj4gKwo+ICsvKiBh dWRpbyAqLwo+ICsjZGVmaW5lIEFVRElPX1BBQ0tfRU4JCQkJQklUKDgpCj4gKyNkZWZpbmUgU0FN UExJTkdfRlJFUSh4KQkJCSgoKHgpICYgMHhmKSA8PCAxNikKPiArI2RlZmluZSBPUklHSU5BTF9T QU1QX0ZSRVEoeCkJCQkoKCh4KSAmIDB4ZikgPDwgMjQpCj4gKyNkZWZpbmUgU1lOQ19XUl9UT19D SF9aRVJPCQkJQklUKDEpCj4gKyNkZWZpbmUgSTJTX0RFQ19TVEFSVAkJCQlCSVQoMSkKPiArI2Rl ZmluZSBBVURJT19TV19SU1QJCQkJQklUKDApCj4gKyNkZWZpbmUgU01QTDJQS1RfRU4JCQkJQklU KDEpCj4gKyNkZWZpbmUgTUFYX05VTV9DSCh4KQkJCQkoKCh4KSAmIDB4MWYpIC0gMSkKPiArI2Rl ZmluZSBOVU1fT0ZfSTJTX1BPUlRTKHgpCQkJKCgoKHgpIC8gMiAtIDEpICYgMHgzKSA8PCA1KQo+ ICsjZGVmaW5lIEFVRElPX1RZUEVfTFBDTQkJCQkoMiA8PCA3KQo+ICsjZGVmaW5lIENGR19TVUJf UENLVF9OVU0oeCkJCQkoKCgoeCkgLSAxKSAmIDB4NykgPDwgMTEpCj4gKyNkZWZpbmUgQVVESU9f Q0hfTlVNKHgpCQkJCSgoKCh4KSAtIDEpICYgMHgxZikgPDwgMikKPiArI2RlZmluZSBUUkFOU19T TVBMX1dJRFRIXzE2CQkJMAo+ICsjZGVmaW5lIFRSQU5TX1NNUExfV0lEVEhfMjQJCQlCSVQoMTEp Cj4gKyNkZWZpbmUgVFJBTlNfU01QTF9XSURUSF8zMgkJCSgyIDw8IDExKQo+ICsjZGVmaW5lIEky U19ERUNfUE9SVF9FTih4KQkJCSgoKHgpICYgMHhmKSA8PCAxNykKPiArI2RlZmluZSBTUERJRl9F TkFCTEUJCQkJQklUKDIxKQo+ICsjZGVmaW5lIFNQRElGX0FWR19TRUwJCQkJQklUKDIwKQo+ICsj ZGVmaW5lIFNQRElGX0pJVFRFUl9CWVBBU1MJCQlCSVQoMTkpCj4gKyNkZWZpbmUgU1BESUZfRklG T19NSURfUkFOR0UoeCkJCQkoKCh4KSAmIDB4ZmYpIDw8IDExKQo+ICsjZGVmaW5lIFNQRElGX0pJ VFRFUl9USFJTSCh4KQkJCSgoKHgpICYgMHhmZikgPDwgMykKPiArI2RlZmluZSBTUERJRl9KSVRU RVJfQVZHX1dJTih4KQkJCSgoeCkgJiAweDcpCj4gKwo+ICsvKiBSZWZlcm5jZSBjeWNsZXMgd2hl biB1c2luZyBsYW5lIGNsb2NrIGFzIHJlZmVybmNlICovCj4gKyNkZWZpbmUgTEFORV9SRUZfQ1lD CQkJCTB4ODAwMAo+ICsKPiArZW51bSB2b2x0YWdlX3N3aW5nX2xldmVsIHsKPiArCVZPTFRBR0Vf TEVWRUxfMCwKPiArCVZPTFRBR0VfTEVWRUxfMSwKPiArCVZPTFRBR0VfTEVWRUxfMiwKPiArCVZP TFRBR0VfTEVWRUxfMywKPiArfTsKPiArCj4gK2VudW0gcHJlX2VtcGhhc2lzX2xldmVsIHsKPiAr CVBSRV9FTVBIQVNJU19MRVZFTF8wLAo+ICsJUFJFX0VNUEhBU0lTX0xFVkVMXzEsCj4gKwlQUkVf RU1QSEFTSVNfTEVWRUxfMiwKPiArCVBSRV9FTVBIQVNJU19MRVZFTF8zLAo+ICt9Owo+ICsKPiAr ZW51bSBwYXR0ZXJuX3NldCB7Cj4gKwlQVFMxCQk9IEJJVCgwKSwKPiArCVBUUzIJCT0gQklUKDEp LAo+ICsJUFRTMwkJPSBCSVQoMiksCj4gKwlQVFM0CQk9IEJJVCgzKSwKPiArCURQX05PTkUJCT0g QklUKDQpCj4gK307Cj4gKwo+ICtlbnVtIHZpY19jb2xvcl9kZXB0aCB7Cj4gKwlCQ1NfNiA9IDB4 MSwKPiArCUJDU184ID0gMHgyLAo+ICsJQkNTXzEwID0gMHg0LAo+ICsJQkNTXzEyID0gMHg4LAo+ ICsJQkNTXzE2ID0gMHgxMCwKPiArfTsKPiArCj4gK2VudW0gdmljX2J0X3R5cGUgewo+ICsJQlRf NjAxID0gMHgwLAo+ICsJQlRfNzA5ID0gMHgxLAo+ICt9Owo+ICsKPiArdm9pZCBjZG5fZHBfY2xv Y2tfcmVzZXQoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwKTsKPiArCj4gK3ZvaWQgY2RuX2RwX3Nl dF9md19jbGsoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLCB1MzIgY2xrKTsKPiAraW50IGNkbl9k cF9sb2FkX2Zpcm13YXJlKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgY29uc3QgdTMyICppX21l bSwKPiArCQkJIHUzMiBpX3NpemUsIGNvbnN0IHUzMiAqZF9tZW0sIHUzMiBkX3NpemUpOwo+ICtp bnQgY2RuX2RwX2FjdGl2ZShzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAsIGJvb2wgZW5hYmxlKTsK PiAraW50IGNkbl9kcF9zZXRfaG9zdF9jYXAoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLCB1OCBs YW5lcyk7Cj4gK2ludCBjZG5fZHBfZXZlbnRfY29uZmlnKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpk cCk7Cj4gK3UzMiBjZG5fZHBfZ2V0X2V2ZW50KHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCk7Cj4g K2ludCBjZG5fZHBfZ2V0X2hwZF9zdGF0dXMoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwKTsKPiAr aW50IGNkbl9kcF9kcGNkX3dyaXRlKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgdTMyIGFkZHIs IHU4IHZhbHVlKTsKPiAraW50IGNkbl9kcF9kcGNkX3JlYWQoc3RydWN0IGNkbl9kcF9kZXZpY2Ug KmRwLCB1MzIgYWRkciwgdTggKmRhdGEsIHUxNiBsZW4pOwo+ICtpbnQgY2RuX2RwX2dldF9lZGlk X2Jsb2NrKHZvaWQgKmRwLCB1OCAqZWRpZCwKPiArCQkJICB1bnNpZ25lZCBpbnQgYmxvY2ssIHNp emVfdCBsZW5ndGgpOwo+ICtpbnQgY2RuX2RwX3RyYWluaW5nX3N0YXJ0KHN0cnVjdCBjZG5fZHBf ZGV2aWNlICpkcCk7Cj4gK2ludCBjZG5fZHBfZ2V0X3RyYWluaW5nX3N0YXR1cyhzdHJ1Y3QgY2Ru X2RwX2RldmljZSAqZHApOwo+ICtpbnQgY2RuX2RwX3NldF92aWRlb19zdGF0dXMoc3RydWN0IGNk bl9kcF9kZXZpY2UgKmRwLCBpbnQgYWN0aXZlKTsKPiAraW50IGNkbl9kcF9jb25maWdfdmlkZW8o c3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwKTsKPiAraW50IGNkbl9kcF9hdWRpb19zdG9wKHN0cnVj dCBjZG5fZHBfZGV2aWNlICpkcCwgc3RydWN0IGF1ZGlvX2luZm8gKmF1ZGlvKTsKPiAraW50IGNk bl9kcF9hdWRpb19tdXRlKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgYm9vbCBlbmFibGUpOwo+ ICtpbnQgY2RuX2RwX2F1ZGlvX2NvbmZpZ19zZXQoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLCBz dHJ1Y3QgYXVkaW9faW5mbyAqYXVkaW8pOwo+ICsjZW5kaWYgLyogX0NETl9EUF9SRUdfSCAqLwo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX3ZvcC5j IGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV92b3AuYwo+IGluZGV4IGVk ZDdlYzIuLmQ3MjNkOGUgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3Jv Y2tjaGlwX2RybV92b3AuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hp cF9kcm1fdm9wLmMKPiBAQCAtOTY5LDkgKzk2OSwxMSBAQCBzdGF0aWMgdm9pZCB2b3BfY3J0Y19l bmFibGUoc3RydWN0IGRybV9jcnRjICpjcnRjKQo+ICAgCQl2b3BfZHNwX2hvbGRfdmFsaWRfaXJx X2Rpc2FibGUodm9wKTsKPiAgIAl9Cj4gICAKPiAtCXBpbl9wb2wgPSAweDg7Cj4gLQlwaW5fcG9s IHw9IChhZGp1c3RlZF9tb2RlLT5mbGFncyAmIERSTV9NT0RFX0ZMQUdfTkhTWU5DKSA/IDAgOiAx Owo+IC0JcGluX3BvbCB8PSAoYWRqdXN0ZWRfbW9kZS0+ZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX05W U1lOQykgPyAwIDogKDEgPDwgMSk7Cj4gKwlwaW5fcG9sID0gQklUKERDTEtfSU5WRVJUKTsKPiAr CXBpbl9wb2wgfD0gKGFkanVzdGVkX21vZGUtPmZsYWdzICYgRFJNX01PREVfRkxBR19OSFNZTkMp ID8KPiArCQkgICAwIDogQklUKEhTWU5DX1BPU0lUSVZFKTsKPiArCXBpbl9wb2wgfD0gKGFkanVz dGVkX21vZGUtPmZsYWdzICYgRFJNX01PREVfRkxBR19OVlNZTkMpID8KPiArCQkgICAwIDogQklU KFZTWU5DX1BPU0lUSVZFKTsKPiAgIAlWT1BfQ1RSTF9TRVQodm9wLCBwaW5fcG9sLCBwaW5fcG9s KTsKPiAgIAo+ICAgCXN3aXRjaCAocy0+b3V0cHV0X3R5cGUpIHsKPiBAQCAtOTkxLDYgKzk5Mywx MSBAQCBzdGF0aWMgdm9pZCB2b3BfY3J0Y19lbmFibGUoc3RydWN0IGRybV9jcnRjICpjcnRjKQo+ ICAgCQlWT1BfQ1RSTF9TRVQodm9wLCBtaXBpX3Bpbl9wb2wsIHBpbl9wb2wpOwo+ICAgCQlWT1Bf Q1RSTF9TRVQodm9wLCBtaXBpX2VuLCAxKTsKPiAgIAkJYnJlYWs7Cj4gKwljYXNlIERSTV9NT0RF X0NPTk5FQ1RPUl9EaXNwbGF5UG9ydDoKPiArCQlwaW5fcG9sICY9IH5CSVQoRENMS19JTlZFUlQp Owo+ICsJCVZPUF9DVFJMX1NFVCh2b3AsIGRwX3Bpbl9wb2wsIHBpbl9wb2wpOwo+ICsJCVZPUF9D VFJMX1NFVCh2b3AsIGRwX2VuLCAxKTsKPiArCQlicmVhazsKPiAgIAlkZWZhdWx0Ogo+ICAgCQlE Uk1fRVJST1IoInVuc3VwcG9ydCBjb25uZWN0b3JfdHlwZVslZF1cbiIsIHMtPm91dHB1dF90eXBl KTsKPiAgIAl9Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hp cF9kcm1fdm9wLmggYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX3ZvcC5o Cj4gaW5kZXggZmY0ZjUyZS4uNDgyMGE4YiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0v cm9ja2NoaXAvcm9ja2NoaXBfZHJtX3ZvcC5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tj aGlwL3JvY2tjaGlwX2RybV92b3AuaAo+IEBAIC00NSw2ICs0NSw3IEBAIHN0cnVjdCB2b3BfY3Ry bCB7Cj4gICAJc3RydWN0IHZvcF9yZWcgZWRwX2VuOwo+ICAgCXN0cnVjdCB2b3BfcmVnIGhkbWlf ZW47Cj4gICAJc3RydWN0IHZvcF9yZWcgbWlwaV9lbjsKPiArCXN0cnVjdCB2b3BfcmVnIGRwX2Vu Owo+ICAgCXN0cnVjdCB2b3BfcmVnIG91dF9tb2RlOwo+ICAgCXN0cnVjdCB2b3BfcmVnIGRpdGhl cl9kb3duOwo+ICAgCXN0cnVjdCB2b3BfcmVnIGRpdGhlcl91cDsKPiBAQCAtNTMsNiArNTQsNyBA QCBzdHJ1Y3Qgdm9wX2N0cmwgewo+ICAgCXN0cnVjdCB2b3BfcmVnIGhkbWlfcGluX3BvbDsKPiAg IAlzdHJ1Y3Qgdm9wX3JlZyBlZHBfcGluX3BvbDsKPiAgIAlzdHJ1Y3Qgdm9wX3JlZyBtaXBpX3Bp bl9wb2w7Cj4gKwlzdHJ1Y3Qgdm9wX3JlZyBkcF9waW5fcG9sOwo+ICAgCj4gICAJc3RydWN0IHZv cF9yZWcgaHRvdGFsX3B3Owo+ICAgCXN0cnVjdCB2b3BfcmVnIGhhY3Rfc3RfZW5kOwo+IEBAIC0y NDIsNiArMjQ0LDEzIEBAIGVudW0gc2NhbGVfZG93bl9tb2RlIHsKPiAgIAlTQ0FMRV9ET1dOX0FW RyA9IDB4MQo+ICAgfTsKPiAgIAo+ICtlbnVtIHZvcF9wb2wgewo+ICsJSFNZTkNfUE9TSVRJVkUg PSAwLAo+ICsJVlNZTkNfUE9TSVRJVkUgPSAxLAo+ICsJREVOX05FR0FUSVZFICAgPSAyLAo+ICsJ RENMS19JTlZFUlQgICAgPSAzCj4gK307Cj4gKwo+ICAgI2RlZmluZSBGUkFDXzE2XzE2KG11bHQs IGRpdikgICAgKCgobXVsdCkgPDwgMTYpIC8gKGRpdikpCj4gICAjZGVmaW5lIFNDTF9GVF9ERUZB VUxUX0ZJWFBPSU5UX1NISUZUCTEyCj4gICAjZGVmaW5lIFNDTF9NQVhfVlNLSVBMSU5FUwkJNAo+ IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfdm9wX3JlZy5j IGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX3ZvcF9yZWcuYwo+IGluZGV4IDVi MWFlMWYuLmRjZjE3MmUgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3Jv Y2tjaGlwX3ZvcF9yZWcuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hp cF92b3BfcmVnLmMKPiBAQCAtMjgxLDYgKzI4MSw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgdm9w X2RhdGEgcmszMjg4X3ZvcCA9IHsKPiAgIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgdm9wX2N0cmwgcmsz Mzk5X2N0cmxfZGF0YSA9IHsKPiAgIAkuc3RhbmRieSA9IFZPUF9SRUcoUkszMzk5X1NZU19DVFJM LCAweDEsIDIyKSwKPiAgIAkuZ2F0ZV9lbiA9IFZPUF9SRUcoUkszMzk5X1NZU19DVFJMLCAweDEs IDIzKSwKPiArCS5kcF9lbiA9IFZPUF9SRUcoUkszMzk5X1NZU19DVFJMLCAweDEsIDExKSwKPiAg IAkucmdiX2VuID0gVk9QX1JFRyhSSzMzOTlfU1lTX0NUUkwsIDB4MSwgMTIpLAo+ICAgCS5oZG1p X2VuID0gVk9QX1JFRyhSSzMzOTlfU1lTX0NUUkwsIDB4MSwgMTMpLAo+ICAgCS5lZHBfZW4gPSBW T1BfUkVHKFJLMzM5OV9TWVNfQ1RSTCwgMHgxLCAxNCksCj4gQEAgLTI5MCw2ICsyOTEsNyBAQCBz dGF0aWMgY29uc3Qgc3RydWN0IHZvcF9jdHJsIHJrMzM5OV9jdHJsX2RhdGEgPSB7Cj4gICAJLmRh dGFfYmxhbmsgPSBWT1BfUkVHKFJLMzM5OV9EU1BfQ1RSTDAsIDB4MSwgMTkpLAo+ICAgCS5vdXRf bW9kZSA9IFZPUF9SRUcoUkszMzk5X0RTUF9DVFJMMCwgMHhmLCAwKSwKPiAgIAkucmdiX3Bpbl9w b2wgPSBWT1BfUkVHKFJLMzM5OV9EU1BfQ1RSTDEsIDB4ZiwgMTYpLAo+ICsJLmRwX3Bpbl9wb2wg PSBWT1BfUkVHKFJLMzM5OV9EU1BfQ1RSTDEsIDB4ZiwgMTYpLAo+ICAgCS5oZG1pX3Bpbl9wb2wg PSBWT1BfUkVHKFJLMzM5OV9EU1BfQ1RSTDEsIDB4ZiwgMjApLAo+ICAgCS5lZHBfcGluX3BvbCA9 IFZPUF9SRUcoUkszMzk5X0RTUF9DVFJMMSwgMHhmLCAyNCksCj4gICAJLm1pcGlfcGluX3BvbCA9 IFZPUF9SRUcoUkszMzk5X0RTUF9DVFJMMSwgMHhmLCAyOCksCgoKLS0gCu+8rWFyayBZYW8KCgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwg bWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0 cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 From: mark.yao@rock-chips.com (Mark yao) Date: Fri, 22 Jul 2016 08:41:19 +0800 Subject: [v6 PATCH 6/6] drm/rockchip: cdn-dp: add cdn DP support for rk3399 In-Reply-To: <1469106808-28297-7-git-send-email-zyw@rock-chips.com> References: <1469106808-28297-1-git-send-email-zyw@rock-chips.com> <1469106808-28297-7-git-send-email-zyw@rock-chips.com> Message-ID: <57916BAF.10109@rock-chips.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On 2016?07?21? 21:13, Chris Zhong wrote: > Add support for cdn DP controller which is embedded in the rk3399 > SoCs. The DP is compliant with DisplayPort Specification, > Version 1.3, This IP is compatible with the rockchip type-c PHY IP. > There is a uCPU in DP controller, it need a firmware to work, > please put the firmware file to /lib/firmware/cdn/dptx.bin. The > uCPU in charge of aux communication and link training, the host use > mailbox to communicate with the ucpu. > The dclk pin_pol of vop must not be invert for DP. > > Signed-off-by: Chris Zhong > Reviewed-by: Sean Paul Sean Paul already do a good review, I think it's ready to be merged, so Acked-by: Mark Yao > --- > > Changes in v6: > - add a port struct > - select SND_SOC_HDMI_CODEC > - force reset the phy when hpd detected > > Changes in v5: > - alphabetical order > - do not use long, use u32 or u64 > - return MODE_CLOCK_HIGH when requested > actual > - Optimized Coding Style > - add a formula to get better tu size and symbol value. > - modify according to Sean Paul's comments > - fixed the fw_wait always 0 > > Changes in v4: > - use phy framework to control DP phy > - support 2 phys > > Changes in v3: > - use EXTCON_DISP_DP and EXTCON_DISP_DP_ALT cable to get dp port state. > - reset spdif before config it > - modify the firmware clk to 100Mhz > - retry load firmware if fw file is requested too early > > Changes in v2: > - Alphabetic order > - remove excess error message > - use define clk_rate > - check all return value > - remove dev_set_name(dp->dev, "cdn-dp"); > - use schedule_delayed_work > - remove never-called functions > - remove some unnecessary () > > Changes in v1: > - use extcon API > - use hdmi-codec for the DP Asoc > - do not initialize the "ret" > - printk a err log when drm_of_encoder_active_endpoint_id > - modify the dclk pin_pol to a single line > > drivers/gpu/drm/rockchip/Kconfig | 10 + > drivers/gpu/drm/rockchip/Makefile | 1 + > drivers/gpu/drm/rockchip/cdn-dp-core.c | 868 ++++++++++++++++++++++++++ > drivers/gpu/drm/rockchip/cdn-dp-core.h | 102 ++++ > drivers/gpu/drm/rockchip/cdn-dp-reg.c | 904 ++++++++++++++++++++++++++++ > drivers/gpu/drm/rockchip/cdn-dp-reg.h | 479 +++++++++++++++ > drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 13 +- > drivers/gpu/drm/rockchip/rockchip_drm_vop.h | 9 + > drivers/gpu/drm/rockchip/rockchip_vop_reg.c | 2 + > 9 files changed, 2385 insertions(+), 3 deletions(-) > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-core.c > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-core.h > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-reg.c > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-reg.h > > diff --git a/drivers/gpu/drm/rockchip/Kconfig b/drivers/gpu/drm/rockchip/Kconfig > index d30bdc3..20aaafe 100644 > --- a/drivers/gpu/drm/rockchip/Kconfig > +++ b/drivers/gpu/drm/rockchip/Kconfig > @@ -25,6 +25,16 @@ config ROCKCHIP_ANALOGIX_DP > for the Analogix Core DP driver. If you want to enable DP > on RK3288 based SoC, you should selet this option. > > +config ROCKCHIP_CDN_DP > + tristate "Rockchip cdn DP" > + depends on DRM_ROCKCHIP > + select SND_SOC_HDMI_CODEC if SND_SOC > + help > + This selects support for Rockchip SoC specific extensions > + for the cdn DP driver. If you want to enable Dp on > + RK3399 based SoC, you should select this > + option. > + > config ROCKCHIP_DW_HDMI > tristate "Rockchip specific extensions for Synopsys DW HDMI" > depends on DRM_ROCKCHIP > diff --git a/drivers/gpu/drm/rockchip/Makefile b/drivers/gpu/drm/rockchip/Makefile > index 05d0713..abdecd5 100644 > --- a/drivers/gpu/drm/rockchip/Makefile > +++ b/drivers/gpu/drm/rockchip/Makefile > @@ -7,6 +7,7 @@ rockchipdrm-y := rockchip_drm_drv.o rockchip_drm_fb.o \ > rockchipdrm-$(CONFIG_DRM_FBDEV_EMULATION) += rockchip_drm_fbdev.o > > obj-$(CONFIG_ROCKCHIP_ANALOGIX_DP) += analogix_dp-rockchip.o > +obj-$(CONFIG_ROCKCHIP_CDN_DP) += cdn-dp-core.o cdn-dp-reg.o > obj-$(CONFIG_ROCKCHIP_DW_HDMI) += dw_hdmi-rockchip.o > obj-$(CONFIG_ROCKCHIP_DW_MIPI_DSI) += dw-mipi-dsi.o > obj-$(CONFIG_ROCKCHIP_INNO_HDMI) += inno_hdmi.o > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-core.c b/drivers/gpu/drm/rockchip/cdn-dp-core.c > new file mode 100644 > index 0000000..209a7ef > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-core.c > @@ -0,0 +1,868 @@ > +/* > + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd > + * Author: Chris Zhong > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > + > +#include "cdn-dp-core.h" > +#include "cdn-dp-reg.h" > +#include "rockchip_drm_vop.h" > + > +#define connector_to_dp(c) \ > + container_of(c, struct cdn_dp_device, connector) > + > +#define encoder_to_dp(c) \ > + container_of(c, struct cdn_dp_device, encoder) > + > +/* dp grf register offset */ > +#define DP_VOP_SEL 0x6224 > +#define DP_SEL_VOP_LIT BIT(12) > +#define MAX_FW_WAIT_SECS 64 > +#define CDN_DP_FIRMWARE "rockchip/dptx.bin" > + > +struct cdn_dp_data { > + u8 max_phy; > +}; > + > +struct cdn_dp_data rk3399_cdn_dp = { > + .max_phy = 2, > +}; > + > +static const struct of_device_id cdn_dp_dt_ids[] = { > + { .compatible = "rockchip,rk3399-cdn-dp", > + .data = (void *)&rk3399_cdn_dp }, align the .data? > + {} > +}; > + > +MODULE_DEVICE_TABLE(of, cdn_dp_dt_ids); > + > +static int cdn_dp_clk_enable(struct cdn_dp_device *dp) > +{ > + int ret; > + u32 rate; > + > + ret = clk_prepare_enable(dp->pclk); > + if (ret < 0) { > + dev_err(dp->dev, "cannot enable dp pclk %d\n", ret); > + goto err_pclk; > + } > + > + ret = clk_prepare_enable(dp->core_clk); > + if (ret < 0) { > + dev_err(dp->dev, "cannot enable core_clk %d\n", ret); > + goto err_core_clk; > + } > + > + rate = clk_get_rate(dp->core_clk); > + if (rate < 0) { > + dev_err(dp->dev, "get clk rate failed: %d\n", rate); > + goto err_set_rate; > + } > + > + cdn_dp_set_fw_clk(dp, rate); > + > + return 0; > + > +err_set_rate: > + clk_disable_unprepare(dp->core_clk); > +err_core_clk: > + clk_disable_unprepare(dp->pclk); > +err_pclk: > + return ret; > +} > + > +static enum drm_connector_status > +cdn_dp_connector_detect(struct drm_connector *connector, bool force) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + > + return dp->hpd_status; > +} > + > +static void cdn_dp_connector_destroy(struct drm_connector *connector) > +{ > + drm_connector_unregister(connector); > + drm_connector_cleanup(connector); > +} > + > +static struct drm_connector_funcs cdn_dp_atomic_connector_funcs = { > + .dpms = drm_atomic_helper_connector_dpms, > + .detect = cdn_dp_connector_detect, > + .destroy = cdn_dp_connector_destroy, > + .fill_modes = drm_helper_probe_single_connector_modes, > + .reset = drm_atomic_helper_connector_reset, > + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, > + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, > +}; > + > +static int cdn_dp_connector_get_modes(struct drm_connector *connector) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + struct edid *edid; > + int ret = 0; > + > + edid = drm_do_get_edid(connector, cdn_dp_get_edid_block, dp); > + if (edid) { > + dev_dbg(dp->dev, "got edid: width[%d] x height[%d]\n", > + edid->width_cm, edid->height_cm); > + > + dp->sink_has_audio = drm_detect_monitor_audio(edid); > + ret = drm_add_edid_modes(connector, edid); > + if (ret) { > + drm_mode_connector_update_edid_property(connector, > + edid); > + drm_edid_to_eld(connector, edid); > + } > + kfree(edid); > + } else { > + dev_warn(dp->dev, "failed to get edid\n"); > + } > + > + return ret; > +} > + > +static struct drm_encoder * > + cdn_dp_connector_best_encoder(struct drm_connector *connector) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + > + return &dp->encoder; > +} > + > +static int cdn_dp_connector_mode_valid(struct drm_connector *connector, > + struct drm_display_mode *mode) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + struct drm_display_info *display_info = &dp->connector.display_info; > + u32 requested = mode->clock * display_info->bpc * 3 / 1000; > + u32 sink_max, source_max, rate; > + u8 lanes, i; > + u32 actual; > + > + /* find the running port */ > + for (i = 0; i < dp->ports; i++) { > + if (dp->port[i]->phy_status == 1) { > + source_max = dp->port[i]->cap_lanes; > + break; > + } > + } > + > + sink_max = drm_dp_max_lane_count(dp->dpcd); > + lanes = min(source_max, sink_max); > + > + source_max = drm_dp_bw_code_to_link_rate(CDN_DP_MAX_LINK_RATE); > + sink_max = drm_dp_max_link_rate(dp->dpcd); > + rate = min(source_max, sink_max); > + > + actual = rate * lanes / 100; > + > + /* efficiency is about 0.8 */ > + actual = actual * 8 / 10; > + > + if (requested > actual) { > + dev_dbg(dp->dev, "requested=%d, actual=%d, clock=%d\n", > + requested, actual, mode->clock); > + return MODE_CLOCK_HIGH; > + } > + > + return MODE_OK; > +} > + > +static struct drm_connector_helper_funcs cdn_dp_connector_helper_funcs = { > + .get_modes = cdn_dp_connector_get_modes, > + .best_encoder = cdn_dp_connector_best_encoder, > + .mode_valid = cdn_dp_connector_mode_valid, > +}; > + > +static void cdn_dp_commit(struct drm_encoder *encoder) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + int ret; > + > + ret = cdn_dp_training_start(dp); > + if (ret) { > + dev_err(dp->dev, "link training failed: %d\n", ret); > + return; > + } > + > + ret = cdn_dp_get_training_status(dp); > + if (ret) { > + dev_err(dp->dev, "get link training status failed: %d\n", ret); > + return; > + } > + > + dev_info(dp->dev, "rate:%d, lanes:%d\n", > + dp->link.rate, dp->link.num_lanes); > + > + if (cdn_dp_set_video_status(dp, CONTROL_VIDEO_IDLE)) > + return; > + > + if (cdn_dp_config_video(dp)) { > + dev_err(dp->dev, "unable to config video\n"); > + return; > + } > + > + if (cdn_dp_set_video_status(dp, CONTROL_VIDEO_VALID)) > + return; > + > + dp->dpms_mode = DRM_MODE_DPMS_ON; > +} > + > +static void cdn_dp_encoder_mode_set(struct drm_encoder *encoder, > + struct drm_display_mode *mode, > + struct drm_display_mode *adjusted) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + struct drm_display_info *display_info = &dp->connector.display_info; > + struct rockchip_crtc_state *state; > + struct video_info *video = &dp->video_info; > + int ret, val; > + > + switch (display_info->bpc) { > + case 16: > + case 12: > + case 10: > + video->color_depth = 10; > + break; > + case 6: > + video->color_depth = 6; > + break; > + default: > + video->color_depth = 8; > + break; > + } > + > + video->color_fmt = PXL_RGB; > + > + video->v_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NVSYNC); > + video->h_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NHSYNC); > + > + ret = drm_of_encoder_active_endpoint_id(dp->dev->of_node, encoder); > + if (ret < 0) { > + dev_err(dp->dev, "Could not get vop id, %d", ret); > + return; > + } > + > + dev_dbg(dp->dev, "vop %s output to cdn-dp\n", (ret) ? "LIT" : "BIG"); > + state = to_rockchip_crtc_state(encoder->crtc->state); > + if (ret) { > + val = DP_SEL_VOP_LIT | (DP_SEL_VOP_LIT << 16); > + state->output_mode = ROCKCHIP_OUT_MODE_P888; > + } else { > + val = DP_SEL_VOP_LIT << 16; > + state->output_mode = ROCKCHIP_OUT_MODE_AAAA; > + } > + ret = regmap_write(dp->grf, DP_VOP_SEL, val); > + if (ret != 0) > + dev_err(dp->dev, "Could not write to GRF: %d\n", ret); > + > + memcpy(&dp->mode, adjusted, sizeof(*mode)); > +} > + > +static void cdn_dp_encoder_enable(struct drm_encoder *encoder) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + > + if (dp->dpms_mode != DRM_MODE_DPMS_ON) > + cdn_dp_commit(encoder); > +} > + > +static void cdn_dp_encoder_disable(struct drm_encoder *encoder) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + > + if (dp->dpms_mode != DRM_MODE_DPMS_OFF) { > + cdn_dp_set_video_status(dp, CONTROL_VIDEO_IDLE); > + dp->dpms_mode = DRM_MODE_DPMS_OFF; > + } > +} > + > +static int > +cdn_dp_encoder_atomic_check(struct drm_encoder *encoder, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state) > +{ > + struct rockchip_crtc_state *s = to_rockchip_crtc_state(crtc_state); > + > + s->output_mode = ROCKCHIP_OUT_MODE_AAAA; > + s->output_type = DRM_MODE_CONNECTOR_DisplayPort; > + > + return 0; > +} > + > +static struct drm_encoder_helper_funcs cdn_dp_encoder_helper_funcs = { > + .mode_set = cdn_dp_encoder_mode_set, > + .enable = cdn_dp_encoder_enable, > + .disable = cdn_dp_encoder_disable, > + .atomic_check = cdn_dp_encoder_atomic_check, > +}; > + > +static struct drm_encoder_funcs cdn_dp_encoder_funcs = { > + .destroy = drm_encoder_cleanup, > +}; > + > +static int cdn_dp_firmware_init(struct cdn_dp_device *dp) > +{ > + int ret; > + const u32 *iram_data, *dram_data; > + const struct firmware *fw = dp->fw; > + const struct cdn_firmware_header *hdr; > + > + hdr = (struct cdn_firmware_header *)fw->data; > + if (fw->size != le32_to_cpu(hdr->size_bytes)) { > + dev_err(dp->dev, "firmware is invalid\n"); > + return -EINVAL; > + } > + > + iram_data = (const u32 *)(fw->data + hdr->header_size); > + dram_data = (const u32 *)(fw->data + hdr->header_size + hdr->iram_size); > + > + ret = cdn_dp_load_firmware(dp, iram_data, hdr->iram_size, > + dram_data, hdr->dram_size); > + if (ret) > + return ret; > + > + dp->fw_loaded = 1; > + > + ret = cdn_dp_active(dp, true); > + if (ret) { > + dev_err(dp->dev, "active ucpu failed: %d\n", ret); > + return ret; > + } > + > + return cdn_dp_event_config(dp); > +} > + > +static int cdn_dp_init(struct cdn_dp_device *dp) > +{ > + struct device *dev = dp->dev; > + struct device_node *np = dev->of_node; > + struct platform_device *pdev = to_platform_device(dev); > + struct resource *res; > + int ret; > + > + dp->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf"); > + if (IS_ERR(dp->grf)) { > + dev_err(dev, "cdn-dp needs rockchip,grf property\n"); > + return PTR_ERR(dp->grf); > + } > + > + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); > + dp->regs = devm_ioremap_resource(dev, res); > + if (IS_ERR(dp->regs)) { > + dev_err(dev, "ioremap reg failed\n"); > + return PTR_ERR(dp->regs); > + } > + > + dp->core_clk = devm_clk_get(dev, "core-clk"); > + if (IS_ERR(dp->core_clk)) { > + dev_err(dev, "cannot get core_clk_dp\n"); > + return PTR_ERR(dp->core_clk); > + } > + > + dp->pclk = devm_clk_get(dev, "pclk"); > + if (IS_ERR(dp->pclk)) { > + dev_err(dev, "cannot get pclk\n"); > + return PTR_ERR(dp->pclk); > + } > + > + dp->spdif_clk = devm_clk_get(dev, "spdif"); > + if (IS_ERR(dp->spdif_clk)) { > + dev_err(dev, "cannot get spdif_clk\n"); > + return PTR_ERR(dp->spdif_clk); > + } > + > + dp->spdif_rst = devm_reset_control_get(dev, "spdif"); > + if (IS_ERR(dp->spdif_rst)) { > + dev_err(dev, "no spdif reset control found\n"); > + return PTR_ERR(dp->spdif_rst); > + } > + > + dp->dpms_mode = DRM_MODE_DPMS_OFF; > + > + ret = cdn_dp_clk_enable(dp); > + if (ret < 0) > + return ret; > + > + cdn_dp_clock_reset(dp); > + > + return 0; > +} > + > +static int cdn_dp_audio_hw_params(struct device *dev, > + struct hdmi_codec_daifmt *daifmt, > + struct hdmi_codec_params *params) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct audio_info audio = { > + .sample_width = params->sample_width, > + .sample_rate = params->sample_rate, > + .channels = params->channels, > + }; > + int ret; > + > + if (!dp->encoder.crtc) > + return -ENODEV; > + > + switch (daifmt->fmt) { > + case HDMI_I2S: > + audio.format = AFMT_I2S; > + break; > + case HDMI_SPDIF: > + audio.format = AFMT_SPDIF; > + break; > + default: > + dev_err(dev, "%s: Invalid format %d\n", __func__, daifmt->fmt); > + return -EINVAL; > + } > + > + ret = cdn_dp_audio_config_set(dp, &audio); > + if (!ret) > + dp->audio_info = audio; > + > + return ret; > +} > + > +static void cdn_dp_audio_shutdown(struct device *dev) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + int ret = cdn_dp_audio_stop(dp, &dp->audio_info); > + > + if (!ret) > + dp->audio_info.format = AFMT_UNUSED; > +} > + > +static int cdn_dp_audio_digital_mute(struct device *dev, bool enable) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + > + return cdn_dp_audio_mute(dp, enable); > +} > + > +static int cdn_dp_audio_get_eld(struct device *dev, uint8_t *buf, size_t len) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct drm_mode_config *config = &dp->encoder.dev->mode_config; > + struct drm_connector *connector; > + int ret = -ENODEV; > + > + mutex_lock(&config->mutex); > + list_for_each_entry(connector, &config->connector_list, head) { > + if (&dp->encoder == connector->encoder) { > + memcpy(buf, connector->eld, > + min(sizeof(connector->eld), len)); > + ret = 0; > + } > + } > + mutex_unlock(&config->mutex); > + > + return ret; > +} > + > +static const struct hdmi_codec_ops audio_codec_ops = { > + .hw_params = cdn_dp_audio_hw_params, > + .audio_shutdown = cdn_dp_audio_shutdown, > + .digital_mute = cdn_dp_audio_digital_mute, > + .get_eld = cdn_dp_audio_get_eld, > +}; > + > +static int cdn_dp_audio_codec_init(struct cdn_dp_device *dp, > + struct device *dev) > +{ > + struct hdmi_codec_pdata codec_data = { > + .i2s = 1, > + .spdif = 1, > + .ops = &audio_codec_ops, > + .max_i2s_channels = 8, > + }; > + > + dp->audio_pdev = platform_device_register_data( > + dev, HDMI_CODEC_DRV_NAME, PLATFORM_DEVID_AUTO, > + &codec_data, sizeof(codec_data)); > + > + return PTR_ERR_OR_ZERO(dp->audio_pdev); > +} > + > +static int cdn_dp_get_cap_lanes(struct cdn_dp_device *dp, > + struct extcon_dev *edev) > +{ > + bool dfp, dptx; > + u8 lanes; > + > + dfp = extcon_get_cable_state_(edev, EXTCON_USB_HOST); > + dptx = extcon_get_cable_state_(edev, EXTCON_DISP_DP); > + > + if (dfp && dptx) > + lanes = 2; > + else if (dptx) > + lanes = 4; > + else > + lanes = 0; > + > + return lanes; > +} > + > +static int cdn_dp_phy_power_ctrl(struct cdn_dp_device *dp, > + struct cdn_dp_port *port, bool enable) > +{ > + struct phy *phy = port->phy; > + int ret; > + int count = 0; > + > + while (phy->power_count > 0) { > + ret = phy_power_off(phy); > + if (ret) > + return ret; > + count++; > + } > + > + count = enable ? count + 1 : count - 1; > + while (count-- > 0) { > + ret = phy_power_on(phy); > + if (ret) > + return ret; > + } > + > + port->phy_status = enable; > + return 0; > +} > + > +static int cdn_dp_pd_event(struct notifier_block *nb, > + unsigned long event, void *priv) > +{ > + struct cdn_dp_port *port; > + > + port = container_of(nb, struct cdn_dp_port, event_nb); > + > + schedule_delayed_work(&port->event_wq, 0); > + > + return 0; > +} > + > +static void cdn_dp_pd_event_wq(struct work_struct *work) > +{ > + struct cdn_dp_port *port = container_of(work, struct cdn_dp_port, > + event_wq.work); > + struct cdn_dp_device *dp = port->dp; > + u8 new_cap_lanes; > + int ret; > + u8 i; > + > + new_cap_lanes = cdn_dp_get_cap_lanes(dp, port->extcon); > + > + if (new_cap_lanes == port->cap_lanes) { > + dev_err(dp->dev, "lanes count does not change: %d\n", > + new_cap_lanes); > + return; > + } > + > + if (!new_cap_lanes) { > + ret = cdn_dp_phy_power_ctrl(dp, port, 0); > + if (ret) { > + dev_err(dp->dev, "phy power off failed: %d", ret); > + return; > + } > + port->phy_status = 0; > + port->cap_lanes = new_cap_lanes; > + for (i = 0; i < dp->ports; i++) { > + if (dp->port[i]->phy_status == 1) > + return; > + } > + > + dp->hpd_status = connector_status_disconnected; > + drm_helper_hpd_irq_event(dp->drm_dev); > + return; > + } > + > + /* if other phy is running, do not touch the hpd_status, and return */ > + for (i = 0; i < dp->ports; i++) { > + if (dp->port[i]->phy_status == 1) { > + dev_warn(dp->dev, "busy, phy[%d] is running", > + dp->port[i]->id); > + return; > + } > + } > + > + if (!dp->fw_loaded) { > + ret = request_firmware(&dp->fw, CDN_DP_FIRMWARE, dp->dev); > + if (ret == -ENOENT && dp->fw_wait <= MAX_FW_WAIT_SECS) { > + unsigned long time = msecs_to_jiffies(dp->fw_wait * HZ); > + > + /* > + * If can not find the file, retry to load the firmware > + * in 1 second, if still failed after 1 minute, give up. > + */ > + schedule_delayed_work(&port->event_wq, time); > + dev_warn(dp->dev, "retry to request firmware in %dS\n", > + dp->fw_wait); > + dp->fw_wait *= 2; > + return; > + } else if (ret) { > + dev_err(dp->dev, "failed to request firmware: %d\n", > + ret); > + return; > + } > + } > + > + ret = cdn_dp_phy_power_ctrl(dp, port, 1); > + if (ret) { > + if (!dp->fw_loaded) > + release_firmware(dp->fw); > + dev_err(dp->dev, "phy power on failed: %d\n", ret); > + return; > + } > + > + if (!dp->fw_loaded) { > + ret = cdn_dp_firmware_init(dp); > + release_firmware(dp->fw); > + if (ret) { > + dev_err(dp->dev, "firmware init failed: %d", ret); > + goto err_firmware; > + } > + } > + > + /* read hpd status failed, or the hpd does not exist. */ > + ret = cdn_dp_get_hpd_status(dp); > + if (ret <= 0) { > + dev_err(dp->dev, "get hpd failed: %d", ret); > + goto err_firmware; > + } > + > + ret = cdn_dp_set_host_cap(dp, new_cap_lanes); > + if (ret) { > + dev_err(dp->dev, "set host capabilities failed: %d\n", ret); > + goto err_firmware; > + } > + > + /* > + * Native read with retry for link status and receiver capability reads > + * for cases where the sink may still be asleep. > + * > + * Sinks are *supposed* to come up within 1ms from an off state, but > + * we're also supposed to retry 3 times per the spec. > + */ > + for (i = 0; i < 3; i++) { > + ret = cdn_dp_dpcd_read(dp, 0x000, dp->dpcd, > + DP_RECEIVER_CAP_SIZE); > + if (!ret) { > + port->cap_lanes = new_cap_lanes; > + dp->hpd_status = connector_status_connected; > + drm_helper_hpd_irq_event(dp->drm_dev); > + return; > + } > + usleep_range(1000, 1050); > + } > + > + dev_err(dp->dev, "get dpcd failed: %d", ret); > + > +err_firmware: > + ret = cdn_dp_phy_power_ctrl(dp, port, 0); > + if (ret) > + dev_err(dp->dev, "phy power off failed: %d", ret); > +} > + > +static int cdn_dp_bind(struct device *dev, struct device *master, > + void *data) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct drm_encoder *encoder; > + struct drm_connector *connector; > + struct cdn_dp_port *port; > + struct drm_device *drm_dev = data; > + int ret, i; > + > + ret = cdn_dp_init(dp); > + if (ret < 0) > + return ret; > + > + dp->drm_dev = drm_dev; > + dp->hpd_status = connector_status_disconnected; > + dp->fw_wait = 1; > + > + encoder = &dp->encoder; > + > + encoder->possible_crtcs = drm_of_find_possible_crtcs(drm_dev, > + dev->of_node); > + DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs); > + > + ret = drm_encoder_init(drm_dev, encoder, &cdn_dp_encoder_funcs, > + DRM_MODE_ENCODER_TMDS, NULL); > + if (ret) { > + DRM_ERROR("failed to initialize encoder with drm\n"); > + return ret; > + } > + > + drm_encoder_helper_add(encoder, &cdn_dp_encoder_helper_funcs); > + > + connector = &dp->connector; > + connector->polled = DRM_CONNECTOR_POLL_HPD; > + connector->dpms = DRM_MODE_DPMS_OFF; > + > + ret = drm_connector_init(drm_dev, connector, > + &cdn_dp_atomic_connector_funcs, > + DRM_MODE_CONNECTOR_DisplayPort); > + if (ret) { > + DRM_ERROR("failed to initialize connector with drm\n"); > + goto err_free_encoder; > + } > + > + drm_connector_helper_add(connector, &cdn_dp_connector_helper_funcs); > + > + ret = drm_mode_connector_attach_encoder(connector, encoder); > + if (ret) { > + DRM_ERROR("failed to attach connector and encoder\n"); > + goto err_free_connector; > + } > + > + cdn_dp_audio_codec_init(dp, dev); > + > + > + for (i = 0; i < dp->ports; i++) { > + port = dp->port[i]; > + > + port->event_nb.notifier_call = cdn_dp_pd_event; > + INIT_DELAYED_WORK(&port->event_wq, cdn_dp_pd_event_wq); > + ret = extcon_register_notifier(port->extcon, EXTCON_DISP_DP, > + &port->event_nb); > + if (ret) { > + dev_err(dev, "regitster EXTCON_DISP_DP notifier err\n"); > + return ret; > + } > + > + if (extcon_get_cable_state_(port->extcon, EXTCON_DISP_DP)) > + schedule_delayed_work(&port->event_wq, 0); > + } > + > + return 0; > + > +err_free_connector: > + drm_connector_cleanup(connector); > +err_free_encoder: > + drm_encoder_cleanup(encoder); > + return ret; > +} > + > +static void cdn_dp_unbind(struct device *dev, struct device *master, void *data) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct drm_encoder *encoder = &dp->encoder; > + struct drm_connector *connector = &dp->connector; > + struct cdn_dp_port *port; > + int i; > + > + platform_device_unregister(dp->audio_pdev); > + cdn_dp_encoder_disable(encoder); > + encoder->funcs->destroy(encoder); > + connector->funcs->destroy(connector); > + > + for (i = 0; i < dp->ports; i++) { > + port = dp->port[i]; > + extcon_unregister_notifier(port->extcon, EXTCON_DISP_DP, > + &port->event_nb); > + } > +} > + > +static const struct component_ops cdn_dp_component_ops = { > + .bind = cdn_dp_bind, > + .unbind = cdn_dp_unbind, > +}; > + > +static int cdn_dp_probe(struct platform_device *pdev) > +{ > + struct device *dev = &pdev->dev; > + const struct of_device_id *match; > + struct cdn_dp_data *dp_data; > + struct cdn_dp_port *port; > + struct cdn_dp_device *dp; > + struct extcon_dev *extcon; > + struct phy *phy; > + int i; > + > + dp = devm_kzalloc(dev, sizeof(*dp), GFP_KERNEL); > + if (!dp) > + return -ENOMEM; > + dp->dev = dev; > + > + match = of_match_node(cdn_dp_dt_ids, pdev->dev.of_node); > + dp_data = (struct cdn_dp_data *)match->data; > + > + for (i = 0; i < dp_data->max_phy; i++) { > + extcon = extcon_get_edev_by_phandle(dev, i); > + phy = devm_of_phy_get_by_index(dev, dev->of_node, i); > + > + if (PTR_ERR(extcon) == -EPROBE_DEFER || > + PTR_ERR(phy) == -EPROBE_DEFER) > + return -EPROBE_DEFER; > + > + if (IS_ERR(extcon) || IS_ERR(phy)) > + continue; > + > + port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL); > + if (!dp) > + return -ENOMEM; > + > + port->extcon = extcon; > + port->phy = phy; > + port->dp = dp; > + port->id = i; > + dp->port[dp->ports++] = port; > + } > + > + if (!dp->ports) { > + dev_err(dev, "missing extcon or phy\n"); > + return -EINVAL; > + } > + > + dev_set_drvdata(dev, dp); > + > + return component_add(dev, &cdn_dp_component_ops); > +} > + > +static int cdn_dp_remove(struct platform_device *pdev) > +{ > + component_del(&pdev->dev, &cdn_dp_component_ops); > + > + return 0; > +} > + > +static struct platform_driver cdn_dp_driver = { > + .probe = cdn_dp_probe, > + .remove = cdn_dp_remove, > + .driver = { > + .name = "cdn-dp", > + .owner = THIS_MODULE, > + .of_match_table = of_match_ptr(cdn_dp_dt_ids), > + }, > +}; > + > +module_platform_driver(cdn_dp_driver); > + > +MODULE_AUTHOR("Chris Zhong "); > +MODULE_DESCRIPTION("cdn DP Driver"); > +MODULE_LICENSE("GPL v2"); > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-core.h b/drivers/gpu/drm/rockchip/cdn-dp-core.h > new file mode 100644 > index 0000000..6eb7b72 > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-core.h > @@ -0,0 +1,102 @@ > +/* > + * Copyright (C) 2016 Chris Zhong > + * Copyright (C) 2016 ROCKCHIP, Inc. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#ifndef _CDN_DP_CORE_H > +#define _CDN_DP_CORE_H > + > +#include > +#include > +#include > +#include > +#include "rockchip_drm_drv.h" > + > +#define MAX_PHY 2 > + > +enum audio_format { > + AFMT_I2S = 0, > + AFMT_SPDIF = 1, > + AFMT_UNUSED, > +}; > + > +struct audio_info { > + enum audio_format format; > + int sample_rate; > + int channels; > + int sample_width; > +}; > + > +enum vic_pxl_encoding_format { > + PXL_RGB = 0x1, > + YCBCR_4_4_4 = 0x2, > + YCBCR_4_2_2 = 0x4, > + YCBCR_4_2_0 = 0x8, > + Y_ONLY = 0x10, > +}; > + > +struct video_info { > + bool h_sync_polarity; > + bool v_sync_polarity; > + bool interlaced; > + int color_depth; > + enum vic_pxl_encoding_format color_fmt; > +}; > + > +struct cdn_firmware_header { > + u32 size_bytes; /* size of the entire header+image(s) in bytes */ > + u32 header_size; /* size of just the header in bytes */ > + u32 iram_size; /* size of iram */ > + u32 dram_size; /* size of dram */ > +}; > + > +struct cdn_dp_port { > + struct cdn_dp_device *dp; > + struct notifier_block event_nb; > + struct delayed_work event_wq; > + struct extcon_dev *extcon; > + struct phy *phy; > + u8 cap_lanes; > + bool phy_status; > + u8 id; > +}; > + > +struct cdn_dp_device { > + struct device *dev; > + struct drm_device *drm_dev; > + struct drm_connector connector; > + struct drm_encoder encoder; > + struct drm_display_mode mode; > + struct platform_device *audio_pdev; > + > + const struct firmware *fw; /* cdn dp firmware */ > + unsigned int fw_version; /* cdn fw version */ > + u32 fw_wait; > + bool fw_loaded; > + void __iomem *regs; > + struct regmap *grf; > + struct clk *core_clk; > + struct clk *pclk; > + struct clk *spdif_clk; > + struct reset_control *spdif_rst; > + struct audio_info audio_info; > + struct video_info video_info; > + struct drm_dp_link link; > + struct cdn_dp_port *port[MAX_PHY]; > + u8 ports; > + > + u8 dpcd[DP_RECEIVER_CAP_SIZE]; > + enum drm_connector_status hpd_status; > + int dpms_mode; > + bool sink_has_audio; > +}; > +#endif /* _CDN_DP_CORE_H */ > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-reg.c b/drivers/gpu/drm/rockchip/cdn-dp-reg.c > new file mode 100644 > index 0000000..a224a6b > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-reg.c > @@ -0,0 +1,904 @@ > +/* > + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd > + * Author: Chris Zhong > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "cdn-dp-core.h" > +#include "cdn-dp-reg.h" > + > +#define CDN_DP_SPDIF_CLK 200000000 > +#define FW_ALIVE_TIMEOUT_US 1000000 > +#define MAILBOX_RETRY_US 1000 > +#define MAILBOX_TIMEOUT_US 5000000 > +#define LINK_TRAINING_RETRY_MS 20 > +#define LINK_TRAINING_TIMEOUT_MS 500 > + > +void cdn_dp_set_fw_clk(struct cdn_dp_device *dp, u32 clk) > +{ > + writel(clk / 1000000, dp->regs + SW_CLK_H); > +} > + > +void cdn_dp_clock_reset(struct cdn_dp_device *dp) > +{ > + u32 val; > + > + val = DPTX_FRMR_DATA_CLK_RSTN_EN | > + DPTX_FRMR_DATA_CLK_EN | > + DPTX_PHY_DATA_RSTN_EN | > + DPTX_PHY_DATA_CLK_EN | > + DPTX_PHY_CHAR_RSTN_EN | > + DPTX_PHY_CHAR_CLK_EN | > + SOURCE_AUX_SYS_CLK_RSTN_EN | > + SOURCE_AUX_SYS_CLK_EN | > + DPTX_SYS_CLK_RSTN_EN | > + DPTX_SYS_CLK_EN | > + CFG_DPTX_VIF_CLK_RSTN_EN | > + CFG_DPTX_VIF_CLK_EN; > + writel(val, dp->regs + SOURCE_DPTX_CAR); > + > + val = SOURCE_PHY_RSTN_EN | SOURCE_PHY_CLK_EN; > + writel(val, dp->regs + SOURCE_PHY_CAR); > + > + val = SOURCE_PKT_SYS_RSTN_EN | > + SOURCE_PKT_SYS_CLK_EN | > + SOURCE_PKT_DATA_RSTN_EN | > + SOURCE_PKT_DATA_CLK_EN; > + writel(val, dp->regs + SOURCE_PKT_CAR); > + > + val = SPDIF_CDR_CLK_RSTN_EN | > + SPDIF_CDR_CLK_EN | > + SOURCE_AIF_SYS_RSTN_EN | > + SOURCE_AIF_SYS_CLK_EN | > + SOURCE_AIF_CLK_RSTN_EN | > + SOURCE_AIF_CLK_EN; > + writel(val, dp->regs + SOURCE_AIF_CAR); > + > + val = SOURCE_CIPHER_SYSTEM_CLK_RSTN_EN | > + SOURCE_CIPHER_SYS_CLK_EN | > + SOURCE_CIPHER_CHAR_CLK_RSTN_EN | > + SOURCE_CIPHER_CHAR_CLK_EN; > + writel(val, dp->regs + SOURCE_CIPHER_CAR); > + > + val = SOURCE_CRYPTO_SYS_CLK_RSTN_EN | > + SOURCE_CRYPTO_SYS_CLK_EN; > + writel(val, dp->regs + SOURCE_CRYPTO_CAR); > + > + val = ~(MAILBOX_INT_MASK_BIT | PIF_INT_MASK_BIT) & ALL_INT_MASK; > + writel(val, dp->regs + APB_INT_MASK); > +} > + > +static int cdn_dp_mailbox_read(struct cdn_dp_device *dp) > +{ > + int val, ret; > + > + if (!dp->fw_loaded) > + return -EPERM; > + > + ret = readx_poll_timeout(readl, dp->regs + MAILBOX_EMPTY_ADDR, > + val, !val, MAILBOX_RETRY_US, > + MAILBOX_TIMEOUT_US); > + if (ret < 0) { > + dev_err(dp->dev, "failed to read mailbox, keep alive = %x\n", > + readl(dp->regs + KEEP_ALIVE)); > + return ret; > + } > + > + return readl(dp->regs + MAILBOX0_RD_DATA) & 0xff; > +} > + > +static int cdp_dp_mailbox_write(struct cdn_dp_device *dp, u8 val) > +{ > + int ret, full; > + > + if (!dp->fw_loaded) > + return -EPERM; > + > + ret = readx_poll_timeout(readl, dp->regs + MAILBOX_FULL_ADDR, > + full, !full, MAILBOX_RETRY_US, > + MAILBOX_TIMEOUT_US); > + if (ret < 0) { > + dev_err(dp->dev, "mailbox is full, keep alive = %x\n", > + readl(dp->regs + KEEP_ALIVE)); > + return ret; > + } > + > + writel(val, dp->regs + MAILBOX0_WR_DATA); > + > + return 0; > +} > + > +static int cdn_dp_mailbox_validate_receive(struct cdn_dp_device *dp, > + u8 module_id, u8 opcode, > + u8 req_size) > +{ > + u32 mbox_size, i; > + u8 header[4]; > + int ret; > + > + /* read the header of the message */ > + for (i = 0; i < 4; i++) { > + ret = cdn_dp_mailbox_read(dp); > + if (ret < 0) > + return ret; > + > + header[i] = ret; > + } > + > + mbox_size = (header[2] << 8) | header[3]; > + > + if (opcode != header[0] || module_id != header[1] || > + req_size != mbox_size) { > + dev_err(dp->dev, "mailbox validate failed"); > + > + /* > + * If the message in mailbox is not what we want, we need to > + * clear the mailbox by read. > + */ > + for (i = 0; i < mbox_size; i++) > + if (cdn_dp_mailbox_read(dp) < 0) > + break; > + > + return -EINVAL; > + } > + > + return 0; > +} > + > +static int cdn_dp_mailbox_read_receive(struct cdn_dp_device *dp, > + u8 *buff, u8 buff_size) > +{ > + u32 i; > + int ret; > + > + for (i = 0; i < buff_size; i++) { > + ret = cdn_dp_mailbox_read(dp); > + if (ret < 0) > + return ret; > + > + buff[i] = ret; > + } > + > + return 0; > +} > + > +static int cdn_dp_mailbox_send(struct cdn_dp_device *dp, u8 module_id, > + u8 opcode, u16 size, u8 *message) > +{ > + u8 header[4]; > + int ret, i; > + > + header[0] = opcode; > + header[1] = module_id; > + header[2] = (size >> 8) & 0xff; > + header[3] = size & 0xff; > + > + for (i = 0; i < 4; i++) { > + ret = cdp_dp_mailbox_write(dp, header[i]); > + if (ret) > + return ret; > + } > + > + for (i = 0; i < size; i++) { > + ret = cdp_dp_mailbox_write(dp, message[i]); > + if (ret) { > + dev_err(dp->dev, "mailbox send failed: %d", ret); > + return ret; > + } > + } > + > + return 0; > +} > + > +static int cdn_dp_reg_write(struct cdn_dp_device *dp, u16 addr, u32 val) > +{ > + u8 msg[6]; > + > + msg[0] = (addr >> 8) & 0xff; > + msg[1] = addr & 0xff; > + msg[2] = (val >> 24) & 0xff; > + msg[3] = (val >> 16) & 0xff; > + msg[4] = (val >> 8) & 0xff; > + msg[5] = val & 0xff; > + return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_REGISTER, > + sizeof(msg), msg); > +} > + > +int cdn_dp_dpcd_read(struct cdn_dp_device *dp, u32 addr, u8 *data, u16 len) > +{ > + u8 msg[5], reg[5]; > + int ret; > + > + msg[0] = (len >> 8) & 0xff; > + msg[1] = len & 0xff; > + msg[2] = (addr >> 16) & 0xff; > + msg[3] = (addr >> 8) & 0xff; > + msg[4] = addr & 0xff; > + cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_DPCD, > + sizeof(msg), msg); > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_DPCD, > + sizeof(reg) + len); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg)); > + if (ret) > + return ret; > + > + return cdn_dp_mailbox_read_receive(dp, data, len); > +} > + > +int cdn_dp_dpcd_write(struct cdn_dp_device *dp, u32 addr, u8 value) > +{ > + u8 msg[6], reg[5]; > + int ret; > + > + msg[0] = 0; > + msg[1] = 1; > + msg[2] = (addr >> 16) & 0xff; > + msg[3] = (addr >> 8) & 0xff; > + msg[4] = addr & 0xff; > + msg[5] = value; > + cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_DPCD, > + sizeof(msg), msg); > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_WRITE_DPCD, sizeof(reg)); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg)); > + if (ret) > + return ret; > + > + if (addr != (reg[2] << 16 | reg[3] << 8 | reg[4])) { > + dev_err(dp->dev, "write dpcd failed\n"); > + return -EINVAL; > + } > + > + return 0; > +} > + > +int cdn_dp_load_firmware(struct cdn_dp_device *dp, const u32 *i_mem, > + u32 i_size, const u32 *d_mem, u32 d_size) > +{ > + int i, ret; > + u32 reg; > + > + /* reset ucpu before load firmware*/ > + writel(APB_IRAM_PATH | APB_DRAM_PATH | APB_XT_RESET, > + dp->regs + APB_CTRL); > + > + for (i = 0; i < i_size; i += 4) > + writel(*i_mem++, dp->regs + ADDR_IMEM + i); > + > + for (i = 0; i < d_size; i += 4) > + writel(*d_mem++, dp->regs + ADDR_DMEM + i); > + > + /* un-reset ucpu */ > + writel(0, dp->regs + APB_CTRL); > + > + /* check the keep alive register to make sure fw working */ > + ret = readx_poll_timeout(readl, dp->regs + KEEP_ALIVE, > + reg, reg, 2000, FW_ALIVE_TIMEOUT_US); > + if (ret < 0) { > + dev_err(dp->dev, "failed to loaded the FW reg = %x\n", reg); > + return -EINVAL; > + } > + > + reg = readl(dp->regs + VER_L) & 0xff; > + dp->fw_version = reg; > + reg = readl(dp->regs + VER_H) & 0xff; > + dp->fw_version |= reg << 8; > + reg = readl(dp->regs + VER_LIB_L_ADDR) & 0xff; > + dp->fw_version |= reg << 16; > + reg = readl(dp->regs + VER_LIB_H_ADDR) & 0xff; > + dp->fw_version |= reg << 24; > + > + dev_dbg(dp->dev, "firmware version: %x\n", dp->fw_version); > + > + return 0; > +} > + > +int cdn_dp_reg_write_bit(struct cdn_dp_device *dp, u16 addr, u8 start_bit, > + u8 bits_no, u32 val) > +{ > + u8 field[8]; > + > + field[0] = (addr >> 8) & 0xff; > + field[1] = addr & 0xff; > + field[2] = start_bit; > + field[3] = bits_no; > + field[4] = (val >> 24) & 0xff; > + field[5] = (val >> 16) & 0xff; > + field[6] = (val >> 8) & 0xff; > + field[7] = val & 0xff; > + > + return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_FIELD, > + sizeof(field), field); > +} > + > +int cdn_dp_active(struct cdn_dp_device *dp, bool enable) > +{ > + u8 active = enable ? 1 : 0; > + u8 resp; > + int ret; > + > + /* set firmware status, 1: active; 0: standby */ > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_GENERAL, > + GENERAL_MAIN_CONTROL, sizeof(active), > + &active); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_GENERAL, > + GENERAL_MAIN_CONTROL, > + sizeof(resp)); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, &resp, sizeof(resp)); > + if (ret) > + return ret; > + > + return resp ? 0 : -EINVAL; > +} > + > +int cdn_dp_set_host_cap(struct cdn_dp_device *dp, u8 lanes) > +{ > + u8 msg[8]; > + int ret; > + > + msg[0] = CDN_DP_MAX_LINK_RATE; > + msg[1] = lanes; > + msg[2] = VOLTAGE_LEVEL_2; > + msg[3] = PRE_EMPHASIS_LEVEL_3; > + msg[4] = PTS1 | PTS2 | PTS3 | PTS4; > + msg[5] = FAST_LT_NOT_SUPPORT; > + msg[6] = LANE_MAPPING_NORMAL; > + msg[7] = ENHANCED; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, > + DPTX_SET_HOST_CAPABILITIES, > + sizeof(msg), msg); > + if (ret) > + return ret; > + > + ret = cdn_dp_reg_write(dp, DP_AUX_SWAP_INVERSION_CONTROL, > + AUX_HOST_INVERT); > + if (ret) > + return ret; > + > + return 0; > +} > + > +int cdn_dp_event_config(struct cdn_dp_device *dp) > +{ > + u8 msg[5]; > + > + memset(msg, 0, sizeof(msg)); > + > + msg[0] = DPTX_EVENT_ENABLE_HPD | DPTX_EVENT_ENABLE_TRAINING; > + > + return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_ENABLE_EVENT, > + sizeof(msg), msg); > +} > + > +u32 cdn_dp_get_event(struct cdn_dp_device *dp) > +{ > + return readl(dp->regs + SW_EVENTS0); > +} > + > +int cdn_dp_get_hpd_status(struct cdn_dp_device *dp) > +{ > + u8 status; > + int ret; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_HPD_STATE, > + 0, NULL); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_HPD_STATE, sizeof(status)); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, &status, sizeof(status)); > + if (ret) > + return ret; > + > + return status; > +} > + > +int cdn_dp_get_edid_block(void *data, u8 *edid, > + unsigned int block, size_t length) > +{ > + struct cdn_dp_device *dp = data; > + u8 msg[2], reg[2]; > + int ret; > + > + msg[0] = block / 2; > + msg[1] = block % 2; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_GET_EDID, > + sizeof(msg), msg); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_GET_EDID, > + sizeof(reg) + length); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg)); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, edid, length); > + if (ret) > + return ret; > + > + if (reg[0] != length || reg[1] != block / 2) { > + dev_err(dp->dev, "edid block size err\n"); > + return -EINVAL; > + } > + > + return 0; > +} > + > +int cdn_dp_training_start(struct cdn_dp_device *dp) > +{ > + u8 msg, event[2]; > + unsigned long timeout; > + int ret; > + > + msg = LINK_TRAINING_RUN; > + > + /* start training */ > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_TRAINING_CONTROL, > + sizeof(msg), &msg); > + if (ret) > + return ret; > + > + timeout = jiffies + msecs_to_jiffies(LINK_TRAINING_TIMEOUT_MS); > + while (time_before(jiffies, timeout)) { > + msleep(LINK_TRAINING_RETRY_MS); > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_EVENT, 0, NULL); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_EVENT, > + sizeof(event)); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, event, sizeof(event)); > + if (ret) > + return ret; > + > + if (event[1] & EQ_PHASE_FINISHED) > + return 0; > + } > + > + return -ETIMEDOUT; > +} > + > +int cdn_dp_get_training_status(struct cdn_dp_device *dp) > +{ > + u8 status[10]; > + int ret; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_LINK_STAT, > + 0, NULL); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_LINK_STAT, > + sizeof(status)); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, status, sizeof(status)); > + if (ret) > + return ret; > + > + dp->link.rate = status[0]; > + dp->link.num_lanes = status[1]; > + > + return 0; > +} > + > +int cdn_dp_set_video_status(struct cdn_dp_device *dp, int active) > +{ > + u8 msg; > + > + msg = !!active; > + > + return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_SET_VIDEO, > + sizeof(msg), &msg); > +} > + > +static int cdn_dp_get_msa_misc(struct video_info *video, > + struct drm_display_mode *mode) > +{ > + u8 val[2]; > + u32 msa_misc; > + > + switch (video->color_fmt) { > + case PXL_RGB: > + case Y_ONLY: > + val[0] = 0; > + break; > + /* set YUV default color space conversion to BT601 */ > + case YCBCR_4_4_4: > + val[0] = 6 + BT_601 * 8; > + break; > + case YCBCR_4_2_2: > + val[0] = 5 + BT_601 * 8; > + break; > + case YCBCR_4_2_0: > + val[0] = 5; > + break; > + }; > + > + switch (video->color_depth) { > + case 6: > + val[1] = 0; > + break; > + case 8: > + val[1] = 1; > + break; > + case 10: > + val[1] = 2; > + break; > + case 12: > + val[1] = 3; > + break; > + case 16: > + val[1] = 4; > + break; > + }; > + > + msa_misc = 2 * val[0] + 32 * val[1] + > + ((video->color_fmt == Y_ONLY) ? (1 << 14) : 0); > + > + return msa_misc; > +} > + > +int cdn_dp_config_video(struct cdn_dp_device *dp) > +{ > + struct video_info *video = &dp->video_info; > + struct drm_display_mode *mode = &dp->mode; > + u64 symbol; > + u32 val, link_rate; > + u8 bit_per_pix; > + u8 tu_size_reg = TU_SIZE; > + int ret; > + > + bit_per_pix = (video->color_fmt == YCBCR_4_2_2) ? > + (video->color_depth * 2) : (video->color_depth * 3); > + > + link_rate = drm_dp_bw_code_to_link_rate(dp->link.rate); > + > + val = VIF_BYPASS_INTERLACE; > + ret = cdn_dp_reg_write(dp, BND_HSYNC2VSYNC, val); > + if (ret) > + return ret; > + > + ret = cdn_dp_reg_write(dp, HSYNC2VSYNC_POL_CTRL, 0); > + if (ret) > + return ret; > + > + /* get a best tu_size and symbol */ > + do { > + tu_size_reg += 2; > + symbol = tu_size_reg * mode->clock * bit_per_pix; > + symbol /= dp->link.num_lanes * link_rate * 8; > + } while ((symbol == 1) || (tu_size_reg - symbol < 4)); > + > + val = symbol + (tu_size_reg << 8); > + ret = cdn_dp_reg_write(dp, DP_FRAMER_TU, val); > + if (ret) > + return ret; > + > + /* set the FIFO Buffer size */ > + val = ((mode->clock * (symbol + 1) / 1000) + link_rate); > + val /= (dp->link.num_lanes * link_rate); > + val = 8 * (symbol + 1) / bit_per_pix - val; > + val += 2; > + ret = cdn_dp_reg_write(dp, DP_VC_TABLE(15), val); > + > + switch (video->color_depth) { > + case 6: > + val = BCS_6; > + break; > + case 8: > + val = BCS_8; > + break; > + case 10: > + val = BCS_10; > + break; > + case 12: > + val = BCS_12; > + break; > + case 16: > + val = BCS_16; > + break; > + }; > + > + val += video->color_fmt << 8; > + ret = cdn_dp_reg_write(dp, DP_FRAMER_PXL_REPR, val); > + if (ret) > + return ret; > + > + val = video->h_sync_polarity ? DP_FRAMER_SP_HSP : 0; > + val |= video->v_sync_polarity ? DP_FRAMER_SP_VSP : 0; > + ret = cdn_dp_reg_write(dp, DP_FRAMER_SP, val); > + if (ret) > + return ret; > + > + val = (mode->hsync_start - mode->hdisplay) << 16; > + val |= mode->htotal - mode->hsync_end; > + ret = cdn_dp_reg_write(dp, DP_FRONT_BACK_PORCH, val); > + if (ret) > + return ret; > + > + val = mode->hdisplay * bit_per_pix / 8; > + ret = cdn_dp_reg_write(dp, DP_BYTE_COUNT, val); > + if (ret) > + return ret; > + > + val = mode->htotal | ((mode->htotal - mode->hsync_start) << 16); > + ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_0, val); > + if (ret) > + return ret; > + > + val = mode->hsync_end - mode->hsync_start; > + val |= (mode->hdisplay << 16) | (video->h_sync_polarity << 15); > + ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_1, val); > + if (ret) > + return ret; > + > + val = mode->vtotal; > + val |= ((mode->vtotal - mode->vsync_start) << 16); > + ret = cdn_dp_reg_write(dp, MSA_VERTICAL_0, val); > + if (ret) > + return ret; > + > + val = mode->vsync_end - mode->vsync_start; > + val |= mode->vdisplay << 16 | (video->v_sync_polarity << 15); > + ret = cdn_dp_reg_write(dp, MSA_VERTICAL_1, val); > + if (ret) > + return ret; > + > + val = cdn_dp_get_msa_misc(video, mode); > + ret = cdn_dp_reg_write(dp, MSA_MISC, val); > + if (ret) > + return ret; > + > + ret = cdn_dp_reg_write(dp, STREAM_CONFIG, 1); > + if (ret) > + return ret; > + > + val = mode->hsync_end - mode->hsync_start; > + val |= (mode->hdisplay << 16); > + ret = cdn_dp_reg_write(dp, DP_HORIZONTAL, val); > + if (ret) > + return ret; > + > + val = mode->vtotal; > + val -= (mode->vtotal - mode->vdisplay); > + val |= (mode->vtotal - mode->vsync_start) << 16; > + ret = cdn_dp_reg_write(dp, DP_VERTICAL_0, val); > + if (ret) > + return ret; > + > + val = mode->vtotal; > + ret = cdn_dp_reg_write(dp, DP_VERTICAL_1, val); > + if (ret) > + return ret; > + > + val = 0; > + return cdn_dp_reg_write_bit(dp, DP_VB_ID, 2, 1, val); > +} > + > +int cdn_dp_audio_stop(struct cdn_dp_device *dp, struct audio_info *audio) > +{ > + u32 val; > + int ret; > + > + ret = cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, 0); > + if (ret) > + return ret; > + > + val = SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS; > + val |= SPDIF_FIFO_MID_RANGE(0xe0); > + val |= SPDIF_JITTER_THRSH(0xe0); > + val |= SPDIF_JITTER_AVG_WIN(7); > + writel(val, dp->regs + SPDIF_CTRL_ADDR); > + > + /* clearn the audio config and reset */ > + writel(0, dp->regs + AUDIO_SRC_CNTL); > + writel(0, dp->regs + AUDIO_SRC_CNFG); > + writel(AUDIO_SW_RST, dp->regs + AUDIO_SRC_CNTL); > + writel(0, dp->regs + AUDIO_SRC_CNTL); > + > + /* reset smpl2pckt component */ > + writel(0, dp->regs + SMPL2PKT_CNTL); > + writel(AUDIO_SW_RST, dp->regs + SMPL2PKT_CNTL); > + writel(0, dp->regs + SMPL2PKT_CNTL); > + > + /* reset FIFO */ > + writel(AUDIO_SW_RST, dp->regs + FIFO_CNTL); > + writel(0, dp->regs + FIFO_CNTL); > + > + if (audio->format == AFMT_SPDIF) > + clk_disable_unprepare(dp->spdif_clk); > + > + return 0; > +} > + > +int cdn_dp_audio_mute(struct cdn_dp_device *dp, bool enable) > +{ > + return cdn_dp_reg_write_bit(dp, DP_VB_ID, 4, 1, enable); > +} > + > +static void cdn_dp_audio_config_i2s(struct cdn_dp_device *dp, > + struct audio_info *audio) > +{ > + int sub_pckt_num = 1, i2s_port_en_val = 0xf, i; > + u32 val; > + > + if (audio->channels == 2) { > + if (dp->link.num_lanes == 1) > + sub_pckt_num = 2; > + else > + sub_pckt_num = 4; > + > + i2s_port_en_val = 1; > + } else if (audio->channels == 4) { > + i2s_port_en_val = 3; > + } > + > + writel(0x0, dp->regs + SPDIF_CTRL_ADDR); > + > + writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL); > + > + val = MAX_NUM_CH(audio->channels); > + val |= NUM_OF_I2S_PORTS(audio->channels); > + val |= AUDIO_TYPE_LPCM; > + val |= CFG_SUB_PCKT_NUM(sub_pckt_num); > + writel(val, dp->regs + SMPL2PKT_CNFG); > + > + if (audio->sample_width == 16) > + val = 0; > + else if (audio->sample_width == 24) > + val = 1 << 9; > + else > + val = 2 << 9; > + > + val |= AUDIO_CH_NUM(audio->channels); > + val |= I2S_DEC_PORT_EN(i2s_port_en_val); > + val |= TRANS_SMPL_WIDTH_32; > + writel(val, dp->regs + AUDIO_SRC_CNFG); > + > + for (i = 0; i < (audio->channels + 1) / 2; i++) { > + if (audio->sample_width == 16) > + val = (0x08 << 8) | (0x08 << 20); > + else if (audio->sample_width == 24) > + val = (0x0b << 8) | (0x0b << 20); > + > + val |= ((2 * i) << 4) | ((2 * i + 1) << 16); > + writel(val, dp->regs + STTS_BIT_CH(i)); > + } > + > + switch (audio->sample_rate) { > + case 32000: > + val = SAMPLING_FREQ(3) | > + ORIGINAL_SAMP_FREQ(0xc); > + break; > + case 44100: > + val = SAMPLING_FREQ(0) | > + ORIGINAL_SAMP_FREQ(0xf); > + break; > + case 48000: > + val = SAMPLING_FREQ(2) | > + ORIGINAL_SAMP_FREQ(0xd); > + break; > + case 88200: > + val = SAMPLING_FREQ(8) | > + ORIGINAL_SAMP_FREQ(0x7); > + break; > + case 96000: > + val = SAMPLING_FREQ(0xa) | > + ORIGINAL_SAMP_FREQ(5); > + break; > + case 176400: > + val = SAMPLING_FREQ(0xc) | > + ORIGINAL_SAMP_FREQ(3); > + break; > + case 192000: > + val = SAMPLING_FREQ(0xe) | > + ORIGINAL_SAMP_FREQ(1); > + break; > + } > + val |= 4; > + writel(val, dp->regs + COM_CH_STTS_BITS); > + > + writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL); > + writel(I2S_DEC_START, dp->regs + AUDIO_SRC_CNTL); > +} > + > +static void cdn_dp_audio_config_spdif(struct cdn_dp_device *dp) > +{ > + u32 val; > + > + val = SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS; > + val |= SPDIF_FIFO_MID_RANGE(0xe0); > + val |= SPDIF_JITTER_THRSH(0xe0); > + val |= SPDIF_JITTER_AVG_WIN(7); > + writel(val, dp->regs + SPDIF_CTRL_ADDR); > + > + writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL); > + > + val = MAX_NUM_CH(2) | AUDIO_TYPE_LPCM | CFG_SUB_PCKT_NUM(4); > + writel(val, dp->regs + SMPL2PKT_CNFG); > + writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL); > + > + val = SPDIF_ENABLE | SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS; > + val |= SPDIF_FIFO_MID_RANGE(0xe0); > + val |= SPDIF_JITTER_THRSH(0xe0); > + val |= SPDIF_JITTER_AVG_WIN(7); > + writel(val, dp->regs + SPDIF_CTRL_ADDR); > + > + clk_prepare_enable(dp->spdif_clk); > + clk_set_rate(dp->spdif_clk, CDN_DP_SPDIF_CLK); > +} > + > +int cdn_dp_audio_config_set(struct cdn_dp_device *dp, struct audio_info *audio) > +{ > + int ret; > + > + /* reset the spdif clk before config */ > + if (audio->format == AFMT_SPDIF) { > + reset_control_assert(dp->spdif_rst); > + reset_control_deassert(dp->spdif_rst); > + } > + > + ret = cdn_dp_reg_write(dp, CM_LANE_CTRL, LANE_REF_CYC); > + if (ret) > + return ret; > + > + ret = cdn_dp_reg_write(dp, CM_CTRL, 0); > + if (ret) > + return ret; > + > + if (audio->format == AFMT_I2S) > + cdn_dp_audio_config_i2s(dp, audio); > + else > + cdn_dp_audio_config_spdif(dp); > + > + return cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, AUDIO_PACK_EN); > +} > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-reg.h b/drivers/gpu/drm/rockchip/cdn-dp-reg.h > new file mode 100644 > index 0000000..1affeed > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-reg.h > @@ -0,0 +1,479 @@ > +/* > + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd > + * Author: Chris Zhong > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#ifndef _CDN_DP_REG_H > +#define _CDN_DP_REG_H > + > +#include > + > +#define ADDR_IMEM 0x10000 > +#define ADDR_DMEM 0x20000 > + > +/* APB CFG addr */ > +#define APB_CTRL 0 > +#define XT_INT_CTRL 0x04 > +#define MAILBOX_FULL_ADDR 0x08 > +#define MAILBOX_EMPTY_ADDR 0x0c > +#define MAILBOX0_WR_DATA 0x10 > +#define MAILBOX0_RD_DATA 0x14 > +#define KEEP_ALIVE 0x18 > +#define VER_L 0x1c > +#define VER_H 0x20 > +#define VER_LIB_L_ADDR 0x24 > +#define VER_LIB_H_ADDR 0x28 > +#define SW_DEBUG_L 0x2c > +#define SW_DEBUG_H 0x30 > +#define MAILBOX_INT_MASK 0x34 > +#define MAILBOX_INT_STATUS 0x38 > +#define SW_CLK_L 0x3c > +#define SW_CLK_H 0x40 > +#define SW_EVENTS0 0x44 > +#define SW_EVENTS1 0x48 > +#define SW_EVENTS2 0x4c > +#define SW_EVENTS3 0x50 > +#define XT_OCD_CTRL 0x60 > +#define APB_INT_MASK 0x6c > +#define APB_STATUS_MASK 0x70 > + > +/* audio decoder addr */ > +#define AUDIO_SRC_CNTL 0x30000 > +#define AUDIO_SRC_CNFG 0x30004 > +#define COM_CH_STTS_BITS 0x30008 > +#define STTS_BIT_CH(x) (0x3000c + ((x) << 2)) > +#define SPDIF_CTRL_ADDR 0x3004c > +#define SPDIF_CH1_CS_3100_ADDR 0x30050 > +#define SPDIF_CH1_CS_6332_ADDR 0x30054 > +#define SPDIF_CH1_CS_9564_ADDR 0x30058 > +#define SPDIF_CH1_CS_12796_ADDR 0x3005c > +#define SPDIF_CH1_CS_159128_ADDR 0x30060 > +#define SPDIF_CH1_CS_191160_ADDR 0x30064 > +#define SPDIF_CH2_CS_3100_ADDR 0x30068 > +#define SPDIF_CH2_CS_6332_ADDR 0x3006c > +#define SPDIF_CH2_CS_9564_ADDR 0x30070 > +#define SPDIF_CH2_CS_12796_ADDR 0x30074 > +#define SPDIF_CH2_CS_159128_ADDR 0x30078 > +#define SPDIF_CH2_CS_191160_ADDR 0x3007c > +#define SMPL2PKT_CNTL 0x30080 > +#define SMPL2PKT_CNFG 0x30084 > +#define FIFO_CNTL 0x30088 > +#define FIFO_STTS 0x3008c > + > +/* source pif addr */ > +#define SOURCE_PIF_WR_ADDR 0x30800 > +#define SOURCE_PIF_WR_REQ 0x30804 > +#define SOURCE_PIF_RD_ADDR 0x30808 > +#define SOURCE_PIF_RD_REQ 0x3080c > +#define SOURCE_PIF_DATA_WR 0x30810 > +#define SOURCE_PIF_DATA_RD 0x30814 > +#define SOURCE_PIF_FIFO1_FLUSH 0x30818 > +#define SOURCE_PIF_FIFO2_FLUSH 0x3081c > +#define SOURCE_PIF_STATUS 0x30820 > +#define SOURCE_PIF_INTERRUPT_SOURCE 0x30824 > +#define SOURCE_PIF_INTERRUPT_MASK 0x30828 > +#define SOURCE_PIF_PKT_ALLOC_REG 0x3082c > +#define SOURCE_PIF_PKT_ALLOC_WR_EN 0x30830 > +#define SOURCE_PIF_SW_RESET 0x30834 > + > +/* bellow registers need access by mailbox */ > +/* source car addr */ > +#define SOURCE_HDTX_CAR 0x0900 > +#define SOURCE_DPTX_CAR 0x0904 > +#define SOURCE_PHY_CAR 0x0908 > +#define SOURCE_CEC_CAR 0x090c > +#define SOURCE_CBUS_CAR 0x0910 > +#define SOURCE_PKT_CAR 0x0918 > +#define SOURCE_AIF_CAR 0x091c > +#define SOURCE_CIPHER_CAR 0x0920 > +#define SOURCE_CRYPTO_CAR 0x0924 > + > +/* clock meters addr */ > +#define CM_CTRL 0x0a00 > +#define CM_I2S_CTRL 0x0a04 > +#define CM_SPDIF_CTRL 0x0a08 > +#define CM_VID_CTRL 0x0a0c > +#define CM_LANE_CTRL 0x0a10 > +#define I2S_NM_STABLE 0x0a14 > +#define I2S_NCTS_STABLE 0x0a18 > +#define SPDIF_NM_STABLE 0x0a1c > +#define SPDIF_NCTS_STABLE 0x0a20 > +#define NMVID_MEAS_STABLE 0x0a24 > +#define I2S_MEAS 0x0a40 > +#define SPDIF_MEAS 0x0a80 > +#define NMVID_MEAS 0x0ac0 > + > +/* source vif addr */ > +#define BND_HSYNC2VSYNC 0x0b00 > +#define HSYNC2VSYNC_F1_L1 0x0b04 > +#define HSYNC2VSYNC_F2_L1 0x0b08 > +#define HSYNC2VSYNC_STATUS 0x0b0c > +#define HSYNC2VSYNC_POL_CTRL 0x0b10 > + > +/* dptx phy addr */ > +#define DP_TX_PHY_CONFIG_REG 0x2000 > +#define DP_TX_PHY_STATUS_REG 0x2004 > +#define DP_TX_PHY_SW_RESET 0x2008 > +#define DP_TX_PHY_SCRAMBLER_SEED 0x200c > +#define DP_TX_PHY_TRAINING_01_04 0x2010 > +#define DP_TX_PHY_TRAINING_05_08 0x2014 > +#define DP_TX_PHY_TRAINING_09_10 0x2018 > +#define TEST_COR 0x23fc > + > +/* dptx hpd addr */ > +#define HPD_IRQ_DET_MIN_TIMER 0x2100 > +#define HPD_IRQ_DET_MAX_TIMER 0x2104 > +#define HPD_UNPLGED_DET_MIN_TIMER 0x2108 > +#define HPD_STABLE_TIMER 0x210c > +#define HPD_FILTER_TIMER 0x2110 > +#define HPD_EVENT_MASK 0x211c > +#define HPD_EVENT_DET 0x2120 > + > +/* dpyx framer addr */ > +#define DP_FRAMER_GLOBAL_CONFIG 0x2200 > +#define DP_SW_RESET 0x2204 > +#define DP_FRAMER_TU 0x2208 > +#define DP_FRAMER_PXL_REPR 0x220c > +#define DP_FRAMER_SP 0x2210 > +#define AUDIO_PACK_CONTROL 0x2214 > +#define DP_VC_TABLE(x) (0x2218 + ((x) << 2)) > +#define DP_VB_ID 0x2258 > +#define DP_MTPH_LVP_CONTROL 0x225c > +#define DP_MTPH_SYMBOL_VALUES 0x2260 > +#define DP_MTPH_ECF_CONTROL 0x2264 > +#define DP_MTPH_ACT_CONTROL 0x2268 > +#define DP_MTPH_STATUS 0x226c > +#define DP_INTERRUPT_SOURCE 0x2270 > +#define DP_INTERRUPT_MASK 0x2274 > +#define DP_FRONT_BACK_PORCH 0x2278 > +#define DP_BYTE_COUNT 0x227c > + > +/* dptx stream addr */ > +#define MSA_HORIZONTAL_0 0x2280 > +#define MSA_HORIZONTAL_1 0x2284 > +#define MSA_VERTICAL_0 0x2288 > +#define MSA_VERTICAL_1 0x228c > +#define MSA_MISC 0x2290 > +#define STREAM_CONFIG 0x2294 > +#define AUDIO_PACK_STATUS 0x2298 > +#define VIF_STATUS 0x229c > +#define PCK_STUFF_STATUS_0 0x22a0 > +#define PCK_STUFF_STATUS_1 0x22a4 > +#define INFO_PACK_STATUS 0x22a8 > +#define RATE_GOVERNOR_STATUS 0x22ac > +#define DP_HORIZONTAL 0x22b0 > +#define DP_VERTICAL_0 0x22b4 > +#define DP_VERTICAL_1 0x22b8 > +#define DP_BLOCK_SDP 0x22bc > + > +/* dptx glbl addr */ > +#define DPTX_LANE_EN 0x2300 > +#define DPTX_ENHNCD 0x2304 > +#define DPTX_INT_MASK 0x2308 > +#define DPTX_INT_STATUS 0x230c > + > +/* dp aux addr */ > +#define DP_AUX_HOST_CONTROL 0x2800 > +#define DP_AUX_INTERRUPT_SOURCE 0x2804 > +#define DP_AUX_INTERRUPT_MASK 0x2808 > +#define DP_AUX_SWAP_INVERSION_CONTROL 0x280c > +#define DP_AUX_SEND_NACK_TRANSACTION 0x2810 > +#define DP_AUX_CLEAR_RX 0x2814 > +#define DP_AUX_CLEAR_TX 0x2818 > +#define DP_AUX_TIMER_STOP 0x281c > +#define DP_AUX_TIMER_CLEAR 0x2820 > +#define DP_AUX_RESET_SW 0x2824 > +#define DP_AUX_DIVIDE_2M 0x2828 > +#define DP_AUX_TX_PREACHARGE_LENGTH 0x282c > +#define DP_AUX_FREQUENCY_1M_MAX 0x2830 > +#define DP_AUX_FREQUENCY_1M_MIN 0x2834 > +#define DP_AUX_RX_PRE_MIN 0x2838 > +#define DP_AUX_RX_PRE_MAX 0x283c > +#define DP_AUX_TIMER_PRESET 0x2840 > +#define DP_AUX_NACK_FORMAT 0x2844 > +#define DP_AUX_TX_DATA 0x2848 > +#define DP_AUX_RX_DATA 0x284c > +#define DP_AUX_TX_STATUS 0x2850 > +#define DP_AUX_RX_STATUS 0x2854 > +#define DP_AUX_RX_CYCLE_COUNTER 0x2858 > +#define DP_AUX_MAIN_STATES 0x285c > +#define DP_AUX_MAIN_TIMER 0x2860 > +#define DP_AUX_AFE_OUT 0x2864 > + > +/* crypto addr */ > +#define CRYPTO_HDCP_REVISION 0x5800 > +#define HDCP_CRYPTO_CONFIG 0x5804 > +#define CRYPTO_INTERRUPT_SOURCE 0x5808 > +#define CRYPTO_INTERRUPT_MASK 0x580c > +#define CRYPTO22_CONFIG 0x5818 > +#define CRYPTO22_STATUS 0x581c > +#define SHA_256_DATA_IN 0x583c > +#define SHA_256_DATA_OUT_(x) (0x5850 + ((x) << 2)) > +#define AES_32_KEY_(x) (0x5870 + ((x) << 2)) > +#define AES_32_DATA_IN 0x5880 > +#define AES_32_DATA_OUT_(x) (0x5884 + ((x) << 2)) > +#define CRYPTO14_CONFIG 0x58a0 > +#define CRYPTO14_STATUS 0x58a4 > +#define CRYPTO14_PRNM_OUT 0x58a8 > +#define CRYPTO14_KM_0 0x58ac > +#define CRYPTO14_KM_1 0x58b0 > +#define CRYPTO14_AN_0 0x58b4 > +#define CRYPTO14_AN_1 0x58b8 > +#define CRYPTO14_YOUR_KSV_0 0x58bc > +#define CRYPTO14_YOUR_KSV_1 0x58c0 > +#define CRYPTO14_MI_0 0x58c4 > +#define CRYPTO14_MI_1 0x58c8 > +#define CRYPTO14_TI_0 0x58cc > +#define CRYPTO14_KI_0 0x58d0 > +#define CRYPTO14_KI_1 0x58d4 > +#define CRYPTO14_BLOCKS_NUM 0x58d8 > +#define CRYPTO14_KEY_MEM_DATA_0 0x58dc > +#define CRYPTO14_KEY_MEM_DATA_1 0x58e0 > +#define CRYPTO14_SHA1_MSG_DATA 0x58e4 > +#define CRYPTO14_SHA1_V_VALUE_(x) (0x58e8 + ((x) << 2)) > +#define TRNG_CTRL 0x58fc > +#define TRNG_DATA_RDY 0x5900 > +#define TRNG_DATA 0x5904 > + > +/* cipher addr */ > +#define HDCP_REVISION 0x60000 > +#define INTERRUPT_SOURCE 0x60004 > +#define INTERRUPT_MASK 0x60008 > +#define HDCP_CIPHER_CONFIG 0x6000c > +#define AES_128_KEY_0 0x60010 > +#define AES_128_KEY_1 0x60014 > +#define AES_128_KEY_2 0x60018 > +#define AES_128_KEY_3 0x6001c > +#define AES_128_RANDOM_0 0x60020 > +#define AES_128_RANDOM_1 0x60024 > +#define CIPHER14_KM_0 0x60028 > +#define CIPHER14_KM_1 0x6002c > +#define CIPHER14_STATUS 0x60030 > +#define CIPHER14_RI_PJ_STATUS 0x60034 > +#define CIPHER_MODE 0x60038 > +#define CIPHER14_AN_0 0x6003c > +#define CIPHER14_AN_1 0x60040 > +#define CIPHER22_AUTH 0x60044 > +#define CIPHER14_R0_DP_STATUS 0x60048 > +#define CIPHER14_BOOTSTRAP 0x6004c > + > +#define DPTX_FRMR_DATA_CLK_RSTN_EN BIT(11) > +#define DPTX_FRMR_DATA_CLK_EN BIT(10) > +#define DPTX_PHY_DATA_RSTN_EN BIT(9) > +#define DPTX_PHY_DATA_CLK_EN BIT(8) > +#define DPTX_PHY_CHAR_RSTN_EN BIT(7) > +#define DPTX_PHY_CHAR_CLK_EN BIT(6) > +#define SOURCE_AUX_SYS_CLK_RSTN_EN BIT(5) > +#define SOURCE_AUX_SYS_CLK_EN BIT(4) > +#define DPTX_SYS_CLK_RSTN_EN BIT(3) > +#define DPTX_SYS_CLK_EN BIT(2) > +#define CFG_DPTX_VIF_CLK_RSTN_EN BIT(1) > +#define CFG_DPTX_VIF_CLK_EN BIT(0) > + > +#define SOURCE_PHY_RSTN_EN BIT(1) > +#define SOURCE_PHY_CLK_EN BIT(0) > + > +#define SOURCE_PKT_SYS_RSTN_EN BIT(3) > +#define SOURCE_PKT_SYS_CLK_EN BIT(2) > +#define SOURCE_PKT_DATA_RSTN_EN BIT(1) > +#define SOURCE_PKT_DATA_CLK_EN BIT(0) > + > +#define SPDIF_CDR_CLK_RSTN_EN BIT(5) > +#define SPDIF_CDR_CLK_EN BIT(4) > +#define SOURCE_AIF_SYS_RSTN_EN BIT(3) > +#define SOURCE_AIF_SYS_CLK_EN BIT(2) > +#define SOURCE_AIF_CLK_RSTN_EN BIT(1) > +#define SOURCE_AIF_CLK_EN BIT(0) > + > +#define SOURCE_CIPHER_SYSTEM_CLK_RSTN_EN BIT(3) > +#define SOURCE_CIPHER_SYS_CLK_EN BIT(2) > +#define SOURCE_CIPHER_CHAR_CLK_RSTN_EN BIT(1) > +#define SOURCE_CIPHER_CHAR_CLK_EN BIT(0) > + > +#define SOURCE_CRYPTO_SYS_CLK_RSTN_EN BIT(1) > +#define SOURCE_CRYPTO_SYS_CLK_EN BIT(0) > + > +#define APB_IRAM_PATH BIT(2) > +#define APB_DRAM_PATH BIT(1) > +#define APB_XT_RESET BIT(0) > + > +#define MAILBOX_INT_MASK_BIT BIT(1) > +#define PIF_INT_MASK_BIT BIT(0) > +#define ALL_INT_MASK 3 > + > +/* mailbox */ > +#define MB_OPCODE_ID 0 > +#define MB_MODULE_ID 1 > +#define MB_SIZE_MSB_ID 2 > +#define MB_SIZE_LSB_ID 3 > +#define MB_DATA_ID 4 > + > +#define MB_MODULE_ID_DP_TX 0x01 > +#define MB_MODULE_ID_HDCP_TX 0x07 > +#define MB_MODULE_ID_HDCP_RX 0x08 > +#define MB_MODULE_ID_HDCP_GENERAL 0x09 > +#define MB_MODULE_ID_GENERAL 0x0a > + > +/* general opcode */ > +#define GENERAL_MAIN_CONTROL 0x01 > +#define GENERAL_TEST_ECHO 0x02 > +#define GENERAL_BUS_SETTINGS 0x03 > +#define GENERAL_TEST_ACCESS 0x04 > + > +#define DPTX_SET_POWER_MNG 0x00 > +#define DPTX_SET_HOST_CAPABILITIES 0x01 > +#define DPTX_GET_EDID 0x02 > +#define DPTX_READ_DPCD 0x03 > +#define DPTX_WRITE_DPCD 0x04 > +#define DPTX_ENABLE_EVENT 0x05 > +#define DPTX_WRITE_REGISTER 0x06 > +#define DPTX_READ_REGISTER 0x07 > +#define DPTX_WRITE_FIELD 0x08 > +#define DPTX_TRAINING_CONTROL 0x09 > +#define DPTX_READ_EVENT 0x0a > +#define DPTX_READ_LINK_STAT 0x0b > +#define DPTX_SET_VIDEO 0x0c > +#define DPTX_SET_AUDIO 0x0d > +#define DPTX_GET_LAST_AUX_STAUS 0x0e > +#define DPTX_SET_LINK_BREAK_POINT 0x0f > +#define DPTX_FORCE_LANES 0x10 > +#define DPTX_HPD_STATE 0x11 > + > +#define DPTX_EVENT_ENABLE_HPD BIT(0) > +#define DPTX_EVENT_ENABLE_TRAINING BIT(1) > + > +#define LINK_TRAINING_NOT_ACTIVE 0 > +#define LINK_TRAINING_RUN 1 > +#define LINK_TRAINING_RESTART 2 > + > +#define CONTROL_VIDEO_IDLE 0 > +#define CONTROL_VIDEO_VALID 1 > + > +#define VIF_BYPASS_INTERLACE BIT(13) > +#define INTERLACE_FMT_DET BIT(12) > +#define INTERLACE_DTCT_WIN 0x20 > + > +#define DP_FRAMER_SP_INTERLACE_EN BIT(2) > +#define DP_FRAMER_SP_HSP BIT(1) > +#define DP_FRAMER_SP_VSP BIT(0) > + > +/* capability */ > +#define AUX_HOST_INVERT 3 > +#define FAST_LT_SUPPORT 1 > +#define FAST_LT_NOT_SUPPORT 0 > +#define LANE_MAPPING_NORMAL 0xe4 > +#define LANE_MAPPING_FLIPPED 0x1b > +#define ENHANCED 1 > + > +#define FULL_LT_STARTED BIT(0) > +#define FASE_LT_STARTED BIT(1) > +#define CLK_RECOVERY_FINISHED BIT(2) > +#define EQ_PHASE_FINISHED BIT(3) > +#define FASE_LT_START_FINISHED BIT(4) > +#define CLK_RECOVERY_FAILED BIT(5) > +#define EQ_PHASE_FAILED BIT(6) > +#define FASE_LT_FAILED BIT(7) > + > +#define DPTX_HPD_EVENT BIT(0) > +#define DPTX_TRAINING_EVENT BIT(1) > +#define HDCP_TX_STATUS_EVENT BIT(4) > +#define HDCP2_TX_IS_KM_STORED_EVENT BIT(5) > +#define HDCP2_TX_STORE_KM_EVENT BIT(6) > +#define HDCP_TX_IS_RECEIVER_ID_VALID_EVENT BIT(7) > + > +#define TU_SIZE 30 > +#define CDN_DP_MAX_LINK_RATE DP_LINK_BW_5_4 > + > +/* audio */ > +#define AUDIO_PACK_EN BIT(8) > +#define SAMPLING_FREQ(x) (((x) & 0xf) << 16) > +#define ORIGINAL_SAMP_FREQ(x) (((x) & 0xf) << 24) > +#define SYNC_WR_TO_CH_ZERO BIT(1) > +#define I2S_DEC_START BIT(1) > +#define AUDIO_SW_RST BIT(0) > +#define SMPL2PKT_EN BIT(1) > +#define MAX_NUM_CH(x) (((x) & 0x1f) - 1) > +#define NUM_OF_I2S_PORTS(x) ((((x) / 2 - 1) & 0x3) << 5) > +#define AUDIO_TYPE_LPCM (2 << 7) > +#define CFG_SUB_PCKT_NUM(x) ((((x) - 1) & 0x7) << 11) > +#define AUDIO_CH_NUM(x) ((((x) - 1) & 0x1f) << 2) > +#define TRANS_SMPL_WIDTH_16 0 > +#define TRANS_SMPL_WIDTH_24 BIT(11) > +#define TRANS_SMPL_WIDTH_32 (2 << 11) > +#define I2S_DEC_PORT_EN(x) (((x) & 0xf) << 17) > +#define SPDIF_ENABLE BIT(21) > +#define SPDIF_AVG_SEL BIT(20) > +#define SPDIF_JITTER_BYPASS BIT(19) > +#define SPDIF_FIFO_MID_RANGE(x) (((x) & 0xff) << 11) > +#define SPDIF_JITTER_THRSH(x) (((x) & 0xff) << 3) > +#define SPDIF_JITTER_AVG_WIN(x) ((x) & 0x7) > + > +/* Refernce cycles when using lane clock as refernce */ > +#define LANE_REF_CYC 0x8000 > + > +enum voltage_swing_level { > + VOLTAGE_LEVEL_0, > + VOLTAGE_LEVEL_1, > + VOLTAGE_LEVEL_2, > + VOLTAGE_LEVEL_3, > +}; > + > +enum pre_emphasis_level { > + PRE_EMPHASIS_LEVEL_0, > + PRE_EMPHASIS_LEVEL_1, > + PRE_EMPHASIS_LEVEL_2, > + PRE_EMPHASIS_LEVEL_3, > +}; > + > +enum pattern_set { > + PTS1 = BIT(0), > + PTS2 = BIT(1), > + PTS3 = BIT(2), > + PTS4 = BIT(3), > + DP_NONE = BIT(4) > +}; > + > +enum vic_color_depth { > + BCS_6 = 0x1, > + BCS_8 = 0x2, > + BCS_10 = 0x4, > + BCS_12 = 0x8, > + BCS_16 = 0x10, > +}; > + > +enum vic_bt_type { > + BT_601 = 0x0, > + BT_709 = 0x1, > +}; > + > +void cdn_dp_clock_reset(struct cdn_dp_device *dp); > + > +void cdn_dp_set_fw_clk(struct cdn_dp_device *dp, u32 clk); > +int cdn_dp_load_firmware(struct cdn_dp_device *dp, const u32 *i_mem, > + u32 i_size, const u32 *d_mem, u32 d_size); > +int cdn_dp_active(struct cdn_dp_device *dp, bool enable); > +int cdn_dp_set_host_cap(struct cdn_dp_device *dp, u8 lanes); > +int cdn_dp_event_config(struct cdn_dp_device *dp); > +u32 cdn_dp_get_event(struct cdn_dp_device *dp); > +int cdn_dp_get_hpd_status(struct cdn_dp_device *dp); > +int cdn_dp_dpcd_write(struct cdn_dp_device *dp, u32 addr, u8 value); > +int cdn_dp_dpcd_read(struct cdn_dp_device *dp, u32 addr, u8 *data, u16 len); > +int cdn_dp_get_edid_block(void *dp, u8 *edid, > + unsigned int block, size_t length); > +int cdn_dp_training_start(struct cdn_dp_device *dp); > +int cdn_dp_get_training_status(struct cdn_dp_device *dp); > +int cdn_dp_set_video_status(struct cdn_dp_device *dp, int active); > +int cdn_dp_config_video(struct cdn_dp_device *dp); > +int cdn_dp_audio_stop(struct cdn_dp_device *dp, struct audio_info *audio); > +int cdn_dp_audio_mute(struct cdn_dp_device *dp, bool enable); > +int cdn_dp_audio_config_set(struct cdn_dp_device *dp, struct audio_info *audio); > +#endif /* _CDN_DP_REG_H */ > diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c > index edd7ec2..d723d8e 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c > +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c > @@ -969,9 +969,11 @@ static void vop_crtc_enable(struct drm_crtc *crtc) > vop_dsp_hold_valid_irq_disable(vop); > } > > - pin_pol = 0x8; > - pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NHSYNC) ? 0 : 1; > - pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NVSYNC) ? 0 : (1 << 1); > + pin_pol = BIT(DCLK_INVERT); > + pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NHSYNC) ? > + 0 : BIT(HSYNC_POSITIVE); > + pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NVSYNC) ? > + 0 : BIT(VSYNC_POSITIVE); > VOP_CTRL_SET(vop, pin_pol, pin_pol); > > switch (s->output_type) { > @@ -991,6 +993,11 @@ static void vop_crtc_enable(struct drm_crtc *crtc) > VOP_CTRL_SET(vop, mipi_pin_pol, pin_pol); > VOP_CTRL_SET(vop, mipi_en, 1); > break; > + case DRM_MODE_CONNECTOR_DisplayPort: > + pin_pol &= ~BIT(DCLK_INVERT); > + VOP_CTRL_SET(vop, dp_pin_pol, pin_pol); > + VOP_CTRL_SET(vop, dp_en, 1); > + break; > default: > DRM_ERROR("unsupport connector_type[%d]\n", s->output_type); > } > diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.h b/drivers/gpu/drm/rockchip/rockchip_drm_vop.h > index ff4f52e..4820a8b 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.h > +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.h > @@ -45,6 +45,7 @@ struct vop_ctrl { > struct vop_reg edp_en; > struct vop_reg hdmi_en; > struct vop_reg mipi_en; > + struct vop_reg dp_en; > struct vop_reg out_mode; > struct vop_reg dither_down; > struct vop_reg dither_up; > @@ -53,6 +54,7 @@ struct vop_ctrl { > struct vop_reg hdmi_pin_pol; > struct vop_reg edp_pin_pol; > struct vop_reg mipi_pin_pol; > + struct vop_reg dp_pin_pol; > > struct vop_reg htotal_pw; > struct vop_reg hact_st_end; > @@ -242,6 +244,13 @@ enum scale_down_mode { > SCALE_DOWN_AVG = 0x1 > }; > > +enum vop_pol { > + HSYNC_POSITIVE = 0, > + VSYNC_POSITIVE = 1, > + DEN_NEGATIVE = 2, > + DCLK_INVERT = 3 > +}; > + > #define FRAC_16_16(mult, div) (((mult) << 16) / (div)) > #define SCL_FT_DEFAULT_FIXPOINT_SHIFT 12 > #define SCL_MAX_VSKIPLINES 4 > diff --git a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c > index 5b1ae1f..dcf172e 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c > +++ b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c > @@ -281,6 +281,7 @@ static const struct vop_data rk3288_vop = { > static const struct vop_ctrl rk3399_ctrl_data = { > .standby = VOP_REG(RK3399_SYS_CTRL, 0x1, 22), > .gate_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 23), > + .dp_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 11), > .rgb_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 12), > .hdmi_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 13), > .edp_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 14), > @@ -290,6 +291,7 @@ static const struct vop_ctrl rk3399_ctrl_data = { > .data_blank = VOP_REG(RK3399_DSP_CTRL0, 0x1, 19), > .out_mode = VOP_REG(RK3399_DSP_CTRL0, 0xf, 0), > .rgb_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 16), > + .dp_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 16), > .hdmi_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 20), > .edp_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 24), > .mipi_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 28), -- ?ark Yao From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752958AbcGVAmJ (ORCPT ); Thu, 21 Jul 2016 20:42:09 -0400 Received: from regular1.263xmail.com ([211.150.99.133]:33499 "EHLO regular1.263xmail.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751951AbcGVAmC (ORCPT ); Thu, 21 Jul 2016 20:42:02 -0400 X-263anti-spam: KSV:0; X-MAIL-GRAY: 0 X-MAIL-DELIVERY: 1 X-KSVirus-check: 0 X-ABS-CHECKED: 4 X-ADDR-CHECKED: 0 X-RL-SENDER: mark.yao@rock-chips.com X-FST-TO: linux-arm-kernel@lists.infradead.org X-SENDER-IP: 58.22.7.114 X-LOGIN-NAME: mark.yao@rock-chips.com X-UNIQUE-TAG: <3264c28869bd7f2db4e2f46d079d0ebb> X-ATTACHMENT-NUM: 0 X-DNS-TYPE: 0 Subject: Re: [v6 PATCH 6/6] drm/rockchip: cdn-dp: add cdn DP support for rk3399 To: Chris Zhong , dianders@chromium.org, tfiga@chromium.org, heiko@sntech.de, yzq@rock-chips.com, groeck@chromium.org, myungjoo.ham@samsung.com, cw00.choi@samsung.com, wulf@rock-chips.com, marcheu@chromium.org References: <1469106808-28297-1-git-send-email-zyw@rock-chips.com> <1469106808-28297-7-git-send-email-zyw@rock-chips.com> Cc: linux-rockchip@lists.infradead.org, David Airlie , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-arm-kernel@lists.infradead.org From: Mark yao Message-ID: <57916BAF.10109@rock-chips.com> Date: Fri, 22 Jul 2016 08:41:19 +0800 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.3.0 MIME-Version: 1.0 In-Reply-To: <1469106808-28297-7-git-send-email-zyw@rock-chips.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 2016年07月21日 21:13, Chris Zhong wrote: > Add support for cdn DP controller which is embedded in the rk3399 > SoCs. The DP is compliant with DisplayPort Specification, > Version 1.3, This IP is compatible with the rockchip type-c PHY IP. > There is a uCPU in DP controller, it need a firmware to work, > please put the firmware file to /lib/firmware/cdn/dptx.bin. The > uCPU in charge of aux communication and link training, the host use > mailbox to communicate with the ucpu. > The dclk pin_pol of vop must not be invert for DP. > > Signed-off-by: Chris Zhong > Reviewed-by: Sean Paul Sean Paul already do a good review, I think it's ready to be merged, so Acked-by: Mark Yao > --- > > Changes in v6: > - add a port struct > - select SND_SOC_HDMI_CODEC > - force reset the phy when hpd detected > > Changes in v5: > - alphabetical order > - do not use long, use u32 or u64 > - return MODE_CLOCK_HIGH when requested > actual > - Optimized Coding Style > - add a formula to get better tu size and symbol value. > - modify according to Sean Paul's comments > - fixed the fw_wait always 0 > > Changes in v4: > - use phy framework to control DP phy > - support 2 phys > > Changes in v3: > - use EXTCON_DISP_DP and EXTCON_DISP_DP_ALT cable to get dp port state. > - reset spdif before config it > - modify the firmware clk to 100Mhz > - retry load firmware if fw file is requested too early > > Changes in v2: > - Alphabetic order > - remove excess error message > - use define clk_rate > - check all return value > - remove dev_set_name(dp->dev, "cdn-dp"); > - use schedule_delayed_work > - remove never-called functions > - remove some unnecessary () > > Changes in v1: > - use extcon API > - use hdmi-codec for the DP Asoc > - do not initialize the "ret" > - printk a err log when drm_of_encoder_active_endpoint_id > - modify the dclk pin_pol to a single line > > drivers/gpu/drm/rockchip/Kconfig | 10 + > drivers/gpu/drm/rockchip/Makefile | 1 + > drivers/gpu/drm/rockchip/cdn-dp-core.c | 868 ++++++++++++++++++++++++++ > drivers/gpu/drm/rockchip/cdn-dp-core.h | 102 ++++ > drivers/gpu/drm/rockchip/cdn-dp-reg.c | 904 ++++++++++++++++++++++++++++ > drivers/gpu/drm/rockchip/cdn-dp-reg.h | 479 +++++++++++++++ > drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 13 +- > drivers/gpu/drm/rockchip/rockchip_drm_vop.h | 9 + > drivers/gpu/drm/rockchip/rockchip_vop_reg.c | 2 + > 9 files changed, 2385 insertions(+), 3 deletions(-) > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-core.c > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-core.h > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-reg.c > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-reg.h > > diff --git a/drivers/gpu/drm/rockchip/Kconfig b/drivers/gpu/drm/rockchip/Kconfig > index d30bdc3..20aaafe 100644 > --- a/drivers/gpu/drm/rockchip/Kconfig > +++ b/drivers/gpu/drm/rockchip/Kconfig > @@ -25,6 +25,16 @@ config ROCKCHIP_ANALOGIX_DP > for the Analogix Core DP driver. If you want to enable DP > on RK3288 based SoC, you should selet this option. > > +config ROCKCHIP_CDN_DP > + tristate "Rockchip cdn DP" > + depends on DRM_ROCKCHIP > + select SND_SOC_HDMI_CODEC if SND_SOC > + help > + This selects support for Rockchip SoC specific extensions > + for the cdn DP driver. If you want to enable Dp on > + RK3399 based SoC, you should select this > + option. > + > config ROCKCHIP_DW_HDMI > tristate "Rockchip specific extensions for Synopsys DW HDMI" > depends on DRM_ROCKCHIP > diff --git a/drivers/gpu/drm/rockchip/Makefile b/drivers/gpu/drm/rockchip/Makefile > index 05d0713..abdecd5 100644 > --- a/drivers/gpu/drm/rockchip/Makefile > +++ b/drivers/gpu/drm/rockchip/Makefile > @@ -7,6 +7,7 @@ rockchipdrm-y := rockchip_drm_drv.o rockchip_drm_fb.o \ > rockchipdrm-$(CONFIG_DRM_FBDEV_EMULATION) += rockchip_drm_fbdev.o > > obj-$(CONFIG_ROCKCHIP_ANALOGIX_DP) += analogix_dp-rockchip.o > +obj-$(CONFIG_ROCKCHIP_CDN_DP) += cdn-dp-core.o cdn-dp-reg.o > obj-$(CONFIG_ROCKCHIP_DW_HDMI) += dw_hdmi-rockchip.o > obj-$(CONFIG_ROCKCHIP_DW_MIPI_DSI) += dw-mipi-dsi.o > obj-$(CONFIG_ROCKCHIP_INNO_HDMI) += inno_hdmi.o > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-core.c b/drivers/gpu/drm/rockchip/cdn-dp-core.c > new file mode 100644 > index 0000000..209a7ef > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-core.c > @@ -0,0 +1,868 @@ > +/* > + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd > + * Author: Chris Zhong > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > + > +#include "cdn-dp-core.h" > +#include "cdn-dp-reg.h" > +#include "rockchip_drm_vop.h" > + > +#define connector_to_dp(c) \ > + container_of(c, struct cdn_dp_device, connector) > + > +#define encoder_to_dp(c) \ > + container_of(c, struct cdn_dp_device, encoder) > + > +/* dp grf register offset */ > +#define DP_VOP_SEL 0x6224 > +#define DP_SEL_VOP_LIT BIT(12) > +#define MAX_FW_WAIT_SECS 64 > +#define CDN_DP_FIRMWARE "rockchip/dptx.bin" > + > +struct cdn_dp_data { > + u8 max_phy; > +}; > + > +struct cdn_dp_data rk3399_cdn_dp = { > + .max_phy = 2, > +}; > + > +static const struct of_device_id cdn_dp_dt_ids[] = { > + { .compatible = "rockchip,rk3399-cdn-dp", > + .data = (void *)&rk3399_cdn_dp }, align the .data? > + {} > +}; > + > +MODULE_DEVICE_TABLE(of, cdn_dp_dt_ids); > + > +static int cdn_dp_clk_enable(struct cdn_dp_device *dp) > +{ > + int ret; > + u32 rate; > + > + ret = clk_prepare_enable(dp->pclk); > + if (ret < 0) { > + dev_err(dp->dev, "cannot enable dp pclk %d\n", ret); > + goto err_pclk; > + } > + > + ret = clk_prepare_enable(dp->core_clk); > + if (ret < 0) { > + dev_err(dp->dev, "cannot enable core_clk %d\n", ret); > + goto err_core_clk; > + } > + > + rate = clk_get_rate(dp->core_clk); > + if (rate < 0) { > + dev_err(dp->dev, "get clk rate failed: %d\n", rate); > + goto err_set_rate; > + } > + > + cdn_dp_set_fw_clk(dp, rate); > + > + return 0; > + > +err_set_rate: > + clk_disable_unprepare(dp->core_clk); > +err_core_clk: > + clk_disable_unprepare(dp->pclk); > +err_pclk: > + return ret; > +} > + > +static enum drm_connector_status > +cdn_dp_connector_detect(struct drm_connector *connector, bool force) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + > + return dp->hpd_status; > +} > + > +static void cdn_dp_connector_destroy(struct drm_connector *connector) > +{ > + drm_connector_unregister(connector); > + drm_connector_cleanup(connector); > +} > + > +static struct drm_connector_funcs cdn_dp_atomic_connector_funcs = { > + .dpms = drm_atomic_helper_connector_dpms, > + .detect = cdn_dp_connector_detect, > + .destroy = cdn_dp_connector_destroy, > + .fill_modes = drm_helper_probe_single_connector_modes, > + .reset = drm_atomic_helper_connector_reset, > + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, > + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, > +}; > + > +static int cdn_dp_connector_get_modes(struct drm_connector *connector) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + struct edid *edid; > + int ret = 0; > + > + edid = drm_do_get_edid(connector, cdn_dp_get_edid_block, dp); > + if (edid) { > + dev_dbg(dp->dev, "got edid: width[%d] x height[%d]\n", > + edid->width_cm, edid->height_cm); > + > + dp->sink_has_audio = drm_detect_monitor_audio(edid); > + ret = drm_add_edid_modes(connector, edid); > + if (ret) { > + drm_mode_connector_update_edid_property(connector, > + edid); > + drm_edid_to_eld(connector, edid); > + } > + kfree(edid); > + } else { > + dev_warn(dp->dev, "failed to get edid\n"); > + } > + > + return ret; > +} > + > +static struct drm_encoder * > + cdn_dp_connector_best_encoder(struct drm_connector *connector) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + > + return &dp->encoder; > +} > + > +static int cdn_dp_connector_mode_valid(struct drm_connector *connector, > + struct drm_display_mode *mode) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + struct drm_display_info *display_info = &dp->connector.display_info; > + u32 requested = mode->clock * display_info->bpc * 3 / 1000; > + u32 sink_max, source_max, rate; > + u8 lanes, i; > + u32 actual; > + > + /* find the running port */ > + for (i = 0; i < dp->ports; i++) { > + if (dp->port[i]->phy_status == 1) { > + source_max = dp->port[i]->cap_lanes; > + break; > + } > + } > + > + sink_max = drm_dp_max_lane_count(dp->dpcd); > + lanes = min(source_max, sink_max); > + > + source_max = drm_dp_bw_code_to_link_rate(CDN_DP_MAX_LINK_RATE); > + sink_max = drm_dp_max_link_rate(dp->dpcd); > + rate = min(source_max, sink_max); > + > + actual = rate * lanes / 100; > + > + /* efficiency is about 0.8 */ > + actual = actual * 8 / 10; > + > + if (requested > actual) { > + dev_dbg(dp->dev, "requested=%d, actual=%d, clock=%d\n", > + requested, actual, mode->clock); > + return MODE_CLOCK_HIGH; > + } > + > + return MODE_OK; > +} > + > +static struct drm_connector_helper_funcs cdn_dp_connector_helper_funcs = { > + .get_modes = cdn_dp_connector_get_modes, > + .best_encoder = cdn_dp_connector_best_encoder, > + .mode_valid = cdn_dp_connector_mode_valid, > +}; > + > +static void cdn_dp_commit(struct drm_encoder *encoder) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + int ret; > + > + ret = cdn_dp_training_start(dp); > + if (ret) { > + dev_err(dp->dev, "link training failed: %d\n", ret); > + return; > + } > + > + ret = cdn_dp_get_training_status(dp); > + if (ret) { > + dev_err(dp->dev, "get link training status failed: %d\n", ret); > + return; > + } > + > + dev_info(dp->dev, "rate:%d, lanes:%d\n", > + dp->link.rate, dp->link.num_lanes); > + > + if (cdn_dp_set_video_status(dp, CONTROL_VIDEO_IDLE)) > + return; > + > + if (cdn_dp_config_video(dp)) { > + dev_err(dp->dev, "unable to config video\n"); > + return; > + } > + > + if (cdn_dp_set_video_status(dp, CONTROL_VIDEO_VALID)) > + return; > + > + dp->dpms_mode = DRM_MODE_DPMS_ON; > +} > + > +static void cdn_dp_encoder_mode_set(struct drm_encoder *encoder, > + struct drm_display_mode *mode, > + struct drm_display_mode *adjusted) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + struct drm_display_info *display_info = &dp->connector.display_info; > + struct rockchip_crtc_state *state; > + struct video_info *video = &dp->video_info; > + int ret, val; > + > + switch (display_info->bpc) { > + case 16: > + case 12: > + case 10: > + video->color_depth = 10; > + break; > + case 6: > + video->color_depth = 6; > + break; > + default: > + video->color_depth = 8; > + break; > + } > + > + video->color_fmt = PXL_RGB; > + > + video->v_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NVSYNC); > + video->h_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NHSYNC); > + > + ret = drm_of_encoder_active_endpoint_id(dp->dev->of_node, encoder); > + if (ret < 0) { > + dev_err(dp->dev, "Could not get vop id, %d", ret); > + return; > + } > + > + dev_dbg(dp->dev, "vop %s output to cdn-dp\n", (ret) ? "LIT" : "BIG"); > + state = to_rockchip_crtc_state(encoder->crtc->state); > + if (ret) { > + val = DP_SEL_VOP_LIT | (DP_SEL_VOP_LIT << 16); > + state->output_mode = ROCKCHIP_OUT_MODE_P888; > + } else { > + val = DP_SEL_VOP_LIT << 16; > + state->output_mode = ROCKCHIP_OUT_MODE_AAAA; > + } > + ret = regmap_write(dp->grf, DP_VOP_SEL, val); > + if (ret != 0) > + dev_err(dp->dev, "Could not write to GRF: %d\n", ret); > + > + memcpy(&dp->mode, adjusted, sizeof(*mode)); > +} > + > +static void cdn_dp_encoder_enable(struct drm_encoder *encoder) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + > + if (dp->dpms_mode != DRM_MODE_DPMS_ON) > + cdn_dp_commit(encoder); > +} > + > +static void cdn_dp_encoder_disable(struct drm_encoder *encoder) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + > + if (dp->dpms_mode != DRM_MODE_DPMS_OFF) { > + cdn_dp_set_video_status(dp, CONTROL_VIDEO_IDLE); > + dp->dpms_mode = DRM_MODE_DPMS_OFF; > + } > +} > + > +static int > +cdn_dp_encoder_atomic_check(struct drm_encoder *encoder, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state) > +{ > + struct rockchip_crtc_state *s = to_rockchip_crtc_state(crtc_state); > + > + s->output_mode = ROCKCHIP_OUT_MODE_AAAA; > + s->output_type = DRM_MODE_CONNECTOR_DisplayPort; > + > + return 0; > +} > + > +static struct drm_encoder_helper_funcs cdn_dp_encoder_helper_funcs = { > + .mode_set = cdn_dp_encoder_mode_set, > + .enable = cdn_dp_encoder_enable, > + .disable = cdn_dp_encoder_disable, > + .atomic_check = cdn_dp_encoder_atomic_check, > +}; > + > +static struct drm_encoder_funcs cdn_dp_encoder_funcs = { > + .destroy = drm_encoder_cleanup, > +}; > + > +static int cdn_dp_firmware_init(struct cdn_dp_device *dp) > +{ > + int ret; > + const u32 *iram_data, *dram_data; > + const struct firmware *fw = dp->fw; > + const struct cdn_firmware_header *hdr; > + > + hdr = (struct cdn_firmware_header *)fw->data; > + if (fw->size != le32_to_cpu(hdr->size_bytes)) { > + dev_err(dp->dev, "firmware is invalid\n"); > + return -EINVAL; > + } > + > + iram_data = (const u32 *)(fw->data + hdr->header_size); > + dram_data = (const u32 *)(fw->data + hdr->header_size + hdr->iram_size); > + > + ret = cdn_dp_load_firmware(dp, iram_data, hdr->iram_size, > + dram_data, hdr->dram_size); > + if (ret) > + return ret; > + > + dp->fw_loaded = 1; > + > + ret = cdn_dp_active(dp, true); > + if (ret) { > + dev_err(dp->dev, "active ucpu failed: %d\n", ret); > + return ret; > + } > + > + return cdn_dp_event_config(dp); > +} > + > +static int cdn_dp_init(struct cdn_dp_device *dp) > +{ > + struct device *dev = dp->dev; > + struct device_node *np = dev->of_node; > + struct platform_device *pdev = to_platform_device(dev); > + struct resource *res; > + int ret; > + > + dp->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf"); > + if (IS_ERR(dp->grf)) { > + dev_err(dev, "cdn-dp needs rockchip,grf property\n"); > + return PTR_ERR(dp->grf); > + } > + > + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); > + dp->regs = devm_ioremap_resource(dev, res); > + if (IS_ERR(dp->regs)) { > + dev_err(dev, "ioremap reg failed\n"); > + return PTR_ERR(dp->regs); > + } > + > + dp->core_clk = devm_clk_get(dev, "core-clk"); > + if (IS_ERR(dp->core_clk)) { > + dev_err(dev, "cannot get core_clk_dp\n"); > + return PTR_ERR(dp->core_clk); > + } > + > + dp->pclk = devm_clk_get(dev, "pclk"); > + if (IS_ERR(dp->pclk)) { > + dev_err(dev, "cannot get pclk\n"); > + return PTR_ERR(dp->pclk); > + } > + > + dp->spdif_clk = devm_clk_get(dev, "spdif"); > + if (IS_ERR(dp->spdif_clk)) { > + dev_err(dev, "cannot get spdif_clk\n"); > + return PTR_ERR(dp->spdif_clk); > + } > + > + dp->spdif_rst = devm_reset_control_get(dev, "spdif"); > + if (IS_ERR(dp->spdif_rst)) { > + dev_err(dev, "no spdif reset control found\n"); > + return PTR_ERR(dp->spdif_rst); > + } > + > + dp->dpms_mode = DRM_MODE_DPMS_OFF; > + > + ret = cdn_dp_clk_enable(dp); > + if (ret < 0) > + return ret; > + > + cdn_dp_clock_reset(dp); > + > + return 0; > +} > + > +static int cdn_dp_audio_hw_params(struct device *dev, > + struct hdmi_codec_daifmt *daifmt, > + struct hdmi_codec_params *params) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct audio_info audio = { > + .sample_width = params->sample_width, > + .sample_rate = params->sample_rate, > + .channels = params->channels, > + }; > + int ret; > + > + if (!dp->encoder.crtc) > + return -ENODEV; > + > + switch (daifmt->fmt) { > + case HDMI_I2S: > + audio.format = AFMT_I2S; > + break; > + case HDMI_SPDIF: > + audio.format = AFMT_SPDIF; > + break; > + default: > + dev_err(dev, "%s: Invalid format %d\n", __func__, daifmt->fmt); > + return -EINVAL; > + } > + > + ret = cdn_dp_audio_config_set(dp, &audio); > + if (!ret) > + dp->audio_info = audio; > + > + return ret; > +} > + > +static void cdn_dp_audio_shutdown(struct device *dev) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + int ret = cdn_dp_audio_stop(dp, &dp->audio_info); > + > + if (!ret) > + dp->audio_info.format = AFMT_UNUSED; > +} > + > +static int cdn_dp_audio_digital_mute(struct device *dev, bool enable) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + > + return cdn_dp_audio_mute(dp, enable); > +} > + > +static int cdn_dp_audio_get_eld(struct device *dev, uint8_t *buf, size_t len) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct drm_mode_config *config = &dp->encoder.dev->mode_config; > + struct drm_connector *connector; > + int ret = -ENODEV; > + > + mutex_lock(&config->mutex); > + list_for_each_entry(connector, &config->connector_list, head) { > + if (&dp->encoder == connector->encoder) { > + memcpy(buf, connector->eld, > + min(sizeof(connector->eld), len)); > + ret = 0; > + } > + } > + mutex_unlock(&config->mutex); > + > + return ret; > +} > + > +static const struct hdmi_codec_ops audio_codec_ops = { > + .hw_params = cdn_dp_audio_hw_params, > + .audio_shutdown = cdn_dp_audio_shutdown, > + .digital_mute = cdn_dp_audio_digital_mute, > + .get_eld = cdn_dp_audio_get_eld, > +}; > + > +static int cdn_dp_audio_codec_init(struct cdn_dp_device *dp, > + struct device *dev) > +{ > + struct hdmi_codec_pdata codec_data = { > + .i2s = 1, > + .spdif = 1, > + .ops = &audio_codec_ops, > + .max_i2s_channels = 8, > + }; > + > + dp->audio_pdev = platform_device_register_data( > + dev, HDMI_CODEC_DRV_NAME, PLATFORM_DEVID_AUTO, > + &codec_data, sizeof(codec_data)); > + > + return PTR_ERR_OR_ZERO(dp->audio_pdev); > +} > + > +static int cdn_dp_get_cap_lanes(struct cdn_dp_device *dp, > + struct extcon_dev *edev) > +{ > + bool dfp, dptx; > + u8 lanes; > + > + dfp = extcon_get_cable_state_(edev, EXTCON_USB_HOST); > + dptx = extcon_get_cable_state_(edev, EXTCON_DISP_DP); > + > + if (dfp && dptx) > + lanes = 2; > + else if (dptx) > + lanes = 4; > + else > + lanes = 0; > + > + return lanes; > +} > + > +static int cdn_dp_phy_power_ctrl(struct cdn_dp_device *dp, > + struct cdn_dp_port *port, bool enable) > +{ > + struct phy *phy = port->phy; > + int ret; > + int count = 0; > + > + while (phy->power_count > 0) { > + ret = phy_power_off(phy); > + if (ret) > + return ret; > + count++; > + } > + > + count = enable ? count + 1 : count - 1; > + while (count-- > 0) { > + ret = phy_power_on(phy); > + if (ret) > + return ret; > + } > + > + port->phy_status = enable; > + return 0; > +} > + > +static int cdn_dp_pd_event(struct notifier_block *nb, > + unsigned long event, void *priv) > +{ > + struct cdn_dp_port *port; > + > + port = container_of(nb, struct cdn_dp_port, event_nb); > + > + schedule_delayed_work(&port->event_wq, 0); > + > + return 0; > +} > + > +static void cdn_dp_pd_event_wq(struct work_struct *work) > +{ > + struct cdn_dp_port *port = container_of(work, struct cdn_dp_port, > + event_wq.work); > + struct cdn_dp_device *dp = port->dp; > + u8 new_cap_lanes; > + int ret; > + u8 i; > + > + new_cap_lanes = cdn_dp_get_cap_lanes(dp, port->extcon); > + > + if (new_cap_lanes == port->cap_lanes) { > + dev_err(dp->dev, "lanes count does not change: %d\n", > + new_cap_lanes); > + return; > + } > + > + if (!new_cap_lanes) { > + ret = cdn_dp_phy_power_ctrl(dp, port, 0); > + if (ret) { > + dev_err(dp->dev, "phy power off failed: %d", ret); > + return; > + } > + port->phy_status = 0; > + port->cap_lanes = new_cap_lanes; > + for (i = 0; i < dp->ports; i++) { > + if (dp->port[i]->phy_status == 1) > + return; > + } > + > + dp->hpd_status = connector_status_disconnected; > + drm_helper_hpd_irq_event(dp->drm_dev); > + return; > + } > + > + /* if other phy is running, do not touch the hpd_status, and return */ > + for (i = 0; i < dp->ports; i++) { > + if (dp->port[i]->phy_status == 1) { > + dev_warn(dp->dev, "busy, phy[%d] is running", > + dp->port[i]->id); > + return; > + } > + } > + > + if (!dp->fw_loaded) { > + ret = request_firmware(&dp->fw, CDN_DP_FIRMWARE, dp->dev); > + if (ret == -ENOENT && dp->fw_wait <= MAX_FW_WAIT_SECS) { > + unsigned long time = msecs_to_jiffies(dp->fw_wait * HZ); > + > + /* > + * If can not find the file, retry to load the firmware > + * in 1 second, if still failed after 1 minute, give up. > + */ > + schedule_delayed_work(&port->event_wq, time); > + dev_warn(dp->dev, "retry to request firmware in %dS\n", > + dp->fw_wait); > + dp->fw_wait *= 2; > + return; > + } else if (ret) { > + dev_err(dp->dev, "failed to request firmware: %d\n", > + ret); > + return; > + } > + } > + > + ret = cdn_dp_phy_power_ctrl(dp, port, 1); > + if (ret) { > + if (!dp->fw_loaded) > + release_firmware(dp->fw); > + dev_err(dp->dev, "phy power on failed: %d\n", ret); > + return; > + } > + > + if (!dp->fw_loaded) { > + ret = cdn_dp_firmware_init(dp); > + release_firmware(dp->fw); > + if (ret) { > + dev_err(dp->dev, "firmware init failed: %d", ret); > + goto err_firmware; > + } > + } > + > + /* read hpd status failed, or the hpd does not exist. */ > + ret = cdn_dp_get_hpd_status(dp); > + if (ret <= 0) { > + dev_err(dp->dev, "get hpd failed: %d", ret); > + goto err_firmware; > + } > + > + ret = cdn_dp_set_host_cap(dp, new_cap_lanes); > + if (ret) { > + dev_err(dp->dev, "set host capabilities failed: %d\n", ret); > + goto err_firmware; > + } > + > + /* > + * Native read with retry for link status and receiver capability reads > + * for cases where the sink may still be asleep. > + * > + * Sinks are *supposed* to come up within 1ms from an off state, but > + * we're also supposed to retry 3 times per the spec. > + */ > + for (i = 0; i < 3; i++) { > + ret = cdn_dp_dpcd_read(dp, 0x000, dp->dpcd, > + DP_RECEIVER_CAP_SIZE); > + if (!ret) { > + port->cap_lanes = new_cap_lanes; > + dp->hpd_status = connector_status_connected; > + drm_helper_hpd_irq_event(dp->drm_dev); > + return; > + } > + usleep_range(1000, 1050); > + } > + > + dev_err(dp->dev, "get dpcd failed: %d", ret); > + > +err_firmware: > + ret = cdn_dp_phy_power_ctrl(dp, port, 0); > + if (ret) > + dev_err(dp->dev, "phy power off failed: %d", ret); > +} > + > +static int cdn_dp_bind(struct device *dev, struct device *master, > + void *data) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct drm_encoder *encoder; > + struct drm_connector *connector; > + struct cdn_dp_port *port; > + struct drm_device *drm_dev = data; > + int ret, i; > + > + ret = cdn_dp_init(dp); > + if (ret < 0) > + return ret; > + > + dp->drm_dev = drm_dev; > + dp->hpd_status = connector_status_disconnected; > + dp->fw_wait = 1; > + > + encoder = &dp->encoder; > + > + encoder->possible_crtcs = drm_of_find_possible_crtcs(drm_dev, > + dev->of_node); > + DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs); > + > + ret = drm_encoder_init(drm_dev, encoder, &cdn_dp_encoder_funcs, > + DRM_MODE_ENCODER_TMDS, NULL); > + if (ret) { > + DRM_ERROR("failed to initialize encoder with drm\n"); > + return ret; > + } > + > + drm_encoder_helper_add(encoder, &cdn_dp_encoder_helper_funcs); > + > + connector = &dp->connector; > + connector->polled = DRM_CONNECTOR_POLL_HPD; > + connector->dpms = DRM_MODE_DPMS_OFF; > + > + ret = drm_connector_init(drm_dev, connector, > + &cdn_dp_atomic_connector_funcs, > + DRM_MODE_CONNECTOR_DisplayPort); > + if (ret) { > + DRM_ERROR("failed to initialize connector with drm\n"); > + goto err_free_encoder; > + } > + > + drm_connector_helper_add(connector, &cdn_dp_connector_helper_funcs); > + > + ret = drm_mode_connector_attach_encoder(connector, encoder); > + if (ret) { > + DRM_ERROR("failed to attach connector and encoder\n"); > + goto err_free_connector; > + } > + > + cdn_dp_audio_codec_init(dp, dev); > + > + > + for (i = 0; i < dp->ports; i++) { > + port = dp->port[i]; > + > + port->event_nb.notifier_call = cdn_dp_pd_event; > + INIT_DELAYED_WORK(&port->event_wq, cdn_dp_pd_event_wq); > + ret = extcon_register_notifier(port->extcon, EXTCON_DISP_DP, > + &port->event_nb); > + if (ret) { > + dev_err(dev, "regitster EXTCON_DISP_DP notifier err\n"); > + return ret; > + } > + > + if (extcon_get_cable_state_(port->extcon, EXTCON_DISP_DP)) > + schedule_delayed_work(&port->event_wq, 0); > + } > + > + return 0; > + > +err_free_connector: > + drm_connector_cleanup(connector); > +err_free_encoder: > + drm_encoder_cleanup(encoder); > + return ret; > +} > + > +static void cdn_dp_unbind(struct device *dev, struct device *master, void *data) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct drm_encoder *encoder = &dp->encoder; > + struct drm_connector *connector = &dp->connector; > + struct cdn_dp_port *port; > + int i; > + > + platform_device_unregister(dp->audio_pdev); > + cdn_dp_encoder_disable(encoder); > + encoder->funcs->destroy(encoder); > + connector->funcs->destroy(connector); > + > + for (i = 0; i < dp->ports; i++) { > + port = dp->port[i]; > + extcon_unregister_notifier(port->extcon, EXTCON_DISP_DP, > + &port->event_nb); > + } > +} > + > +static const struct component_ops cdn_dp_component_ops = { > + .bind = cdn_dp_bind, > + .unbind = cdn_dp_unbind, > +}; > + > +static int cdn_dp_probe(struct platform_device *pdev) > +{ > + struct device *dev = &pdev->dev; > + const struct of_device_id *match; > + struct cdn_dp_data *dp_data; > + struct cdn_dp_port *port; > + struct cdn_dp_device *dp; > + struct extcon_dev *extcon; > + struct phy *phy; > + int i; > + > + dp = devm_kzalloc(dev, sizeof(*dp), GFP_KERNEL); > + if (!dp) > + return -ENOMEM; > + dp->dev = dev; > + > + match = of_match_node(cdn_dp_dt_ids, pdev->dev.of_node); > + dp_data = (struct cdn_dp_data *)match->data; > + > + for (i = 0; i < dp_data->max_phy; i++) { > + extcon = extcon_get_edev_by_phandle(dev, i); > + phy = devm_of_phy_get_by_index(dev, dev->of_node, i); > + > + if (PTR_ERR(extcon) == -EPROBE_DEFER || > + PTR_ERR(phy) == -EPROBE_DEFER) > + return -EPROBE_DEFER; > + > + if (IS_ERR(extcon) || IS_ERR(phy)) > + continue; > + > + port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL); > + if (!dp) > + return -ENOMEM; > + > + port->extcon = extcon; > + port->phy = phy; > + port->dp = dp; > + port->id = i; > + dp->port[dp->ports++] = port; > + } > + > + if (!dp->ports) { > + dev_err(dev, "missing extcon or phy\n"); > + return -EINVAL; > + } > + > + dev_set_drvdata(dev, dp); > + > + return component_add(dev, &cdn_dp_component_ops); > +} > + > +static int cdn_dp_remove(struct platform_device *pdev) > +{ > + component_del(&pdev->dev, &cdn_dp_component_ops); > + > + return 0; > +} > + > +static struct platform_driver cdn_dp_driver = { > + .probe = cdn_dp_probe, > + .remove = cdn_dp_remove, > + .driver = { > + .name = "cdn-dp", > + .owner = THIS_MODULE, > + .of_match_table = of_match_ptr(cdn_dp_dt_ids), > + }, > +}; > + > +module_platform_driver(cdn_dp_driver); > + > +MODULE_AUTHOR("Chris Zhong "); > +MODULE_DESCRIPTION("cdn DP Driver"); > +MODULE_LICENSE("GPL v2"); > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-core.h b/drivers/gpu/drm/rockchip/cdn-dp-core.h > new file mode 100644 > index 0000000..6eb7b72 > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-core.h > @@ -0,0 +1,102 @@ > +/* > + * Copyright (C) 2016 Chris Zhong > + * Copyright (C) 2016 ROCKCHIP, Inc. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#ifndef _CDN_DP_CORE_H > +#define _CDN_DP_CORE_H > + > +#include > +#include > +#include > +#include > +#include "rockchip_drm_drv.h" > + > +#define MAX_PHY 2 > + > +enum audio_format { > + AFMT_I2S = 0, > + AFMT_SPDIF = 1, > + AFMT_UNUSED, > +}; > + > +struct audio_info { > + enum audio_format format; > + int sample_rate; > + int channels; > + int sample_width; > +}; > + > +enum vic_pxl_encoding_format { > + PXL_RGB = 0x1, > + YCBCR_4_4_4 = 0x2, > + YCBCR_4_2_2 = 0x4, > + YCBCR_4_2_0 = 0x8, > + Y_ONLY = 0x10, > +}; > + > +struct video_info { > + bool h_sync_polarity; > + bool v_sync_polarity; > + bool interlaced; > + int color_depth; > + enum vic_pxl_encoding_format color_fmt; > +}; > + > +struct cdn_firmware_header { > + u32 size_bytes; /* size of the entire header+image(s) in bytes */ > + u32 header_size; /* size of just the header in bytes */ > + u32 iram_size; /* size of iram */ > + u32 dram_size; /* size of dram */ > +}; > + > +struct cdn_dp_port { > + struct cdn_dp_device *dp; > + struct notifier_block event_nb; > + struct delayed_work event_wq; > + struct extcon_dev *extcon; > + struct phy *phy; > + u8 cap_lanes; > + bool phy_status; > + u8 id; > +}; > + > +struct cdn_dp_device { > + struct device *dev; > + struct drm_device *drm_dev; > + struct drm_connector connector; > + struct drm_encoder encoder; > + struct drm_display_mode mode; > + struct platform_device *audio_pdev; > + > + const struct firmware *fw; /* cdn dp firmware */ > + unsigned int fw_version; /* cdn fw version */ > + u32 fw_wait; > + bool fw_loaded; > + void __iomem *regs; > + struct regmap *grf; > + struct clk *core_clk; > + struct clk *pclk; > + struct clk *spdif_clk; > + struct reset_control *spdif_rst; > + struct audio_info audio_info; > + struct video_info video_info; > + struct drm_dp_link link; > + struct cdn_dp_port *port[MAX_PHY]; > + u8 ports; > + > + u8 dpcd[DP_RECEIVER_CAP_SIZE]; > + enum drm_connector_status hpd_status; > + int dpms_mode; > + bool sink_has_audio; > +}; > +#endif /* _CDN_DP_CORE_H */ > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-reg.c b/drivers/gpu/drm/rockchip/cdn-dp-reg.c > new file mode 100644 > index 0000000..a224a6b > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-reg.c > @@ -0,0 +1,904 @@ > +/* > + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd > + * Author: Chris Zhong > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "cdn-dp-core.h" > +#include "cdn-dp-reg.h" > + > +#define CDN_DP_SPDIF_CLK 200000000 > +#define FW_ALIVE_TIMEOUT_US 1000000 > +#define MAILBOX_RETRY_US 1000 > +#define MAILBOX_TIMEOUT_US 5000000 > +#define LINK_TRAINING_RETRY_MS 20 > +#define LINK_TRAINING_TIMEOUT_MS 500 > + > +void cdn_dp_set_fw_clk(struct cdn_dp_device *dp, u32 clk) > +{ > + writel(clk / 1000000, dp->regs + SW_CLK_H); > +} > + > +void cdn_dp_clock_reset(struct cdn_dp_device *dp) > +{ > + u32 val; > + > + val = DPTX_FRMR_DATA_CLK_RSTN_EN | > + DPTX_FRMR_DATA_CLK_EN | > + DPTX_PHY_DATA_RSTN_EN | > + DPTX_PHY_DATA_CLK_EN | > + DPTX_PHY_CHAR_RSTN_EN | > + DPTX_PHY_CHAR_CLK_EN | > + SOURCE_AUX_SYS_CLK_RSTN_EN | > + SOURCE_AUX_SYS_CLK_EN | > + DPTX_SYS_CLK_RSTN_EN | > + DPTX_SYS_CLK_EN | > + CFG_DPTX_VIF_CLK_RSTN_EN | > + CFG_DPTX_VIF_CLK_EN; > + writel(val, dp->regs + SOURCE_DPTX_CAR); > + > + val = SOURCE_PHY_RSTN_EN | SOURCE_PHY_CLK_EN; > + writel(val, dp->regs + SOURCE_PHY_CAR); > + > + val = SOURCE_PKT_SYS_RSTN_EN | > + SOURCE_PKT_SYS_CLK_EN | > + SOURCE_PKT_DATA_RSTN_EN | > + SOURCE_PKT_DATA_CLK_EN; > + writel(val, dp->regs + SOURCE_PKT_CAR); > + > + val = SPDIF_CDR_CLK_RSTN_EN | > + SPDIF_CDR_CLK_EN | > + SOURCE_AIF_SYS_RSTN_EN | > + SOURCE_AIF_SYS_CLK_EN | > + SOURCE_AIF_CLK_RSTN_EN | > + SOURCE_AIF_CLK_EN; > + writel(val, dp->regs + SOURCE_AIF_CAR); > + > + val = SOURCE_CIPHER_SYSTEM_CLK_RSTN_EN | > + SOURCE_CIPHER_SYS_CLK_EN | > + SOURCE_CIPHER_CHAR_CLK_RSTN_EN | > + SOURCE_CIPHER_CHAR_CLK_EN; > + writel(val, dp->regs + SOURCE_CIPHER_CAR); > + > + val = SOURCE_CRYPTO_SYS_CLK_RSTN_EN | > + SOURCE_CRYPTO_SYS_CLK_EN; > + writel(val, dp->regs + SOURCE_CRYPTO_CAR); > + > + val = ~(MAILBOX_INT_MASK_BIT | PIF_INT_MASK_BIT) & ALL_INT_MASK; > + writel(val, dp->regs + APB_INT_MASK); > +} > + > +static int cdn_dp_mailbox_read(struct cdn_dp_device *dp) > +{ > + int val, ret; > + > + if (!dp->fw_loaded) > + return -EPERM; > + > + ret = readx_poll_timeout(readl, dp->regs + MAILBOX_EMPTY_ADDR, > + val, !val, MAILBOX_RETRY_US, > + MAILBOX_TIMEOUT_US); > + if (ret < 0) { > + dev_err(dp->dev, "failed to read mailbox, keep alive = %x\n", > + readl(dp->regs + KEEP_ALIVE)); > + return ret; > + } > + > + return readl(dp->regs + MAILBOX0_RD_DATA) & 0xff; > +} > + > +static int cdp_dp_mailbox_write(struct cdn_dp_device *dp, u8 val) > +{ > + int ret, full; > + > + if (!dp->fw_loaded) > + return -EPERM; > + > + ret = readx_poll_timeout(readl, dp->regs + MAILBOX_FULL_ADDR, > + full, !full, MAILBOX_RETRY_US, > + MAILBOX_TIMEOUT_US); > + if (ret < 0) { > + dev_err(dp->dev, "mailbox is full, keep alive = %x\n", > + readl(dp->regs + KEEP_ALIVE)); > + return ret; > + } > + > + writel(val, dp->regs + MAILBOX0_WR_DATA); > + > + return 0; > +} > + > +static int cdn_dp_mailbox_validate_receive(struct cdn_dp_device *dp, > + u8 module_id, u8 opcode, > + u8 req_size) > +{ > + u32 mbox_size, i; > + u8 header[4]; > + int ret; > + > + /* read the header of the message */ > + for (i = 0; i < 4; i++) { > + ret = cdn_dp_mailbox_read(dp); > + if (ret < 0) > + return ret; > + > + header[i] = ret; > + } > + > + mbox_size = (header[2] << 8) | header[3]; > + > + if (opcode != header[0] || module_id != header[1] || > + req_size != mbox_size) { > + dev_err(dp->dev, "mailbox validate failed"); > + > + /* > + * If the message in mailbox is not what we want, we need to > + * clear the mailbox by read. > + */ > + for (i = 0; i < mbox_size; i++) > + if (cdn_dp_mailbox_read(dp) < 0) > + break; > + > + return -EINVAL; > + } > + > + return 0; > +} > + > +static int cdn_dp_mailbox_read_receive(struct cdn_dp_device *dp, > + u8 *buff, u8 buff_size) > +{ > + u32 i; > + int ret; > + > + for (i = 0; i < buff_size; i++) { > + ret = cdn_dp_mailbox_read(dp); > + if (ret < 0) > + return ret; > + > + buff[i] = ret; > + } > + > + return 0; > +} > + > +static int cdn_dp_mailbox_send(struct cdn_dp_device *dp, u8 module_id, > + u8 opcode, u16 size, u8 *message) > +{ > + u8 header[4]; > + int ret, i; > + > + header[0] = opcode; > + header[1] = module_id; > + header[2] = (size >> 8) & 0xff; > + header[3] = size & 0xff; > + > + for (i = 0; i < 4; i++) { > + ret = cdp_dp_mailbox_write(dp, header[i]); > + if (ret) > + return ret; > + } > + > + for (i = 0; i < size; i++) { > + ret = cdp_dp_mailbox_write(dp, message[i]); > + if (ret) { > + dev_err(dp->dev, "mailbox send failed: %d", ret); > + return ret; > + } > + } > + > + return 0; > +} > + > +static int cdn_dp_reg_write(struct cdn_dp_device *dp, u16 addr, u32 val) > +{ > + u8 msg[6]; > + > + msg[0] = (addr >> 8) & 0xff; > + msg[1] = addr & 0xff; > + msg[2] = (val >> 24) & 0xff; > + msg[3] = (val >> 16) & 0xff; > + msg[4] = (val >> 8) & 0xff; > + msg[5] = val & 0xff; > + return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_REGISTER, > + sizeof(msg), msg); > +} > + > +int cdn_dp_dpcd_read(struct cdn_dp_device *dp, u32 addr, u8 *data, u16 len) > +{ > + u8 msg[5], reg[5]; > + int ret; > + > + msg[0] = (len >> 8) & 0xff; > + msg[1] = len & 0xff; > + msg[2] = (addr >> 16) & 0xff; > + msg[3] = (addr >> 8) & 0xff; > + msg[4] = addr & 0xff; > + cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_DPCD, > + sizeof(msg), msg); > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_DPCD, > + sizeof(reg) + len); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg)); > + if (ret) > + return ret; > + > + return cdn_dp_mailbox_read_receive(dp, data, len); > +} > + > +int cdn_dp_dpcd_write(struct cdn_dp_device *dp, u32 addr, u8 value) > +{ > + u8 msg[6], reg[5]; > + int ret; > + > + msg[0] = 0; > + msg[1] = 1; > + msg[2] = (addr >> 16) & 0xff; > + msg[3] = (addr >> 8) & 0xff; > + msg[4] = addr & 0xff; > + msg[5] = value; > + cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_DPCD, > + sizeof(msg), msg); > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_WRITE_DPCD, sizeof(reg)); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg)); > + if (ret) > + return ret; > + > + if (addr != (reg[2] << 16 | reg[3] << 8 | reg[4])) { > + dev_err(dp->dev, "write dpcd failed\n"); > + return -EINVAL; > + } > + > + return 0; > +} > + > +int cdn_dp_load_firmware(struct cdn_dp_device *dp, const u32 *i_mem, > + u32 i_size, const u32 *d_mem, u32 d_size) > +{ > + int i, ret; > + u32 reg; > + > + /* reset ucpu before load firmware*/ > + writel(APB_IRAM_PATH | APB_DRAM_PATH | APB_XT_RESET, > + dp->regs + APB_CTRL); > + > + for (i = 0; i < i_size; i += 4) > + writel(*i_mem++, dp->regs + ADDR_IMEM + i); > + > + for (i = 0; i < d_size; i += 4) > + writel(*d_mem++, dp->regs + ADDR_DMEM + i); > + > + /* un-reset ucpu */ > + writel(0, dp->regs + APB_CTRL); > + > + /* check the keep alive register to make sure fw working */ > + ret = readx_poll_timeout(readl, dp->regs + KEEP_ALIVE, > + reg, reg, 2000, FW_ALIVE_TIMEOUT_US); > + if (ret < 0) { > + dev_err(dp->dev, "failed to loaded the FW reg = %x\n", reg); > + return -EINVAL; > + } > + > + reg = readl(dp->regs + VER_L) & 0xff; > + dp->fw_version = reg; > + reg = readl(dp->regs + VER_H) & 0xff; > + dp->fw_version |= reg << 8; > + reg = readl(dp->regs + VER_LIB_L_ADDR) & 0xff; > + dp->fw_version |= reg << 16; > + reg = readl(dp->regs + VER_LIB_H_ADDR) & 0xff; > + dp->fw_version |= reg << 24; > + > + dev_dbg(dp->dev, "firmware version: %x\n", dp->fw_version); > + > + return 0; > +} > + > +int cdn_dp_reg_write_bit(struct cdn_dp_device *dp, u16 addr, u8 start_bit, > + u8 bits_no, u32 val) > +{ > + u8 field[8]; > + > + field[0] = (addr >> 8) & 0xff; > + field[1] = addr & 0xff; > + field[2] = start_bit; > + field[3] = bits_no; > + field[4] = (val >> 24) & 0xff; > + field[5] = (val >> 16) & 0xff; > + field[6] = (val >> 8) & 0xff; > + field[7] = val & 0xff; > + > + return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_FIELD, > + sizeof(field), field); > +} > + > +int cdn_dp_active(struct cdn_dp_device *dp, bool enable) > +{ > + u8 active = enable ? 1 : 0; > + u8 resp; > + int ret; > + > + /* set firmware status, 1: active; 0: standby */ > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_GENERAL, > + GENERAL_MAIN_CONTROL, sizeof(active), > + &active); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_GENERAL, > + GENERAL_MAIN_CONTROL, > + sizeof(resp)); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, &resp, sizeof(resp)); > + if (ret) > + return ret; > + > + return resp ? 0 : -EINVAL; > +} > + > +int cdn_dp_set_host_cap(struct cdn_dp_device *dp, u8 lanes) > +{ > + u8 msg[8]; > + int ret; > + > + msg[0] = CDN_DP_MAX_LINK_RATE; > + msg[1] = lanes; > + msg[2] = VOLTAGE_LEVEL_2; > + msg[3] = PRE_EMPHASIS_LEVEL_3; > + msg[4] = PTS1 | PTS2 | PTS3 | PTS4; > + msg[5] = FAST_LT_NOT_SUPPORT; > + msg[6] = LANE_MAPPING_NORMAL; > + msg[7] = ENHANCED; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, > + DPTX_SET_HOST_CAPABILITIES, > + sizeof(msg), msg); > + if (ret) > + return ret; > + > + ret = cdn_dp_reg_write(dp, DP_AUX_SWAP_INVERSION_CONTROL, > + AUX_HOST_INVERT); > + if (ret) > + return ret; > + > + return 0; > +} > + > +int cdn_dp_event_config(struct cdn_dp_device *dp) > +{ > + u8 msg[5]; > + > + memset(msg, 0, sizeof(msg)); > + > + msg[0] = DPTX_EVENT_ENABLE_HPD | DPTX_EVENT_ENABLE_TRAINING; > + > + return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_ENABLE_EVENT, > + sizeof(msg), msg); > +} > + > +u32 cdn_dp_get_event(struct cdn_dp_device *dp) > +{ > + return readl(dp->regs + SW_EVENTS0); > +} > + > +int cdn_dp_get_hpd_status(struct cdn_dp_device *dp) > +{ > + u8 status; > + int ret; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_HPD_STATE, > + 0, NULL); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_HPD_STATE, sizeof(status)); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, &status, sizeof(status)); > + if (ret) > + return ret; > + > + return status; > +} > + > +int cdn_dp_get_edid_block(void *data, u8 *edid, > + unsigned int block, size_t length) > +{ > + struct cdn_dp_device *dp = data; > + u8 msg[2], reg[2]; > + int ret; > + > + msg[0] = block / 2; > + msg[1] = block % 2; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_GET_EDID, > + sizeof(msg), msg); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_GET_EDID, > + sizeof(reg) + length); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg)); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, edid, length); > + if (ret) > + return ret; > + > + if (reg[0] != length || reg[1] != block / 2) { > + dev_err(dp->dev, "edid block size err\n"); > + return -EINVAL; > + } > + > + return 0; > +} > + > +int cdn_dp_training_start(struct cdn_dp_device *dp) > +{ > + u8 msg, event[2]; > + unsigned long timeout; > + int ret; > + > + msg = LINK_TRAINING_RUN; > + > + /* start training */ > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_TRAINING_CONTROL, > + sizeof(msg), &msg); > + if (ret) > + return ret; > + > + timeout = jiffies + msecs_to_jiffies(LINK_TRAINING_TIMEOUT_MS); > + while (time_before(jiffies, timeout)) { > + msleep(LINK_TRAINING_RETRY_MS); > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_EVENT, 0, NULL); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_EVENT, > + sizeof(event)); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, event, sizeof(event)); > + if (ret) > + return ret; > + > + if (event[1] & EQ_PHASE_FINISHED) > + return 0; > + } > + > + return -ETIMEDOUT; > +} > + > +int cdn_dp_get_training_status(struct cdn_dp_device *dp) > +{ > + u8 status[10]; > + int ret; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_LINK_STAT, > + 0, NULL); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_LINK_STAT, > + sizeof(status)); > + if (ret) > + return ret; > + > + ret = cdn_dp_mailbox_read_receive(dp, status, sizeof(status)); > + if (ret) > + return ret; > + > + dp->link.rate = status[0]; > + dp->link.num_lanes = status[1]; > + > + return 0; > +} > + > +int cdn_dp_set_video_status(struct cdn_dp_device *dp, int active) > +{ > + u8 msg; > + > + msg = !!active; > + > + return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_SET_VIDEO, > + sizeof(msg), &msg); > +} > + > +static int cdn_dp_get_msa_misc(struct video_info *video, > + struct drm_display_mode *mode) > +{ > + u8 val[2]; > + u32 msa_misc; > + > + switch (video->color_fmt) { > + case PXL_RGB: > + case Y_ONLY: > + val[0] = 0; > + break; > + /* set YUV default color space conversion to BT601 */ > + case YCBCR_4_4_4: > + val[0] = 6 + BT_601 * 8; > + break; > + case YCBCR_4_2_2: > + val[0] = 5 + BT_601 * 8; > + break; > + case YCBCR_4_2_0: > + val[0] = 5; > + break; > + }; > + > + switch (video->color_depth) { > + case 6: > + val[1] = 0; > + break; > + case 8: > + val[1] = 1; > + break; > + case 10: > + val[1] = 2; > + break; > + case 12: > + val[1] = 3; > + break; > + case 16: > + val[1] = 4; > + break; > + }; > + > + msa_misc = 2 * val[0] + 32 * val[1] + > + ((video->color_fmt == Y_ONLY) ? (1 << 14) : 0); > + > + return msa_misc; > +} > + > +int cdn_dp_config_video(struct cdn_dp_device *dp) > +{ > + struct video_info *video = &dp->video_info; > + struct drm_display_mode *mode = &dp->mode; > + u64 symbol; > + u32 val, link_rate; > + u8 bit_per_pix; > + u8 tu_size_reg = TU_SIZE; > + int ret; > + > + bit_per_pix = (video->color_fmt == YCBCR_4_2_2) ? > + (video->color_depth * 2) : (video->color_depth * 3); > + > + link_rate = drm_dp_bw_code_to_link_rate(dp->link.rate); > + > + val = VIF_BYPASS_INTERLACE; > + ret = cdn_dp_reg_write(dp, BND_HSYNC2VSYNC, val); > + if (ret) > + return ret; > + > + ret = cdn_dp_reg_write(dp, HSYNC2VSYNC_POL_CTRL, 0); > + if (ret) > + return ret; > + > + /* get a best tu_size and symbol */ > + do { > + tu_size_reg += 2; > + symbol = tu_size_reg * mode->clock * bit_per_pix; > + symbol /= dp->link.num_lanes * link_rate * 8; > + } while ((symbol == 1) || (tu_size_reg - symbol < 4)); > + > + val = symbol + (tu_size_reg << 8); > + ret = cdn_dp_reg_write(dp, DP_FRAMER_TU, val); > + if (ret) > + return ret; > + > + /* set the FIFO Buffer size */ > + val = ((mode->clock * (symbol + 1) / 1000) + link_rate); > + val /= (dp->link.num_lanes * link_rate); > + val = 8 * (symbol + 1) / bit_per_pix - val; > + val += 2; > + ret = cdn_dp_reg_write(dp, DP_VC_TABLE(15), val); > + > + switch (video->color_depth) { > + case 6: > + val = BCS_6; > + break; > + case 8: > + val = BCS_8; > + break; > + case 10: > + val = BCS_10; > + break; > + case 12: > + val = BCS_12; > + break; > + case 16: > + val = BCS_16; > + break; > + }; > + > + val += video->color_fmt << 8; > + ret = cdn_dp_reg_write(dp, DP_FRAMER_PXL_REPR, val); > + if (ret) > + return ret; > + > + val = video->h_sync_polarity ? DP_FRAMER_SP_HSP : 0; > + val |= video->v_sync_polarity ? DP_FRAMER_SP_VSP : 0; > + ret = cdn_dp_reg_write(dp, DP_FRAMER_SP, val); > + if (ret) > + return ret; > + > + val = (mode->hsync_start - mode->hdisplay) << 16; > + val |= mode->htotal - mode->hsync_end; > + ret = cdn_dp_reg_write(dp, DP_FRONT_BACK_PORCH, val); > + if (ret) > + return ret; > + > + val = mode->hdisplay * bit_per_pix / 8; > + ret = cdn_dp_reg_write(dp, DP_BYTE_COUNT, val); > + if (ret) > + return ret; > + > + val = mode->htotal | ((mode->htotal - mode->hsync_start) << 16); > + ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_0, val); > + if (ret) > + return ret; > + > + val = mode->hsync_end - mode->hsync_start; > + val |= (mode->hdisplay << 16) | (video->h_sync_polarity << 15); > + ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_1, val); > + if (ret) > + return ret; > + > + val = mode->vtotal; > + val |= ((mode->vtotal - mode->vsync_start) << 16); > + ret = cdn_dp_reg_write(dp, MSA_VERTICAL_0, val); > + if (ret) > + return ret; > + > + val = mode->vsync_end - mode->vsync_start; > + val |= mode->vdisplay << 16 | (video->v_sync_polarity << 15); > + ret = cdn_dp_reg_write(dp, MSA_VERTICAL_1, val); > + if (ret) > + return ret; > + > + val = cdn_dp_get_msa_misc(video, mode); > + ret = cdn_dp_reg_write(dp, MSA_MISC, val); > + if (ret) > + return ret; > + > + ret = cdn_dp_reg_write(dp, STREAM_CONFIG, 1); > + if (ret) > + return ret; > + > + val = mode->hsync_end - mode->hsync_start; > + val |= (mode->hdisplay << 16); > + ret = cdn_dp_reg_write(dp, DP_HORIZONTAL, val); > + if (ret) > + return ret; > + > + val = mode->vtotal; > + val -= (mode->vtotal - mode->vdisplay); > + val |= (mode->vtotal - mode->vsync_start) << 16; > + ret = cdn_dp_reg_write(dp, DP_VERTICAL_0, val); > + if (ret) > + return ret; > + > + val = mode->vtotal; > + ret = cdn_dp_reg_write(dp, DP_VERTICAL_1, val); > + if (ret) > + return ret; > + > + val = 0; > + return cdn_dp_reg_write_bit(dp, DP_VB_ID, 2, 1, val); > +} > + > +int cdn_dp_audio_stop(struct cdn_dp_device *dp, struct audio_info *audio) > +{ > + u32 val; > + int ret; > + > + ret = cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, 0); > + if (ret) > + return ret; > + > + val = SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS; > + val |= SPDIF_FIFO_MID_RANGE(0xe0); > + val |= SPDIF_JITTER_THRSH(0xe0); > + val |= SPDIF_JITTER_AVG_WIN(7); > + writel(val, dp->regs + SPDIF_CTRL_ADDR); > + > + /* clearn the audio config and reset */ > + writel(0, dp->regs + AUDIO_SRC_CNTL); > + writel(0, dp->regs + AUDIO_SRC_CNFG); > + writel(AUDIO_SW_RST, dp->regs + AUDIO_SRC_CNTL); > + writel(0, dp->regs + AUDIO_SRC_CNTL); > + > + /* reset smpl2pckt component */ > + writel(0, dp->regs + SMPL2PKT_CNTL); > + writel(AUDIO_SW_RST, dp->regs + SMPL2PKT_CNTL); > + writel(0, dp->regs + SMPL2PKT_CNTL); > + > + /* reset FIFO */ > + writel(AUDIO_SW_RST, dp->regs + FIFO_CNTL); > + writel(0, dp->regs + FIFO_CNTL); > + > + if (audio->format == AFMT_SPDIF) > + clk_disable_unprepare(dp->spdif_clk); > + > + return 0; > +} > + > +int cdn_dp_audio_mute(struct cdn_dp_device *dp, bool enable) > +{ > + return cdn_dp_reg_write_bit(dp, DP_VB_ID, 4, 1, enable); > +} > + > +static void cdn_dp_audio_config_i2s(struct cdn_dp_device *dp, > + struct audio_info *audio) > +{ > + int sub_pckt_num = 1, i2s_port_en_val = 0xf, i; > + u32 val; > + > + if (audio->channels == 2) { > + if (dp->link.num_lanes == 1) > + sub_pckt_num = 2; > + else > + sub_pckt_num = 4; > + > + i2s_port_en_val = 1; > + } else if (audio->channels == 4) { > + i2s_port_en_val = 3; > + } > + > + writel(0x0, dp->regs + SPDIF_CTRL_ADDR); > + > + writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL); > + > + val = MAX_NUM_CH(audio->channels); > + val |= NUM_OF_I2S_PORTS(audio->channels); > + val |= AUDIO_TYPE_LPCM; > + val |= CFG_SUB_PCKT_NUM(sub_pckt_num); > + writel(val, dp->regs + SMPL2PKT_CNFG); > + > + if (audio->sample_width == 16) > + val = 0; > + else if (audio->sample_width == 24) > + val = 1 << 9; > + else > + val = 2 << 9; > + > + val |= AUDIO_CH_NUM(audio->channels); > + val |= I2S_DEC_PORT_EN(i2s_port_en_val); > + val |= TRANS_SMPL_WIDTH_32; > + writel(val, dp->regs + AUDIO_SRC_CNFG); > + > + for (i = 0; i < (audio->channels + 1) / 2; i++) { > + if (audio->sample_width == 16) > + val = (0x08 << 8) | (0x08 << 20); > + else if (audio->sample_width == 24) > + val = (0x0b << 8) | (0x0b << 20); > + > + val |= ((2 * i) << 4) | ((2 * i + 1) << 16); > + writel(val, dp->regs + STTS_BIT_CH(i)); > + } > + > + switch (audio->sample_rate) { > + case 32000: > + val = SAMPLING_FREQ(3) | > + ORIGINAL_SAMP_FREQ(0xc); > + break; > + case 44100: > + val = SAMPLING_FREQ(0) | > + ORIGINAL_SAMP_FREQ(0xf); > + break; > + case 48000: > + val = SAMPLING_FREQ(2) | > + ORIGINAL_SAMP_FREQ(0xd); > + break; > + case 88200: > + val = SAMPLING_FREQ(8) | > + ORIGINAL_SAMP_FREQ(0x7); > + break; > + case 96000: > + val = SAMPLING_FREQ(0xa) | > + ORIGINAL_SAMP_FREQ(5); > + break; > + case 176400: > + val = SAMPLING_FREQ(0xc) | > + ORIGINAL_SAMP_FREQ(3); > + break; > + case 192000: > + val = SAMPLING_FREQ(0xe) | > + ORIGINAL_SAMP_FREQ(1); > + break; > + } > + val |= 4; > + writel(val, dp->regs + COM_CH_STTS_BITS); > + > + writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL); > + writel(I2S_DEC_START, dp->regs + AUDIO_SRC_CNTL); > +} > + > +static void cdn_dp_audio_config_spdif(struct cdn_dp_device *dp) > +{ > + u32 val; > + > + val = SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS; > + val |= SPDIF_FIFO_MID_RANGE(0xe0); > + val |= SPDIF_JITTER_THRSH(0xe0); > + val |= SPDIF_JITTER_AVG_WIN(7); > + writel(val, dp->regs + SPDIF_CTRL_ADDR); > + > + writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL); > + > + val = MAX_NUM_CH(2) | AUDIO_TYPE_LPCM | CFG_SUB_PCKT_NUM(4); > + writel(val, dp->regs + SMPL2PKT_CNFG); > + writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL); > + > + val = SPDIF_ENABLE | SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS; > + val |= SPDIF_FIFO_MID_RANGE(0xe0); > + val |= SPDIF_JITTER_THRSH(0xe0); > + val |= SPDIF_JITTER_AVG_WIN(7); > + writel(val, dp->regs + SPDIF_CTRL_ADDR); > + > + clk_prepare_enable(dp->spdif_clk); > + clk_set_rate(dp->spdif_clk, CDN_DP_SPDIF_CLK); > +} > + > +int cdn_dp_audio_config_set(struct cdn_dp_device *dp, struct audio_info *audio) > +{ > + int ret; > + > + /* reset the spdif clk before config */ > + if (audio->format == AFMT_SPDIF) { > + reset_control_assert(dp->spdif_rst); > + reset_control_deassert(dp->spdif_rst); > + } > + > + ret = cdn_dp_reg_write(dp, CM_LANE_CTRL, LANE_REF_CYC); > + if (ret) > + return ret; > + > + ret = cdn_dp_reg_write(dp, CM_CTRL, 0); > + if (ret) > + return ret; > + > + if (audio->format == AFMT_I2S) > + cdn_dp_audio_config_i2s(dp, audio); > + else > + cdn_dp_audio_config_spdif(dp); > + > + return cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, AUDIO_PACK_EN); > +} > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-reg.h b/drivers/gpu/drm/rockchip/cdn-dp-reg.h > new file mode 100644 > index 0000000..1affeed > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-reg.h > @@ -0,0 +1,479 @@ > +/* > + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd > + * Author: Chris Zhong > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#ifndef _CDN_DP_REG_H > +#define _CDN_DP_REG_H > + > +#include > + > +#define ADDR_IMEM 0x10000 > +#define ADDR_DMEM 0x20000 > + > +/* APB CFG addr */ > +#define APB_CTRL 0 > +#define XT_INT_CTRL 0x04 > +#define MAILBOX_FULL_ADDR 0x08 > +#define MAILBOX_EMPTY_ADDR 0x0c > +#define MAILBOX0_WR_DATA 0x10 > +#define MAILBOX0_RD_DATA 0x14 > +#define KEEP_ALIVE 0x18 > +#define VER_L 0x1c > +#define VER_H 0x20 > +#define VER_LIB_L_ADDR 0x24 > +#define VER_LIB_H_ADDR 0x28 > +#define SW_DEBUG_L 0x2c > +#define SW_DEBUG_H 0x30 > +#define MAILBOX_INT_MASK 0x34 > +#define MAILBOX_INT_STATUS 0x38 > +#define SW_CLK_L 0x3c > +#define SW_CLK_H 0x40 > +#define SW_EVENTS0 0x44 > +#define SW_EVENTS1 0x48 > +#define SW_EVENTS2 0x4c > +#define SW_EVENTS3 0x50 > +#define XT_OCD_CTRL 0x60 > +#define APB_INT_MASK 0x6c > +#define APB_STATUS_MASK 0x70 > + > +/* audio decoder addr */ > +#define AUDIO_SRC_CNTL 0x30000 > +#define AUDIO_SRC_CNFG 0x30004 > +#define COM_CH_STTS_BITS 0x30008 > +#define STTS_BIT_CH(x) (0x3000c + ((x) << 2)) > +#define SPDIF_CTRL_ADDR 0x3004c > +#define SPDIF_CH1_CS_3100_ADDR 0x30050 > +#define SPDIF_CH1_CS_6332_ADDR 0x30054 > +#define SPDIF_CH1_CS_9564_ADDR 0x30058 > +#define SPDIF_CH1_CS_12796_ADDR 0x3005c > +#define SPDIF_CH1_CS_159128_ADDR 0x30060 > +#define SPDIF_CH1_CS_191160_ADDR 0x30064 > +#define SPDIF_CH2_CS_3100_ADDR 0x30068 > +#define SPDIF_CH2_CS_6332_ADDR 0x3006c > +#define SPDIF_CH2_CS_9564_ADDR 0x30070 > +#define SPDIF_CH2_CS_12796_ADDR 0x30074 > +#define SPDIF_CH2_CS_159128_ADDR 0x30078 > +#define SPDIF_CH2_CS_191160_ADDR 0x3007c > +#define SMPL2PKT_CNTL 0x30080 > +#define SMPL2PKT_CNFG 0x30084 > +#define FIFO_CNTL 0x30088 > +#define FIFO_STTS 0x3008c > + > +/* source pif addr */ > +#define SOURCE_PIF_WR_ADDR 0x30800 > +#define SOURCE_PIF_WR_REQ 0x30804 > +#define SOURCE_PIF_RD_ADDR 0x30808 > +#define SOURCE_PIF_RD_REQ 0x3080c > +#define SOURCE_PIF_DATA_WR 0x30810 > +#define SOURCE_PIF_DATA_RD 0x30814 > +#define SOURCE_PIF_FIFO1_FLUSH 0x30818 > +#define SOURCE_PIF_FIFO2_FLUSH 0x3081c > +#define SOURCE_PIF_STATUS 0x30820 > +#define SOURCE_PIF_INTERRUPT_SOURCE 0x30824 > +#define SOURCE_PIF_INTERRUPT_MASK 0x30828 > +#define SOURCE_PIF_PKT_ALLOC_REG 0x3082c > +#define SOURCE_PIF_PKT_ALLOC_WR_EN 0x30830 > +#define SOURCE_PIF_SW_RESET 0x30834 > + > +/* bellow registers need access by mailbox */ > +/* source car addr */ > +#define SOURCE_HDTX_CAR 0x0900 > +#define SOURCE_DPTX_CAR 0x0904 > +#define SOURCE_PHY_CAR 0x0908 > +#define SOURCE_CEC_CAR 0x090c > +#define SOURCE_CBUS_CAR 0x0910 > +#define SOURCE_PKT_CAR 0x0918 > +#define SOURCE_AIF_CAR 0x091c > +#define SOURCE_CIPHER_CAR 0x0920 > +#define SOURCE_CRYPTO_CAR 0x0924 > + > +/* clock meters addr */ > +#define CM_CTRL 0x0a00 > +#define CM_I2S_CTRL 0x0a04 > +#define CM_SPDIF_CTRL 0x0a08 > +#define CM_VID_CTRL 0x0a0c > +#define CM_LANE_CTRL 0x0a10 > +#define I2S_NM_STABLE 0x0a14 > +#define I2S_NCTS_STABLE 0x0a18 > +#define SPDIF_NM_STABLE 0x0a1c > +#define SPDIF_NCTS_STABLE 0x0a20 > +#define NMVID_MEAS_STABLE 0x0a24 > +#define I2S_MEAS 0x0a40 > +#define SPDIF_MEAS 0x0a80 > +#define NMVID_MEAS 0x0ac0 > + > +/* source vif addr */ > +#define BND_HSYNC2VSYNC 0x0b00 > +#define HSYNC2VSYNC_F1_L1 0x0b04 > +#define HSYNC2VSYNC_F2_L1 0x0b08 > +#define HSYNC2VSYNC_STATUS 0x0b0c > +#define HSYNC2VSYNC_POL_CTRL 0x0b10 > + > +/* dptx phy addr */ > +#define DP_TX_PHY_CONFIG_REG 0x2000 > +#define DP_TX_PHY_STATUS_REG 0x2004 > +#define DP_TX_PHY_SW_RESET 0x2008 > +#define DP_TX_PHY_SCRAMBLER_SEED 0x200c > +#define DP_TX_PHY_TRAINING_01_04 0x2010 > +#define DP_TX_PHY_TRAINING_05_08 0x2014 > +#define DP_TX_PHY_TRAINING_09_10 0x2018 > +#define TEST_COR 0x23fc > + > +/* dptx hpd addr */ > +#define HPD_IRQ_DET_MIN_TIMER 0x2100 > +#define HPD_IRQ_DET_MAX_TIMER 0x2104 > +#define HPD_UNPLGED_DET_MIN_TIMER 0x2108 > +#define HPD_STABLE_TIMER 0x210c > +#define HPD_FILTER_TIMER 0x2110 > +#define HPD_EVENT_MASK 0x211c > +#define HPD_EVENT_DET 0x2120 > + > +/* dpyx framer addr */ > +#define DP_FRAMER_GLOBAL_CONFIG 0x2200 > +#define DP_SW_RESET 0x2204 > +#define DP_FRAMER_TU 0x2208 > +#define DP_FRAMER_PXL_REPR 0x220c > +#define DP_FRAMER_SP 0x2210 > +#define AUDIO_PACK_CONTROL 0x2214 > +#define DP_VC_TABLE(x) (0x2218 + ((x) << 2)) > +#define DP_VB_ID 0x2258 > +#define DP_MTPH_LVP_CONTROL 0x225c > +#define DP_MTPH_SYMBOL_VALUES 0x2260 > +#define DP_MTPH_ECF_CONTROL 0x2264 > +#define DP_MTPH_ACT_CONTROL 0x2268 > +#define DP_MTPH_STATUS 0x226c > +#define DP_INTERRUPT_SOURCE 0x2270 > +#define DP_INTERRUPT_MASK 0x2274 > +#define DP_FRONT_BACK_PORCH 0x2278 > +#define DP_BYTE_COUNT 0x227c > + > +/* dptx stream addr */ > +#define MSA_HORIZONTAL_0 0x2280 > +#define MSA_HORIZONTAL_1 0x2284 > +#define MSA_VERTICAL_0 0x2288 > +#define MSA_VERTICAL_1 0x228c > +#define MSA_MISC 0x2290 > +#define STREAM_CONFIG 0x2294 > +#define AUDIO_PACK_STATUS 0x2298 > +#define VIF_STATUS 0x229c > +#define PCK_STUFF_STATUS_0 0x22a0 > +#define PCK_STUFF_STATUS_1 0x22a4 > +#define INFO_PACK_STATUS 0x22a8 > +#define RATE_GOVERNOR_STATUS 0x22ac > +#define DP_HORIZONTAL 0x22b0 > +#define DP_VERTICAL_0 0x22b4 > +#define DP_VERTICAL_1 0x22b8 > +#define DP_BLOCK_SDP 0x22bc > + > +/* dptx glbl addr */ > +#define DPTX_LANE_EN 0x2300 > +#define DPTX_ENHNCD 0x2304 > +#define DPTX_INT_MASK 0x2308 > +#define DPTX_INT_STATUS 0x230c > + > +/* dp aux addr */ > +#define DP_AUX_HOST_CONTROL 0x2800 > +#define DP_AUX_INTERRUPT_SOURCE 0x2804 > +#define DP_AUX_INTERRUPT_MASK 0x2808 > +#define DP_AUX_SWAP_INVERSION_CONTROL 0x280c > +#define DP_AUX_SEND_NACK_TRANSACTION 0x2810 > +#define DP_AUX_CLEAR_RX 0x2814 > +#define DP_AUX_CLEAR_TX 0x2818 > +#define DP_AUX_TIMER_STOP 0x281c > +#define DP_AUX_TIMER_CLEAR 0x2820 > +#define DP_AUX_RESET_SW 0x2824 > +#define DP_AUX_DIVIDE_2M 0x2828 > +#define DP_AUX_TX_PREACHARGE_LENGTH 0x282c > +#define DP_AUX_FREQUENCY_1M_MAX 0x2830 > +#define DP_AUX_FREQUENCY_1M_MIN 0x2834 > +#define DP_AUX_RX_PRE_MIN 0x2838 > +#define DP_AUX_RX_PRE_MAX 0x283c > +#define DP_AUX_TIMER_PRESET 0x2840 > +#define DP_AUX_NACK_FORMAT 0x2844 > +#define DP_AUX_TX_DATA 0x2848 > +#define DP_AUX_RX_DATA 0x284c > +#define DP_AUX_TX_STATUS 0x2850 > +#define DP_AUX_RX_STATUS 0x2854 > +#define DP_AUX_RX_CYCLE_COUNTER 0x2858 > +#define DP_AUX_MAIN_STATES 0x285c > +#define DP_AUX_MAIN_TIMER 0x2860 > +#define DP_AUX_AFE_OUT 0x2864 > + > +/* crypto addr */ > +#define CRYPTO_HDCP_REVISION 0x5800 > +#define HDCP_CRYPTO_CONFIG 0x5804 > +#define CRYPTO_INTERRUPT_SOURCE 0x5808 > +#define CRYPTO_INTERRUPT_MASK 0x580c > +#define CRYPTO22_CONFIG 0x5818 > +#define CRYPTO22_STATUS 0x581c > +#define SHA_256_DATA_IN 0x583c > +#define SHA_256_DATA_OUT_(x) (0x5850 + ((x) << 2)) > +#define AES_32_KEY_(x) (0x5870 + ((x) << 2)) > +#define AES_32_DATA_IN 0x5880 > +#define AES_32_DATA_OUT_(x) (0x5884 + ((x) << 2)) > +#define CRYPTO14_CONFIG 0x58a0 > +#define CRYPTO14_STATUS 0x58a4 > +#define CRYPTO14_PRNM_OUT 0x58a8 > +#define CRYPTO14_KM_0 0x58ac > +#define CRYPTO14_KM_1 0x58b0 > +#define CRYPTO14_AN_0 0x58b4 > +#define CRYPTO14_AN_1 0x58b8 > +#define CRYPTO14_YOUR_KSV_0 0x58bc > +#define CRYPTO14_YOUR_KSV_1 0x58c0 > +#define CRYPTO14_MI_0 0x58c4 > +#define CRYPTO14_MI_1 0x58c8 > +#define CRYPTO14_TI_0 0x58cc > +#define CRYPTO14_KI_0 0x58d0 > +#define CRYPTO14_KI_1 0x58d4 > +#define CRYPTO14_BLOCKS_NUM 0x58d8 > +#define CRYPTO14_KEY_MEM_DATA_0 0x58dc > +#define CRYPTO14_KEY_MEM_DATA_1 0x58e0 > +#define CRYPTO14_SHA1_MSG_DATA 0x58e4 > +#define CRYPTO14_SHA1_V_VALUE_(x) (0x58e8 + ((x) << 2)) > +#define TRNG_CTRL 0x58fc > +#define TRNG_DATA_RDY 0x5900 > +#define TRNG_DATA 0x5904 > + > +/* cipher addr */ > +#define HDCP_REVISION 0x60000 > +#define INTERRUPT_SOURCE 0x60004 > +#define INTERRUPT_MASK 0x60008 > +#define HDCP_CIPHER_CONFIG 0x6000c > +#define AES_128_KEY_0 0x60010 > +#define AES_128_KEY_1 0x60014 > +#define AES_128_KEY_2 0x60018 > +#define AES_128_KEY_3 0x6001c > +#define AES_128_RANDOM_0 0x60020 > +#define AES_128_RANDOM_1 0x60024 > +#define CIPHER14_KM_0 0x60028 > +#define CIPHER14_KM_1 0x6002c > +#define CIPHER14_STATUS 0x60030 > +#define CIPHER14_RI_PJ_STATUS 0x60034 > +#define CIPHER_MODE 0x60038 > +#define CIPHER14_AN_0 0x6003c > +#define CIPHER14_AN_1 0x60040 > +#define CIPHER22_AUTH 0x60044 > +#define CIPHER14_R0_DP_STATUS 0x60048 > +#define CIPHER14_BOOTSTRAP 0x6004c > + > +#define DPTX_FRMR_DATA_CLK_RSTN_EN BIT(11) > +#define DPTX_FRMR_DATA_CLK_EN BIT(10) > +#define DPTX_PHY_DATA_RSTN_EN BIT(9) > +#define DPTX_PHY_DATA_CLK_EN BIT(8) > +#define DPTX_PHY_CHAR_RSTN_EN BIT(7) > +#define DPTX_PHY_CHAR_CLK_EN BIT(6) > +#define SOURCE_AUX_SYS_CLK_RSTN_EN BIT(5) > +#define SOURCE_AUX_SYS_CLK_EN BIT(4) > +#define DPTX_SYS_CLK_RSTN_EN BIT(3) > +#define DPTX_SYS_CLK_EN BIT(2) > +#define CFG_DPTX_VIF_CLK_RSTN_EN BIT(1) > +#define CFG_DPTX_VIF_CLK_EN BIT(0) > + > +#define SOURCE_PHY_RSTN_EN BIT(1) > +#define SOURCE_PHY_CLK_EN BIT(0) > + > +#define SOURCE_PKT_SYS_RSTN_EN BIT(3) > +#define SOURCE_PKT_SYS_CLK_EN BIT(2) > +#define SOURCE_PKT_DATA_RSTN_EN BIT(1) > +#define SOURCE_PKT_DATA_CLK_EN BIT(0) > + > +#define SPDIF_CDR_CLK_RSTN_EN BIT(5) > +#define SPDIF_CDR_CLK_EN BIT(4) > +#define SOURCE_AIF_SYS_RSTN_EN BIT(3) > +#define SOURCE_AIF_SYS_CLK_EN BIT(2) > +#define SOURCE_AIF_CLK_RSTN_EN BIT(1) > +#define SOURCE_AIF_CLK_EN BIT(0) > + > +#define SOURCE_CIPHER_SYSTEM_CLK_RSTN_EN BIT(3) > +#define SOURCE_CIPHER_SYS_CLK_EN BIT(2) > +#define SOURCE_CIPHER_CHAR_CLK_RSTN_EN BIT(1) > +#define SOURCE_CIPHER_CHAR_CLK_EN BIT(0) > + > +#define SOURCE_CRYPTO_SYS_CLK_RSTN_EN BIT(1) > +#define SOURCE_CRYPTO_SYS_CLK_EN BIT(0) > + > +#define APB_IRAM_PATH BIT(2) > +#define APB_DRAM_PATH BIT(1) > +#define APB_XT_RESET BIT(0) > + > +#define MAILBOX_INT_MASK_BIT BIT(1) > +#define PIF_INT_MASK_BIT BIT(0) > +#define ALL_INT_MASK 3 > + > +/* mailbox */ > +#define MB_OPCODE_ID 0 > +#define MB_MODULE_ID 1 > +#define MB_SIZE_MSB_ID 2 > +#define MB_SIZE_LSB_ID 3 > +#define MB_DATA_ID 4 > + > +#define MB_MODULE_ID_DP_TX 0x01 > +#define MB_MODULE_ID_HDCP_TX 0x07 > +#define MB_MODULE_ID_HDCP_RX 0x08 > +#define MB_MODULE_ID_HDCP_GENERAL 0x09 > +#define MB_MODULE_ID_GENERAL 0x0a > + > +/* general opcode */ > +#define GENERAL_MAIN_CONTROL 0x01 > +#define GENERAL_TEST_ECHO 0x02 > +#define GENERAL_BUS_SETTINGS 0x03 > +#define GENERAL_TEST_ACCESS 0x04 > + > +#define DPTX_SET_POWER_MNG 0x00 > +#define DPTX_SET_HOST_CAPABILITIES 0x01 > +#define DPTX_GET_EDID 0x02 > +#define DPTX_READ_DPCD 0x03 > +#define DPTX_WRITE_DPCD 0x04 > +#define DPTX_ENABLE_EVENT 0x05 > +#define DPTX_WRITE_REGISTER 0x06 > +#define DPTX_READ_REGISTER 0x07 > +#define DPTX_WRITE_FIELD 0x08 > +#define DPTX_TRAINING_CONTROL 0x09 > +#define DPTX_READ_EVENT 0x0a > +#define DPTX_READ_LINK_STAT 0x0b > +#define DPTX_SET_VIDEO 0x0c > +#define DPTX_SET_AUDIO 0x0d > +#define DPTX_GET_LAST_AUX_STAUS 0x0e > +#define DPTX_SET_LINK_BREAK_POINT 0x0f > +#define DPTX_FORCE_LANES 0x10 > +#define DPTX_HPD_STATE 0x11 > + > +#define DPTX_EVENT_ENABLE_HPD BIT(0) > +#define DPTX_EVENT_ENABLE_TRAINING BIT(1) > + > +#define LINK_TRAINING_NOT_ACTIVE 0 > +#define LINK_TRAINING_RUN 1 > +#define LINK_TRAINING_RESTART 2 > + > +#define CONTROL_VIDEO_IDLE 0 > +#define CONTROL_VIDEO_VALID 1 > + > +#define VIF_BYPASS_INTERLACE BIT(13) > +#define INTERLACE_FMT_DET BIT(12) > +#define INTERLACE_DTCT_WIN 0x20 > + > +#define DP_FRAMER_SP_INTERLACE_EN BIT(2) > +#define DP_FRAMER_SP_HSP BIT(1) > +#define DP_FRAMER_SP_VSP BIT(0) > + > +/* capability */ > +#define AUX_HOST_INVERT 3 > +#define FAST_LT_SUPPORT 1 > +#define FAST_LT_NOT_SUPPORT 0 > +#define LANE_MAPPING_NORMAL 0xe4 > +#define LANE_MAPPING_FLIPPED 0x1b > +#define ENHANCED 1 > + > +#define FULL_LT_STARTED BIT(0) > +#define FASE_LT_STARTED BIT(1) > +#define CLK_RECOVERY_FINISHED BIT(2) > +#define EQ_PHASE_FINISHED BIT(3) > +#define FASE_LT_START_FINISHED BIT(4) > +#define CLK_RECOVERY_FAILED BIT(5) > +#define EQ_PHASE_FAILED BIT(6) > +#define FASE_LT_FAILED BIT(7) > + > +#define DPTX_HPD_EVENT BIT(0) > +#define DPTX_TRAINING_EVENT BIT(1) > +#define HDCP_TX_STATUS_EVENT BIT(4) > +#define HDCP2_TX_IS_KM_STORED_EVENT BIT(5) > +#define HDCP2_TX_STORE_KM_EVENT BIT(6) > +#define HDCP_TX_IS_RECEIVER_ID_VALID_EVENT BIT(7) > + > +#define TU_SIZE 30 > +#define CDN_DP_MAX_LINK_RATE DP_LINK_BW_5_4 > + > +/* audio */ > +#define AUDIO_PACK_EN BIT(8) > +#define SAMPLING_FREQ(x) (((x) & 0xf) << 16) > +#define ORIGINAL_SAMP_FREQ(x) (((x) & 0xf) << 24) > +#define SYNC_WR_TO_CH_ZERO BIT(1) > +#define I2S_DEC_START BIT(1) > +#define AUDIO_SW_RST BIT(0) > +#define SMPL2PKT_EN BIT(1) > +#define MAX_NUM_CH(x) (((x) & 0x1f) - 1) > +#define NUM_OF_I2S_PORTS(x) ((((x) / 2 - 1) & 0x3) << 5) > +#define AUDIO_TYPE_LPCM (2 << 7) > +#define CFG_SUB_PCKT_NUM(x) ((((x) - 1) & 0x7) << 11) > +#define AUDIO_CH_NUM(x) ((((x) - 1) & 0x1f) << 2) > +#define TRANS_SMPL_WIDTH_16 0 > +#define TRANS_SMPL_WIDTH_24 BIT(11) > +#define TRANS_SMPL_WIDTH_32 (2 << 11) > +#define I2S_DEC_PORT_EN(x) (((x) & 0xf) << 17) > +#define SPDIF_ENABLE BIT(21) > +#define SPDIF_AVG_SEL BIT(20) > +#define SPDIF_JITTER_BYPASS BIT(19) > +#define SPDIF_FIFO_MID_RANGE(x) (((x) & 0xff) << 11) > +#define SPDIF_JITTER_THRSH(x) (((x) & 0xff) << 3) > +#define SPDIF_JITTER_AVG_WIN(x) ((x) & 0x7) > + > +/* Refernce cycles when using lane clock as refernce */ > +#define LANE_REF_CYC 0x8000 > + > +enum voltage_swing_level { > + VOLTAGE_LEVEL_0, > + VOLTAGE_LEVEL_1, > + VOLTAGE_LEVEL_2, > + VOLTAGE_LEVEL_3, > +}; > + > +enum pre_emphasis_level { > + PRE_EMPHASIS_LEVEL_0, > + PRE_EMPHASIS_LEVEL_1, > + PRE_EMPHASIS_LEVEL_2, > + PRE_EMPHASIS_LEVEL_3, > +}; > + > +enum pattern_set { > + PTS1 = BIT(0), > + PTS2 = BIT(1), > + PTS3 = BIT(2), > + PTS4 = BIT(3), > + DP_NONE = BIT(4) > +}; > + > +enum vic_color_depth { > + BCS_6 = 0x1, > + BCS_8 = 0x2, > + BCS_10 = 0x4, > + BCS_12 = 0x8, > + BCS_16 = 0x10, > +}; > + > +enum vic_bt_type { > + BT_601 = 0x0, > + BT_709 = 0x1, > +}; > + > +void cdn_dp_clock_reset(struct cdn_dp_device *dp); > + > +void cdn_dp_set_fw_clk(struct cdn_dp_device *dp, u32 clk); > +int cdn_dp_load_firmware(struct cdn_dp_device *dp, const u32 *i_mem, > + u32 i_size, const u32 *d_mem, u32 d_size); > +int cdn_dp_active(struct cdn_dp_device *dp, bool enable); > +int cdn_dp_set_host_cap(struct cdn_dp_device *dp, u8 lanes); > +int cdn_dp_event_config(struct cdn_dp_device *dp); > +u32 cdn_dp_get_event(struct cdn_dp_device *dp); > +int cdn_dp_get_hpd_status(struct cdn_dp_device *dp); > +int cdn_dp_dpcd_write(struct cdn_dp_device *dp, u32 addr, u8 value); > +int cdn_dp_dpcd_read(struct cdn_dp_device *dp, u32 addr, u8 *data, u16 len); > +int cdn_dp_get_edid_block(void *dp, u8 *edid, > + unsigned int block, size_t length); > +int cdn_dp_training_start(struct cdn_dp_device *dp); > +int cdn_dp_get_training_status(struct cdn_dp_device *dp); > +int cdn_dp_set_video_status(struct cdn_dp_device *dp, int active); > +int cdn_dp_config_video(struct cdn_dp_device *dp); > +int cdn_dp_audio_stop(struct cdn_dp_device *dp, struct audio_info *audio); > +int cdn_dp_audio_mute(struct cdn_dp_device *dp, bool enable); > +int cdn_dp_audio_config_set(struct cdn_dp_device *dp, struct audio_info *audio); > +#endif /* _CDN_DP_REG_H */ > diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c > index edd7ec2..d723d8e 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c > +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c > @@ -969,9 +969,11 @@ static void vop_crtc_enable(struct drm_crtc *crtc) > vop_dsp_hold_valid_irq_disable(vop); > } > > - pin_pol = 0x8; > - pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NHSYNC) ? 0 : 1; > - pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NVSYNC) ? 0 : (1 << 1); > + pin_pol = BIT(DCLK_INVERT); > + pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NHSYNC) ? > + 0 : BIT(HSYNC_POSITIVE); > + pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NVSYNC) ? > + 0 : BIT(VSYNC_POSITIVE); > VOP_CTRL_SET(vop, pin_pol, pin_pol); > > switch (s->output_type) { > @@ -991,6 +993,11 @@ static void vop_crtc_enable(struct drm_crtc *crtc) > VOP_CTRL_SET(vop, mipi_pin_pol, pin_pol); > VOP_CTRL_SET(vop, mipi_en, 1); > break; > + case DRM_MODE_CONNECTOR_DisplayPort: > + pin_pol &= ~BIT(DCLK_INVERT); > + VOP_CTRL_SET(vop, dp_pin_pol, pin_pol); > + VOP_CTRL_SET(vop, dp_en, 1); > + break; > default: > DRM_ERROR("unsupport connector_type[%d]\n", s->output_type); > } > diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.h b/drivers/gpu/drm/rockchip/rockchip_drm_vop.h > index ff4f52e..4820a8b 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.h > +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.h > @@ -45,6 +45,7 @@ struct vop_ctrl { > struct vop_reg edp_en; > struct vop_reg hdmi_en; > struct vop_reg mipi_en; > + struct vop_reg dp_en; > struct vop_reg out_mode; > struct vop_reg dither_down; > struct vop_reg dither_up; > @@ -53,6 +54,7 @@ struct vop_ctrl { > struct vop_reg hdmi_pin_pol; > struct vop_reg edp_pin_pol; > struct vop_reg mipi_pin_pol; > + struct vop_reg dp_pin_pol; > > struct vop_reg htotal_pw; > struct vop_reg hact_st_end; > @@ -242,6 +244,13 @@ enum scale_down_mode { > SCALE_DOWN_AVG = 0x1 > }; > > +enum vop_pol { > + HSYNC_POSITIVE = 0, > + VSYNC_POSITIVE = 1, > + DEN_NEGATIVE = 2, > + DCLK_INVERT = 3 > +}; > + > #define FRAC_16_16(mult, div) (((mult) << 16) / (div)) > #define SCL_FT_DEFAULT_FIXPOINT_SHIFT 12 > #define SCL_MAX_VSKIPLINES 4 > diff --git a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c > index 5b1ae1f..dcf172e 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c > +++ b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c > @@ -281,6 +281,7 @@ static const struct vop_data rk3288_vop = { > static const struct vop_ctrl rk3399_ctrl_data = { > .standby = VOP_REG(RK3399_SYS_CTRL, 0x1, 22), > .gate_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 23), > + .dp_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 11), > .rgb_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 12), > .hdmi_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 13), > .edp_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 14), > @@ -290,6 +291,7 @@ static const struct vop_ctrl rk3399_ctrl_data = { > .data_blank = VOP_REG(RK3399_DSP_CTRL0, 0x1, 19), > .out_mode = VOP_REG(RK3399_DSP_CTRL0, 0xf, 0), > .rgb_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 16), > + .dp_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 16), > .hdmi_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 20), > .edp_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 24), > .mipi_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 28), -- Ｍark Yao