From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCHv4 3/3] DRM:ivip Intel FPGA Video and Image Processing Suite Date: Tue, 01 Aug 2017 17:30:36 +0300 Message-ID: <2323445.Hdzqrs3Ziv@avalon> References: <1501554694-3378-1-git-send-email-hean.loong.ong@intel.com> <1501554694-3378-4-git-send-email-hean.loong.ong@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1501554694-3378-4-git-send-email-hean.loong.ong@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: devicetree@vger.kernel.org, "Hean Loong, Ong" , linux-kernel@vger.kernel.org, Dinh Nguyen , Rob Herring , Daniel Vetter , Ong@freedesktop.org List-Id: devicetree@vger.kernel.org SGkgSGVhbiBMb29uZywKClRoYW5rIHlvdSBmb3IgdGhlIHBhdGNoLgoKT24gVHVlc2RheSAwMSBB dWcgMjAxNyAxMDozMTozNCBIZWFuIExvb25nLCBPbmcgd3JvdGU6Cj4gRnJvbTogT25nIEhlYW4g TG9vbmcgPGhlYW4ubG9vbmcub25nQGludGVsLmNvbT4KPiAKPiBEcml2ZXIgZm9yIEludGVsIEZQ R0EgVmlkZW8gYW5kIEltYWdlIFByb2Nlc3NpbmcKPiBTdWl0ZSBGcmFtZSBCdWZmZXIgSUkuIFRo ZSBkcml2ZXIgb25seSBzdXBwb3J0cyB0aGUgSW50ZWwKPiBBcnJpYTEwIGRldmtpdCBhbmQgaXRz IHZhcmlhbnRzLiBUaGlzIGRyaXZlciBjYW4gYmUgZWl0aGVyCj4gbG9hZGVkIHN0YXRpY2xseSBv ciBpbiBtb2R1bGVzLiBUaGUgT0YgZGV2aWNlIHRyZWUgYmluZGluZwo+IGlzIGxvY2F0ZWQgYXQ6 Cj4gRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL2Rpc3BsYXkvYWx0cix2aXAtZmIy LnR4dAo+IAo+IFNpZ25lZC1vZmYtYnk6IE9uZywgSGVhbiBMb29uZyA8aGVhbi5sb29uZy5vbmdA aW50ZWwuY29tPgo+IC0tLQo+IFYzOgo+ICpDaGFuZ2VzIHRvIGZpeGluZyBkcm1fc2ltcGxlX3Bp cGUKPiAqVXNlZCBkcm1fZmJfY21hX2dldF9nZW1fYWRkcgo+IAo+IFYyOgo+ICpBZGRpbmcgZHJt X3NpbXBsZV9kaXNwbGF5X3BpcGVfaW5pdAo+IC0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vS2NvbmZp ZyAgICAgICAgICAgICAgIHwgICAyICsKPiAgZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlICAgICAg ICAgICAgICB8ICAgMSArCj4gIGRyaXZlcnMvZ3B1L2RybS9pdmlwL0tjb25maWcgICAgICAgICAg fCAgMTMgKysrCj4gIGRyaXZlcnMvZ3B1L2RybS9pdmlwL01ha2VmaWxlICAgICAgICAgfCAgIDkg KysKPiAgZHJpdmVycy9ncHUvZHJtL2l2aXAvaW50ZWxfdmlwX2Nvbm4uYyB8ICA5NiArKysrKysr KysrKysrKysrCj4gIGRyaXZlcnMvZ3B1L2RybS9pdmlwL2ludGVsX3ZpcF9jb3JlLmMgfCAxODMg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gIGRyaXZlcnMvZ3B1L2RybS9pdmlwL2lu dGVsX3ZpcF9kcnYuaCAgfCAgNTQgKysrKysrKysrCj4gIGRyaXZlcnMvZ3B1L2RybS9pdmlwL2lu dGVsX3ZpcF9vZi5jICAgfCAyMDQgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICA4 IGZpbGVzIGNoYW5nZWQsIDU2MiBpbnNlcnRpb25zKCspCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2dwdS9kcm0vaXZpcC9LY29uZmlnCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJz L2dwdS9kcm0vaXZpcC9NYWtlZmlsZQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUv ZHJtL2l2aXAvaW50ZWxfdmlwX2Nvbm4uYwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9n cHUvZHJtL2l2aXAvaW50ZWxfdmlwX2NvcmUuYwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy cy9ncHUvZHJtL2l2aXAvaW50ZWxfdmlwX2Rydi5oCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL2dwdS9kcm0vaXZpcC9pbnRlbF92aXBfb2YuYwoKW3NuaXBdCgo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaXZpcC9LY29uZmlnIGIvZHJpdmVycy9ncHUvZHJtL2l2aXAvS2NvbmZp Zwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uOWE4YzVjZQo+IC0tLSAv ZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaXZpcC9LY29uZmlnCj4gQEAgLTAsMCAr MSwxMyBAQAo+ICtjb25maWcgRFJNX0lWSVAKPiArCSB0cmlzdGF0ZSAiSW50ZWwgRkdQQSBWaWRl byBhbmQgSW1hZ2UgUHJvY2Vzc2luZyIKPiArCSBkZXBlbmRzIG9uIERSTSAmJiBPRgo+ICsJIHNl bGVjdCBEUk1fR0VNX0NNQV9IRUxQRVIKPiArCSBzZWxlY3QgRFJNX0tNU19IRUxQRVIKPiArCSBz ZWxlY3QgRFJNX0tNU19GQl9IRUxQRVIKPiArCSBzZWxlY3QgRFJNX0tNU19DTUFfSEVMUEVSCj4g KwkgaGVscAo+ICsJICAgICBDaG9vc2UgdGhpcyBvcHRpb24gaWYgeW91IGhhdmUgYSBJbnRlbCBG UEdBIEFycmlhIDEwIHN5c3RlbQo+ICsJICAgICBhbmQgYWJvdmUgd2l0aCBhIERpc3BsYXkgUG9y dCBJUC4gVGhpcyBkb2VzIG5vdCBzdXBwb3J0IGxlZ2FjeQo+ICsJICAgICBJbnRlbCBGUEdBIEN5 Y2xvbmUgViBkaXNwbGF5IHBvcnQuIEN1cnJlbnRseSBvbmx5IHNpbmdsZSBmcmFtZQo+ICsJICAg ICBidWZmZXIgaXMgc3VwcG9ydGVkLgoKSSB0aGluayB0aGlzIHNob3VsZCBiZSBmaXhlZCB0byB1 cHN0cmVhbSB0aGlzIGRyaXZlci4KCj4gTm90ZSB0aGF0IEFDUEkgYW5kIFhfODYgYXJjaGl0ZWN0 dXJlIGlzIHlldAoKQUNQSSBvbiBGUEdBLi4uIEkgd29uZGVyIGlmIGl0IGNvdWxkIGdldCBhbnkg Y3JhemllciB0aGFuIHRoYXQgOi0pCgo+ICsJICAgICB0byBiZSBzdXBwb3J0ZWQuSWYgTSBpcyBz ZWxlY3RlZCB0aGUgbW9kdWxlIHdvdWxkIGJlIGNhbGxlZCBpdmlwLgoKcy8uSWYvLiBJZi8KCltz bmlwXQoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2l2aXAvaW50ZWxfdmlwX2NvcmUu Ywo+IGIvZHJpdmVycy9ncHUvZHJtL2l2aXAvaW50ZWxfdmlwX2NvcmUuYyBuZXcgZmlsZSBtb2Rl IDEwMDY0NAo+IGluZGV4IDAwMDAwMDAuLmVhODU3MTUKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIv ZHJpdmVycy9ncHUvZHJtL2l2aXAvaW50ZWxfdmlwX2NvcmUuYwo+IEBAIC0wLDAgKzEsMTgzIEBA Cj4gKy8qCj4gKyAqIGludGVsX3ZpcF9jb3JlLmMgLS0gSW50ZWwgVmlkZW8gYW5kIEltYWdlIFBy b2Nlc3NpbmcoVklQKQo+ICsgKiBGcmFtZSBCdWZmZXIgSUkgZHJpdmVyCj4gKyAqCj4gKyAqIFRo aXMgZHJpdmVyIHN1cHBvcnRzIHRoZSBJbnRlbCBWSVAgRnJhbWUgUmVhZGVyIGNvbXBvbmVudC4K PiArICogTW9yZSBpbmZvIG9uIHRoZSBoYXJkd2FyZSBjYW4gYmUgZm91bmQgaW4gdGhlIEludGVs IFZpZGVvCj4gKyAqIGFuZCBJbWFnZSBQcm9jZXNzaW5nIFN1aXRlIFVzZXIgR3VpZGUgYXQgdGhp cyBhZGRyZXNzCj4gKyAqIGh0dHA6Ly93d3cuYWx0ZXJhLmNvbS9saXRlcmF0dXJlL3VnL3VnX3Zp cC5wZGYuCj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0Cj4gKyAqIHVuZGVyIHRoZSB0ZXJtcyBh bmQgY29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UsCj4gKyAqIHZl cnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCj4g KyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSBpdCB3aWxs IGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKPiArICogQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4g dGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yCj4gKyAqIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZQo+IGZvciArICogbW9yZSBkZXRhaWxzLgo+ICsgKgo+ICsgKiBBdXRob3JzOgo+ICsgKiBP bmcsIEhlYW4tTG9vbmcgPGhlYW4ubG9vbmcub25nQGludGVsLmNvbT4KPiArICoKPiArICovCj4g Kwo+ICsjaW5jbHVkZSA8bGludXgvaW5pdC5oPgo+ICsjaW5jbHVkZSA8bGludXgva2VybmVsLmg+ Cj4gKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KPiArCj4gKyNpbmNsdWRlIDxkcm0vZHJtUC5o Pgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWMuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1fYXRv bWljX2hlbHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5oPgo+ICsjaW5j bHVkZSA8ZHJtL2RybV9mYl9oZWxwZXIuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1fZmJfY21hX2hl bHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9nZW1fY21hX2hlbHBlci5oPgo+ICsjaW5jbHVk ZSA8ZHJtL2RybV9wbGFuZV9oZWxwZXIuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1fc2ltcGxlX2tt c19oZWxwZXIuaD4KPiArCj4gKyNpbmNsdWRlICJpbnRlbF92aXBfZHJ2LmgiCj4gKwo+ICtzdGF0 aWMgdm9pZCBpbnRlbHZpcGZiX2VuYWJsZShzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUg KnBpcGUsCj4gKwlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUpCj4gK3sKPiArCS8q Cj4gKwkgKiBUaGUgZnJhbWVpbmZvIHZhcmlhYmxlIGhhcyB0byBjb3JyZXNwb25kIHRvIHRoZSBz aXplIG9mIHRoZSBWSVAgClN1aXRlCj4gKwkgKiBGcmFtZSBSZWFkZXIgcmVnaXN0ZXIgNyB3aGlj aCB3aWxsIGRldGVybWluZSB0aGUgbWF4aW11bSBzaXplIHVzZWQKPiArCSAqIGluIHRoaXMgZnJh bWVpbmZvCj4gKwkgKi8KPiArCj4gKwl1MzIgZnJhbWVpbmZvOwo+ICsJc3RydWN0IGludGVsdmlw ZmJfcHJpdiAqcHJpdiA9IHBpcGUtPnBsYW5lLmRldi0+ZGV2X3ByaXZhdGU7Cj4gKwl2b2lkIF9f aW9tZW0gKmJhc2UgPSBwcml2LT5iYXNlOwo+ICsJc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqc3Rh dGUgPSBwaXBlLT5wbGFuZS5zdGF0ZTsKPiArCWRtYV9hZGRyX3QgYWRkcjsKPiArCj4gKwlhZGRy ID0gZHJtX2ZiX2NtYV9nZXRfZ2VtX2FkZHIoc3RhdGUtPmZiLCBzdGF0ZSwgMCk7Cj4gKwo+ICsJ ZGV2X2luZm8ocGlwZS0+cGxhbmUuZGV2LT5kZXYsICJBZGRyZXNzIDB4JXhcbiIsIGFkZHIpOwo+ ICsKPiArCWZyYW1laW5mbyA9Cj4gKwkJICByZWFkbChiYXNlICsgSU5URUxWSVBGQl9GUkFNRV9S RUFERVIpICYgMHgwMGZmZmZmZjsKPiArCXdyaXRlbChmcmFtZWluZm8sIGJhc2UgKyBJTlRFTFZJ UEZCX0ZSQU1FX0lORk8pOwo+ICsJd3JpdGVsKGFkZHIsIGJhc2UgKyBJTlRFTFZJUEZCX0ZSQU1F X1NUQVJUKTsKPiArCS8qIEZpbmFsbHkgc2V0IHRoZSBjb250cm9sIHJlZ2lzdGVyIHRvIDEgdG8g c3RhcnQgc3RyZWFtaW5nICovCj4gKwl3cml0ZWwoMSwgYmFzZSArIElOVEVMVklQRkJfQ09OVFJP TCk7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIGludGVsdmlwZmJfZGlzYWJsZShzdHJ1Y3QgZHJt X3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUpCj4gK3sKPiArCXN0cnVjdCBpbnRlbHZpcGZiX3By aXYgKnByaXYgPSBwaXBlLT5wbGFuZS5kZXYtPmRldl9wcml2YXRlOwo+ICsJdm9pZCBfX2lvbWVt ICpiYXNlID0gcHJpdi0+YmFzZTsKCk1pc3NpbmcgYmxhbmsgbGluZS4KCj4gKwkvKiBzZXQgdGhl IGNvbnRyb2wgcmVnaXN0ZXIgdG8gMCB0byBzdG9wIHN0cmVhbWluZyAqLwo+ICsJd3JpdGVsKDAs IGJhc2UgKyBJTlRFTFZJUEZCX0NPTlRST0wpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3Ry dWN0IGRybV9tb2RlX2NvbmZpZ19mdW5jcyBpbnRlbHZpcGZiX21vZGVfY29uZmlnX2Z1bmNzID0g ewo+ICsJLmZiX2NyZWF0ZSA9IGRybV9mYl9jbWFfY3JlYXRlLAo+ICsJLmF0b21pY19jaGVjayA9 IGRybV9hdG9taWNfaGVscGVyX2NoZWNrLAo+ICsJLmF0b21pY19jb21taXQgPSBkcm1fYXRvbWlj X2hlbHBlcl9jb21taXQsCj4gK307Cj4gKwo+ICtzdGF0aWMgdm9pZCBpbnRlbHZpcGZiX3NldHVw X21vZGVfY29uZmlnKHN0cnVjdCBkcm1fZGV2aWNlICpkcm0pCj4gK3sKPiArCWRybV9tb2RlX2Nv bmZpZ19pbml0KGRybSk7Cj4gKwlkcm0tPm1vZGVfY29uZmlnLmZ1bmNzID0gJmludGVsdmlwZmJf bW9kZV9jb25maWdfZnVuY3M7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgaW50ZWx2aXBmYl9waXBl X3ByZXBhcmVfZmIoc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlICpwaXBlLAo+ICsJCXN0 cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnBsYW5lX3N0YXRlKQo+ICt7Cj4gKwlyZXR1cm4gZHJtX2Zi X2NtYV9wcmVwYXJlX2ZiKCZwaXBlLT5wbGFuZSwgcGxhbmVfc3RhdGUpOwo+ICt9Cj4gKwo+ICtz dGF0aWMgdm9pZCBpbnRlbHZpcGZiX3VwZGF0ZShzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3Bp cGUgKnBpcGUsCj4gKwkJc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqb2xkX3N0YXRlKQo+ICt7Cj4g KwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMgPSAmcGlwZS0+Y3J0YzsKPiArCj4gKwlpZiAoY3J0Yy0+ c3RhdGUtPmV2ZW50KSB7Cj4gKwkJc3Bpbl9sb2NrX2lycSgmY3J0Yy0+ZGV2LT5ldmVudF9sb2Nr KTsKPiArCQlkcm1fY3J0Y19zZW5kX3ZibGFua19ldmVudChjcnRjLCBjcnRjLT5zdGF0ZS0+ZXZl bnQpOwo+ICsJCXNwaW5fdW5sb2NrX2lycSgmY3J0Yy0+ZGV2LT5ldmVudF9sb2NrKTsKPiArCQlj cnRjLT5zdGF0ZS0+ZXZlbnQgPSBOVUxMOwo+ICsJfQoKVGhpcyBpcyBub3QgcXVpdGUgcmlnaHQu IFVzZXJzcGFjZSBleHBlY3RzIHRoZSBkcml2ZXIgdG8gcGVyZm9ybSBhIHBhZ2UgZmxpcCAKaGVy ZSwgYW5kIHlvdSBqdXN0IHNpZ25hbCBwYWdlIGZsaXAgY29tcGxldGlvbiB3aXRob3V0IGRvaW5n IGFueXRoaW5nLgoKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlf cGlwZV9mdW5jcyBmYnByaXZfZnVuY3MgPSB7Cj4gKwkucHJlcGFyZV9mYiA9IGludGVsdmlwZmJf cGlwZV9wcmVwYXJlX2ZiLAo+ICsJLnVwZGF0ZSA9IGludGVsdmlwZmJfdXBkYXRlLAo+ICsJLmVu YWJsZSA9IGludGVsdmlwZmJfZW5hYmxlLAo+ICsJLmRpc2FibGUgPSBpbnRlbHZpcGZiX2Rpc2Fi bGUKPiArfTsKPiArCj4gK2ludCBpbnRlbHZpcGZiX3Byb2JlKHN0cnVjdCBkZXZpY2UgKmRldiwg dm9pZCBfX2lvbWVtICpiYXNlKQoKWW91IGRvbid0IHVzZSB0aGUgYmFzZSBhcmd1bWVudCwgeW91 IGNhbiByZW1vdmUgaXQuCgo+ICt7Cj4gKwlpbnQgcmV0dmFsOwo+ICsJc3RydWN0IGRybV9kZXZp Y2UgKmRybTsKPiArCXN0cnVjdCBpbnRlbHZpcGZiX3ByaXYgKmZicHJpdiA9IGRldl9nZXRfZHJ2 ZGF0YShkZXYpOwo+ICsJc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcjsKPiArCgpFeHRy YSBibGFuayBsaW5lLgoKPiArCXUzMiBmb3JtYXRzW10gPSB7RFJNX0ZPUk1BVF9YUkdCODg4OH07 Cj4gKwo+ICsJZGV2X3NldF9kcnZkYXRhKGRldiwgZmJwcml2KTsKCkFzIGZicHJpdiBpcyBvYnRh aW5lZCBieSBhIGNhbGwgdG8gZGV2X2dldF9kcnZkYXRhKCksIHRoaXMgaXNuJ3QgbmVlZGVkLgoK QSBiZXR0ZXIgb3B0aW9uIHdvdWxkIGJlIHRvIHBhc3MgdGhlIGludGVsdmlwZmJfcHJpdiBwb2lu dGVyIGFzIGFuIGFyZ3VtZW50IHRvIAp0aGlzIGZ1bmN0aW9uLgoKPiArCWRybSA9IGZicHJpdi0+ ZHJtOwo+ICsKPiArCWRybS0+ZGV2X3ByaXZhdGUgPSBmYnByaXY7Cj4gKwo+ICsJaW50ZWx2aXBm Yl9zZXR1cF9tb2RlX2NvbmZpZyhkcm0pOwo+ICsKPiArCWNvbm5lY3RvciA9IGludGVsdmlwZmJf Y29ubl9zZXR1cChkcm0pOwo+ICsJaWYgKCFjb25uZWN0b3IpIHsKPiArCQlkZXZfZXJyKGRybS0+ ZGV2LCAiQ29ubmVjdG9yIHNldHVwIGZhaWxlZFxuIik7Cj4gKwkJZ290byBlcnJfbW9kZV9jb25m aWc7Cj4gKwl9Cj4gKwo+ICsJcmV0dmFsID0gZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGVfaW5pdChk cm0sICZmYnByaXYtPnBpcGUsCj4gKwkJJmZicHJpdl9mdW5jcywgZm9ybWF0cywKPiArCQlBUlJB WV9TSVpFKGZvcm1hdHMpLCBjb25uZWN0b3IpOwo+ICsJaWYgKHJldHZhbCA8IDApIHsKPiArCQlk ZXZfZXJyKGRybS0+ZGV2LCAiQ2Fubm90IHNldHVwIHNpbXBsZSBkaXNwbGF5IHBpcGVcbiIpOwo+ ICsJCWdvdG8gZXJyX21vZGVfY29uZmlnOwo+ICsJfQo+ICsKPiArCWZicHJpdi0+ZmJjbWEgPSBk cm1fZmJkZXZfY21hX2luaXQoZHJtLAo+ICsJCWRybS0+bW9kZV9jb25maWcucHJlZmVycmVkX2Rl cHRoLAo+ICsJCWRybS0+bW9kZV9jb25maWcubnVtX2Nvbm5lY3Rvcik7Cj4gKwo+ICsJZHJtX21v ZGVfY29uZmlnX3Jlc2V0KGRybSk7Cj4gKwo+ICsJZHJtX2Rldl9yZWdpc3Rlcihkcm0sIDApOwo+ ICsKPiArCXJldHVybiByZXR2YWw7Cj4gKwo+ICtlcnJfbW9kZV9jb25maWc6Cj4gKwo+ICsJZHJt X21vZGVfY29uZmlnX2NsZWFudXAoZHJtKTsKPiArCXJldHVybiAtRU5PREVWOwo+ICt9Cj4gK0VY UE9SVF9TWU1CT0xfR1BMKGludGVsdmlwZmJfcHJvYmUpOwoKV2h5IGRvIHlvdSBuZWVkIHRvIGV4 cG9ydCB0aGlzIHN5bWJvbCA/Cgo+ICtpbnQgaW50ZWx2aXBmYl9yZW1vdmUoc3RydWN0IGRldmlj ZSAqZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgaW50ZWx2aXBmYl9wcml2ICpmYnByaXYgPSBkZXZfZ2V0 X2RydmRhdGEoZGV2KTsKPiArCXN0cnVjdCBkcm1fZGV2aWNlICpkcm0gPSAgZmJwcml2LT5kcm07 Cj4gKwo+ICsJZHJtX2Rldl91bnJlZ2lzdGVyKGRybSk7Cj4gKwo+ICsJaWYgKGZicHJpdi0+ZmJj bWEpCj4gKwkJZHJtX2ZiZGV2X2NtYV9maW5pKGZicHJpdi0+ZmJjbWEpOwo+ICsKPiArCWRybV9t b2RlX2NvbmZpZ19jbGVhbnVwKGRybSk7Cj4gKwo+ICsJZHJtX2Rldl91bnJlZihkcm0pOwo+ICsK PiArCWRldm1fa2ZyZWUoZGV2LCBmYnByaXYpOwoKVGhlIHdob2xlIHBvaW50IG9mIGRldm1fa3ph bGxvYygpIGlzIHRoYXQgeW91IGRvbid0IG5lZWQgdG8gZnJlZSB0aGUgbWVtb3J5IGF0IApyZW1v dmUgdGltZS4KCj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArRVhQT1JUX1NZTUJPTF9HUEwoaW50 ZWx2aXBmYl9yZW1vdmUpOwo+ICsKPiArTU9EVUxFX0FVVEhPUigiT25nLCBIZWFuLUxvb25nIDxo ZWFuLmxvb25nLm9uZ0BpbnRlbC5jb20+Iik7Cj4gK01PRFVMRV9ERVNDUklQVElPTigiSW50ZWwg VklQIEZyYW1lIEJ1ZmZlciBJSSBkcml2ZXIiKTsKPiArTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIp Owo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaXZpcC9pbnRlbF92aXBfZHJ2LmgKPiBi L2RyaXZlcnMvZ3B1L2RybS9pdmlwL2ludGVsX3ZpcF9kcnYuaCBuZXcgZmlsZSBtb2RlIDEwMDY0 NAo+IGluZGV4IDAwMDAwMDAuLmViZGJkNTAKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVy cy9ncHUvZHJtL2l2aXAvaW50ZWxfdmlwX2Rydi5oCj4gQEAgLTAsMCArMSw1NCBAQAo+ICsvKgo+ ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTcgSW50ZWwgQ29ycG9yYXRpb24uCj4gKyAqCj4gKyAqIElu dGVsIFZpZGVvIGFuZCBJbWFnZSBQcm9jZXNzaW5nKFZJUCkgRnJhbWUgQnVmZmVyIElJIGRyaXZl ci4KPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKPiArICogdW5kZXIgdGhlIHRlcm1zIGFuZCBj b25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKPiArICogdmVyc2lv biAyLCBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KPiArICoK PiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIGl0IHdpbGwgYmUg dXNlZnVsLCBidXQgV0lUSE9VVAo+ICsgKiBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUg aW1wbGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3IKPiArICogRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl Cj4gZm9yICsgKiBtb3JlIGRldGFpbHMuCj4gKyAqCj4gKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNl aXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nCj4gd2l0 aCArICogdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNl bnNlcy8+Lgo+ICsgKgo+ICsgKiBBdXRob3JzOgo+ICsgKiBPbmcsIEhlYW4tTG9vbmcgPGhlYW4u bG9vbmcub25nQGludGVsLmNvbT4KPiArICoKPiArICovCj4gKyNpZm5kZWYgX0lOVEVMX1ZJUF9E UlZfSAo+ICsjZGVmaW5lIF9JTlRFTF9WSVBfRFJWX0gKCk1pc3NpbmcgYmxhbmsgbGluZS4KCj4g KyNpbmNsdWRlIDxsaW51eC9pby5oPgo+ICsjaW5jbHVkZSA8bGludXgvZmIuaD4KCkkgZG9uJ3Qg dGhpbmsgdGhpcyBoZWFkZXIgaXMgbmVlZGVkLgoKPiArI2RlZmluZSBEUklWRVJfTkFNRSAgICAi aW50ZWx2aXBmYiIKPiArI2RlZmluZSBCWVRFU19QRVJfUElYRUwgICAgICAgIDQKPiArI2RlZmlu ZSBDUlRDX05VTSAgICAgICAgICAgICAgIDEKPiArI2RlZmluZSBDT05OX05VTSAgICAgICAgICAg ICAgIDEKPiArCj4gKy8qIGNvbnRyb2wgcmVnaXN0ZXJzICovCj4gKyNkZWZpbmUgSU5URUxWSVBG Ql9DT05UUk9MICAgICAgICAgICAgIDAKPiArI2RlZmluZSBJTlRFTFZJUEZCX1NUQVRVUyAgICAg ICAgICAgICAgMHg0Cj4gKyNkZWZpbmUgSU5URUxWSVBGQl9JTlRFUlJVUFQgICAgICAgICAgIDB4 OAo+ICsjZGVmaW5lIElOVEVMVklQRkJfRlJBTUVfQ09VTlRFUiAgICAgICAweEMKPiArI2RlZmlu ZSBJTlRFTFZJUEZCX0ZSQU1FX0RST1AgICAgICAgICAgMHgxMAo+ICsjZGVmaW5lIElOVEVMVklQ RkJfRlJBTUVfSU5GTyAgICAgICAgICAweDE0Cj4gKyNkZWZpbmUgSU5URUxWSVBGQl9GUkFNRV9T VEFSVCAgICAgICAgIDB4MTgKPiArI2RlZmluZSBJTlRFTFZJUEZCX0ZSQU1FX1JFQURFUiAgICAg ICAgICAgICAgICAweDFDCj4gKwo+ICtpbnQgaW50ZWx2aXBmYl9wcm9iZShzdHJ1Y3QgZGV2aWNl ICpkZXYsIHZvaWQgX19pb21lbSAqYmFzZSk7Cj4gK2ludCBpbnRlbHZpcGZiX3JlbW92ZShzdHJ1 Y3QgZGV2aWNlICpkZXYpOwo+ICtpbnQgaW50ZWx2aXBmYl9zZXR1cF9jcnRjKHN0cnVjdCBkcm1f ZGV2aWNlICpkcm0pOwo+ICtzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqaW50ZWx2aXBmYl9jb25uX3Nl dHVwKHN0cnVjdCBkcm1fZGV2aWNlICpkcm0pOwo+ICsKPiArc3RydWN0IGludGVsdmlwZmJfcHJp diB7Cj4gKwlzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgcGlwZTsKPiArCXN0cnVjdCBk cm1fZmJkZXZfY21hICpmYmNtYTsKPiArCXN0cnVjdCBkcm1fZGV2aWNlICpkcm07Cj4gKwl2b2lk ICAgIF9faW9tZW0gKmJhc2U7Cj4gK307Cj4gKwo+ICsjZW5kaWYKPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2l2aXAvaW50ZWxfdmlwX29mLmMKPiBiL2RyaXZlcnMvZ3B1L2RybS9pdmlw L2ludGVsX3ZpcF9vZi5jIG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uNWE3 YzYzYgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaXZpcC9pbnRlbF92 aXBfb2YuYwo+IEBAIC0wLDAgKzEsMjA0IEBACj4gKy8qCj4gKyAqIGludGVsX3ZpcF9vZi5jIC0t IEludGVsIFZpZGVvIGFuZCBJbWFnZSBQcm9jZXNzaW5nKFZJUCkKPiArICogRnJhbWUgQnVmZmVy IElJIGRyaXZlcgo+ICsgKgo+ICsgKiBUaGlzIGRyaXZlciBzdXBwb3J0cyB0aGUgSW50ZWwgVklQ IEZyYW1lIFJlYWRlciBjb21wb25lbnQuCj4gKyAqIE1vcmUgaW5mbyBvbiB0aGUgaGFyZHdhcmUg Y2FuIGJlIGZvdW5kIGluIHRoZSBJbnRlbCBWaWRlbwo+ICsgKiBhbmQgSW1hZ2UgUHJvY2Vzc2lu ZyBTdWl0ZSBVc2VyIEd1aWRlIGF0IHRoaXMgYWRkcmVzcwo+ICsgKiBodHRwOi8vd3d3LmFsdGVy YS5jb20vbGl0ZXJhdHVyZS91Zy91Z192aXAucGRmLgo+ICsgKgo+ICsgKiBUaGlzIHByb2dyYW0g aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBp dAo+ICsgKiB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlLAo+ICsgKiB2ZXJzaW9uIDIsIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgo+ICsgKgo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCj4gKyAqIEFO WSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIE1FUkNIQU5U QUJJTElUWSBvcgo+ICsgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKPiBmb3IKPiArICogbW9yZSBkZXRhaWxzLgo+ ICsgKgo+ICsgKiBBdXRob3JzOgo+ICsgKiBPbmcsIEhlYW4tTG9vbmcgPGhlYW4ubG9vbmcub25n QGludGVsLmNvbT4KPiArICoKPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvY29tcG9uZW50 Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9mYi5oPgoKSSBkb24ndCB0aGluayB0aG9zZSB0d28gaGVh ZGVycyBhcmUgbmVlZGVkLgoKPiArI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KPiArI2luY2x1ZGUg PGxpbnV4L2tlcm5lbC5oPgo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRl IDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KPiArCj4gKyNpbmNsdWRlIDxkcm0vZHJtX2ZiX2hl bHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9vZi5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9m Yl9jbWFfaGVscGVyLmg+Cj4gKyNpbmNsdWRlIDxkcm0vZHJtX2dlbV9jbWFfaGVscGVyLmg+Cj4g KyNpbmNsdWRlIDxkcm0vZHJtX3NpbXBsZV9rbXNfaGVscGVyLmg+CgpQbGVhc2Ugc29ydCB0aGVz ZSBhbHBoYWJldGljYWxseS4KCj4gKwo+ICsjaW5jbHVkZSAiaW50ZWxfdmlwX2Rydi5oIgo+ICsK PiArREVGSU5FX0RSTV9HRU1fQ01BX0ZPUFMoZHJtX2ZvcHMpOwo+ICsKPiArc3RhdGljIHZvaWQg aW50ZWx2aXBmYl9sYXN0Y2xvc2Uoc3RydWN0IGRybV9kZXZpY2UgKmRybSkKPiArewo+ICsJc3Ry dWN0IGludGVsdmlwZmJfcHJpdiAqcHJpdiA9IGRybS0+ZGV2X3ByaXZhdGU7Cj4gKwo+ICsJZHJt X2ZiZGV2X2NtYV9yZXN0b3JlX21vZGUocHJpdi0+ZmJjbWEpOwo+ICt9Cj4gKwo+ICtzdGF0aWMg c3RydWN0IGRybV9kcml2ZXIgaW50ZWx2aXBmYl9kcm0gPSB7Cj4gKwkuZHJpdmVyX2ZlYXR1cmVz ID0KPiArCQlEUklWRVJfTU9ERVNFVCB8IERSSVZFUl9HRU0gfAo+ICsJCURSSVZFUl9QUklNRSB8 IERSSVZFUl9BVE9NSUMsCj4gKwkuZ2VtX2ZyZWVfb2JqZWN0X3VubG9ja2VkID0gZHJtX2dlbV9j bWFfZnJlZV9vYmplY3QsCj4gKwkuZ2VtX3ZtX29wcyA9ICZkcm1fZ2VtX2NtYV92bV9vcHMsCj4g KwkuZHVtYl9jcmVhdGUgPSBkcm1fZ2VtX2NtYV9kdW1iX2NyZWF0ZSwKPiArCS5kdW1iX21hcF9v ZmZzZXQgPSBkcm1fZ2VtX2NtYV9kdW1iX21hcF9vZmZzZXQsCj4gKwkuZHVtYl9kZXN0cm95ID0g ZHJtX2dlbV9kdW1iX2Rlc3Ryb3ksCj4gKwkucHJpbWVfaGFuZGxlX3RvX2ZkID0gZHJtX2dlbV9w cmltZV9oYW5kbGVfdG9fZmQsCj4gKwkucHJpbWVfZmRfdG9faGFuZGxlID0gZHJtX2dlbV9wcmlt ZV9mZF90b19oYW5kbGUsCj4gKwkuZ2VtX3ByaW1lX2V4cG9ydCA9IGRybV9nZW1fcHJpbWVfZXhw b3J0LAo+ICsJLmdlbV9wcmltZV9pbXBvcnQgPSBkcm1fZ2VtX3ByaW1lX2ltcG9ydCwKPiArCS5n ZW1fcHJpbWVfZ2V0X3NnX3RhYmxlID0gZHJtX2dlbV9jbWFfcHJpbWVfZ2V0X3NnX3RhYmxlLAo+ ICsJLmdlbV9wcmltZV9pbXBvcnRfc2dfdGFibGUgPSBkcm1fZ2VtX2NtYV9wcmltZV9pbXBvcnRf c2dfdGFibGUsCj4gKwkuZ2VtX3ByaW1lX3ZtYXAgPSBkcm1fZ2VtX2NtYV9wcmltZV92bWFwLAo+ ICsJLmdlbV9wcmltZV92dW5tYXAgPSBkcm1fZ2VtX2NtYV9wcmltZV92dW5tYXAsCj4gKwkuZ2Vt X3ByaW1lX21tYXAgPSBkcm1fZ2VtX2NtYV9wcmltZV9tbWFwLAo+ICsJLmxhc3RjbG9zZSA9IGlu dGVsdmlwZmJfbGFzdGNsb3NlLAo+ICsJLm5hbWUgPSBEUklWRVJfTkFNRSwKPiArCS5kYXRlID0g IjIwMTcwNzI5IiwKPiArCS5kZXNjID0gIkludGVsIEZQR0EgVklQIFNVSVRFIiwKPiArCS5tYWpv ciA9IDEsCj4gKwkubWlub3IgPSAwLAo+ICsJLmlvY3RscyA9IE5VTEwsCj4gKwkucGF0Y2hsZXZl bCA9IDAsCj4gKwkuZm9wcyA9ICZkcm1fZm9wcywKPiArfTsKPiArCj4gKy8qCj4gKyAqIFNldHRp bmcgdXAgaW5mb3JtYXRpb24gZGVyaXZlZCBmcm9tIE9GIERldmljZSBUcmVlIE5vZGVzCj4gKyAq IG1heC13aWR0aCwgbWF4LWhlaWdodCwgYml0cyBwZXIgcGl4ZWwsIG1lbW9yeSBwb3J0IHdpZHRo Cj4gKyAqLwo+ICsKPiArc3RhdGljIGludCBpbnRlbHZpcGZiX2RybV9zZXR1cChzdHJ1Y3QgZGV2 aWNlICpkZXYsCj4gKwkJCXN0cnVjdCBpbnRlbHZpcGZiX3ByaXYgKmZicHJpdikKPiArewo+ICsJ c3RydWN0IGRybV9kZXZpY2UgKmRybSA9IGZicHJpdi0+ZHJtOwo+ICsJc3RydWN0IGRldmljZV9u b2RlICpucCA9IGRldi0+b2Zfbm9kZTsKPiArCWludCBtZW1fd29yZF93aWR0aDsKPiArCWludCBt YXhfaCwgbWF4X3c7Cj4gKwlpbnQgYnBwOwo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQgPSBvZl9w cm9wZXJ0eV9yZWFkX3UzMihucCwgImFsdHIsbWF4LXdpZHRoIiwgJm1heF93KTsKPiArCWlmIChy ZXQpIHsKPiArCQlkZXZfZXJyKGRldiwKPiArCQkiTWlzc2luZyByZXF1aXJlZCBwYXJhbWV0ZXIg J2FsdHIsbWF4LXdpZHRoJyIpOwo+ICsJCXJldHVybiByZXQ7Cj4gKwl9Cj4gKwo+ICsJcmV0ID0g b2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJhbHRyLG1heC1oZWlnaHQiLCAmbWF4X2gpOwo+ICsJ aWYgKHJldCkgewo+ICsJCWRldl9lcnIoZGV2LAo+ICsJCSJNaXNzaW5nIHJlcXVpcmVkIHBhcmFt ZXRlciAnYWx0cixtYXgtaGVpZ2h0JyIpOwo+ICsJCXJldHVybiByZXQ7Cj4gKwl9Cj4gKwo+ICsJ cmV0ID0gb2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJhbHRyLGJpdHMtcGVyLXN5bWJvbCIsICZi cHApOwoKVGhpcyBwcm9wZXJ0eSBpcyBub3QgZG9jdW1lbnRlZCBpbiBwYXRjaCAxLzMuCgo+ICsJ aWYgKHJldCkgewo+ICsJCWRldl9lcnIoZGV2LAo+ICsJCSJNaXNzaW5nIHJlcXVpcmVkIHBhcmFt ZXRlciAnYWx0cixiaXRzLXBlci1zeW1ib2wnIik7Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0KPiAr Cj4gKwlyZXQgPSBvZl9wcm9wZXJ0eV9yZWFkX3UzMihucCwgImFsdHIsbWVtLXBvcnQtd2lkdGgi LCAKJm1lbV93b3JkX3dpZHRoKTsKPiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKGRldiwgIk1p c3NpbmcgcmVxdWlyZWQgcGFyYW1ldGVyICdhbHRyLG1lbS1wb3J0LXdpZHRoIAonIik7Cj4gKwkJ cmV0dXJuIHJldDsKPiArCX0KPiArCj4gKwlpZiAoIShtZW1fd29yZF93aWR0aCA+PSAzMiAmJiBt ZW1fd29yZF93aWR0aCAlIDMyID09IDApKSB7Cj4gKwkJZGV2X2VycihkZXYsCj4gKwkJIm1lbS13 b3JkLXdpZHRoIGlzIHNldCB0byAlaS4gbXVzdCBiZSA+PSAzMiBhbmQgbXVsdGlwbGUgb2YgCjMy LiIsCj4gKwkJbWVtX3dvcmRfd2lkdGgpOwo+ICsJCXJldHVybiAtRU5PREVWOwo+ICsJfQo+ICsK PiArCWRybS0+bW9kZV9jb25maWcubWluX3dpZHRoID0gNjQwOwo+ICsJZHJtLT5tb2RlX2NvbmZp Zy5taW5faGVpZ2h0ID0gNDgwOwo+ICsJZHJtLT5tb2RlX2NvbmZpZy5tYXhfd2lkdGggPSBtYXhf dzsKPiArCWRybS0+bW9kZV9jb25maWcubWF4X2hlaWdodCA9IG1heF9oOwo+ICsJZHJtLT5tb2Rl X2NvbmZpZy5wcmVmZXJyZWRfZGVwdGggPSBicHAgKiBCWVRFU19QRVJfUElYRUw7Cj4gKwo+ICsJ cmV0dXJuIDA7Cj4gK30KCi0tIApSZWdhcmRzLAoKTGF1cmVudCBQaW5jaGFydAoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcg bGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRl c2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751933AbdHAOof (ORCPT ); Tue, 1 Aug 2017 10:44:35 -0400 Received: from galahad.ideasonboard.com ([185.26.127.97]:46022 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751722AbdHAOoV (ORCPT ); Tue, 1 Aug 2017 10:44:21 -0400 From: Laurent Pinchart To: dri-devel@lists.freedesktop.org Cc: "Hean Loong, Ong" , Rob Herring , Dinh Nguyen , Daniel Vetter , devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Ong@freedesktop.org Subject: Re: [PATCHv4 3/3] DRM:ivip Intel FPGA Video and Image Processing Suite Date: Tue, 01 Aug 2017 17:30:36 +0300 Message-ID: <2323445.Hdzqrs3Ziv@avalon> User-Agent: KMail/4.14.10 (Linux/4.9.34-gentoo; KDE/4.14.32; x86_64; ; ) In-Reply-To: <1501554694-3378-4-git-send-email-hean.loong.ong@intel.com> References: <1501554694-3378-1-git-send-email-hean.loong.ong@intel.com> <1501554694-3378-4-git-send-email-hean.loong.ong@intel.com> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi Hean Loong, Thank you for the patch. On Tuesday 01 Aug 2017 10:31:34 Hean Loong, Ong wrote: > From: Ong Hean Loong > > Driver for Intel FPGA Video and Image Processing > Suite Frame Buffer II. The driver only supports the Intel > Arria10 devkit and its variants. This driver can be either > loaded staticlly or in modules. The OF device tree binding > is located at: > Documentation/devicetree/bindings/display/altr,vip-fb2.txt > > Signed-off-by: Ong, Hean Loong > --- > V3: > *Changes to fixing drm_simple_pipe > *Used drm_fb_cma_get_gem_addr > > V2: > *Adding drm_simple_display_pipe_init > --- > drivers/gpu/drm/Kconfig | 2 + > drivers/gpu/drm/Makefile | 1 + > drivers/gpu/drm/ivip/Kconfig | 13 +++ > drivers/gpu/drm/ivip/Makefile | 9 ++ > drivers/gpu/drm/ivip/intel_vip_conn.c | 96 ++++++++++++++++ > drivers/gpu/drm/ivip/intel_vip_core.c | 183 ++++++++++++++++++++++++++++++ > drivers/gpu/drm/ivip/intel_vip_drv.h | 54 +++++++++ > drivers/gpu/drm/ivip/intel_vip_of.c | 204 +++++++++++++++++++++++++++++++ > 8 files changed, 562 insertions(+) > create mode 100644 drivers/gpu/drm/ivip/Kconfig > create mode 100644 drivers/gpu/drm/ivip/Makefile > create mode 100644 drivers/gpu/drm/ivip/intel_vip_conn.c > create mode 100644 drivers/gpu/drm/ivip/intel_vip_core.c > create mode 100644 drivers/gpu/drm/ivip/intel_vip_drv.h > create mode 100644 drivers/gpu/drm/ivip/intel_vip_of.c [snip] > diff --git a/drivers/gpu/drm/ivip/Kconfig b/drivers/gpu/drm/ivip/Kconfig > new file mode 100644 > index 0000000..9a8c5ce > --- /dev/null > +++ b/drivers/gpu/drm/ivip/Kconfig > @@ -0,0 +1,13 @@ > +config DRM_IVIP > + tristate "Intel FGPA Video and Image Processing" > + depends on DRM && OF > + select DRM_GEM_CMA_HELPER > + select DRM_KMS_HELPER > + select DRM_KMS_FB_HELPER > + select DRM_KMS_CMA_HELPER > + help > + Choose this option if you have a Intel FPGA Arria 10 system > + and above with a Display Port IP. This does not support legacy > + Intel FPGA Cyclone V display port. Currently only single frame > + buffer is supported. I think this should be fixed to upstream this driver. > Note that ACPI and X_86 architecture is yet ACPI on FPGA... I wonder if it could get any crazier than that :-) > + to be supported.If M is selected the module would be called ivip. s/.If/. If/ [snip] > diff --git a/drivers/gpu/drm/ivip/intel_vip_core.c > b/drivers/gpu/drm/ivip/intel_vip_core.c new file mode 100644 > index 0000000..ea85715 > --- /dev/null > +++ b/drivers/gpu/drm/ivip/intel_vip_core.c > @@ -0,0 +1,183 @@ > +/* > + * intel_vip_core.c -- Intel Video and Image Processing(VIP) > + * Frame Buffer II driver > + * > + * This driver supports the Intel VIP Frame Reader component. > + * More info on the hardware can be found in the Intel Video > + * and Image Processing Suite User Guide at this address > + * http://www.altera.com/literature/ug/ug_vip.pdf. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope 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. > + * > + * Authors: > + * Ong, Hean-Loong > + * > + */ > + > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "intel_vip_drv.h" > + > +static void intelvipfb_enable(struct drm_simple_display_pipe *pipe, > + struct drm_crtc_state *crtc_state) > +{ > + /* > + * The frameinfo variable has to correspond to the size of the VIP Suite > + * Frame Reader register 7 which will determine the maximum size used > + * in this frameinfo > + */ > + > + u32 frameinfo; > + struct intelvipfb_priv *priv = pipe->plane.dev->dev_private; > + void __iomem *base = priv->base; > + struct drm_plane_state *state = pipe->plane.state; > + dma_addr_t addr; > + > + addr = drm_fb_cma_get_gem_addr(state->fb, state, 0); > + > + dev_info(pipe->plane.dev->dev, "Address 0x%x\n", addr); > + > + frameinfo = > + readl(base + INTELVIPFB_FRAME_READER) & 0x00ffffff; > + writel(frameinfo, base + INTELVIPFB_FRAME_INFO); > + writel(addr, base + INTELVIPFB_FRAME_START); > + /* Finally set the control register to 1 to start streaming */ > + writel(1, base + INTELVIPFB_CONTROL); > +} > + > +static void intelvipfb_disable(struct drm_simple_display_pipe *pipe) > +{ > + struct intelvipfb_priv *priv = pipe->plane.dev->dev_private; > + void __iomem *base = priv->base; Missing blank line. > + /* set the control register to 0 to stop streaming */ > + writel(0, base + INTELVIPFB_CONTROL); > +} > + > +static const struct drm_mode_config_funcs intelvipfb_mode_config_funcs = { > + .fb_create = drm_fb_cma_create, > + .atomic_check = drm_atomic_helper_check, > + .atomic_commit = drm_atomic_helper_commit, > +}; > + > +static void intelvipfb_setup_mode_config(struct drm_device *drm) > +{ > + drm_mode_config_init(drm); > + drm->mode_config.funcs = &intelvipfb_mode_config_funcs; > +} > + > +static int intelvipfb_pipe_prepare_fb(struct drm_simple_display_pipe *pipe, > + struct drm_plane_state *plane_state) > +{ > + return drm_fb_cma_prepare_fb(&pipe->plane, plane_state); > +} > + > +static void intelvipfb_update(struct drm_simple_display_pipe *pipe, > + struct drm_plane_state *old_state) > +{ > + struct drm_crtc *crtc = &pipe->crtc; > + > + if (crtc->state->event) { > + spin_lock_irq(&crtc->dev->event_lock); > + drm_crtc_send_vblank_event(crtc, crtc->state->event); > + spin_unlock_irq(&crtc->dev->event_lock); > + crtc->state->event = NULL; > + } This is not quite right. Userspace expects the driver to perform a page flip here, and you just signal page flip completion without doing anything. > +} > + > +static struct drm_simple_display_pipe_funcs fbpriv_funcs = { > + .prepare_fb = intelvipfb_pipe_prepare_fb, > + .update = intelvipfb_update, > + .enable = intelvipfb_enable, > + .disable = intelvipfb_disable > +}; > + > +int intelvipfb_probe(struct device *dev, void __iomem *base) You don't use the base argument, you can remove it. > +{ > + int retval; > + struct drm_device *drm; > + struct intelvipfb_priv *fbpriv = dev_get_drvdata(dev); > + struct drm_connector *connector; > + Extra blank line. > + u32 formats[] = {DRM_FORMAT_XRGB8888}; > + > + dev_set_drvdata(dev, fbpriv); As fbpriv is obtained by a call to dev_get_drvdata(), this isn't needed. A better option would be to pass the intelvipfb_priv pointer as an argument to this function. > + drm = fbpriv->drm; > + > + drm->dev_private = fbpriv; > + > + intelvipfb_setup_mode_config(drm); > + > + connector = intelvipfb_conn_setup(drm); > + if (!connector) { > + dev_err(drm->dev, "Connector setup failed\n"); > + goto err_mode_config; > + } > + > + retval = drm_simple_display_pipe_init(drm, &fbpriv->pipe, > + &fbpriv_funcs, formats, > + ARRAY_SIZE(formats), connector); > + if (retval < 0) { > + dev_err(drm->dev, "Cannot setup simple display pipe\n"); > + goto err_mode_config; > + } > + > + fbpriv->fbcma = drm_fbdev_cma_init(drm, > + drm->mode_config.preferred_depth, > + drm->mode_config.num_connector); > + > + drm_mode_config_reset(drm); > + > + drm_dev_register(drm, 0); > + > + return retval; > + > +err_mode_config: > + > + drm_mode_config_cleanup(drm); > + return -ENODEV; > +} > +EXPORT_SYMBOL_GPL(intelvipfb_probe); Why do you need to export this symbol ? > +int intelvipfb_remove(struct device *dev) > +{ > + struct intelvipfb_priv *fbpriv = dev_get_drvdata(dev); > + struct drm_device *drm = fbpriv->drm; > + > + drm_dev_unregister(drm); > + > + if (fbpriv->fbcma) > + drm_fbdev_cma_fini(fbpriv->fbcma); > + > + drm_mode_config_cleanup(drm); > + > + drm_dev_unref(drm); > + > + devm_kfree(dev, fbpriv); The whole point of devm_kzalloc() is that you don't need to free the memory at remove time. > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(intelvipfb_remove); > + > +MODULE_AUTHOR("Ong, Hean-Loong "); > +MODULE_DESCRIPTION("Intel VIP Frame Buffer II driver"); > +MODULE_LICENSE("GPL v2"); > diff --git a/drivers/gpu/drm/ivip/intel_vip_drv.h > b/drivers/gpu/drm/ivip/intel_vip_drv.h new file mode 100644 > index 0000000..ebdbd50 > --- /dev/null > +++ b/drivers/gpu/drm/ivip/intel_vip_drv.h > @@ -0,0 +1,54 @@ > +/* > + * Copyright (C) 2017 Intel Corporation. > + * > + * Intel Video and Image Processing(VIP) Frame Buffer II driver. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope 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. > + * > + * You should have received a copy of the GNU General Public License along > with + * this program. If not, see . > + * > + * Authors: > + * Ong, Hean-Loong > + * > + */ > +#ifndef _INTEL_VIP_DRV_H > +#define _INTEL_VIP_DRV_H Missing blank line. > +#include > +#include I don't think this header is needed. > +#define DRIVER_NAME "intelvipfb" > +#define BYTES_PER_PIXEL 4 > +#define CRTC_NUM 1 > +#define CONN_NUM 1 > + > +/* control registers */ > +#define INTELVIPFB_CONTROL 0 > +#define INTELVIPFB_STATUS 0x4 > +#define INTELVIPFB_INTERRUPT 0x8 > +#define INTELVIPFB_FRAME_COUNTER 0xC > +#define INTELVIPFB_FRAME_DROP 0x10 > +#define INTELVIPFB_FRAME_INFO 0x14 > +#define INTELVIPFB_FRAME_START 0x18 > +#define INTELVIPFB_FRAME_READER 0x1C > + > +int intelvipfb_probe(struct device *dev, void __iomem *base); > +int intelvipfb_remove(struct device *dev); > +int intelvipfb_setup_crtc(struct drm_device *drm); > +struct drm_connector *intelvipfb_conn_setup(struct drm_device *drm); > + > +struct intelvipfb_priv { > + struct drm_simple_display_pipe pipe; > + struct drm_fbdev_cma *fbcma; > + struct drm_device *drm; > + void __iomem *base; > +}; > + > +#endif > diff --git a/drivers/gpu/drm/ivip/intel_vip_of.c > b/drivers/gpu/drm/ivip/intel_vip_of.c new file mode 100644 > index 0000000..5a7c63b > --- /dev/null > +++ b/drivers/gpu/drm/ivip/intel_vip_of.c > @@ -0,0 +1,204 @@ > +/* > + * intel_vip_of.c -- Intel Video and Image Processing(VIP) > + * Frame Buffer II driver > + * > + * This driver supports the Intel VIP Frame Reader component. > + * More info on the hardware can be found in the Intel Video > + * and Image Processing Suite User Guide at this address > + * http://www.altera.com/literature/ug/ug_vip.pdf. > + * > + * This program is free software; you can redistribute it and/or modify it > + * under the terms and conditions of the GNU General Public License, > + * version 2, as published by the Free Software Foundation. > + * > + * This program is distributed in the hope 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. > + * > + * Authors: > + * Ong, Hean-Loong > + * > + */ > + > +#include > +#include I don't think those two headers are needed. > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include Please sort these alphabetically. > + > +#include "intel_vip_drv.h" > + > +DEFINE_DRM_GEM_CMA_FOPS(drm_fops); > + > +static void intelvipfb_lastclose(struct drm_device *drm) > +{ > + struct intelvipfb_priv *priv = drm->dev_private; > + > + drm_fbdev_cma_restore_mode(priv->fbcma); > +} > + > +static struct drm_driver intelvipfb_drm = { > + .driver_features = > + DRIVER_MODESET | DRIVER_GEM | > + DRIVER_PRIME | DRIVER_ATOMIC, > + .gem_free_object_unlocked = drm_gem_cma_free_object, > + .gem_vm_ops = &drm_gem_cma_vm_ops, > + .dumb_create = drm_gem_cma_dumb_create, > + .dumb_map_offset = drm_gem_cma_dumb_map_offset, > + .dumb_destroy = drm_gem_dumb_destroy, > + .prime_handle_to_fd = drm_gem_prime_handle_to_fd, > + .prime_fd_to_handle = drm_gem_prime_fd_to_handle, > + .gem_prime_export = drm_gem_prime_export, > + .gem_prime_import = drm_gem_prime_import, > + .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table, > + .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table, > + .gem_prime_vmap = drm_gem_cma_prime_vmap, > + .gem_prime_vunmap = drm_gem_cma_prime_vunmap, > + .gem_prime_mmap = drm_gem_cma_prime_mmap, > + .lastclose = intelvipfb_lastclose, > + .name = DRIVER_NAME, > + .date = "20170729", > + .desc = "Intel FPGA VIP SUITE", > + .major = 1, > + .minor = 0, > + .ioctls = NULL, > + .patchlevel = 0, > + .fops = &drm_fops, > +}; > + > +/* > + * Setting up information derived from OF Device Tree Nodes > + * max-width, max-height, bits per pixel, memory port width > + */ > + > +static int intelvipfb_drm_setup(struct device *dev, > + struct intelvipfb_priv *fbpriv) > +{ > + struct drm_device *drm = fbpriv->drm; > + struct device_node *np = dev->of_node; > + int mem_word_width; > + int max_h, max_w; > + int bpp; > + int ret; > + > + ret = of_property_read_u32(np, "altr,max-width", &max_w); > + if (ret) { > + dev_err(dev, > + "Missing required parameter 'altr,max-width'"); > + return ret; > + } > + > + ret = of_property_read_u32(np, "altr,max-height", &max_h); > + if (ret) { > + dev_err(dev, > + "Missing required parameter 'altr,max-height'"); > + return ret; > + } > + > + ret = of_property_read_u32(np, "altr,bits-per-symbol", &bpp); This property is not documented in patch 1/3. > + if (ret) { > + dev_err(dev, > + "Missing required parameter 'altr,bits-per-symbol'"); > + return ret; > + } > + > + ret = of_property_read_u32(np, "altr,mem-port-width", &mem_word_width); > + if (ret) { > + dev_err(dev, "Missing required parameter 'altr,mem-port-width '"); > + return ret; > + } > + > + if (!(mem_word_width >= 32 && mem_word_width % 32 == 0)) { > + dev_err(dev, > + "mem-word-width is set to %i. must be >= 32 and multiple of 32.", > + mem_word_width); > + return -ENODEV; > + } > + > + drm->mode_config.min_width = 640; > + drm->mode_config.min_height = 480; > + drm->mode_config.max_width = max_w; > + drm->mode_config.max_height = max_h; > + drm->mode_config.preferred_depth = bpp * BYTES_PER_PIXEL; > + > + return 0; > +} -- Regards, Laurent Pinchart