From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ayan Halder Subject: Re: [PATCH v4] drm/komeda: Add writeback support Date: Fri, 24 May 2019 10:25:31 +0000 Message-ID: <20190524102530.GA25679@arm.com> References: <20190523093618.24483-1-james.qian.wang@arm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from EUR04-HE1-obe.outbound.protection.outlook.com (mail-eopbgr70074.outbound.protection.outlook.com [40.107.7.74]) by gabe.freedesktop.org (Postfix) with ESMTPS id 3755C89F9F for ; Fri, 24 May 2019 10:25:35 +0000 (UTC) In-Reply-To: <20190523093618.24483-1-james.qian.wang@arm.com> Content-Language: en-US Content-ID: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: "james qian wang (Arm Technology China)" Cc: nd , "Oscar Zhang (Arm Technology China)" , "Tiannan Zhu (Arm Technology China)" , "airlied@linux.ie" , Liviu Dudau , "Jonathan Chai (Arm Technology China)" , "linux-kernel@vger.kernel.org" , "dri-devel@lists.freedesktop.org" , "Julien Yin (Arm Technology China)" , "Channing Chen (Arm Technology China)" , "Yiqi Kang (Arm Technology China)" , "thomas Sun (Arm Technology China)" , "Lowry Li (Arm Technology China)" , "sean@poorly.run" , Ben Davis List-Id: dri-devel@lists.freedesktop.org T24gVGh1LCBNYXkgMjMsIDIwMTkgYXQgMTA6MzY6MzhBTSArMDEwMCwgamFtZXMgcWlhbiB3YW5n IChBcm0gVGVjaG5vbG9neSBDaGluYSkgd3JvdGU6Cj4gS29tZWRhIGRyaXZlciB1c2VzIGEgaW5k aXZpZHVhbCBjb21wb25lbnQgdG8gZGVzY3JpYmUgdGhlIEhXJ3Mgd3JpdGViYWNrCj4gY2Fwcywg YnV0IGRyaXZlcnMgZG9lc24ndCBkZWZpbmUgYSBuZXcgc3RydWN0dXJlIGFuZCBzdGlsbCB1c2Vz IHRoZQo+IGV4aXN0aW5nICJzdHJ1Y3Qga29tZWRhX2xheWVyIiB0byBkZXNjcmliZSB0aGlzIG5l dyBjb21wb25lbnQuCj4gVGhlIGRldGFpbGVkIGNoYW5nZXMgYXMgZm9sbG93Ogo+IAo+IDEuIElu aXRpYWxpemUgd2JfbGF5ZXIgYWNjb3JkaW5nIHRvIEhXIGFuZCByZXBvcnQgaXQgdG8gQ09SRS4K PiAyLiBDT1JFIGV4cG9zZXMgd2JfbGF5ZXIgYXMgYSByZXNvdXJjZSB0byBLTVMgYnkgcHJpdmF0 ZV9vYmouCj4gMy4gUmVwb3J0IHdyaXRlYmFjayBzdXBwb3J0aW5nIGJ5IGFkZCBhIHdiX2Nvbm5l Y3RvciB0byBLTVMsIGFuZCB0aGVuCj4gICAgd2JfY29ubmVjdG9yIHdpbGwgdGFrZSBhY3QgYXMg YSBjb21wb25lbnQgcmVzb3VyY2VzIHVzZXIsCj4gICAgc28gdGhlIGZ1bmMga29tZWRhX3diX2Vu Y29kZXJfYXRvbWljX2NoZWNrIGNsYWltcyBrb21lZGEgcmVzb3VyY2VzCj4gICAgKHNjYWxlciBh bmQgd2JfbGF5ZXIpIGFjY3JvZGluZyB0byBpdHMgc3RhdGUgY29uZmlndXJhdGlvbiB0byB0aGUK PiAgICB3Yl9jb25uZWN0b3IuIGFuZCB0aGUgd2Jfc3RhdGUgY29uZmlndXJhdGlvbiB3aWxsIGJl IHZhbGlkYXRlZCBvbiB0aGUKPiAgICBzcGVjaWZpYyBjb21wb25lbnQgcmVzb3VyY2VzIHRvIHNl ZSBpZiB0aGUgY2FwcyBvZiBjb21wb25lbnQgY2FuCj4gICAgbWVldCB0aGUgcmVxdWlyZW1lbnQg b2Ygd2JfY29ubmVjdG9yLiBpZiBub3QgY2hlY2sgZmFpbGVkLgo+IDQuIFVwZGF0ZSBpcnFfaGFu ZGxlciB0byBub3RpZnkgdGhlIGNvbXBsZXRpb24gb2Ygd3JpdGViYWNrLgo+IAo+IE5PVEU6Cj4g VGhpcyBjaGFuZ2UgZG9lc24ndCBhZGQgc2NhbGluZyB3cml0ZWJhY2sgc3VwcG9ydCwgdGhhdCBz dXBwb3J0IHdpbGwKPiBiZSBhZGRlZCBpbiB0aGUgZnV0dXJlIGFmdGVyIHRoZSBzY2FsZXIgc3Vw cG9ydC4KPiAKPiB2MjogUmViYXNlCj4gdjM6IFJlYmFzZSBhbmQgY29uc3RpZnkgdGhlIGQ3MV93 Yl9sYXllcl9mdW5jcwo+IHY0OiBBZGRyZXNzZWQgQXlhbidzIGNvbW1lbnRzCj4gCj4gRGVwZW5k cyBvbjoKPiAtIGh0dHBzOi8vcGF0Y2h3b3JrLmZyZWVkZXNrdG9wLm9yZy9zZXJpZXMvNTk5MTUv Cj4gCj4gU2lnbmVkLW9mZi1ieTogSmFtZXMgUWlhbiBXYW5nIChBcm0gVGVjaG5vbG9neSBDaGlu YSkgPGphbWVzLnFpYW4ud2FuZ0Bhcm0uY29tPgo+IC0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vYXJt L2Rpc3BsYXkva29tZWRhL01ha2VmaWxlICAgfCAgIDEgKwo+ICAuLi4vYXJtL2Rpc3BsYXkva29t ZWRhL2Q3MS9kNzFfY29tcG9uZW50LmMgICAgfCAgOTAgKysrKysrKystCj4gIC4uLi9ncHUvZHJt L2FybS9kaXNwbGF5L2tvbWVkYS9rb21lZGFfY3J0Yy5jICB8ICAxNSArKwo+ICAuLi4vYXJtL2Rp c3BsYXkva29tZWRhL2tvbWVkYV9mcmFtZWJ1ZmZlci5jICAgfCAgMTkgKysKPiAgLi4uL2dwdS9k cm0vYXJtL2Rpc3BsYXkva29tZWRhL2tvbWVkYV9rbXMuYyAgIHwgICA0ICsKPiAgLi4uL2dwdS9k cm0vYXJtL2Rpc3BsYXkva29tZWRhL2tvbWVkYV9rbXMuaCAgIHwgIDI3ICsrKwo+ICAuLi4vZHJt L2FybS9kaXNwbGF5L2tvbWVkYS9rb21lZGFfcGlwZWxpbmUuaCAgfCAgIDcgKwo+ICAuLi4vZGlz cGxheS9rb21lZGEva29tZWRhX3BpcGVsaW5lX3N0YXRlLmMgICAgfCAgNTEgKysrKy0KPiAgLi4u L2FybS9kaXNwbGF5L2tvbWVkYS9rb21lZGFfcHJpdmF0ZV9vYmouYyAgIHwgICA2ICsKPiAgLi4u L2FybS9kaXNwbGF5L2tvbWVkYS9rb21lZGFfd2JfY29ubmVjdG9yLmMgIHwgMTgxICsrKysrKysr KysrKysrKysrKwo+ICAxMCBmaWxlcyBjaGFuZ2VkLCAzOTggaW5zZXJ0aW9ucygrKSwgMyBkZWxl dGlvbnMoLSkKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxh eS9rb21lZGEva29tZWRhX3diX2Nvbm5lY3Rvci5jCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9hcm0vZGlzcGxheS9rb21lZGEvTWFrZWZpbGUgYi9kcml2ZXJzL2dwdS9kcm0vYXJt L2Rpc3BsYXkva29tZWRhL01ha2VmaWxlCj4gaW5kZXggNjJiZDFiZmY2NmEzLi5kN2UyOWZjNjg4 YzMgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FybS9kaXNwbGF5L2tvbWVkYS9NYWtl ZmlsZQo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21lZGEvTWFrZWZpbGUK PiBAQCAtMTQsNiArMTQsNyBAQCBrb21lZGEteSA6PSBcCj4gIAlrb21lZGFfa21zLm8gXAo+ICAJ a29tZWRhX2NydGMubyBcCj4gIAlrb21lZGFfcGxhbmUubyBcCj4gKwlrb21lZGFfd2JfY29ubmVj dG9yLm8gXAo+ICAJa29tZWRhX3ByaXZhdGVfb2JqLm8KPiAgCj4gIGtvbWVkYS15ICs9IFwKPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FybS9kaXNwbGF5L2tvbWVkYS9kNzEvZDcxX2Nv bXBvbmVudC5jIGIvZHJpdmVycy9ncHUvZHJtL2FybS9kaXNwbGF5L2tvbWVkYS9kNzEvZDcxX2Nv bXBvbmVudC5jCj4gaW5kZXggNmJhYjgxNmVkOGU3Li4zMjNlNTk5NGE1NWMgMTAwNjQ0Cj4gLS0t IGEvZHJpdmVycy9ncHUvZHJtL2FybS9kaXNwbGF5L2tvbWVkYS9kNzEvZDcxX2NvbXBvbmVudC5j Cj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2FybS9kaXNwbGF5L2tvbWVkYS9kNzEvZDcxX2NvbXBv bmVudC5jCj4gQEAgLTI4OCwxMCArMjg4LDk4IEBAIHN0YXRpYyBpbnQgZDcxX2xheWVyX2luaXQo c3RydWN0IGQ3MV9kZXYgKmQ3MSwKPiAgCXJldHVybiAwOwo+ICB9Cj4gIAo+ICtzdGF0aWMgdm9p ZCBkNzFfd2JfbGF5ZXJfdXBkYXRlKHN0cnVjdCBrb21lZGFfY29tcG9uZW50ICpjLAo+ICsJCQkJ c3RydWN0IGtvbWVkYV9jb21wb25lbnRfc3RhdGUgKnN0YXRlKQo+ICt7Cj4gKwlzdHJ1Y3Qga29t ZWRhX2xheWVyX3N0YXRlICpzdCA9IHRvX2xheWVyX3N0KHN0YXRlKTsKPiArCXN0cnVjdCBkcm1f Y29ubmVjdG9yX3N0YXRlICpjb25uX3N0ID0gc3RhdGUtPndiX2Nvbm4tPnN0YXRlOwo+ICsJc3Ry dWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIgPSBjb25uX3N0LT53cml0ZWJhY2tfam9iLT5mYjsKPiAr CXN0cnVjdCBrb21lZGFfZmIgKmtmYiA9IHRvX2tmYihmYik7Cj4gKwl1MzIgX19pb21lbSAqcmVn ID0gYy0+cmVnOwo+ICsJdTMyIGN0cmwgPSBMX0VOIHwgTFdfT0ZNLCBtYXNrID0gTF9FTiB8IExX X09GTSB8IExXX1RCVV9FTjsKPiArCWludCBpOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBmYi0+ Zm9ybWF0LT5udW1fcGxhbmVzOyBpKyspIHsKPiArCQltYWxpZHBfd3JpdGUzMihyZWcgKyBpICog TEFZRVJfUEVSX1BMQU5FX1JFR1MsIEJMS19QMF9QVFJfTE9XLAo+ICsJCQkgICAgICAgbG93ZXJf MzJfYml0cyhzdC0+YWRkcltpXSkpOwo+ICsJCW1hbGlkcF93cml0ZTMyKHJlZyArIGkgKiBMQVlF Ul9QRVJfUExBTkVfUkVHUywgQkxLX1AwX1BUUl9ISUdILAo+ICsJCQkgICAgICAgdXBwZXJfMzJf Yml0cyhzdC0+YWRkcltpXSkpOwo+ICsKPiArCQltYWxpZHBfd3JpdGUzMihyZWcgKyBpICogTEFZ RVJfUEVSX1BMQU5FX1JFR1MsIEJMS19QMF9TVFJJREUsCj4gKwkJCSAgICAgICBmYi0+cGl0Y2hl c1tpXSAmIDB4RkZGRik7Cj4gKwl9Cj4gKwo+ICsJbWFsaWRwX3dyaXRlMzIocmVnLCBMQVlFUl9G TVQsIGtmYi0+Zm9ybWF0X2NhcHMtPmh3X2lkKTsKPiArCW1hbGlkcF93cml0ZTMyKHJlZywgQkxL X0lOX1NJWkUsIEhWX1NJWkUoc3QtPmhzaXplLCBzdC0+dnNpemUpKTsKPiArCW1hbGlkcF93cml0 ZTMyKHJlZywgQkxLX0lOUFVUX0lEMCwgdG9fZDcxX2lucHV0X2lkKCZzdGF0ZS0+aW5wdXRzWzBd KSk7Cj4gKwltYWxpZHBfd3JpdGUzMl9tYXNrKHJlZywgQkxLX0NPTlRST0wsIG1hc2ssIGN0cmwp Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBkNzFfd2JfbGF5ZXJfZHVtcChzdHJ1Y3Qga29tZWRh X2NvbXBvbmVudCAqYywgc3RydWN0IHNlcV9maWxlICpzZikKPiArewo+ICsJdTMyIHZbMTJdLCBp Owo+ICsKPiArCWR1bXBfYmxvY2tfaGVhZGVyKHNmLCBjLT5yZWcpOwo+ICsKPiArCWdldF92YWx1 ZXNfZnJvbV9yZWcoYy0+cmVnLCAweDgwLCAxLCB2KTsKPiArCXNlcV9wcmludGYoc2YsICJMV19J TlBVVF9JRDA6XHRcdDB4JVhcbiIsIHZbMF0pOwo+ICsKPiArCWdldF92YWx1ZXNfZnJvbV9yZWco Yy0+cmVnLCAweEQwLCAzLCB2KTsKPiArCXNlcV9wcmludGYoc2YsICJMV19DT05UUk9MOlx0XHQw eCVYXG4iLCB2WzBdKTsKPiArCXNlcV9wcmludGYoc2YsICJMV19QUk9HX0xJTkU6XHRcdDB4JVhc biIsIHZbMV0pOwo+ICsJc2VxX3ByaW50ZihzZiwgIkxXX0ZPUk1BVDpcdFx0MHglWFxuIiwgdlsy XSk7Cj4gKwo+ICsJZ2V0X3ZhbHVlc19mcm9tX3JlZyhjLT5yZWcsIDB4RTAsIDEsIHYpOwo+ICsJ c2VxX3ByaW50ZihzZiwgIkxXX0lOX1NJWkU6XHRcdDB4JVhcbiIsIHZbMF0pOwo+ICsKPiArCWZv ciAoaSA9IDA7IGkgPCAyOyBpKyspIHsKPiArCQlnZXRfdmFsdWVzX2Zyb21fcmVnKGMtPnJlZywg MHgxMDAgKyBpICogMHgxMCwgMywgdik7Cj4gKwkJc2VxX3ByaW50ZihzZiwgIkxXX1AldV9QVFJf TE9XOlx0XHQweCVYXG4iLCBpLCB2WzBdKTsKPiArCQlzZXFfcHJpbnRmKHNmLCAiTFdfUCV1X1BU Ul9ISUdIOlx0XHQweCVYXG4iLCBpLCB2WzFdKTsKPiArCQlzZXFfcHJpbnRmKHNmLCAiTFdfUCV1 X1NUUklERTpcdFx0MHglWFxuIiwgaSwgdlsyXSk7Cj4gKwl9Cj4gKwo+ICsJZ2V0X3ZhbHVlc19m cm9tX3JlZyhjLT5yZWcsIDB4MTMwLCAxMiwgdik7Cj4gKwlmb3IgKGkgPSAwOyBpIDwgMTI7IGkr KykKPiArCQlzZXFfcHJpbnRmKHNmLCAiTFdfUkdCX1lVVl9DT0VGRiV1Olx0MHglWFxuIiwgaSwg dltpXSk7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIGQ3MV93Yl9sYXllcl9kaXNhYmxlKHN0cnVj dCBrb21lZGFfY29tcG9uZW50ICpjKQo+ICt7Cj4gKwltYWxpZHBfd3JpdGUzMihjLT5yZWcsIEJM S19JTlBVVF9JRDAsIDApOwo+ICsJbWFsaWRwX3dyaXRlMzJfbWFzayhjLT5yZWcsIEJMS19DT05U Uk9MLCBMX0VOLCAwKTsKPiArfQo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBrb21lZGFfY29t cG9uZW50X2Z1bmNzIGQ3MV93Yl9sYXllcl9mdW5jcyA9IHsKPiArCS51cGRhdGUJCT0gZDcxX3di X2xheWVyX3VwZGF0ZSwKPiArCS5kaXNhYmxlCT0gZDcxX3diX2xheWVyX2Rpc2FibGUsCj4gKwku ZHVtcF9yZWdpc3Rlcgk9IGQ3MV93Yl9sYXllcl9kdW1wLAo+ICt9Owo+ICsKPiAgc3RhdGljIGlu dCBkNzFfd2JfbGF5ZXJfaW5pdChzdHJ1Y3QgZDcxX2RldiAqZDcxLAo+ICAJCQkgICAgIHN0cnVj dCBibG9ja19oZWFkZXIgKmJsaywgdTMyIF9faW9tZW0gKnJlZykKPiAgewo+IC0JRFJNX0RFQlVH KCJEZXRlY3QgRDcxX1diX0xheWVyLlxuIik7Cj4gKwlzdHJ1Y3Qga29tZWRhX2NvbXBvbmVudCAq YzsKPiArCXN0cnVjdCBrb21lZGFfbGF5ZXIgKndiX2xheWVyOwo+ICsJdTMyIHBpcGVfaWQsIGxh eWVyX2lkOwo+ICsKPiArCWdldF9yZXNvdXJjZXNfaWQoYmxrLT5ibG9ja19pbmZvLCAmcGlwZV9p ZCwgJmxheWVyX2lkKTsKPiArCj4gKwljID0ga29tZWRhX2NvbXBvbmVudF9hZGQoJmQ3MS0+cGlw ZXNbcGlwZV9pZF0tPmJhc2UsIHNpemVvZigqd2JfbGF5ZXIpLAo+ICsJCQkJIGxheWVyX2lkLCBC TE9DS19JTkZPX0lOUFVUX0lEKGJsay0+YmxvY2tfaW5mbyksCj4gKwkJCQkgJmQ3MV93Yl9sYXll cl9mdW5jcywKPiArCQkJCSAxLCBnZXRfdmFsaWRfaW5wdXRzKGJsayksIDAsIHJlZywKPiArCQkJ CSAiTFBVJWRfTEFZRVJfV1IiLCBwaXBlX2lkKTsKPiArCWlmIChJU19FUlIoYykpIHsKPiArCQlE Uk1fRVJST1IoIkZhaWxlZCB0byBhZGQgd2JfbGF5ZXIgY29tcG9uZW50XG4iKTsKPiArCQlyZXR1 cm4gUFRSX0VSUihjKTsKPiArCX0KPiArCj4gKwl3Yl9sYXllciA9IHRvX2xheWVyKGMpOwo+ICsJ d2JfbGF5ZXItPmxheWVyX3R5cGUgPSBLT01FREFfRk1UX1dCX0xBWUVSOwo+ICsKPiArCXNldF9y YW5nZSgmd2JfbGF5ZXItPmhzaXplX2luLCBENzFfTUlOX0xJTkVfU0laRSwgZDcxLT5tYXhfbGlu ZV9zaXplKTsKPiArCXNldF9yYW5nZSgmd2JfbGF5ZXItPnZzaXplX2luLCBENzFfTUlOX1ZFUlRJ Q0FMX1NJWkUsIGQ3MS0+bWF4X3ZzaXplKTsKPiAgCj4gIAlyZXR1cm4gMDsKPiAgfQo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYXJtL2Rpc3BsYXkva29tZWRhL2tvbWVkYV9jcnRjLmMg Yi9kcml2ZXJzL2dwdS9kcm0vYXJtL2Rpc3BsYXkva29tZWRhL2tvbWVkYV9jcnRjLmMKPiBpbmRl eCAyODRjZTA3OWQ4YzQuLjY3MTI2MDNiOGM3YSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9k cm0vYXJtL2Rpc3BsYXkva29tZWRhL2tvbWVkYV9jcnRjLmMKPiArKysgYi9kcml2ZXJzL2dwdS9k cm0vYXJtL2Rpc3BsYXkva29tZWRhL2tvbWVkYV9jcnRjLmMKPiBAQCAtMTY1LDYgKzE2NSwxNSBA QCB2b2lkIGtvbWVkYV9jcnRjX2hhbmRsZV9ldmVudChzdHJ1Y3Qga29tZWRhX2NydGMgICAqa2Ny dGMsCj4gIAlpZiAoZXZlbnRzICYgS09NRURBX0VWRU5UX1ZTWU5DKQo+ICAJCWRybV9jcnRjX2hh bmRsZV92YmxhbmsoY3J0Yyk7Cj4gIAo+ICsJaWYgKGV2ZW50cyAmIEtPTUVEQV9FVkVOVF9FT1cp IHsKPiArCQlzdHJ1Y3Qga29tZWRhX3diX2Nvbm5lY3RvciAqd2JfY29ubiA9IGtjcnRjLT53Yl9j b25uOwo+ICsKPiArCQlpZiAod2JfY29ubikKPiArCQkJZHJtX3dyaXRlYmFja19zaWduYWxfY29t cGxldGlvbigmd2JfY29ubi0+YmFzZSwgMCk7Cj4gKwkJZWxzZQo+ICsJCQlEUk1fV0FSTigiQ1JU Q1slZF06IEVPVyBoYXBwZW4gYnV0IG5vIHdiX2Nvbm5lY3Rvci5cbiIsCj4gKwkJCQkgZHJtX2Ny dGNfaW5kZXgoJmtjcnRjLT5iYXNlKSk7Cj4gKwl9Cj4gIAkvKiB3aWxsIGhhbmRsZSBpdCB0b2dl dGhlciB3aXRoIHRoZSB3cml0ZSBiYWNrIHN1cHBvcnQgKi8KPiAgCWlmIChldmVudHMgJiBLT01F REFfRVZFTlRfRU9XKQo+ICAJCURSTV9ERUJVRygiRU9XLlxuIik7Cj4gQEAgLTIwMSw2ICsyMTAs OCBAQCBrb21lZGFfY3J0Y19kb19mbHVzaChzdHJ1Y3QgZHJtX2NydGMgKmNydGMsCj4gIAlzdHJ1 Y3Qga29tZWRhX2NydGNfc3RhdGUgKmtjcnRjX3N0ID0gdG9fa2NydGNfc3QoY3J0Yy0+c3RhdGUp Owo+ICAJc3RydWN0IGtvbWVkYV9kZXYgKm1kZXYgPSBrY3J0Yy0+YmFzZS5kZXYtPmRldl9wcml2 YXRlOwo+ICAJc3RydWN0IGtvbWVkYV9waXBlbGluZSAqbWFzdGVyID0ga2NydGMtPm1hc3RlcjsK PiArCXN0cnVjdCBrb21lZGFfd2JfY29ubmVjdG9yICp3Yl9jb25uID0ga2NydGMtPndiX2Nvbm47 Cj4gKwlzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdDsKPiAgCj4gIAlEUk1fREVC VUdfQVRPTUlDKCJDUlRDJWRfRkxVU0g6IGFjdGl2ZV9waXBlczogMHgleCwgYWZmZWN0ZWQ6IDB4 JXguXG4iLAo+ICAJCQkgZHJtX2NydGNfaW5kZXgoY3J0YyksCj4gQEAgLTIxMCw2ICsyMjEsMTAg QEAga29tZWRhX2NydGNfZG9fZmx1c2goc3RydWN0IGRybV9jcnRjICpjcnRjLAo+ICAJaWYgKGhh c19iaXQobWFzdGVyLT5pZCwga2NydGNfc3QtPmFmZmVjdGVkX3BpcGVzKSkKPiAgCQlrb21lZGFf cGlwZWxpbmVfdXBkYXRlKG1hc3Rlciwgb2xkLT5zdGF0ZSk7Cj4gIAo+ICsJY29ubl9zdCA9IHdi X2Nvbm4gPyB3Yl9jb25uLT5iYXNlLmJhc2Uuc3RhdGUgOiBOVUxMOwo+ICsJaWYgKGNvbm5fc3Qg JiYgY29ubl9zdC0+d3JpdGViYWNrX2pvYikKPiArCQlkcm1fd3JpdGViYWNrX3F1ZXVlX2pvYigm d2JfY29ubi0+YmFzZSwgY29ubl9zdCk7Cj4gKwo+ICAJLyogc3RlcCAyOiBub3RpZnkgdGhlIEhX IHRvIGtpY2tvZmYgdGhlIHVwZGF0ZSAqLwo+ICAJbWRldi0+ZnVuY3MtPmZsdXNoKG1kZXYsIG1h c3Rlci0+aWQsIGtjcnRjX3N0LT5hY3RpdmVfcGlwZXMpOwo+ICB9Cj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21lZGEva29tZWRhX2ZyYW1lYnVmZmVyLmMgYi9k cml2ZXJzL2dwdS9kcm0vYXJtL2Rpc3BsYXkva29tZWRhL2tvbWVkYV9mcmFtZWJ1ZmZlci5jCj4g aW5kZXggOWNjOTkzNTAyNGY3Li40ZDgxNjBjZjA5YzMgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9n cHUvZHJtL2FybS9kaXNwbGF5L2tvbWVkYS9rb21lZGFfZnJhbWVidWZmZXIuYwo+ICsrKyBiL2Ry aXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21lZGEva29tZWRhX2ZyYW1lYnVmZmVyLmMKPiBA QCAtMTY1LDMgKzE2NSwyMiBAQCBrb21lZGFfZmJfZ2V0X3BpeGVsX2FkZHIoc3RydWN0IGtvbWVk YV9mYiAqa2ZiLCBpbnQgeCwgaW50IHksIGludCBwbGFuZSkKPiAgCj4gIAlyZXR1cm4gb2JqLT5w YWRkciArIG9mZnNldDsKPiAgfQo+ICsKPiArLyogaWYgdGhlIGZiIGNhbiBiZSBzdXBwb3J0ZWQg YnkgYSBzcGVjaWZpYyBsYXllciAqLwo+ICtib29sIGtvbWVkYV9mYl9pc19sYXllcl9zdXBwb3J0 ZWQoc3RydWN0IGtvbWVkYV9mYiAqa2ZiLCB1MzIgbGF5ZXJfdHlwZSkKPiArewo+ICsJc3RydWN0 IGRybV9mcmFtZWJ1ZmZlciAqZmIgPSAma2ZiLT5iYXNlOwo+ICsJc3RydWN0IGtvbWVkYV9kZXYg Km1kZXYgPSBmYi0+ZGV2LT5kZXZfcHJpdmF0ZTsKPiArCWNvbnN0IHN0cnVjdCBrb21lZGFfZm9y bWF0X2NhcHMgKmNhcHM7Cj4gKwl1MzIgZm91cmNjID0gZmItPmZvcm1hdC0+Zm9ybWF0Owo+ICsJ dTY0IG1vZGlmaWVyID0gZmItPm1vZGlmaWVyOwo+ICsKPiArCWNhcHMgPSBrb21lZGFfZ2V0X2Zv cm1hdF9jYXBzKCZtZGV2LT5mbXRfdGJsLCBmb3VyY2MsIG1vZGlmaWVyKTsKPiArCWlmICghY2Fw cykKPiArCQlyZXR1cm4gZmFsc2U7Cj4gKwo+ICsJaWYgKCEoY2Fwcy0+c3VwcG9ydGVkX2xheWVy X3R5cGVzICYgbGF5ZXJfdHlwZSkpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsKPiArCXJldHVybiB0 cnVlOwo+ICt9Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21l ZGEva29tZWRhX2ttcy5jIGIvZHJpdmVycy9ncHUvZHJtL2FybS9kaXNwbGF5L2tvbWVkYS9rb21l ZGFfa21zLmMKPiBpbmRleCA4NmY2NTQyYWZiNDAuLjNlNTg5MDFmYjc3NiAxMDA2NDQKPiAtLS0g YS9kcml2ZXJzL2dwdS9kcm0vYXJtL2Rpc3BsYXkva29tZWRhL2tvbWVkYV9rbXMuYwo+ICsrKyBi L2RyaXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21lZGEva29tZWRhX2ttcy5jCj4gQEAgLTE4 OCw2ICsxODgsMTAgQEAgc3RydWN0IGtvbWVkYV9rbXNfZGV2ICprb21lZGFfa21zX2F0dGFjaChz dHJ1Y3Qga29tZWRhX2RldiAqbWRldikKPiAgCWlmIChlcnIpCj4gIAkJZ290byBjbGVhbnVwX21v ZGVfY29uZmlnOwo+ICAKPiArCWVyciA9IGtvbWVkYV9rbXNfYWRkX3diX2Nvbm5lY3RvcnMoa21z LCBtZGV2KTsKPiArCWlmIChlcnIpCj4gKwkJZ290byBjbGVhbnVwX21vZGVfY29uZmlnOwo+ICsK PiAgCWVyciA9IGNvbXBvbmVudF9iaW5kX2FsbChtZGV2LT5kZXYsIGttcyk7Cj4gIAlpZiAoZXJy KQo+ICAJCWdvdG8gY2xlYW51cF9tb2RlX2NvbmZpZzsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL2FybS9kaXNwbGF5L2tvbWVkYS9rb21lZGFfa21zLmggYi9kcml2ZXJzL2dwdS9kcm0v YXJtL2Rpc3BsYXkva29tZWRhL2tvbWVkYV9rbXMuaAo+IGluZGV4IGFjM2Q5MjA5YjRkOS4uZjE2 ZTllNTc3NTkzIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21l ZGEva29tZWRhX2ttcy5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2FybS9kaXNwbGF5L2tvbWVk YS9rb21lZGFfa21zLmgKPiBAQCAtMTIsNiArMTIsNyBAQAo+ICAjaW5jbHVkZSA8ZHJtL2RybV9j cnRjX2hlbHBlci5oPgo+ICAjaW5jbHVkZSA8ZHJtL2RybV9kZXZpY2UuaD4KPiAgI2luY2x1ZGUg PGRybS9kcm1fd3JpdGViYWNrLmg+Cj4gKyNpbmNsdWRlIDxkcm0vZHJtX3ByaW50Lmg+Cj4gICNp bmNsdWRlIDx2aWRlby92aWRlb21vZGUuaD4KPiAgI2luY2x1ZGUgPHZpZGVvL2Rpc3BsYXlfdGlt aW5nLmg+Cj4gIAo+IEBAIC03Myw2ICs3NCw5IEBAIHN0cnVjdCBrb21lZGFfY3J0YyB7Cj4gIAkg Ki8KPiAgCXN0cnVjdCBrb21lZGFfcGlwZWxpbmUgKnNsYXZlOwo+ICAKPiArCS8qKiBAd2JfY29u bjoga29tZWRhIHdyaXRlIGJhY2sgY29ubmVjdG9yICovCj4gKwlzdHJ1Y3Qga29tZWRhX3diX2Nv bm5lY3RvciAqd2JfY29ubjsKPiArCj4gIAkvKiogQGRpc2FibGVfZG9uZTogdGhpcyBmbGlwX2Rv bmUgaXMgZm9yIHRyYWNpbmcgdGhlIGRpc2FibGUgKi8KPiAgCXN0cnVjdCBjb21wbGV0aW9uICpk aXNhYmxlX2RvbmU7Cj4gIH07Cj4gQEAgLTExNiw2ICsxMjAsMjcgQEAgc3RydWN0IGtvbWVkYV9r bXNfZGV2IHsKPiAgI2RlZmluZSB0b19rY3J0YyhwKQljb250YWluZXJfb2YocCwgc3RydWN0IGtv bWVkYV9jcnRjLCBiYXNlKQo+ICAjZGVmaW5lIHRvX2tjcnRjX3N0KHApCWNvbnRhaW5lcl9vZihw LCBzdHJ1Y3Qga29tZWRhX2NydGNfc3RhdGUsIGJhc2UpCj4gICNkZWZpbmUgdG9fa2RldihwKQlj b250YWluZXJfb2YocCwgc3RydWN0IGtvbWVkYV9rbXNfZGV2LCBiYXNlKQo+ICsjZGVmaW5lIHRv X3diX2Nvbm4oeCkJY29udGFpbmVyX29mKHgsIHN0cnVjdCBkcm1fd3JpdGViYWNrX2Nvbm5lY3Rv ciwgYmFzZSkKPiArCj4gK3N0YXRpYyBpbmxpbmUgYm9vbCBpc193cml0ZWJhY2tfb25seShzdHJ1 Y3QgZHJtX2NydGNfc3RhdGUgKnN0KQo+ICt7Cj4gKwlzdHJ1Y3Qga29tZWRhX3diX2Nvbm5lY3Rv ciAqd2JfY29ubiA9IHRvX2tjcnRjKHN0LT5jcnRjKS0+d2JfY29ubjsKPiArCXN0cnVjdCBkcm1f Y29ubmVjdG9yICpjb25uID0gd2JfY29ubiA/ICZ3Yl9jb25uLT5iYXNlLmJhc2UgOiBOVUxMOwo+ ICsKPiArCXJldHVybiBjb25uICYmIChzdC0+Y29ubmVjdG9yX21hc2sgPT0gQklUKGRybV9jb25u ZWN0b3JfaW5kZXgoY29ubikpKTsKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSBib29sCj4gK2lz X29ubHlfY2hhbmdlZF9jb25uZWN0b3Ioc3RydWN0IGRybV9jcnRjX3N0YXRlICpzdCwgc3RydWN0 IGRybV9jb25uZWN0b3IgKmNvbm4pCj4gK3sKPiArCXN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqb2xk X3N0Owo+ICsJdTMyIGNoYW5nZWRfY29ubmVjdG9yczsKPiArCj4gKwlvbGRfc3QgPSBkcm1fYXRv bWljX2dldF9vbGRfY3J0Y19zdGF0ZShzdC0+c3RhdGUsIHN0LT5jcnRjKTsKPiArCWNoYW5nZWRf Y29ubmVjdG9ycyA9IHN0LT5jb25uZWN0b3JfbWFzayBeIG9sZF9zdC0+Y29ubmVjdG9yX21hc2s7 Cj4gKwo+ICsJcmV0dXJuIEJJVChkcm1fY29ubmVjdG9yX2luZGV4KGNvbm4pKSA9PSBjaGFuZ2Vk X2Nvbm5lY3RvcnM7Cj4gK30KPiAgCj4gIGludCBrb21lZGFfa21zX3NldHVwX2NydGNzKHN0cnVj dCBrb21lZGFfa21zX2RldiAqa21zLCBzdHJ1Y3Qga29tZWRhX2RldiAqbWRldik7Cj4gIAo+IEBA IC0xMjMsNiArMTQ4LDggQEAgaW50IGtvbWVkYV9rbXNfYWRkX2NydGNzKHN0cnVjdCBrb21lZGFf a21zX2RldiAqa21zLCBzdHJ1Y3Qga29tZWRhX2RldiAqbWRldik7Cj4gIGludCBrb21lZGFfa21z X2FkZF9wbGFuZXMoc3RydWN0IGtvbWVkYV9rbXNfZGV2ICprbXMsIHN0cnVjdCBrb21lZGFfZGV2 ICptZGV2KTsKPiAgaW50IGtvbWVkYV9rbXNfYWRkX3ByaXZhdGVfb2JqcyhzdHJ1Y3Qga29tZWRh X2ttc19kZXYgKmttcywKPiAgCQkJCXN0cnVjdCBrb21lZGFfZGV2ICptZGV2KTsKPiAraW50IGtv bWVkYV9rbXNfYWRkX3diX2Nvbm5lY3RvcnMoc3RydWN0IGtvbWVkYV9rbXNfZGV2ICprbXMsCj4g KwkJCQkgc3RydWN0IGtvbWVkYV9kZXYgKm1kZXYpOwo+ICB2b2lkIGtvbWVkYV9rbXNfY2xlYW51 cF9wcml2YXRlX29ianMoc3RydWN0IGtvbWVkYV9rbXNfZGV2ICprbXMpOwo+ICAKPiAgdm9pZCBr b21lZGFfY3J0Y19oYW5kbGVfZXZlbnQoc3RydWN0IGtvbWVkYV9jcnRjICAgKmtjcnRjLAo+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYXJtL2Rpc3BsYXkva29tZWRhL2tvbWVkYV9waXBl bGluZS5oIGIvZHJpdmVycy9ncHUvZHJtL2FybS9kaXNwbGF5L2tvbWVkYS9rb21lZGFfcGlwZWxp bmUuaAo+IGluZGV4IGJhZThhMzJiODFhNi4uMWI3ZTkzM2VhMzAzIDEwMDY0NAo+IC0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21lZGEva29tZWRhX3BpcGVsaW5lLmgKPiArKysg Yi9kcml2ZXJzL2dwdS9kcm0vYXJtL2Rpc3BsYXkva29tZWRhL2tvbWVkYV9waXBlbGluZS5oCj4g QEAgLTQyMywxMCArNDIzLDE3IEBAIHN0cnVjdCBrb21lZGFfcGxhbmVfc3RhdGU7Cj4gIHN0cnVj dCBrb21lZGFfY3J0Y19zdGF0ZTsKPiAgc3RydWN0IGtvbWVkYV9jcnRjOwo+ICAKPiArdm9pZCBw aXBlbGluZV9jb21wb3NpdGlvbl9zaXplKHN0cnVjdCBrb21lZGFfY3J0Y19zdGF0ZSAqa2NydGNf c3QsCj4gKwkJCSAgICAgICB1MTYgKmhzaXplLCB1MTYgKnZzaXplKTsKPiArCj4gIGludCBrb21l ZGFfYnVpbGRfbGF5ZXJfZGF0YV9mbG93KHN0cnVjdCBrb21lZGFfbGF5ZXIgKmxheWVyLAo+ICAJ CQkJIHN0cnVjdCBrb21lZGFfcGxhbmVfc3RhdGUgKmtwbGFuZV9zdCwKPiAgCQkJCSBzdHJ1Y3Qg a29tZWRhX2NydGNfc3RhdGUgKmtjcnRjX3N0LAo+ICAJCQkJIHN0cnVjdCBrb21lZGFfZGF0YV9m bG93X2NmZyAqZGZsb3cpOwo+ICtpbnQga29tZWRhX2J1aWxkX3diX2RhdGFfZmxvdyhzdHJ1Y3Qg a29tZWRhX2xheWVyICp3Yl9sYXllciwKPiArCQkJICAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jf c3RhdGUgKmNvbm5fc3QsCj4gKwkJCSAgICAgIHN0cnVjdCBrb21lZGFfY3J0Y19zdGF0ZSAqa2Ny dGNfc3QsCj4gKwkJCSAgICAgIHN0cnVjdCBrb21lZGFfZGF0YV9mbG93X2NmZyAqZGZsb3cpOwo+ ICBpbnQga29tZWRhX2J1aWxkX2Rpc3BsYXlfZGF0YV9mbG93KHN0cnVjdCBrb21lZGFfY3J0YyAq a2NydGMsCj4gIAkJCQkgICBzdHJ1Y3Qga29tZWRhX2NydGNfc3RhdGUgKmtjcnRjX3N0KTsKPiAg Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21lZGEva29tZWRh X3BpcGVsaW5lX3N0YXRlLmMgYi9kcml2ZXJzL2dwdS9kcm0vYXJtL2Rpc3BsYXkva29tZWRhL2tv bWVkYV9waXBlbGluZV9zdGF0ZS5jCj4gaW5kZXggMzY1NzBkN2RhZDYxLi45NzQ4Yzk0Mzg4Njgg MTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2FybS9kaXNwbGF5L2tvbWVkYS9rb21lZGFf cGlwZWxpbmVfc3RhdGUuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21l ZGEva29tZWRhX3BpcGVsaW5lX3N0YXRlLmMKPiBAQCAtMzA4LDggKzMwOCw0MSBAQCBrb21lZGFf bGF5ZXJfdmFsaWRhdGUoc3RydWN0IGtvbWVkYV9sYXllciAqbGF5ZXIsCj4gIAlyZXR1cm4gMDsK PiAgfQo+ICAKPiAtc3RhdGljIHZvaWQgcGlwZWxpbmVfY29tcG9zaXRpb25fc2l6ZShzdHJ1Y3Qg a29tZWRhX2NydGNfc3RhdGUgKmtjcnRjX3N0LAo+IC0JCQkJICAgICAgdTE2ICpoc2l6ZSwgdTE2 ICp2c2l6ZSkKPiArc3RhdGljIGludAo+ICtrb21lZGFfd2JfbGF5ZXJfdmFsaWRhdGUoc3RydWN0 IGtvbWVkYV9sYXllciAqd2JfbGF5ZXIsCj4gKwkJCSBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0 ZSAqY29ubl9zdCwKPiArCQkJIHN0cnVjdCBrb21lZGFfZGF0YV9mbG93X2NmZyAqZGZsb3cpCj4g K3sKPiArCXN0cnVjdCBrb21lZGFfZmIgKmtmYiA9IHRvX2tmYihjb25uX3N0LT53cml0ZWJhY2tf am9iLT5mYik7Cj4gKwlzdHJ1Y3Qga29tZWRhX2NvbXBvbmVudF9zdGF0ZSAqY19zdDsKPiArCXN0 cnVjdCBrb21lZGFfbGF5ZXJfc3RhdGUgKnN0Owo+ICsJaW50IGk7Cj4gKwo+ICsJaWYgKCFrb21l ZGFfZmJfaXNfbGF5ZXJfc3VwcG9ydGVkKGtmYiwgd2JfbGF5ZXItPmxheWVyX3R5cGUpKQo+ICsJ CXJldHVybiAtRUlOVkFMOwo+ICsKPiArCWNfc3QgPSBrb21lZGFfY29tcG9uZW50X2dldF9zdGF0 ZV9hbmRfc2V0X3VzZXIoJndiX2xheWVyLT5iYXNlLAo+ICsJCQljb25uX3N0LT5zdGF0ZSwgY29u bl9zdC0+Y29ubmVjdG9yLCBjb25uX3N0LT5jcnRjKTsKPiArCWlmIChJU19FUlIoY19zdCkpCj4g KwkJcmV0dXJuIFBUUl9FUlIoY19zdCk7Cj4gKwo+ICsJc3QgPSB0b19sYXllcl9zdChjX3N0KTsK PiArCj4gKwlzdC0+aHNpemUgPSBkZmxvdy0+b3V0X3c7Cj4gKwlzdC0+dnNpemUgPSBkZmxvdy0+ b3V0X2g7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IGtmYi0+YmFzZS5mb3JtYXQtPm51bV9wbGFu ZXM7IGkrKykKPiArCQlzdC0+YWRkcltpXSA9IGtvbWVkYV9mYl9nZXRfcGl4ZWxfYWRkcihrZmIs IGRmbG93LT5vdXRfeCwKPiArCQkJCQkJICAgICAgIGRmbG93LT5vdXRfeSwgaSk7Cj4gKwo+ICsJ a29tZWRhX2NvbXBvbmVudF9hZGRfaW5wdXQoJnN0LT5iYXNlLCAmZGZsb3ctPmlucHV0LCAwKTsK PiArCWtvbWVkYV9jb21wb25lbnRfc2V0X291dHB1dCgmZGZsb3ctPmlucHV0LCAmd2JfbGF5ZXIt PmJhc2UsIDApOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICt2b2lkIHBpcGVsaW5lX2Nv bXBvc2l0aW9uX3NpemUoc3RydWN0IGtvbWVkYV9jcnRjX3N0YXRlICprY3J0Y19zdCwKPiArCQkJ ICAgICAgIHUxNiAqaHNpemUsIHUxNiAqdnNpemUpCj4gIHsKPiAgCXN0cnVjdCBkcm1fZGlzcGxh eV9tb2RlICptID0gJmtjcnRjX3N0LT5iYXNlLmFkanVzdGVkX21vZGU7Cj4gIAo+IEBAIC00Nzgs NiArNTExLDIwIEBAIGludCBrb21lZGFfYnVpbGRfbGF5ZXJfZGF0YV9mbG93KHN0cnVjdCBrb21l ZGFfbGF5ZXIgKmxheWVyLAo+ICAJcmV0dXJuIGVycjsKPiAgfQo+ICAKPiAraW50IGtvbWVkYV9i dWlsZF93Yl9kYXRhX2Zsb3coc3RydWN0IGtvbWVkYV9sYXllciAqd2JfbGF5ZXIsCj4gKwkJCSAg ICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0LAo+ICsJCQkgICAgICBzdHJ1 Y3Qga29tZWRhX2NydGNfc3RhdGUgKmtjcnRjX3N0LAo+ICsJCQkgICAgICBzdHJ1Y3Qga29tZWRh X2RhdGFfZmxvd19jZmcgKmRmbG93KQo+ICt7Cj4gKwlpZiAoKGRmbG93LT5pbl93ICE9IGRmbG93 LT5vdXRfdykgfHwKPiArCSAgICAoZGZsb3ctPmluX2ggIT0gZGZsb3ctPm91dF9oKSkgewo+ICsJ CURSTV9ERUJVR19BVE9NSUMoImN1cnJlbnQgZG8gbm90IHN1cHBvcnQgc2NhbGluZyB3cml0ZWJh Y2suXG4iKTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwlyZXR1cm4ga29tZWRh X3diX2xheWVyX3ZhbGlkYXRlKHdiX2xheWVyLCBjb25uX3N0LCBkZmxvdyk7Cj4gK30KPiArCj4g IC8qIGJ1aWxkIGRpc3BsYXkgb3V0cHV0IGRhdGEgZmxvdywgdGhlIGRhdGEgcGF0aCBpczoKPiAg ICogY29tcGl6IC0+IGltcHJvYyAtPiB0aW1pbmdfY3RybHIKPiAgICovCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21lZGEva29tZWRhX3ByaXZhdGVfb2JqLmMg Yi9kcml2ZXJzL2dwdS9kcm0vYXJtL2Rpc3BsYXkva29tZWRhL2tvbWVkYV9wcml2YXRlX29iai5j Cj4gaW5kZXggYTU0ODc4Y2JkNmU0Li5kNTNiZDZjMjNjNWQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2FybS9kaXNwbGF5L2tvbWVkYS9rb21lZGFfcHJpdmF0ZV9vYmouYwo+ICsrKyBi L2RyaXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21lZGEva29tZWRhX3ByaXZhdGVfb2JqLmMK PiBAQCAtMjUyLDYgKzI1MiwxMiBAQCBpbnQga29tZWRhX2ttc19hZGRfcHJpdmF0ZV9vYmpzKHN0 cnVjdCBrb21lZGFfa21zX2RldiAqa21zLAo+ICAJCQkJcmV0dXJuIGVycjsKPiAgCQl9Cj4gIAo+ ICsJCWlmIChwaXBlLT53Yl9sYXllcikgewo+ICsJCQllcnIgPSBrb21lZGFfbGF5ZXJfb2JqX2Fk ZChrbXMsIHBpcGUtPndiX2xheWVyKTsKPiArCQkJaWYgKGVycikKPiArCQkJCXJldHVybiBlcnI7 Cj4gKwkJfQo+ICsKPiAgCQllcnIgPSBrb21lZGFfY29tcGl6X29ial9hZGQoa21zLCBwaXBlLT5j b21waXopOwo+ICAJCWlmIChlcnIpCj4gIAkJCXJldHVybiBlcnI7Cj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21lZGEva29tZWRhX3diX2Nvbm5lY3Rvci5jIGIv ZHJpdmVycy9ncHUvZHJtL2FybS9kaXNwbGF5L2tvbWVkYS9rb21lZGFfd2JfY29ubmVjdG9yLmMK PiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uMGMxYTQyMjBjMjgw Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hcm0vZGlzcGxheS9rb21l ZGEva29tZWRhX3diX2Nvbm5lY3Rvci5jCj4gQEAgLTAsMCArMSwxODEgQEAKPiArLy8gU1BEWC1M aWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiArLyoKPiArICogKEMpIENPUFlSSUdIVCAyMDE4 IEFSTSBMaW1pdGVkLiBBbGwgcmlnaHRzIHJlc2VydmVkLgo+ICsgKiBBdXRob3I6IEphbWVzLlFp YW4uV2FuZyA8amFtZXMucWlhbi53YW5nQGFybS5jb20+Cj4gKyAqCj4gKyAqLwo+ICsjaW5jbHVk ZSAia29tZWRhX2Rldi5oIgo+ICsjaW5jbHVkZSAia29tZWRhX2ttcy5oIgo+ICsKPiArc3RhdGlj IGludAo+ICtrb21lZGFfd2JfaW5pdF9kYXRhX2Zsb3coc3RydWN0IGtvbWVkYV9sYXllciAqd2Jf bGF5ZXIsCj4gKwkJCSBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdCwKPiArCQkJ IHN0cnVjdCBrb21lZGFfY3J0Y19zdGF0ZSAqa2NydGNfc3QsCj4gKwkJCSBzdHJ1Y3Qga29tZWRh X2RhdGFfZmxvd19jZmcgKmRmbG93KQo+ICt7Cj4gKwlzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpm YiA9IGNvbm5fc3QtPndyaXRlYmFja19qb2IgPwo+ICsJCQkJICAgICBjb25uX3N0LT53cml0ZWJh Y2tfam9iLT5mYiA6IE5VTEw7Cj4gKwo+ICsJaWYgKCFmYikKPiArCQlyZXR1cm4gLUVJTlZBTDsK PiArCj4gKwltZW1zZXQoZGZsb3csIDAsIHNpemVvZigqZGZsb3cpKTsKPiArCj4gKwlkZmxvdy0+ b3V0X3cgPSBmYi0+d2lkdGg7Cj4gKwlkZmxvdy0+b3V0X2ggPSBmYi0+aGVpZ2h0Owo+ICsKPiAr CS8qIHRoZSB3cml0ZSBiYWNrIGRhdGEgY29tZXMgZnJvbSB0aGUgY29tcGl6ICovCj4gKwlwaXBl bGluZV9jb21wb3NpdGlvbl9zaXplKGtjcnRjX3N0LCAmZGZsb3ctPmluX3csICZkZmxvdy0+aW5f aCk7Cj4gKwlkZmxvdy0+aW5wdXQuY29tcG9uZW50ID0gJndiX2xheWVyLT5iYXNlLnBpcGVsaW5l LT5jb21waXotPmJhc2U7Cj4gKwkvKiBjb21waXogZG9lc24ndCBvdXRwdXQgYWxwaGEgKi8KPiAr CWRmbG93LT5waXhlbF9ibGVuZF9tb2RlID0gRFJNX01PREVfQkxFTkRfUElYRUxfTk9ORTsKPiAr CWRmbG93LT5yb3QgPSBEUk1fTU9ERV9ST1RBVEVfMDsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ ICsKPiArc3RhdGljIGludAo+ICtrb21lZGFfd2JfZW5jb2Rlcl9hdG9taWNfY2hlY2soc3RydWN0 IGRybV9lbmNvZGVyICplbmNvZGVyLAo+ICsJCQkgICAgICAgc3RydWN0IGRybV9jcnRjX3N0YXRl ICpjcnRjX3N0LAo+ICsJCQkgICAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5f c3QpCj4gK3sKPiArCXN0cnVjdCBrb21lZGFfY3J0Y19zdGF0ZSAqa2NydGNfc3QgPSB0b19rY3J0 Y19zdChjcnRjX3N0KTsKPiArCXN0cnVjdCBrb21lZGFfbGF5ZXIgKndiX2xheWVyOwo+ICsJc3Ry dWN0IGtvbWVkYV9kYXRhX2Zsb3dfY2ZnIGRmbG93Owo+ICsJaW50IGVycjsKPiArCj4gKwlpZiAo IWNydGNfc3QtPmFjdGl2ZSkgewo+ICsJCURSTV9ERUJVR19BVE9NSUMoIkNhbm5vdCB3cml0ZSB0 aGUgY29tcG9zaXRpb24gcmVzdWx0IG91dCBvbiBhIGluYWN0aXZlIENSVEMuXG4iKTsKPiArCQly ZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwl3Yl9sYXllciA9IHRvX2tjb25uKHRvX3diX2Nv bm4oY29ubl9zdC0+Y29ubmVjdG9yKSktPndiX2xheWVyOwo+ICsKPiArCS8qCj4gKwkgKiBObyBu ZWVkIGZvciBhIGZ1bGwgbW9kZXN0ZWQgd2hlbiB0aGUgb25seSBjb25uZWN0b3IgY2hhbmdlZCBp cyB0aGUKPiArCSAqIHdyaXRlYmFjayBjb25uZWN0b3IuCj4gKwkgKi8KPiArCWlmIChjcnRjX3N0 LT5jb25uZWN0b3JzX2NoYW5nZWQgJiYKPiArCSAgICBpc19vbmx5X2NoYW5nZWRfY29ubmVjdG9y KGNydGNfc3QsIGNvbm5fc3QtPmNvbm5lY3RvcikpCj4gKwkJY3J0Y19zdC0+Y29ubmVjdG9yc19j aGFuZ2VkID0gZmFsc2U7Cj4gKwo+ICsJZXJyID0ga29tZWRhX3diX2luaXRfZGF0YV9mbG93KHdi X2xheWVyLCBjb25uX3N0LCBrY3J0Y19zdCwgJmRmbG93KTsKPiArCWlmIChlcnIpCj4gKwkJcmV0 dXJuIGVycjsKPiArCj4gKwlyZXR1cm4ga29tZWRhX2J1aWxkX3diX2RhdGFfZmxvdyh3Yl9sYXll ciwgY29ubl9zdCwga2NydGNfc3QsICZkZmxvdyk7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBz dHJ1Y3QgZHJtX2VuY29kZXJfaGVscGVyX2Z1bmNzIGtvbWVkYV93Yl9lbmNvZGVyX2hlbHBlcl9m dW5jcyA9IHsKPiArCS5hdG9taWNfY2hlY2sgPSBrb21lZGFfd2JfZW5jb2Rlcl9hdG9taWNfY2hl Y2ssCj4gK307Cj4gKwo+ICtzdGF0aWMgaW50Cj4gK2tvbWVkYV93Yl9jb25uZWN0b3JfZ2V0X21v ZGVzKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IpCj4gK3sKPiArCXJldHVybiAwOwo+ ICt9Cj4gKwo+ICtzdGF0aWMgZW51bSBkcm1fbW9kZV9zdGF0dXMKPiAra29tZWRhX3diX2Nvbm5l Y3Rvcl9tb2RlX3ZhbGlkKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCj4gKwkJCSAg ICAgICBzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZSkKPiArewo+ICsJc3RydWN0IGRybV9k ZXZpY2UgKmRldiA9IGNvbm5lY3Rvci0+ZGV2Owo+ICsJc3RydWN0IGRybV9tb2RlX2NvbmZpZyAq bW9kZV9jb25maWcgPSAmZGV2LT5tb2RlX2NvbmZpZzsKPiArCWludCB3ID0gbW9kZS0+aGRpc3Bs YXksIGggPSBtb2RlLT52ZGlzcGxheTsKPiArCj4gKwlpZiAoKHcgPCBtb2RlX2NvbmZpZy0+bWlu X3dpZHRoKSB8fCAodyA+IG1vZGVfY29uZmlnLT5tYXhfd2lkdGgpKQo+ICsJCXJldHVybiBNT0RF X0JBRF9IVkFMVUU7Cj4gKwo+ICsJaWYgKChoIDwgbW9kZV9jb25maWctPm1pbl9oZWlnaHQpIHx8 IChoID4gbW9kZV9jb25maWctPm1heF9oZWlnaHQpKQo+ICsJCXJldHVybiBNT0RFX0JBRF9WVkFM VUU7Cj4gKwo+ICsJcmV0dXJuIE1PREVfT0s7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1 Y3QgZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3Mga29tZWRhX3diX2Nvbm5faGVscGVyX2Z1bmNz ID0gewo+ICsJLmdldF9tb2Rlcwk9IGtvbWVkYV93Yl9jb25uZWN0b3JfZ2V0X21vZGVzLAo+ICsJ Lm1vZGVfdmFsaWQJPSBrb21lZGFfd2JfY29ubmVjdG9yX21vZGVfdmFsaWQsCj4gK307Cj4gKwo+ ICtzdGF0aWMgZW51bSBkcm1fY29ubmVjdG9yX3N0YXR1cwo+ICtrb21lZGFfd2JfY29ubmVjdG9y X2RldGVjdChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLCBib29sIGZvcmNlKQo+ICt7 Cj4gKwlyZXR1cm4gY29ubmVjdG9yX3N0YXR1c19jb25uZWN0ZWQ7Cj4gK30KPiArCj4gK3N0YXRp YyBpbnQKPiAra29tZWRhX3diX2Nvbm5lY3Rvcl9maWxsX21vZGVzKHN0cnVjdCBkcm1fY29ubmVj dG9yICpjb25uZWN0b3IsCj4gKwkJCSAgICAgICB1aW50MzJfdCBtYXhYLCB1aW50MzJfdCBtYXhZ KQo+ICt7Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQga29tZWRhX3diX2Nv bm5lY3Rvcl9kZXN0cm95KHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IpCj4gK3sKPiAr CWRybV9jb25uZWN0b3JfY2xlYW51cChjb25uZWN0b3IpOwo+ICsJa2ZyZWUodG9fa2Nvbm4odG9f d2JfY29ubihjb25uZWN0b3IpKSk7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJt X2Nvbm5lY3Rvcl9mdW5jcyBrb21lZGFfd2JfY29ubmVjdG9yX2Z1bmNzID0gewo+ICsJLnJlc2V0 CQkJPSBkcm1fYXRvbWljX2hlbHBlcl9jb25uZWN0b3JfcmVzZXQsCj4gKwkuZGV0ZWN0CQkJPSBr b21lZGFfd2JfY29ubmVjdG9yX2RldGVjdCwKPiArCS5maWxsX21vZGVzCQk9IGtvbWVkYV93Yl9j b25uZWN0b3JfZmlsbF9tb2RlcywKPiArCS5kZXN0cm95CQk9IGtvbWVkYV93Yl9jb25uZWN0b3Jf ZGVzdHJveSwKPiArCS5hdG9taWNfZHVwbGljYXRlX3N0YXRlCT0gZHJtX2F0b21pY19oZWxwZXJf Y29ubmVjdG9yX2R1cGxpY2F0ZV9zdGF0ZSwKPiArCS5hdG9taWNfZGVzdHJveV9zdGF0ZQk9IGRy bV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9kZXN0cm95X3N0YXRlLAo+ICt9Owo+ICsKPiArc3Rh dGljIGludCBrb21lZGFfd2JfY29ubmVjdG9yX2FkZChzdHJ1Y3Qga29tZWRhX2ttc19kZXYgKmtt cywKPiArCQkJCSAgIHN0cnVjdCBrb21lZGFfY3J0YyAqa2NydGMpCj4gK3sKPiArCXN0cnVjdCBr b21lZGFfZGV2ICptZGV2ID0ga21zLT5iYXNlLmRldl9wcml2YXRlOwo+ICsJc3RydWN0IGtvbWVk YV93Yl9jb25uZWN0b3IgKmt3Yl9jb25uOwo+ICsJc3RydWN0IGRybV93cml0ZWJhY2tfY29ubmVj dG9yICp3Yl9jb25uOwo+ICsJdTMyICpmb3JtYXRzLCBuX2Zvcm1hdHMgPSAwOwo+ICsJaW50IGVy cjsKPiArCj4gKwlpZiAoIWtjcnRjLT5tYXN0ZXItPndiX2xheWVyKQo+ICsJCXJldHVybiAwOwo+ ICsKPiArCWt3Yl9jb25uID0ga3phbGxvYyhzaXplb2YoKndiX2Nvbm4pLCBHRlBfS0VSTkVMKTsK PiArCWlmICgha3diX2Nvbm4pCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJa3diX2Nvbm4t PndiX2xheWVyID0ga2NydGMtPm1hc3Rlci0+d2JfbGF5ZXI7Cj4gKwo+ICsJd2JfY29ubiA9ICZr d2JfY29ubi0+YmFzZTsKPiArCXdiX2Nvbm4tPmVuY29kZXIucG9zc2libGVfY3J0Y3MgPSBCSVQo ZHJtX2NydGNfaW5kZXgoJmtjcnRjLT5iYXNlKSk7Cj4gKwo+ICsJZm9ybWF0cyA9IGtvbWVkYV9n ZXRfbGF5ZXJfZm91cmNjX2xpc3QoJm1kZXYtPmZtdF90YmwsCj4gKwkJCQkJICAgICAgIGt3Yl9j b25uLT53Yl9sYXllci0+bGF5ZXJfdHlwZSwKPiArCQkJCQkgICAgICAgJm5fZm9ybWF0cyk7Cj4g Kwo+ICsJZXJyID0gZHJtX3dyaXRlYmFja19jb25uZWN0b3JfaW5pdCgma21zLT5iYXNlLCB3Yl9j b25uLAo+ICsJCQkJCSAgICZrb21lZGFfd2JfY29ubmVjdG9yX2Z1bmNzLAo+ICsJCQkJCSAgICZr b21lZGFfd2JfZW5jb2Rlcl9oZWxwZXJfZnVuY3MsCj4gKwkJCQkJICAgZm9ybWF0cywgbl9mb3Jt YXRzKTsKPiArCWtvbWVkYV9wdXRfZm91cmNjX2xpc3QoZm9ybWF0cyk7Cj4gKwlpZiAoZXJyKQo+ ICsJCXJldHVybiBlcnI7Cj4gKwo+ICsJZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfYWRkKCZ3Yl9jb25u LT5iYXNlLCAma29tZWRhX3diX2Nvbm5faGVscGVyX2Z1bmNzKTsKPiArCj4gKwlrY3J0Yy0+d2Jf Y29ubiA9IGt3Yl9jb25uOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtpbnQga29tZWRh X2ttc19hZGRfd2JfY29ubmVjdG9ycyhzdHJ1Y3Qga29tZWRhX2ttc19kZXYgKmttcywKPiArCQkJ CSBzdHJ1Y3Qga29tZWRhX2RldiAqbWRldikKPiArewo+ICsJaW50IGksIGVycjsKPiArCj4gKwlm b3IgKGkgPSAwOyBpIDwga21zLT5uX2NydGNzOyBpKyspIHsKPiArCQllcnIgPSBrb21lZGFfd2Jf Y29ubmVjdG9yX2FkZChrbXMsICZrbXMtPmNydGNzW2ldKTsKPiArCQlpZiAoZXJyKQo+ICsJCQly ZXR1cm4gZXJyOwo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gLS0gCmxndG0sIEFja2Vk LWJ5OiBBeWFuIEt1bWFyIEhhbGRlciA8YXlhbi5oYWxkZXJAYXJtLmNvbT4KPiAyLjE3LjEKPiAK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVs IG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlz dHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 016E7C072B5 for ; Fri, 24 May 2019 10:25:41 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 99D6D20815 for ; Fri, 24 May 2019 10:25:41 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=armh.onmicrosoft.com header.i=@armh.onmicrosoft.com header.b="OFG3LNFD" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2390302AbfEXKZk (ORCPT ); Fri, 24 May 2019 06:25:40 -0400 Received: from mail-eopbgr70041.outbound.protection.outlook.com ([40.107.7.41]:14143 "EHLO EUR04-HE1-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S2389616AbfEXKZk (ORCPT ); Fri, 24 May 2019 06:25:40 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector2-armh-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=I5O8Y4tJtRGq1p2fifr81wwBM/ScK0zy18izZQdBeBA=; b=OFG3LNFD/tW2ACUq002l3C4lrEGl5mGsYBD+aWIj8WyTHokZgIWK29t3/krMTOtlSxNBY1RQQBQP5MRUnQm9posH73XMRhutIh9KPOYOiaqfn0M92qAWtWKG8zlmZYQCUnM4A9T3Acmpt24XSMjF+gHCuQ/FzyI1l3oJMbfbl1E= Received: from AM0PR08MB3891.eurprd08.prod.outlook.com (20.178.82.147) by AM0PR08MB5153.eurprd08.prod.outlook.com (10.255.31.14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.1900.18; Fri, 24 May 2019 10:25:31 +0000 Received: from AM0PR08MB3891.eurprd08.prod.outlook.com ([fe80::edcb:1ae:f84c:422a]) by AM0PR08MB3891.eurprd08.prod.outlook.com ([fe80::edcb:1ae:f84c:422a%2]) with mapi id 15.20.1922.016; Fri, 24 May 2019 10:25:31 +0000 From: Ayan Halder To: "james qian wang (Arm Technology China)" CC: Liviu Dudau , "airlied@linux.ie" , Brian Starkey , "maarten.lankhorst@linux.intel.com" , "sean@poorly.run" , "Jonathan Chai (Arm Technology China)" , "Julien Yin (Arm Technology China)" , "thomas Sun (Arm Technology China)" , "Lowry Li (Arm Technology China)" , "Tiannan Zhu (Arm Technology China)" , "Yiqi Kang (Arm Technology China)" , nd , "linux-kernel@vger.kernel.org" , "dri-devel@lists.freedesktop.org" , Ben Davis , "Oscar Zhang (Arm Technology China)" , "Channing Chen (Arm Technology China)" Subject: Re: [PATCH v4] drm/komeda: Add writeback support Thread-Topic: [PATCH v4] drm/komeda: Add writeback support Thread-Index: AQHVEUsF8jXyOBIZmEuSifirtZkr8qZ6E28A Date: Fri, 24 May 2019 10:25:31 +0000 Message-ID: <20190524102530.GA25679@arm.com> References: <20190523093618.24483-1-james.qian.wang@arm.com> In-Reply-To: <20190523093618.24483-1-james.qian.wang@arm.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-clientproxiedby: LO2P265CA0038.GBRP265.PROD.OUTLOOK.COM (2603:10a6:600:61::26) To AM0PR08MB3891.eurprd08.prod.outlook.com (2603:10a6:208:109::19) authentication-results: spf=none (sender IP is ) smtp.mailfrom=Ayan.Halder@arm.com; x-ms-exchange-messagesentrepresentingtype: 1 x-originating-ip: [217.140.106.52] x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: c1da950c-c13d-4593-2e89-08d6e03225f0 x-ms-office365-filtering-ht: Tenant x-microsoft-antispam: BCL:0;PCL:0;RULEID:(2390118)(7020095)(4652040)(8989299)(4534185)(4627221)(201703031133081)(201702281549075)(8990200)(5600141)(711020)(4605104)(4618075)(2017052603328)(7193020);SRVR:AM0PR08MB5153; x-ms-traffictypediagnostic: AM0PR08MB5153: x-ms-exchange-purlcount: 1 nodisclaimer: True x-microsoft-antispam-prvs: x-ms-oob-tlc-oobclassifiers: OLM:10000; x-forefront-prvs: 0047BC5ADE x-forefront-antispam-report: SFV:NSPM;SFS:(10009020)(979002)(39860400002)(376002)(366004)(346002)(136003)(396003)(189003)(199004)(478600001)(73956011)(52116002)(81156014)(81166006)(76176011)(966005)(8936002)(8676002)(66476007)(86362001)(66446008)(64756008)(66556008)(4326008)(7736002)(14454004)(316002)(37006003)(72206003)(68736007)(6862004)(33656002)(305945005)(6512007)(6306002)(99286004)(25786009)(66946007)(54906003)(53946003)(6506007)(6436002)(53936002)(186003)(6246003)(386003)(6486002)(1076003)(26005)(102836004)(229853002)(14444005)(256004)(6636002)(5660300002)(30864003)(486006)(3846002)(476003)(44832011)(2906002)(36756003)(11346002)(2616005)(5024004)(66066001)(71200400001)(71190400001)(446003)(6116002)(579004)(969003)(989001)(999001)(1009001)(1019001);DIR:OUT;SFP:1101;SCL:1;SRVR:AM0PR08MB5153;H:AM0PR08MB3891.eurprd08.prod.outlook.com;FPR:;SPF:None;LANG:en;PTR:InfoNoRecords;MX:1;A:1; received-spf: None (protection.outlook.com: arm.com does not designate permitted sender hosts) x-ms-exchange-senderadcheck: 1 x-microsoft-antispam-message-info: sTFsf1Sq4glfFbjMsMDW+vfkXRskVQvVcgPIfkcjk7rSEGxvcHvG8Em2I3+Z+fYWhgIFQEF7ApZEIOa4YeqIWlvHp1jxNoGycMQ75luXFVhs2gFq90t8k81KRYvb6BQ16uSc70EIa3SNCNo6f8zfJxAFpbHc/cZf2zKaDZ8rrcuokWed3uWWEWhU6Xh/lQyUbo8KQ0XC+1L9fHE3+ml3cnQIQJglvFavwZnBnCfCSX7B6KZ3lnMhWKbxFTmcCNvDxCHlrafjcSAJ2daApSMVXjz9iGAYj37Wpzz8YXQ1mi3gEraTQIZl5myWYMEF/fme0m0pCZjykivX0I7lbcP4BC2IB89hB/5WSJoMd7GTFitmZ5giSne6O2OQ1KupCk+Bam7syN9OeAq8PQT7dn1Ta2FSiycSLSFkvZHi9zpQuGM= Content-Type: text/plain; charset="us-ascii" Content-ID: Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-Network-Message-Id: c1da950c-c13d-4593-2e89-08d6e03225f0 X-MS-Exchange-CrossTenant-originalarrivaltime: 24 May 2019 10:25:31.1306 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: f34e5979-57d9-4aaa-ad4d-b122a662184d X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM0PR08MB5153 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Thu, May 23, 2019 at 10:36:38AM +0100, james qian wang (Arm Technology C= hina) wrote: > Komeda driver uses a individual component to describe the HW's writeback > caps, but drivers doesn't define a new structure and still uses the > existing "struct komeda_layer" to describe this new component. > The detailed changes as follow: >=20 > 1. Initialize wb_layer according to HW and report it to CORE. > 2. CORE exposes wb_layer as a resource to KMS by private_obj. > 3. Report writeback supporting by add a wb_connector to KMS, and then > wb_connector will take act as a component resources user, > so the func komeda_wb_encoder_atomic_check claims komeda resources > (scaler and wb_layer) accroding to its state configuration to the > wb_connector. and the wb_state configuration will be validated on the > specific component resources to see if the caps of component can > meet the requirement of wb_connector. if not check failed. > 4. Update irq_handler to notify the completion of writeback. >=20 > NOTE: > This change doesn't add scaling writeback support, that support will > be added in the future after the scaler support. >=20 > v2: Rebase > v3: Rebase and constify the d71_wb_layer_funcs > v4: Addressed Ayan's comments >=20 > Depends on: > - https://patchwork.freedesktop.org/series/59915/ >=20 > Signed-off-by: James Qian Wang (Arm Technology China) > --- > drivers/gpu/drm/arm/display/komeda/Makefile | 1 + > .../arm/display/komeda/d71/d71_component.c | 90 ++++++++- > .../gpu/drm/arm/display/komeda/komeda_crtc.c | 15 ++ > .../arm/display/komeda/komeda_framebuffer.c | 19 ++ > .../gpu/drm/arm/display/komeda/komeda_kms.c | 4 + > .../gpu/drm/arm/display/komeda/komeda_kms.h | 27 +++ > .../drm/arm/display/komeda/komeda_pipeline.h | 7 + > .../display/komeda/komeda_pipeline_state.c | 51 ++++- > .../arm/display/komeda/komeda_private_obj.c | 6 + > .../arm/display/komeda/komeda_wb_connector.c | 181 ++++++++++++++++++ > 10 files changed, 398 insertions(+), 3 deletions(-) > create mode 100644 drivers/gpu/drm/arm/display/komeda/komeda_wb_connecto= r.c >=20 > diff --git a/drivers/gpu/drm/arm/display/komeda/Makefile b/drivers/gpu/dr= m/arm/display/komeda/Makefile > index 62bd1bff66a3..d7e29fc688c3 100644 > --- a/drivers/gpu/drm/arm/display/komeda/Makefile > +++ b/drivers/gpu/drm/arm/display/komeda/Makefile > @@ -14,6 +14,7 @@ komeda-y :=3D \ > komeda_kms.o \ > komeda_crtc.o \ > komeda_plane.o \ > + komeda_wb_connector.o \ > komeda_private_obj.o > =20 > komeda-y +=3D \ > diff --git a/drivers/gpu/drm/arm/display/komeda/d71/d71_component.c b/dri= vers/gpu/drm/arm/display/komeda/d71/d71_component.c > index 6bab816ed8e7..323e5994a55c 100644 > --- a/drivers/gpu/drm/arm/display/komeda/d71/d71_component.c > +++ b/drivers/gpu/drm/arm/display/komeda/d71/d71_component.c > @@ -288,10 +288,98 @@ static int d71_layer_init(struct d71_dev *d71, > return 0; > } > =20 > +static void d71_wb_layer_update(struct komeda_component *c, > + struct komeda_component_state *state) > +{ > + struct komeda_layer_state *st =3D to_layer_st(state); > + struct drm_connector_state *conn_st =3D state->wb_conn->state; > + struct drm_framebuffer *fb =3D conn_st->writeback_job->fb; > + struct komeda_fb *kfb =3D to_kfb(fb); > + u32 __iomem *reg =3D c->reg; > + u32 ctrl =3D L_EN | LW_OFM, mask =3D L_EN | LW_OFM | LW_TBU_EN; > + int i; > + > + for (i =3D 0; i < fb->format->num_planes; i++) { > + malidp_write32(reg + i * LAYER_PER_PLANE_REGS, BLK_P0_PTR_LOW, > + lower_32_bits(st->addr[i])); > + malidp_write32(reg + i * LAYER_PER_PLANE_REGS, BLK_P0_PTR_HIGH, > + upper_32_bits(st->addr[i])); > + > + malidp_write32(reg + i * LAYER_PER_PLANE_REGS, BLK_P0_STRIDE, > + fb->pitches[i] & 0xFFFF); > + } > + > + malidp_write32(reg, LAYER_FMT, kfb->format_caps->hw_id); > + malidp_write32(reg, BLK_IN_SIZE, HV_SIZE(st->hsize, st->vsize)); > + malidp_write32(reg, BLK_INPUT_ID0, to_d71_input_id(&state->inputs[0])); > + malidp_write32_mask(reg, BLK_CONTROL, mask, ctrl); > +} > + > +static void d71_wb_layer_dump(struct komeda_component *c, struct seq_fil= e *sf) > +{ > + u32 v[12], i; > + > + dump_block_header(sf, c->reg); > + > + get_values_from_reg(c->reg, 0x80, 1, v); > + seq_printf(sf, "LW_INPUT_ID0:\t\t0x%X\n", v[0]); > + > + get_values_from_reg(c->reg, 0xD0, 3, v); > + seq_printf(sf, "LW_CONTROL:\t\t0x%X\n", v[0]); > + seq_printf(sf, "LW_PROG_LINE:\t\t0x%X\n", v[1]); > + seq_printf(sf, "LW_FORMAT:\t\t0x%X\n", v[2]); > + > + get_values_from_reg(c->reg, 0xE0, 1, v); > + seq_printf(sf, "LW_IN_SIZE:\t\t0x%X\n", v[0]); > + > + for (i =3D 0; i < 2; i++) { > + get_values_from_reg(c->reg, 0x100 + i * 0x10, 3, v); > + seq_printf(sf, "LW_P%u_PTR_LOW:\t\t0x%X\n", i, v[0]); > + seq_printf(sf, "LW_P%u_PTR_HIGH:\t\t0x%X\n", i, v[1]); > + seq_printf(sf, "LW_P%u_STRIDE:\t\t0x%X\n", i, v[2]); > + } > + > + get_values_from_reg(c->reg, 0x130, 12, v); > + for (i =3D 0; i < 12; i++) > + seq_printf(sf, "LW_RGB_YUV_COEFF%u:\t0x%X\n", i, v[i]); > +} > + > +static void d71_wb_layer_disable(struct komeda_component *c) > +{ > + malidp_write32(c->reg, BLK_INPUT_ID0, 0); > + malidp_write32_mask(c->reg, BLK_CONTROL, L_EN, 0); > +} > + > +static const struct komeda_component_funcs d71_wb_layer_funcs =3D { > + .update =3D d71_wb_layer_update, > + .disable =3D d71_wb_layer_disable, > + .dump_register =3D d71_wb_layer_dump, > +}; > + > static int d71_wb_layer_init(struct d71_dev *d71, > struct block_header *blk, u32 __iomem *reg) > { > - DRM_DEBUG("Detect D71_Wb_Layer.\n"); > + struct komeda_component *c; > + struct komeda_layer *wb_layer; > + u32 pipe_id, layer_id; > + > + get_resources_id(blk->block_info, &pipe_id, &layer_id); > + > + c =3D komeda_component_add(&d71->pipes[pipe_id]->base, sizeof(*wb_layer= ), > + layer_id, BLOCK_INFO_INPUT_ID(blk->block_info), > + &d71_wb_layer_funcs, > + 1, get_valid_inputs(blk), 0, reg, > + "LPU%d_LAYER_WR", pipe_id); > + if (IS_ERR(c)) { > + DRM_ERROR("Failed to add wb_layer component\n"); > + return PTR_ERR(c); > + } > + > + wb_layer =3D to_layer(c); > + wb_layer->layer_type =3D KOMEDA_FMT_WB_LAYER; > + > + set_range(&wb_layer->hsize_in, D71_MIN_LINE_SIZE, d71->max_line_size); > + set_range(&wb_layer->vsize_in, D71_MIN_VERTICAL_SIZE, d71->max_vsize); > =20 > return 0; > } > diff --git a/drivers/gpu/drm/arm/display/komeda/komeda_crtc.c b/drivers/g= pu/drm/arm/display/komeda/komeda_crtc.c > index 284ce079d8c4..6712603b8c7a 100644 > --- a/drivers/gpu/drm/arm/display/komeda/komeda_crtc.c > +++ b/drivers/gpu/drm/arm/display/komeda/komeda_crtc.c > @@ -165,6 +165,15 @@ void komeda_crtc_handle_event(struct komeda_crtc *= kcrtc, > if (events & KOMEDA_EVENT_VSYNC) > drm_crtc_handle_vblank(crtc); > =20 > + if (events & KOMEDA_EVENT_EOW) { > + struct komeda_wb_connector *wb_conn =3D kcrtc->wb_conn; > + > + if (wb_conn) > + drm_writeback_signal_completion(&wb_conn->base, 0); > + else > + DRM_WARN("CRTC[%d]: EOW happen but no wb_connector.\n", > + drm_crtc_index(&kcrtc->base)); > + } > /* will handle it together with the write back support */ > if (events & KOMEDA_EVENT_EOW) > DRM_DEBUG("EOW.\n"); > @@ -201,6 +210,8 @@ komeda_crtc_do_flush(struct drm_crtc *crtc, > struct komeda_crtc_state *kcrtc_st =3D to_kcrtc_st(crtc->state); > struct komeda_dev *mdev =3D kcrtc->base.dev->dev_private; > struct komeda_pipeline *master =3D kcrtc->master; > + struct komeda_wb_connector *wb_conn =3D kcrtc->wb_conn; > + struct drm_connector_state *conn_st; > =20 > DRM_DEBUG_ATOMIC("CRTC%d_FLUSH: active_pipes: 0x%x, affected: 0x%x.\n", > drm_crtc_index(crtc), > @@ -210,6 +221,10 @@ komeda_crtc_do_flush(struct drm_crtc *crtc, > if (has_bit(master->id, kcrtc_st->affected_pipes)) > komeda_pipeline_update(master, old->state); > =20 > + conn_st =3D wb_conn ? wb_conn->base.base.state : NULL; > + if (conn_st && conn_st->writeback_job) > + drm_writeback_queue_job(&wb_conn->base, conn_st); > + > /* step 2: notify the HW to kickoff the update */ > mdev->funcs->flush(mdev, master->id, kcrtc_st->active_pipes); > } > diff --git a/drivers/gpu/drm/arm/display/komeda/komeda_framebuffer.c b/dr= ivers/gpu/drm/arm/display/komeda/komeda_framebuffer.c > index 9cc9935024f7..4d8160cf09c3 100644 > --- a/drivers/gpu/drm/arm/display/komeda/komeda_framebuffer.c > +++ b/drivers/gpu/drm/arm/display/komeda/komeda_framebuffer.c > @@ -165,3 +165,22 @@ komeda_fb_get_pixel_addr(struct komeda_fb *kfb, int = x, int y, int plane) > =20 > return obj->paddr + offset; > } > + > +/* if the fb can be supported by a specific layer */ > +bool komeda_fb_is_layer_supported(struct komeda_fb *kfb, u32 layer_type) > +{ > + struct drm_framebuffer *fb =3D &kfb->base; > + struct komeda_dev *mdev =3D fb->dev->dev_private; > + const struct komeda_format_caps *caps; > + u32 fourcc =3D fb->format->format; > + u64 modifier =3D fb->modifier; > + > + caps =3D komeda_get_format_caps(&mdev->fmt_tbl, fourcc, modifier); > + if (!caps) > + return false; > + > + if (!(caps->supported_layer_types & layer_type)) > + return false; > + > + return true; > +} > diff --git a/drivers/gpu/drm/arm/display/komeda/komeda_kms.c b/drivers/gp= u/drm/arm/display/komeda/komeda_kms.c > index 86f6542afb40..3e58901fb776 100644 > --- a/drivers/gpu/drm/arm/display/komeda/komeda_kms.c > +++ b/drivers/gpu/drm/arm/display/komeda/komeda_kms.c > @@ -188,6 +188,10 @@ struct komeda_kms_dev *komeda_kms_attach(struct kome= da_dev *mdev) > if (err) > goto cleanup_mode_config; > =20 > + err =3D komeda_kms_add_wb_connectors(kms, mdev); > + if (err) > + goto cleanup_mode_config; > + > err =3D component_bind_all(mdev->dev, kms); > if (err) > goto cleanup_mode_config; > diff --git a/drivers/gpu/drm/arm/display/komeda/komeda_kms.h b/drivers/gp= u/drm/arm/display/komeda/komeda_kms.h > index ac3d9209b4d9..f16e9e577593 100644 > --- a/drivers/gpu/drm/arm/display/komeda/komeda_kms.h > +++ b/drivers/gpu/drm/arm/display/komeda/komeda_kms.h > @@ -12,6 +12,7 @@ > #include > #include > #include > +#include > #include