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=-8.3 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY,USER_AGENT_SANE_2 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 23E15C433E0 for ; Fri, 5 Jun 2020 08:09:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id B295320835 for ; Fri, 5 Jun 2020 08:09:57 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="dmjTU2jI" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726235AbgFEIJ5 (ORCPT ); Fri, 5 Jun 2020 04:09:57 -0400 Received: from Mailgw01.mediatek.com ([1.203.163.78]:37331 "EHLO mailgw01.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1725280AbgFEIJz (ORCPT ); Fri, 5 Jun 2020 04:09:55 -0400 X-UUID: cc38b2a7a5d34ead9a31bbc36ebd81f3-20200605 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:MIME-Version:Content-Type:References:In-Reply-To:Date:CC:To:From:Subject:Message-ID; bh=K9DWCE9KJeNyNvYHMZZ4SJRiB40zAPO4hL6uIU8WVks=; b=dmjTU2jIkzYZj9yasqmpHYIBS0ii4lIAIXtspjHQeLkioS9yQh+ycz7/rXwHLjQHGUw2Te4Y+mfn/ldcR6AIbmbEeTyIFxGP4vXIU9P5yGDq1zPPGFnDlqZcmureQ2mSzpyS66k5NSkgzjkb8GdO+WxDzXiUdy5Qv1k8u/1l9k4=; X-UUID: cc38b2a7a5d34ead9a31bbc36ebd81f3-20200605 Received: from mtkcas35.mediatek.inc [(172.27.4.253)] by mailgw01.mediatek.com (envelope-from ) (mailgw01.mediatek.com ESMTP with TLS) with ESMTP id 1506095771; Fri, 05 Jun 2020 16:09:07 +0800 Received: from MTKCAS36.mediatek.inc (172.27.4.186) by MTKMBS31N2.mediatek.inc (172.27.4.87) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 5 Jun 2020 16:09:05 +0800 Received: from [10.17.3.153] (10.17.3.153) by MTKCAS36.mediatek.inc (172.27.4.170) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Fri, 5 Jun 2020 16:09:06 +0800 Message-ID: <1591344422.32607.13.camel@mhfsdcap03> Subject: Re: [PATCH v8 14/14] media: platform: Add jpeg dec/enc feature From: Xia Jiang To: Hans Verkuil CC: Mauro Carvalho Chehab , Rob Herring , Matthias Brugger , Rick Chang , , , , , , Marek Szyprowski , Tomasz Figa , , , , , , Date: Fri, 5 Jun 2020 16:07:02 +0800 In-Reply-To: References: <20200403094033.8288-1-xia.jiang@mediatek.com> <20200403094033.8288-15-xia.jiang@mediatek.com> Content-Type: text/plain; charset="UTF-8" X-Mailer: Evolution 3.10.4-0ubuntu2 MIME-Version: 1.0 X-TM-SNTS-SMTP: 585C4E924FF11749F8A6AD7FA9C27571F9413ABEC86FA721C800E77F328703592000:8 X-MTK: N Content-Transfer-Encoding: base64 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org T24gTW9uLCAyMDIwLTA1LTExIGF0IDExOjA0ICswMjAwLCBIYW5zIFZlcmt1aWwgd3JvdGU6DQo+ IE9uIDAzLzA0LzIwMjAgMTE6NDAsIFhpYSBKaWFuZyB3cm90ZToNCj4gPiBBZGQgbXRrIGpwZWcg ZW5jb2RlIHY0bDIgZHJpdmVyIGJhc2VkIG9uIGpwZWcgZGVjb2RlLCBiZWNhdXNlIHRoYXQganBl Zw0KPiA+IGRlY29kZSBhbmQgZW5jb2RlIGhhdmUgZ3JlYXQgc2ltaWxhcml0aWVzIHdpdGggZnVu Y3Rpb24gb3BlcmF0aW9uLg0KPiA+IA0KPiA+IFNpZ25lZC1vZmYtYnk6IFhpYSBKaWFuZyA8eGlh LmppYW5nQG1lZGlhdGVrLmNvbT4NCj4gPiAtLS0NCj4gPiB2ODpqcGVnIGVuY29kZXIgYW5kIGRl Y29kZXIgdXNlIHNlcGFyYXRlIGNhbGxiYWNrcyBpbnN0ZWFkIG9mIHJlcGVhdGluZw0KPiA+ICAg IHRoZSBpZi9lbHNlIGluIGV2ZXJ5IGNhbGxiYWNrLg0KPiA+ICAgIGltcHJvdmUgdmlkaW9jX3Ry eV9mbXQoKSBpbXBsZW1lbnRhdGlvbiB0aGF0IGNhbiBiZSBzaGFyZWQgYnkganBlZw0KPiA+ICAg IGVuY29kZXIgYW5kIGRlY29kZXIuDQo+ID4gICAgZml4IHRoZSBidWcgb2YganBlZyBlbmNvZGVy IHNfc2VsZWN0aW9uIGltcGxlbWVudGF0aW9uLg0KPiA+ICAgIGNhbmNlbCB0aGUgc3RhdGUgb2Yg dGhlIGpwZWcgZW5jb2Rlci4NCj4gPiAgICBpbXByb3ZlIGpwZWcgZW5jb2RlciBhbmQgZGVjb2Rl ciBzZXQgZGVmYXVsdCBwYXJhbXMgZmxvdy4NCj4gPiAgICBwdXQgdGhlIGNsb2NrIG5hbWVzIGFu ZCBvdGhlciBkYXRhcyBpbiBhIG1hdGNoX2RhdGEgc3RydWN0Lg0KPiA+ICAgIGZpeCB0aGUgYnVn IG9mIGdldGluZyBjb3JyZWN0bHkgcXVhbGl0eSB2YWx1ZS4NCj4gPiAgICBkbyB0aGUgYWxsIHRo ZSBiaXRzJyBzZXR0aW5ncyBvZiBvbmUgcmVnaXN0ZXIgaW4gb25lIGZ1bmN0aW9uLg0KPiA+ICAg IG1vdmUgdGhlIGNvZGUgb2YgbXRrX2pwZWdfZW5jX3JlZy5oIHRvIG10a19qcGVnX2VuY19ody5o IGFuZCBkZWxldGUNCj4gPiAgICBtdGtfanBlZ19lbmNfcmVnLmguDQo+ID4gDQo+ID4gdjc6IHJl dmVyc2Ugc3BpbiBsb2NrIGFuZCB1bmxvY2sgb3BlcmF0aW9uIGluIGRldmljZSBydW4gZnVuY3Rp b24gZm9yDQo+ID4gICAgIG11bHRpLWluc3RhbmNlLg0KPiA+IA0KPiA+IHY2OiBhZGQgc3BhY2Ug dG8gYXJvdW5kaW5nICcrJy4NCj4gPiAgICAgYWxpZ25tZW50ICdzdHJ1Y3QgbXRrX2pwZWdfZm10 ICpmbXQnIG1hdGNoIG9wZW4gcGFyZW50aGVzaXMuDQo+ID4gICAgIGNoYW5nZSAnbXRrX2pwZWdf ZW5jX3NldF9lbmNGb3JtYXQnIHRvICdtdGtfanBlZ19lbmNfc2V0X2VuY19mb3JtYXQnLg0KPiA+ ICAgICBtYWtlICdtdGtfanBlZ19jdHJsc19zZXR1cCcgdG8gc3RhdGljIHByb3RvdHlwZS4NCj4g PiAgICAgZGVsZXRlIHVudXNlZCB2YXJpYWJsZXMgJ2pwZWcnLydhbGlnbl9oJy8nYWxpZ25fdycv J2ZsYWdzJy4NCj4gPiAgICAgaW5pdGlhbGl6ZSAneXV2X2Zvcm1hdCcvJ2VuY19xdWFsaXR5JyB2 YXJpYWJsZXMuDQo+ID4gICAgIA0KPiA+IHY1OiBzdXBwb3J0IGNyb3AgZm9yIGVuY29kZXIgYW5k IGNvbXBvc2UgZm9yIGRlY29kZXIgaW4gc19zZWxlY3Rpb24gYW5kDQo+ID4gICAgIGdfc2VsZWN0 aW9uIGZ1bmN0aW9uLg0KPiA+ICAgICB1c2UgY2xhbXAoKSB0byByZXBsYWNlIG10a19qcGVnX2Jv dW5kX2FsaWduX2ltYWdlKCkgYW5kIHJvdW5kX3VwKCkNCj4gPiAgICAgdG8gcmVwbGFjZSBtdGtf anBlZ19hbGlnbigpLg0KPiA+ICAgICBkZWxldGUganBlZ19lbmNfcGFyYW0vbXRrX2pwZWdfZW5j X3BhcmFtIHN0cnVjdHVyZSBhbmQNCj4gPiAgICAgbXRrX2pwZWdfc2V0X3BhcmFtKCksIHByb2dy YW0gdGhlIHJlZ2lzdGVycyBkaXJlY3RseSBiYXNlZCBvbg0KPiA+ICAgICB0aGUgb3JpZ2luYWwg VjRMMiB2YWx1ZXMuDQo+ID4gICAgIG1vdmUgbWFjcm8gZGVmaW5pdGlvbiBhYm91dCBodyB0byBt dGtfanBlZ19lbmNfcmVnLmguDQo+ID4gICAgIGRlbGV0ZSB1bm5lY2Vzc2FyeSBWNEwyIGxvZ3Mg aW4gZHJpdmVyLg0KPiA+ICAgICBjYW5jZWwgc3BpbiBsb2NrIGFuZCB1bmxvY2sgb3BlcmF0aW9u IGluIGRldmllYyBydW4gZnVuY3Rpb24uDQo+ID4gICAgIGNoYW5nZSBqcGVnIGVuYyByZWdpc3Rl ciBvZmZzZXQgaGV4IG51bWJlcmFscyBmcm9tIHVwZXJjYXNlIHRvIGxvd2VyY2FzZS4NCj4gPiAN Cj4gPiB2NDogc3BsaXQgbXRrX2pwZWdfdHJ5X2ZtdF9tcGxhbmUoKSB0byB0d28gZnVuY3Rpb25z LCBvbmUgZm9yIGVuY29kZXIsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgDQo+ID4gICAgIG9uZSBmb3IgZGVjb2Rlci4gICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgDQo+ID4gICAgIHNwbGl0 IG10a19qcGVnX3NldF9kZWZhdWx0X3BhcmFtcygpIHRvIHR3byBmdW5jdGlvbnMsIG9uZSBmb3Ig ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg DQo+ID4gICAgIGVuY29kZXIsIG9uZSBmb3IgZGVjb2Rlci4gICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgDQo+ID4gICAgIGFkZCBjcm9wcGlu ZyBzdXBwb3J0IGZvciBlbmNvZGVyIGluIGcvc19zZWxlY3Rpb24gaW9jdGxzLiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICANCj4gPiAgICAg Y2hhbmdlIGV4aWYgbW9kZSBzdXBwb3J0IGJ5IHVzaW5nIFY0TDJfSlBFR19BQ1RJVkVfTUFSS0VS X0FQUDEuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgDQo+ID4gICAgIGNoYW5nZSBNVEtfSlBFR19NQVhfV0lEVEgvTVRLX0pQRUdfTUFYX0hF SUdIIGZyb20gODE5MiB0byA2NTUzNSBieSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIA0KPiA+ICAgICBzcGVjaWZpY2F0aW9uLiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICANCj4gPiAgICAg bW92ZSB3aWR0aCBzaGlmdGluZyBvcGVyYXRpb24gYmVoaW5kIGFsaWduaW5nIG9wZXJhdGlvbiBp biAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICANCj4gPiAgICAgbXRrX2pwZWdfdHJ5X2VuY19mbXRfbXBsYW5lKCkgZm9yIGJ1ZyBmaXguICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIA0K PiA+ICAgICBmaXggdXNlciBhYnVzZWluZyBkYXRhX29mZnNldCBpc3N1ZSBmb3IgRE1BQlVGIGlu ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IA0KPiA+ICAgICBtdGtfanBlZ19zZXRfZW5jX3NyYygpLiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICANCj4gPiAgICAgZml4IGtidWlsZCB3 YXJpbmdzOiBjaGFuZ2UgTVRLX0pQRUdfTUlOX0hFSUdIVC9NVEtfSlBFR19NQVhfSEVJR0hUICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgDQo+ID4g ICAgICAgICAgICAgICAgICAgICAgICAgYW5kIE1US19KUEVHX01JTl9XSURUSC9NVEtfSlBFR19N QVhfV0lEVEggZnJvbSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIA0KPiA+ICAgICAgICAgICAgICAgICAgICAgICAgICdpbnQnIHR5cGUgdG8gJ3Vu c2lnbmVkIGludCcgdHlwZS4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgDQo+ID4gICAgICAgICAgICAgICAgICAgICAgICAgZml4IG1zbGVh ZGluZ2x5IGluZGVudGVkIG9mICdlbHNlJy4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIA0KPiA+IHYzOiBkZWxldGUgQ2hhbmdlLUlkLiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICANCj4gPiAg ICAgb25seSB0ZXN0IG9uY2UgaGFuZGxlci0+ZXJyb3IgYWZ0ZXIgdGhlIGxhc3QgdjRsMl9jdHJs X25ld19zdGQoKS4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgDQo+ID4gICAgIHNlcGVyYXRlIGNoYW5nZXMgb2YgdjRsMi1jdHJscy5jIGFuZCB2 NGwyLWNvbnRyb2xzLmggdG8gbmV3IHBhdGNoLiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIA0KPiA+IHYyOiBmaXggY29tcGxpYW5jZSB0ZXN0IGZh aWwsIGNoZWNrIGNyZWF0ZWQgYnVmZmVyIHNpemUgaW4gZHJpdmVyLg0KPiA+IC0tLQ0KPiA+ICBk cml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1qcGVnL01ha2VmaWxlICAgICAgfCAgICA1ICstDQo+ ID4gIC4uLi9tZWRpYS9wbGF0Zm9ybS9tdGstanBlZy9tdGtfanBlZ19jb3JlLmMgICB8IDEwMzgg KysrKysrKysrKysrKy0tLS0NCj4gPiAgLi4uL21lZGlhL3BsYXRmb3JtL210ay1qcGVnL210a19q cGVnX2NvcmUuaCAgIHwgICA1MSArLQ0KPiA+ICAuLi4vbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcv bXRrX2pwZWdfZGVjX2h3LmggfCAgICA3ICstDQo+ID4gIC4uLi9tZWRpYS9wbGF0Zm9ybS9tdGst anBlZy9tdGtfanBlZ19lbmNfaHcuYyB8ICAxOTMgKysrDQo+ID4gIC4uLi9tZWRpYS9wbGF0Zm9y bS9tdGstanBlZy9tdGtfanBlZ19lbmNfaHcuaCB8ICAxMjMgKysNCj4gPiAgNiBmaWxlcyBjaGFu Z2VkLCAxMTg4IGluc2VydGlvbnMoKyksIDIyOSBkZWxldGlvbnMoLSkNCj4gPiAgY3JlYXRlIG1v ZGUgMTAwNjQ0IGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfZW5jX2h3 LmMNCj4gPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWpw ZWcvbXRrX2pwZWdfZW5jX2h3LmgNCj4gPiANCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS9tdGstanBlZy9NYWtlZmlsZSBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRr LWpwZWcvTWFrZWZpbGUNCj4gPiBpbmRleCA0ODUxNmRjZjk2ZTYuLjc2YzMzYWFkMGYzZiAxMDA2 NDQNCj4gPiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1qcGVnL01ha2VmaWxlDQo+ ID4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9tdGstanBlZy9NYWtlZmlsZQ0KPiA+IEBA IC0xLDMgKzEsNiBAQA0KPiA+ICAjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9u bHkNCj4gPiAtbXRrX2pwZWctb2JqcyA6PSBtdGtfanBlZ19jb3JlLm8gbXRrX2pwZWdfZGVjX2h3 Lm8gbXRrX2pwZWdfZGVjX3BhcnNlLm8NCj4gPiArbXRrX2pwZWctb2JqcyA6PSBtdGtfanBlZ19j b3JlLm8gXA0KPiA+ICsJCSBtdGtfanBlZ19kZWNfaHcubyBcDQo+ID4gKwkJIG10a19qcGVnX2Rl Y19wYXJzZS5vIFwNCj4gPiArCQkgbXRrX2pwZWdfZW5jX2h3Lm8NCj4gPiAgb2JqLSQoQ09ORklH X1ZJREVPX01FRElBVEVLX0pQRUcpICs9IG10a19qcGVnLm8NCj4gPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9tZWRpYS9wbGF0Zm9ybS9tdGstanBlZy9tdGtfanBlZ19jb3JlLmMgYi9kcml2ZXJzL21l ZGlhL3BsYXRmb3JtL210ay1qcGVnL210a19qcGVnX2NvcmUuYw0KPiA+IGluZGV4IDc3YTk1MTg1 NTg0Yy4uMThhNzU5Y2UyYzQ2IDEwMDY0NA0KPiA+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZv cm0vbXRrLWpwZWcvbXRrX2pwZWdfY29yZS5jDQo+ID4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS9tdGstanBlZy9tdGtfanBlZ19jb3JlLmMNCj4gPiBAQCAtMyw2ICszLDcgQEANCj4gPiAg ICogQ29weXJpZ2h0IChjKSAyMDE2IE1lZGlhVGVrIEluYy4NCj4gPiAgICogQXV0aG9yOiBNaW5n IEhzaXUgVHNhaSA8bWluZ2hzaXUudHNhaUBtZWRpYXRlay5jb20+DQo+ID4gICAqICAgICAgICAg UmljayBDaGFuZyA8cmljay5jaGFuZ0BtZWRpYXRlay5jb20+DQo+ID4gKyAqICAgICAgICAgWGlh IEppYW5nIDx4aWEuamlhbmdAbWVkaWF0ZWsuY29tPg0KPiA+ICAgKi8NCj4gPiAgDQo+ID4gICNp bmNsdWRlIDxsaW51eC9jbGsuaD4NCj4gPiBAQCAtMjMsMTEgKzI0LDYwIEBADQo+ID4gICNpbmNs dWRlIDxtZWRpYS92aWRlb2J1ZjItZG1hLWNvbnRpZy5oPg0KPiA+ICAjaW5jbHVkZSA8c29jL21l ZGlhdGVrL3NtaS5oPg0KPiA+ICANCj4gPiArI2luY2x1ZGUgIm10a19qcGVnX2VuY19ody5oIg0K PiA+ICAjaW5jbHVkZSAibXRrX2pwZWdfZGVjX2h3LmgiDQo+ID4gICNpbmNsdWRlICJtdGtfanBl Z19jb3JlLmgiDQo+ID4gICNpbmNsdWRlICJtdGtfanBlZ19kZWNfcGFyc2UuaCINCj4gPiAgDQo+ ID4gLXN0YXRpYyBzdHJ1Y3QgbXRrX2pwZWdfZm10IG10a19qcGVnX2Zvcm1hdHNbXSA9IHsNCj4g PiArc3RhdGljIHN0cnVjdCBtdGtfanBlZ19mbXQgbXRrX2pwZWdfZW5jX2Zvcm1hdHNbXSA9IHsN Cj4gPiArCXsNCj4gPiArCQkuZm91cmNjCQk9IFY0TDJfUElYX0ZNVF9KUEVHLA0KPiA+ICsJCS5j b2xwbGFuZXMJPSAxLA0KPiA+ICsJCS5mbGFncwkJPSBNVEtfSlBFR19GTVRfRkxBR19FTkNfQ0FQ VFVSRSwNCj4gPiArCX0sDQo+ID4gKwl7DQo+ID4gKwkJLmZvdXJjYwkJPSBWNEwyX1BJWF9GTVRf TlYxMk0sDQo+ID4gKwkJLmh3X2Zvcm1hdAk9IEpQRUdfRU5DX1lVVl9GT1JNQVRfTlYxMiwNCj4g PiArCQkuaF9zYW1wbGUJPSB7NCwgNH0sDQo+ID4gKwkJLnZfc2FtcGxlCT0gezQsIDJ9LA0KPiA+ ICsJCS5jb2xwbGFuZXMJPSAyLA0KPiA+ICsJCS5oX2FsaWduCT0gNCwNCj4gPiArCQkudl9hbGln bgk9IDQsDQo+ID4gKwkJLmZsYWdzCQk9IE1US19KUEVHX0ZNVF9GTEFHX0VOQ19PVVRQVVQsDQo+ ID4gKwl9LA0KPiA+ICsJew0KPiA+ICsJCS5mb3VyY2MJCT0gVjRMMl9QSVhfRk1UX05WMjFNLA0K PiA+ICsJCS5od19mb3JtYXQJPSBKRVBHX0VOQ19ZVVZfRk9STUFUX05WMjEsDQo+ID4gKwkJLmhf c2FtcGxlCT0gezQsIDR9LA0KPiA+ICsJCS52X3NhbXBsZQk9IHs0LCAyfSwNCj4gPiArCQkuY29s cGxhbmVzCT0gMiwNCj4gPiArCQkuaF9hbGlnbgk9IDQsDQo+ID4gKwkJLnZfYWxpZ24JPSA0LA0K PiA+ICsJCS5mbGFncwkJPSBNVEtfSlBFR19GTVRfRkxBR19FTkNfT1VUUFVULA0KPiA+ICsJfSwN Cj4gPiArCXsNCj4gPiArCQkuZm91cmNjCQk9IFY0TDJfUElYX0ZNVF9ZVVlWLA0KPiA+ICsJCS5o d19mb3JtYXQJPSBKUEVHX0VOQ19ZVVZfRk9STUFUX1lVWVYsDQo+ID4gKwkJLmhfc2FtcGxlCT0g ezh9LA0KPiA+ICsJCS52X3NhbXBsZQk9IHs0fSwNCj4gPiArCQkuY29scGxhbmVzCT0gMSwNCj4g PiArCQkuaF9hbGlnbgk9IDUsDQo+ID4gKwkJLnZfYWxpZ24JPSAzLA0KPiA+ICsJCS5mbGFncwkJ PSBNVEtfSlBFR19GTVRfRkxBR19FTkNfT1VUUFVULA0KPiA+ICsJfSwNCj4gPiArCXsNCj4gPiAr CQkuZm91cmNjCQk9IFY0TDJfUElYX0ZNVF9ZVllVLA0KPiA+ICsJCS5od19mb3JtYXQJPSBKUEVH X0VOQ19ZVVZfRk9STUFUX1lWWVUsDQo+ID4gKwkJLmhfc2FtcGxlCT0gezh9LA0KPiA+ICsJCS52 X3NhbXBsZQk9IHs0fSwNCj4gPiArCQkuY29scGxhbmVzCT0gMSwNCj4gPiArCQkuaF9hbGlnbgk9 IDUsDQo+ID4gKwkJLnZfYWxpZ24JPSAzLA0KPiA+ICsJCS5mbGFncwkJPSBNVEtfSlBFR19GTVRf RkxBR19FTkNfT1VUUFVULA0KPiA+ICsJfSwNCj4gPiArfTsNCj4gPiArDQo+ID4gK3N0YXRpYyBz dHJ1Y3QgbXRrX2pwZWdfZm10IG10a19qcGVnX2RlY19mb3JtYXRzW10gPSB7DQo+ID4gIAl7DQo+ ID4gIAkJLmZvdXJjYwkJPSBWNEwyX1BJWF9GTVRfSlBFRywNCj4gPiAgCQkuY29scGxhbmVzCT0g MSwNCj4gPiBAQCAtNTMsNyArMTAzLDggQEAgc3RhdGljIHN0cnVjdCBtdGtfanBlZ19mbXQgbXRr X2pwZWdfZm9ybWF0c1tdID0gew0KPiA+ICAJfSwNCj4gPiAgfTsNCj4gPiAgDQo+ID4gLSNkZWZp bmUgTVRLX0pQRUdfTlVNX0ZPUk1BVFMgQVJSQVlfU0laRShtdGtfanBlZ19mb3JtYXRzKQ0KPiA+ ICsjZGVmaW5lIE1US19KUEVHX0VOQ19OVU1fRk9STUFUUyBBUlJBWV9TSVpFKG10a19qcGVnX2Vu Y19mb3JtYXRzKQ0KPiA+ICsjZGVmaW5lIE1US19KUEVHX0RFQ19OVU1fRk9STUFUUyBBUlJBWV9T SVpFKG10a19qcGVnX2RlY19mb3JtYXRzKQ0KPiA+ICANCj4gPiAgZW51bSB7DQo+ID4gIAlNVEtf SlBFR19CVUZfRkxBR1NfSU5JVAkJCT0gMCwNCj4gPiBAQCAtNzAsNiArMTIxLDExIEBAIHN0cnVj dCBtdGtfanBlZ19zcmNfYnVmIHsNCj4gPiAgc3RhdGljIGludCBkZWJ1ZzsNCj4gPiAgbW9kdWxl X3BhcmFtKGRlYnVnLCBpbnQsIDA2NDQpOw0KPiA+ICANCj4gPiArc3RhdGljIGlubGluZSBzdHJ1 Y3QgbXRrX2pwZWdfY3R4ICpjdHJsX3RvX2N0eChzdHJ1Y3QgdjRsMl9jdHJsICpjdHJsKQ0KPiA+ ICt7DQo+ID4gKwlyZXR1cm4gY29udGFpbmVyX29mKGN0cmwtPmhhbmRsZXIsIHN0cnVjdCBtdGtf anBlZ19jdHgsIGN0cmxfaGRsKTsNCj4gPiArfQ0KPiA+ICsNCj4gPiAgc3RhdGljIGlubGluZSBz dHJ1Y3QgbXRrX2pwZWdfY3R4ICptdGtfanBlZ19maF90b19jdHgoc3RydWN0IHY0bDJfZmggKmZo KQ0KPiA+ICB7DQo+ID4gIAlyZXR1cm4gY29udGFpbmVyX29mKGZoLCBzdHJ1Y3QgbXRrX2pwZWdf Y3R4LCBmaCk7DQo+ID4gQEAgLTgxLDEyICsxMzcsMjUgQEAgc3RhdGljIGlubGluZSBzdHJ1Y3Qg bXRrX2pwZWdfc3JjX2J1ZiAqbXRrX2pwZWdfdmIyX3RvX3NyY2J1ZigNCj4gPiAgCXJldHVybiBj b250YWluZXJfb2YodG9fdmIyX3Y0bDJfYnVmZmVyKHZiKSwgc3RydWN0IG10a19qcGVnX3NyY19i dWYsIGIpOw0KPiA+ICB9DQo+ID4gIA0KPiA+IC1zdGF0aWMgaW50IG10a19qcGVnX3F1ZXJ5Y2Fw KHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LA0KPiA+IC0JCQkgICAgIHN0cnVjdCB2NGwy X2NhcGFiaWxpdHkgKmNhcCkNCj4gPiArc3RhdGljIGludCBtdGtfanBlZ19lbmNfcXVlcnljYXAo c3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsDQo+ID4gKwkJCQkgc3RydWN0IHY0bDJfY2Fw YWJpbGl0eSAqY2FwKQ0KPiA+ICt7DQo+ID4gKwlzdHJ1Y3QgbXRrX2pwZWdfZGV2ICpqcGVnID0g dmlkZW9fZHJ2ZGF0YShmaWxlKTsNCj4gPiArDQo+ID4gKwlzdHJzY3B5KGNhcC0+ZHJpdmVyLCBN VEtfSlBFR19OQU1FLCBzaXplb2YoY2FwLT5kcml2ZXIpKTsNCj4gPiArCXN0cnNjcHkoY2FwLT5j YXJkLCBNVEtfSlBFR19OQU1FICIgZW5jb2RlciIsIHNpemVvZihjYXAtPmNhcmQpKTsNCj4gPiAr CXNucHJpbnRmKGNhcC0+YnVzX2luZm8sIHNpemVvZihjYXAtPmJ1c19pbmZvKSwgInBsYXRmb3Jt OiVzIiwNCj4gPiArCQkgZGV2X25hbWUoanBlZy0+ZGV2KSk7DQo+ID4gKw0KPiA+ICsJcmV0dXJu IDA7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyBpbnQgbXRrX2pwZWdfZGVjX3F1ZXJ5Y2Fw KHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LA0KPiA+ICsJCQkJIHN0cnVjdCB2NGwyX2Nh cGFiaWxpdHkgKmNhcCkNCj4gPiAgew0KPiA+ICAJc3RydWN0IG10a19qcGVnX2RldiAqanBlZyA9 IHZpZGVvX2RydmRhdGEoZmlsZSk7DQo+ID4gIA0KPiA+IC0Jc3Ryc2NweShjYXAtPmRyaXZlciwg TVRLX0pQRUdfTkFNRSAiIGRlY29kZXIiLCBzaXplb2YoY2FwLT5kcml2ZXIpKTsNCj4gPiArCXN0 cnNjcHkoY2FwLT5kcml2ZXIsIE1US19KUEVHX05BTUUsIHNpemVvZihjYXAtPmRyaXZlcikpOw0K PiA+ICAJc3Ryc2NweShjYXAtPmNhcmQsIE1US19KUEVHX05BTUUgIiBkZWNvZGVyIiwgc2l6ZW9m KGNhcC0+Y2FyZCkpOw0KPiA+ICAJc25wcmludGYoY2FwLT5idXNfaW5mbywgc2l6ZW9mKGNhcC0+ YnVzX2luZm8pLCAicGxhdGZvcm06JXMiLA0KPiA+ICAJCSBkZXZfbmFtZShqcGVnLT5kZXYpKTsN Cj4gPiBAQCAtOTQsNiArMTYzLDU0IEBAIHN0YXRpYyBpbnQgbXRrX2pwZWdfcXVlcnljYXAoc3Ry dWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsDQo+ID4gIAlyZXR1cm4gMDsNCj4gPiAgfQ0KPiA+ ICANCj4gPiArc3RhdGljIGludCB2aWRpb2NfanBlZ19lbmNfc19jdHJsKHN0cnVjdCB2NGwyX2N0 cmwgKmN0cmwpDQo+ID4gK3sNCj4gPiArCXN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCA9IGN0cmxf dG9fY3R4KGN0cmwpOw0KPiA+ICsNCj4gPiArCXN3aXRjaCAoY3RybC0+aWQpIHsNCj4gPiArCWNh c2UgVjRMMl9DSURfSlBFR19SRVNUQVJUX0lOVEVSVkFMOg0KPiA+ICsJCWN0eC0+cmVzdGFydF9p bnRlcnZhbCA9IGN0cmwtPnZhbDsNCj4gPiArCQlicmVhazsNCj4gPiArCWNhc2UgVjRMMl9DSURf SlBFR19DT01QUkVTU0lPTl9RVUFMSVRZOg0KPiA+ICsJCWN0eC0+ZW5jX3F1YWxpdHkgPSBjdHJs LT52YWw7DQo+ID4gKwkJYnJlYWs7DQo+ID4gKwljYXNlIFY0TDJfQ0lEX0pQRUdfQUNUSVZFX01B UktFUjoNCj4gPiArCQljdHgtPmVuYWJsZV9leGlmID0gY3RybC0+dmFsICYgVjRMMl9KUEVHX0FD VElWRV9NQVJLRVJfQVBQMSA/DQo+ID4gKwkJCQkgICB0cnVlIDogZmFsc2U7DQo+ID4gKwkJYnJl YWs7DQo+ID4gKwl9DQo+ID4gKw0KPiA+ICsJcmV0dXJuIDA7DQo+ID4gK30NCj4gPiArDQo+ID4g K3N0YXRpYyBjb25zdCBzdHJ1Y3QgdjRsMl9jdHJsX29wcyBtdGtfanBlZ19lbmNfY3RybF9vcHMg PSB7DQo+ID4gKwkuc19jdHJsID0gdmlkaW9jX2pwZWdfZW5jX3NfY3RybCwNCj4gPiArfTsNCj4g PiArDQo+ID4gK3N0YXRpYyBpbnQgbXRrX2pwZWdfZW5jX2N0cmxzX3NldHVwKHN0cnVjdCBtdGtf anBlZ19jdHggKmN0eCkNCj4gPiArew0KPiA+ICsJY29uc3Qgc3RydWN0IHY0bDJfY3RybF9vcHMg Km9wcyA9ICZtdGtfanBlZ19lbmNfY3RybF9vcHM7DQo+ID4gKwlzdHJ1Y3QgdjRsMl9jdHJsX2hh bmRsZXIgKmhhbmRsZXIgPSAmY3R4LT5jdHJsX2hkbDsNCj4gPiArDQo+ID4gKwl2NGwyX2N0cmxf aGFuZGxlcl9pbml0KGhhbmRsZXIsIDMpOw0KPiA+ICsNCj4gPiArCXY0bDJfY3RybF9uZXdfc3Rk KGhhbmRsZXIsIG9wcywgVjRMMl9DSURfSlBFR19SRVNUQVJUX0lOVEVSVkFMLCAwLCAxMDAsDQo+ ID4gKwkJCSAgMSwgMCk7DQo+ID4gKwl2NGwyX2N0cmxfbmV3X3N0ZChoYW5kbGVyLCBvcHMsIFY0 TDJfQ0lEX0pQRUdfQ09NUFJFU1NJT05fUVVBTElUWSwgNDgsDQo+ID4gKwkJCSAgMTAwLCAxLCA5 MCk7DQo+ID4gKwl2NGwyX2N0cmxfbmV3X3N0ZChoYW5kbGVyLCBvcHMsIFY0TDJfQ0lEX0pQRUdf QUNUSVZFX01BUktFUiwgMCwNCj4gPiArCQkJICBWNEwyX0pQRUdfQUNUSVZFX01BUktFUl9BUFAx LCAwLCAwKTsNCj4gPiArDQo+ID4gKwlpZiAoaGFuZGxlci0+ZXJyb3IpIHsNCj4gPiArCQl2NGwy X2N0cmxfaGFuZGxlcl9mcmVlKCZjdHgtPmN0cmxfaGRsKTsNCj4gPiArCQlyZXR1cm4gaGFuZGxl ci0+ZXJyb3I7DQo+ID4gKwl9DQo+ID4gKw0KPiA+ICsJdjRsMl9jdHJsX2hhbmRsZXJfc2V0dXAo JmN0eC0+Y3RybF9oZGwpOw0KPiA+ICsNCj4gPiArCXJldHVybiAwOw0KPiA+ICt9DQo+ID4gKw0K PiA+ICBzdGF0aWMgaW50IG10a19qcGVnX2VudW1fZm10KHN0cnVjdCBtdGtfanBlZ19mbXQgKm10 a19qcGVnX2Zvcm1hdHMsIGludCBuLA0KPiA+ICAJCQkgICAgIHN0cnVjdCB2NGwyX2ZtdGRlc2Mg KmYsIHUzMiB0eXBlKQ0KPiA+ICB7DQo+ID4gQEAgLTExNSwxMTcgKzIzMiwxMDUgQEAgc3RhdGlj IGludCBtdGtfanBlZ19lbnVtX2ZtdChzdHJ1Y3QgbXRrX2pwZWdfZm10ICptdGtfanBlZ19mb3Jt YXRzLCBpbnQgbiwNCj4gPiAgCXJldHVybiAwOw0KPiA+ICB9DQo+ID4gIA0KPiA+IC1zdGF0aWMg aW50IG10a19qcGVnX2VudW1fZm10X3ZpZF9jYXAoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnBy aXYsDQo+ID4gLQkJCQkgICAgIHN0cnVjdCB2NGwyX2ZtdGRlc2MgKmYpDQo+ID4gK3N0YXRpYyBp bnQgbXRrX2pwZWdfZW5jX2VudW1fZm10X3ZpZF9jYXAoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQg KnByaXYsDQo+ID4gKwkJCQkJIHN0cnVjdCB2NGwyX2ZtdGRlc2MgKmYpDQo+ID4gIHsNCj4gPiAt CXJldHVybiBtdGtfanBlZ19lbnVtX2ZtdChtdGtfanBlZ19mb3JtYXRzLCBNVEtfSlBFR19OVU1f Rk9STUFUUywgZiwNCj4gPiArCXJldHVybiBtdGtfanBlZ19lbnVtX2ZtdChtdGtfanBlZ19lbmNf Zm9ybWF0cywNCj4gPiArCQkJCSBNVEtfSlBFR19FTkNfTlVNX0ZPUk1BVFMsIGYsDQo+ID4gKwkJ CQkgTVRLX0pQRUdfRk1UX0ZMQUdfRU5DX0NBUFRVUkUpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtz dGF0aWMgaW50IG10a19qcGVnX2RlY19lbnVtX2ZtdF92aWRfY2FwKHN0cnVjdCBmaWxlICpmaWxl LCB2b2lkICpwcml2LA0KPiA+ICsJCQkJCSBzdHJ1Y3QgdjRsMl9mbXRkZXNjICpmKQ0KPiA+ICt7 DQo+ID4gKwlyZXR1cm4gbXRrX2pwZWdfZW51bV9mbXQobXRrX2pwZWdfZGVjX2Zvcm1hdHMsDQo+ ID4gKwkJCQkgTVRLX0pQRUdfREVDX05VTV9GT1JNQVRTLCBmLA0KPiA+ICAJCQkJIE1US19KUEVH X0ZNVF9GTEFHX0RFQ19DQVBUVVJFKTsNCj4gPiAgfQ0KPiA+ICANCj4gPiAtc3RhdGljIGludCBt dGtfanBlZ19lbnVtX2ZtdF92aWRfb3V0KHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LA0K PiA+IC0JCQkJICAgICBzdHJ1Y3QgdjRsMl9mbXRkZXNjICpmKQ0KPiA+ICtzdGF0aWMgaW50IG10 a19qcGVnX2VuY19lbnVtX2ZtdF92aWRfb3V0KHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2 LA0KPiA+ICsJCQkJCSBzdHJ1Y3QgdjRsMl9mbXRkZXNjICpmKQ0KPiA+ICt7DQo+ID4gKwlyZXR1 cm4gbXRrX2pwZWdfZW51bV9mbXQobXRrX2pwZWdfZW5jX2Zvcm1hdHMsDQo+ID4gKwkJCQkgTVRL X0pQRUdfRU5DX05VTV9GT1JNQVRTLCBmLA0KPiA+ICsJCQkJIE1US19KUEVHX0ZNVF9GTEFHX0VO Q19PVVRQVVQpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgaW50IG10a19qcGVnX2RlY19l bnVtX2ZtdF92aWRfb3V0KHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LA0KPiA+ICsJCQkJ CSBzdHJ1Y3QgdjRsMl9mbXRkZXNjICpmKQ0KPiA+ICB7DQo+ID4gLQlyZXR1cm4gbXRrX2pwZWdf ZW51bV9mbXQobXRrX2pwZWdfZm9ybWF0cywgTVRLX0pQRUdfTlVNX0ZPUk1BVFMsIGYsDQo+ID4g LQkJCQkgTVRLX0pQRUdfRk1UX0ZMQUdfREVDX09VVFBVVCk7DQo+ID4gKwlyZXR1cm4gbXRrX2pw ZWdfZW51bV9mbXQobXRrX2pwZWdfZGVjX2Zvcm1hdHMsIE1US19KUEVHX0RFQ19OVU1fRk9STUFU UywNCj4gPiArCQkJCSBmLCBNVEtfSlBFR19GTVRfRkxBR19ERUNfT1VUUFVUKTsNCj4gPiAgfQ0K PiANCj4gT0ssIHNvIHRoaXMgcGF0Y2ggaXMgdmVyeSBoYXJkIHRvIHJlYWQgYmVjYXVzZSB0aGVy ZSBhcmUgdHdvIGluZGVwZW5kZW50IGNoYW5nZXMNCj4gdGFraW5nIHBsYWNlOg0KPiANCj4gMSkg cmVuYW1lIGV4aXN0aW5nIGZ1bmN0aW9ucy9kZWZpbmVzL3ZhcmlhYmxlcyB3aXRoIGEgX2RlYyBw cmVmaXggdG8gcHJlcGFyZQ0KPiAgICBmb3IgdGhlIGFkZGl0aW9uIG9mIHRoZSBlbmNvZGVyIGZl YXR1cmUuDQo+IA0KPiAyKSBhZGQgdGhlIGVuY29kZXIgZmVhdHVyZS4NCj4gDQo+IFBsZWFzZSBz cGxpdCB1cCB0aGlzIHBhdGNoIGludG8gdHdvIHBhcnRzOiBvbmUgdGhhdCBkb2VzIHRoZSByZW5h bWUgYW5kIGFzIG11Y2ggb2YNCj4gdGhlIHByZXBhcmF0aW9uIHRvIHN1cHBvcnQgYm90aCBkZWNv ZGVyIGFuZCBlbmNvZGVyIHdpdGhvdXQgY2hhbmdpbmcgdGhlDQo+IGZ1bmN0aW9uYWxpdHksIGFu ZCBhIHNlY29uZCBvbmUgdGhhdCBhY3R1YWxseSBhZGRzIHRoZSBuZXcgZW5jb2RlciBmZWF0dXJl Lg0KPiANCj4gSW4gZmFjdCwgb25jZSB0aGF0J3MgZG9uZSBpdCBpcyBsaWtlbHkgdGhhdCBtb3N0 IG9mIHRoaXMgcGF0Y2ggc2VyaWVzIGNhbiBiZQ0KPiBtZXJnZWQsIGV2ZW4gaWYgdGhlcmUgYXJl IHN0aWxsIHRoaW5ncyB0aGF0IG5lZWQgdG8gYmUgY2hhbmdlZCBmb3IgdGhlIGxhc3QNCj4gcGF0 Y2ggYWRkaW5nIHRoZSBlbmNvZGVyIHN1cHBvcnQuIEkgc2VlIG5vdGhpbmcgb2JqZWN0aW9uYWJs ZSBpbiBwYXRjaGVzIDEtMTANCj4gYW5kIDEzLiBTbyBtZXJnaW5nIHRob3NlIHRvZ2V0aGVyIHdp dGggYSBuZXcgcmVuYW1lIHBhdGNoIHdvdWxkbid0IGJlIGFuIGlzc3VlLA0KPiBJIHRoaW5rLg0K PiANCj4gSW4gYW55IGNhc2UsIHRoZSBkaWZmcyBzaG91bGQgYmUgYSBsb3QgY2xlYW5lciBhbmQg ZWFzaWVyIHRvIHJldmlldyBieSBzcGxpdHRpbmcNCj4gaXQgdXAgbGlrZSB0aGF0Lg0KRGVhciBI YW5zLA0KDQpUaGFua3MgZm9yIHlvdXIgZ29vZCBhZHZpY2UuIEkgaGF2ZSBzcGxpdGVkIHVwIHRo aXMgcGF0Y2ggaW50byB0d28NCnBhdGNoZXMgaW4gdjkuDQoNCkJlc3QgUmVnYXJkcywNClhpYSBK aWFuZyANCj4gDQo+IFJlZ2FyZHMsDQo+IA0KPiAJSGFucw0KPiANCj4gPiAgDQo+ID4gLXN0YXRp YyBzdHJ1Y3QgbXRrX2pwZWdfcV9kYXRhICptdGtfanBlZ19nZXRfcV9kYXRhKHN0cnVjdCBtdGtf anBlZ19jdHggKmN0eCwNCj4gPiAtCQkJCQkJICAgZW51bSB2NGwyX2J1Zl90eXBlIHR5cGUpDQo+ ID4gK3N0YXRpYyBzdHJ1Y3QgbXRrX2pwZWdfcV9kYXRhICoNCj4gPiArbXRrX2pwZWdfZ2V0X3Ff ZGF0YShzdHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHgsIGVudW0gdjRsMl9idWZfdHlwZSB0eXBlKQ0K PiA+ICB7DQo+ID4gIAlpZiAoVjRMMl9UWVBFX0lTX09VVFBVVCh0eXBlKSkNCj4gPiAgCQlyZXR1 cm4gJmN0eC0+b3V0X3E7DQo+ID4gIAlyZXR1cm4gJmN0eC0+Y2FwX3E7DQo+ID4gIH0NCj4gPiAg DQo+ID4gLXN0YXRpYyBzdHJ1Y3QgbXRrX2pwZWdfZm10ICptdGtfanBlZ19maW5kX2Zvcm1hdChz dHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHgsDQo+ID4gLQkJCQkJCSB1MzIgcGl4ZWxmb3JtYXQsDQo+ ID4gK3N0YXRpYyBzdHJ1Y3QgbXRrX2pwZWdfZm10ICptdGtfanBlZ19maW5kX2Zvcm1hdCh1MzIg cGl4ZWxmb3JtYXQsDQo+ID4gIAkJCQkJCSB1bnNpZ25lZCBpbnQgZm10X3R5cGUpDQo+ID4gIHsN Cj4gPiAtCXVuc2lnbmVkIGludCBrLCBmbXRfZmxhZzsNCj4gPiAtDQo+ID4gLQlmbXRfZmxhZyA9 IChmbXRfdHlwZSA9PSBNVEtfSlBFR19GTVRfVFlQRV9PVVRQVVQpID8NCj4gPiAtCQkgICBNVEtf SlBFR19GTVRfRkxBR19ERUNfT1VUUFVUIDoNCj4gPiAtCQkgICBNVEtfSlBFR19GTVRfRkxBR19E RUNfQ0FQVFVSRTsNCj4gPiArCXVuc2lnbmVkIGludCBrOw0KPiA+ICsJc3RydWN0IG10a19qcGVn X2ZtdCAqZm10Ow0KPiA+ICANCj4gPiAtCWZvciAoayA9IDA7IGsgPCBNVEtfSlBFR19OVU1fRk9S TUFUUzsgaysrKSB7DQo+ID4gLQkJc3RydWN0IG10a19qcGVnX2ZtdCAqZm10ID0gJm10a19qcGVn X2Zvcm1hdHNba107DQo+ID4gKwlmb3IgKGsgPSAwOyBrIDwgTVRLX0pQRUdfRU5DX05VTV9GT1JN QVRTOyBrKyspIHsNCj4gPiArCQlmbXQgPSAmbXRrX2pwZWdfZW5jX2Zvcm1hdHNba107DQo+ID4g IA0KPiA+IC0JCWlmIChmbXQtPmZvdXJjYyA9PSBwaXhlbGZvcm1hdCAmJiBmbXQtPmZsYWdzICYg Zm10X2ZsYWcpDQo+ID4gKwkJaWYgKGZtdC0+Zm91cmNjID09IHBpeGVsZm9ybWF0ICYmIGZtdC0+ ZmxhZ3MgJiBmbXRfdHlwZSkNCj4gPiAgCQkJcmV0dXJuIGZtdDsNCj4gPiAgCX0NCj4gPiAgDQo+ ID4gLQlyZXR1cm4gTlVMTDsNCj4gPiAtfQ0KPiA+ICsJZm9yIChrID0gMDsgayA8IE1US19KUEVH X0RFQ19OVU1fRk9STUFUUzsgaysrKSB7DQo+ID4gKwkJZm10ID0gJm10a19qcGVnX2RlY19mb3Jt YXRzW2tdOw0KPiA+ICANCj4gPiAtc3RhdGljIHZvaWQgbXRrX2pwZWdfYWRqdXN0X2ZtdF9tcGxh bmUoc3RydWN0IG10a19qcGVnX2N0eCAqY3R4LA0KPiA+IC0JCQkJICAgICAgIHN0cnVjdCB2NGwy X2Zvcm1hdCAqZikNCj4gPiAtew0KPiA+IC0Jc3RydWN0IHY0bDJfcGl4X2Zvcm1hdF9tcGxhbmUg KnBpeF9tcCA9ICZmLT5mbXQucGl4X21wOw0KPiA+IC0Jc3RydWN0IG10a19qcGVnX3FfZGF0YSAq cV9kYXRhOw0KPiA+IC0JaW50IGk7DQo+ID4gLQ0KPiA+IC0JcV9kYXRhID0gbXRrX2pwZWdfZ2V0 X3FfZGF0YShjdHgsIGYtPnR5cGUpOw0KPiA+IC0NCj4gPiAtCXBpeF9tcC0+d2lkdGggPSBxX2Rh dGEtPnc7DQo+ID4gLQlwaXhfbXAtPmhlaWdodCA9IHFfZGF0YS0+aDsNCj4gPiAtCXBpeF9tcC0+ cGl4ZWxmb3JtYXQgPSBxX2RhdGEtPmZtdC0+Zm91cmNjOw0KPiA+IC0JcGl4X21wLT5udW1fcGxh bmVzID0gcV9kYXRhLT5mbXQtPmNvbHBsYW5lczsNCj4gPiAtDQo+ID4gLQlmb3IgKGkgPSAwOyBp IDwgcGl4X21wLT5udW1fcGxhbmVzOyBpKyspIHsNCj4gPiAtCQlwaXhfbXAtPnBsYW5lX2ZtdFtp XS5ieXRlc3BlcmxpbmUgPSBxX2RhdGEtPmJ5dGVzcGVybGluZVtpXTsNCj4gPiAtCQlwaXhfbXAt PnBsYW5lX2ZtdFtpXS5zaXplaW1hZ2UgPSBxX2RhdGEtPnNpemVpbWFnZVtpXTsNCj4gPiArCQlp ZiAoZm10LT5mb3VyY2MgPT0gcGl4ZWxmb3JtYXQgJiYgZm10LT5mbGFncyAmIGZtdF90eXBlKQ0K PiA+ICsJCQlyZXR1cm4gZm10Ow0KPiA+ICAJfQ0KPiA+ICsNCj4gPiArCXJldHVybiBOVUxMOw0K PiA+ICB9DQo+ID4gIA0KPiA+IC1zdGF0aWMgaW50IG10a19qcGVnX3RyeV9mbXRfbXBsYW5lKHN0 cnVjdCB2NGwyX2Zvcm1hdCAqZiwNCj4gPiAtCQkJCSAgIHN0cnVjdCBtdGtfanBlZ19mbXQgKmZt dCwNCj4gPiAtCQkJCSAgIHN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCwgaW50IHFfdHlwZSkNCj4g PiArc3RhdGljIGludCB2aWRpb2NfdHJ5X2ZtdChzdHJ1Y3QgdjRsMl9mb3JtYXQgKmYsIHN0cnVj dCBtdGtfanBlZ19mbXQgKmZtdCkNCj4gPiAgew0KPiA+ICAJc3RydWN0IHY0bDJfcGl4X2Zvcm1h dF9tcGxhbmUgKnBpeF9tcCA9ICZmLT5mbXQucGl4X21wOw0KPiA+ICAJaW50IGk7DQo+ID4gIA0K PiA+IC0JbWVtc2V0KHBpeF9tcC0+cmVzZXJ2ZWQsIDAsIHNpemVvZihwaXhfbXAtPnJlc2VydmVk KSk7DQo+ID4gIAlwaXhfbXAtPmZpZWxkID0gVjRMMl9GSUVMRF9OT05FOw0KPiA+IC0NCj4gPiAt CWlmIChjdHgtPnN0YXRlICE9IE1US19KUEVHX0lOSVQpIHsNCj4gPiAtCQltdGtfanBlZ19hZGp1 c3RfZm10X21wbGFuZShjdHgsIGYpOw0KPiA+IC0JCXJldHVybiAwOw0KPiA+IC0JfQ0KPiA+IC0N Cj4gPiAgCXBpeF9tcC0+bnVtX3BsYW5lcyA9IGZtdC0+Y29scGxhbmVzOw0KPiA+ICAJcGl4X21w LT5waXhlbGZvcm1hdCA9IGZtdC0+Zm91cmNjOw0KPiA+ICANCj4gPiAtCWlmIChxX3R5cGUgPT0g TVRLX0pQRUdfRk1UX1RZUEVfT1VUUFVUKSB7DQo+ID4gLQkJc3RydWN0IHY0bDJfcGxhbmVfcGl4 X2Zvcm1hdCAqcGZtdCA9ICZwaXhfbXAtPnBsYW5lX2ZtdFswXTsNCj4gPiAtDQo+ID4gKwlpZiAo Zm10LT5mb3VyY2MgPT0gVjRMMl9QSVhfRk1UX0pQRUcpIHsNCj4gPiAgCQlwaXhfbXAtPmhlaWdo dCA9IGNsYW1wKHBpeF9tcC0+aGVpZ2h0LCBNVEtfSlBFR19NSU5fSEVJR0hULA0KPiA+ICAJCQkJ ICAgICAgIE1US19KUEVHX01BWF9IRUlHSFQpOw0KPiA+ICAJCXBpeF9tcC0+d2lkdGggPSBjbGFt cChwaXhfbXAtPndpZHRoLCBNVEtfSlBFR19NSU5fV0lEVEgsDQo+ID4gIAkJCQkgICAgICBNVEtf SlBFR19NQVhfV0lEVEgpOw0KPiA+IC0NCj4gPiAtCQltZW1zZXQocGZtdC0+cmVzZXJ2ZWQsIDAs IHNpemVvZihwZm10LT5yZXNlcnZlZCkpOw0KPiA+IC0JCXBmbXQtPmJ5dGVzcGVybGluZSA9IDA7 DQo+ID4gLQkJLyogU291cmNlIHNpemUgbXVzdCBiZSBhbGlnbmVkIHRvIDEyOCAqLw0KPiA+IC0J CXBmbXQtPnNpemVpbWFnZSA9IHJvdW5kX3VwKHBmbXQtPnNpemVpbWFnZSwgMTI4KTsNCj4gPiAt CQlpZiAocGZtdC0+c2l6ZWltYWdlID09IDApDQo+ID4gLQkJCXBmbXQtPnNpemVpbWFnZSA9IE1U S19KUEVHX0RFRkFVTFRfU0laRUlNQUdFOw0KPiA+IC0JCXJldHVybiAwOw0KPiA+ICsJCXBpeF9t cC0+cGxhbmVfZm10WzBdLmJ5dGVzcGVybGluZSA9IDA7DQo+ID4gKwkJcGl4X21wLT5wbGFuZV9m bXRbMF0uc2l6ZWltYWdlID0NCj4gPiArCQkJCXJvdW5kX3VwKHBpeF9tcC0+cGxhbmVfZm10WzBd LnNpemVpbWFnZSwgMTI4KTsNCj4gPiArCQlpZiAocGl4X21wLT5wbGFuZV9mbXRbMF0uc2l6ZWlt YWdlID09IDApDQo+ID4gKwkJCXBpeF9tcC0+cGxhbmVfZm10WzBdLnNpemVpbWFnZSA9DQo+ID4g KwkJCQlNVEtfSlBFR19ERUZBVUxUX1NJWkVJTUFHRTsNCj4gPiArCX0gZWxzZSB7DQo+ID4gKwkJ cGl4X21wLT5oZWlnaHQgPSBjbGFtcChyb3VuZF91cChwaXhfbXAtPmhlaWdodCwgZm10LT52X2Fs aWduKSwNCj4gPiArCQkJCSAgICAgICBNVEtfSlBFR19NSU5fSEVJR0hULA0KPiA+ICsJCQkJICAg ICAgIE1US19KUEVHX01BWF9IRUlHSFQpOw0KPiA+ICsJCXBpeF9tcC0+d2lkdGggPSBjbGFtcChy b3VuZF91cChwaXhfbXAtPndpZHRoLCBmbXQtPmhfYWxpZ24pLA0KPiA+ICsJCQkJICAgICAgTVRL X0pQRUdfTUlOX1dJRFRILCBNVEtfSlBFR19NQVhfV0lEVEgpOw0KPiA+ICsJCWZvciAoaSA9IDA7 IGkgPCBwaXhfbXAtPm51bV9wbGFuZXM7IGkrKykgew0KPiA+ICsJCQlzdHJ1Y3QgdjRsMl9wbGFu ZV9waXhfZm9ybWF0ICpwZm10ID0NCj4gPiArCQkJCQkJCSZwaXhfbXAtPnBsYW5lX2ZtdFtpXTsN Cj4gPiArCQkJdTMyIHN0cmlkZSA9IHBpeF9tcC0+d2lkdGggKiBmbXQtPmhfc2FtcGxlW2ldIC8g NDsNCj4gPiArCQkJdTMyIGggPSBwaXhfbXAtPmhlaWdodCAqIGZtdC0+dl9zYW1wbGVbaV0gLyA0 Ow0KPiA+ICsNCj4gPiArCQkJcGZtdC0+Ynl0ZXNwZXJsaW5lID0gc3RyaWRlOw0KPiA+ICsJCQlw Zm10LT5zaXplaW1hZ2UgPSBzdHJpZGUgKiBoOw0KPiA+ICsJCX0NCj4gPiAgCX0NCj4gPiAgDQo+ ID4gLQkvKiB0eXBlIGlzIE1US19KUEVHX0ZNVF9UWVBFX0NBUFRVUkUgKi8NCj4gPiAtCXBpeF9t cC0+aGVpZ2h0ID0gY2xhbXAocm91bmRfdXAocGl4X21wLT5oZWlnaHQsIGZtdC0+dl9hbGlnbiks DQo+ID4gLQkJCSAgICAgICBNVEtfSlBFR19NSU5fSEVJR0hULCBNVEtfSlBFR19NQVhfSEVJR0hU KTsNCj4gPiAtCXBpeF9tcC0+d2lkdGggPSBjbGFtcChyb3VuZF91cChwaXhfbXAtPndpZHRoLCBm bXQtPmhfYWxpZ24pLA0KPiA+IC0JCQkgICAgICBNVEtfSlBFR19NSU5fV0lEVEgsIE1US19KUEVH X01BWF9XSURUSCk7DQo+ID4gLQ0KPiA+IC0JZm9yIChpID0gMDsgaSA8IGZtdC0+Y29scGxhbmVz OyBpKyspIHsNCj4gPiAtCQlzdHJ1Y3QgdjRsMl9wbGFuZV9waXhfZm9ybWF0ICpwZm10ID0gJnBp eF9tcC0+cGxhbmVfZm10W2ldOw0KPiA+IC0JCXUzMiBzdHJpZGUgPSBwaXhfbXAtPndpZHRoICog Zm10LT5oX3NhbXBsZVtpXSAvIDQ7DQo+ID4gLQkJdTMyIGggPSBwaXhfbXAtPmhlaWdodCAqIGZt dC0+dl9zYW1wbGVbaV0gLyA0Ow0KPiA+IC0NCj4gPiAtCQlwZm10LT5ieXRlc3BlcmxpbmUgPSBz dHJpZGU7DQo+ID4gLQkJcGZtdC0+c2l6ZWltYWdlID0gc3RyaWRlICogaDsNCj4gPiAtCX0NCj4g PiAgCXJldHVybiAwOw0KPiA+ICB9DQo+ID4gIA0KPiA+IEBAIC0yODAsMTQgKzM4NSwzNSBAQCBz dGF0aWMgaW50IG10a19qcGVnX2dfZm10X3ZpZF9tcGxhbmUoc3RydWN0IGZpbGUgKmZpbGUsIHZv aWQgKnByaXYsDQo+ID4gIAlyZXR1cm4gMDsNCj4gPiAgfQ0KPiA+ICANCj4gPiAtc3RhdGljIGlu dCBtdGtfanBlZ190cnlfZm10X3ZpZF9jYXBfbXBsYW5lKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lk ICpwcml2LA0KPiA+IC0JCQkJCSAgIHN0cnVjdCB2NGwyX2Zvcm1hdCAqZikNCj4gPiArc3RhdGlj IGludCBtdGtfanBlZ19lbmNfdHJ5X2ZtdF92aWRfY2FwX21wbGFuZShzdHJ1Y3QgZmlsZSAqZmls ZSwgdm9pZCAqcHJpdiwNCj4gPiArCQkJCQkgICAgICAgc3RydWN0IHY0bDJfZm9ybWF0ICpmKQ0K PiA+ICt7DQo+ID4gKwlzdHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHggPSBtdGtfanBlZ19maF90b19j dHgocHJpdik7DQo+ID4gKwlzdHJ1Y3QgbXRrX2pwZWdfZm10ICpmbXQ7DQo+ID4gKw0KPiA+ICsJ Zm10ID0gbXRrX2pwZWdfZmluZF9mb3JtYXQoZi0+Zm10LnBpeF9tcC5waXhlbGZvcm1hdCwNCj4g PiArCQkJCSAgIE1US19KUEVHX0ZNVF9GTEFHX0VOQ19DQVBUVVJFKTsNCj4gPiArCWlmICghZm10 KQ0KPiA+ICsJCWZtdCA9IGN0eC0+Y2FwX3EuZm10Ow0KPiA+ICsNCj4gPiArCXY0bDJfZGJnKDIs IGRlYnVnLCAmY3R4LT5qcGVnLT52NGwyX2RldiwgIiglZCkgdHJ5X2ZtdDolYyVjJWMlY1xuIiwN Cj4gPiArCQkgZi0+dHlwZSwNCj4gPiArCQkgKGZtdC0+Zm91cmNjICYgMHhmZiksDQo+ID4gKwkJ IChmbXQtPmZvdXJjYyA+PiAgOCAmIDB4ZmYpLA0KPiA+ICsJCSAoZm10LT5mb3VyY2MgPj4gMTYg JiAweGZmKSwNCj4gPiArCQkgKGZtdC0+Zm91cmNjID4+IDI0ICYgMHhmZikpOw0KPiA+ICsNCj4g PiArCXJldHVybiB2aWRpb2NfdHJ5X2ZtdChmLCBmbXQpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtz dGF0aWMgaW50IG10a19qcGVnX2RlY190cnlfZm10X3ZpZF9jYXBfbXBsYW5lKHN0cnVjdCBmaWxl ICpmaWxlLCB2b2lkICpwcml2LA0KPiA+ICsJCQkJCSAgICAgICBzdHJ1Y3QgdjRsMl9mb3JtYXQg KmYpDQo+ID4gIHsNCj4gPiAgCXN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCA9IG10a19qcGVnX2Zo X3RvX2N0eChwcml2KTsNCj4gPiAgCXN0cnVjdCBtdGtfanBlZ19mbXQgKmZtdDsNCj4gPiAgDQo+ ID4gLQlmbXQgPSBtdGtfanBlZ19maW5kX2Zvcm1hdChjdHgsIGYtPmZtdC5waXhfbXAucGl4ZWxm b3JtYXQsDQo+ID4gLQkJCQkgICBNVEtfSlBFR19GTVRfVFlQRV9DQVBUVVJFKTsNCj4gPiArCWZt dCA9IG10a19qcGVnX2ZpbmRfZm9ybWF0KGYtPmZtdC5waXhfbXAucGl4ZWxmb3JtYXQsDQo+ID4g KwkJCQkgICBNVEtfSlBFR19GTVRfRkxBR19ERUNfQ0FQVFVSRSk7DQo+ID4gIAlpZiAoIWZtdCkN Cj4gPiAgCQlmbXQgPSBjdHgtPmNhcF9xLmZtdDsNCj4gPiAgDQo+ID4gQEAgLTI5OCwxNyArNDI0 LDQzIEBAIHN0YXRpYyBpbnQgbXRrX2pwZWdfdHJ5X2ZtdF92aWRfY2FwX21wbGFuZShzdHJ1Y3Qg ZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwNCj4gPiAgCQkgKGZtdC0+Zm91cmNjID4+IDE2ICYgMHhm ZiksDQo+ID4gIAkJIChmbXQtPmZvdXJjYyA+PiAyNCAmIDB4ZmYpKTsNCj4gPiAgDQo+ID4gLQly ZXR1cm4gbXRrX2pwZWdfdHJ5X2ZtdF9tcGxhbmUoZiwgZm10LCBjdHgsIE1US19KUEVHX0ZNVF9U WVBFX0NBUFRVUkUpOw0KPiA+ICsJaWYgKGN0eC0+c3RhdGUgIT0gTVRLX0pQRUdfSU5JVCkgew0K PiA+ICsJCW10a19qcGVnX2dfZm10X3ZpZF9tcGxhbmUoZmlsZSwgcHJpdiwgZik7DQo+ID4gKwkJ cmV0dXJuIDA7DQo+ID4gKwl9DQo+ID4gKw0KPiA+ICsJcmV0dXJuIHZpZGlvY190cnlfZm10KGYs IGZtdCk7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyBpbnQgbXRrX2pwZWdfZW5jX3RyeV9m bXRfdmlkX291dF9tcGxhbmUoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsDQo+ID4gKwkJ CQkJICAgICAgIHN0cnVjdCB2NGwyX2Zvcm1hdCAqZikNCj4gPiArew0KPiA+ICsJc3RydWN0IG10 a19qcGVnX2N0eCAqY3R4ID0gbXRrX2pwZWdfZmhfdG9fY3R4KHByaXYpOw0KPiA+ICsJc3RydWN0 IG10a19qcGVnX2ZtdCAqZm10Ow0KPiA+ICsNCj4gPiArCWZtdCA9IG10a19qcGVnX2ZpbmRfZm9y bWF0KGYtPmZtdC5waXhfbXAucGl4ZWxmb3JtYXQsDQo+ID4gKwkJCQkgICBNVEtfSlBFR19GTVRf RkxBR19FTkNfT1VUUFVUKTsNCj4gPiArCWlmICghZm10KQ0KPiA+ICsJCWZtdCA9IGN0eC0+b3V0 X3EuZm10Ow0KPiA+ICsNCj4gPiArCXY0bDJfZGJnKDIsIGRlYnVnLCAmY3R4LT5qcGVnLT52NGwy X2RldiwgIiglZCkgdHJ5X2ZtdDolYyVjJWMlY1xuIiwNCj4gPiArCQkgZi0+dHlwZSwNCj4gPiAr CQkgKGZtdC0+Zm91cmNjICYgMHhmZiksDQo+ID4gKwkJIChmbXQtPmZvdXJjYyA+PiAgOCAmIDB4 ZmYpLA0KPiA+ICsJCSAoZm10LT5mb3VyY2MgPj4gMTYgJiAweGZmKSwNCj4gPiArCQkgKGZtdC0+ Zm91cmNjID4+IDI0ICYgMHhmZikpOw0KPiA+ICsNCj4gPiArCXJldHVybiB2aWRpb2NfdHJ5X2Zt dChmLCBmbXQpOw0KPiA+ICB9DQo+ID4gIA0KPiA+IC1zdGF0aWMgaW50IG10a19qcGVnX3RyeV9m bXRfdmlkX291dF9tcGxhbmUoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsDQo+ID4gLQkJ CQkJICAgc3RydWN0IHY0bDJfZm9ybWF0ICpmKQ0KPiA+ICtzdGF0aWMgaW50IG10a19qcGVnX2Rl Y190cnlfZm10X3ZpZF9vdXRfbXBsYW5lKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LA0K PiA+ICsJCQkJCSAgICAgICBzdHJ1Y3QgdjRsMl9mb3JtYXQgKmYpDQo+ID4gIHsNCj4gPiAgCXN0 cnVjdCBtdGtfanBlZ19jdHggKmN0eCA9IG10a19qcGVnX2ZoX3RvX2N0eChwcml2KTsNCj4gPiAg CXN0cnVjdCBtdGtfanBlZ19mbXQgKmZtdDsNCj4gPiAgDQo+ID4gLQlmbXQgPSBtdGtfanBlZ19m aW5kX2Zvcm1hdChjdHgsIGYtPmZtdC5waXhfbXAucGl4ZWxmb3JtYXQsDQo+ID4gLQkJCQkgICBN VEtfSlBFR19GTVRfVFlQRV9PVVRQVVQpOw0KPiA+ICsJZm10ID0gbXRrX2pwZWdfZmluZF9mb3Jt YXQoZi0+Zm10LnBpeF9tcC5waXhlbGZvcm1hdCwNCj4gPiArCQkJCSAgIE1US19KUEVHX0ZNVF9G TEFHX0RFQ19PVVRQVVQpOw0KPiA+ICAJaWYgKCFmbXQpDQo+ID4gIAkJZm10ID0gY3R4LT5vdXRf cS5mbXQ7DQo+ID4gIA0KPiA+IEBAIC0zMTksMTcgKzQ3MSwyMSBAQCBzdGF0aWMgaW50IG10a19q cGVnX3RyeV9mbXRfdmlkX291dF9tcGxhbmUoc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYs DQo+ID4gIAkJIChmbXQtPmZvdXJjYyA+PiAxNiAmIDB4ZmYpLA0KPiA+ICAJCSAoZm10LT5mb3Vy Y2MgPj4gMjQgJiAweGZmKSk7DQo+ID4gIA0KPiA+IC0JcmV0dXJuIG10a19qcGVnX3RyeV9mbXRf bXBsYW5lKGYsIGZtdCwgY3R4LCBNVEtfSlBFR19GTVRfVFlQRV9PVVRQVVQpOw0KPiA+ICsJaWYg KGN0eC0+c3RhdGUgIT0gTVRLX0pQRUdfSU5JVCkgew0KPiA+ICsJCW10a19qcGVnX2dfZm10X3Zp ZF9tcGxhbmUoZmlsZSwgcHJpdiwgZik7DQo+ID4gKwkJcmV0dXJuIDA7DQo+ID4gKwl9DQo+ID4g Kw0KPiA+ICsJcmV0dXJuIHZpZGlvY190cnlfZm10KGYsIGZtdCk7DQo+ID4gIH0NCj4gPiAgDQo+ ID4gIHN0YXRpYyBpbnQgbXRrX2pwZWdfc19mbXRfbXBsYW5lKHN0cnVjdCBtdGtfanBlZ19jdHgg KmN0eCwNCj4gPiAtCQkJCSBzdHJ1Y3QgdjRsMl9mb3JtYXQgKmYpDQo+ID4gKwkJCQkgc3RydWN0 IHY0bDJfZm9ybWF0ICpmLCB1bnNpZ25lZCBpbnQgZm10X3R5cGUpDQo+ID4gIHsNCj4gPiAgCXN0 cnVjdCB2YjJfcXVldWUgKnZxOw0KPiA+ICAJc3RydWN0IG10a19qcGVnX3FfZGF0YSAqcV9kYXRh ID0gTlVMTDsNCj4gPiAgCXN0cnVjdCB2NGwyX3BpeF9mb3JtYXRfbXBsYW5lICpwaXhfbXAgPSAm Zi0+Zm10LnBpeF9tcDsNCj4gPiAgCXN0cnVjdCBtdGtfanBlZ19kZXYgKmpwZWcgPSBjdHgtPmpw ZWc7DQo+ID4gLQl1bnNpZ25lZCBpbnQgZl90eXBlOw0KPiA+ICAJaW50IGk7DQo+ID4gIA0KPiA+ ICAJdnEgPSB2NGwyX20ybV9nZXRfdnEoY3R4LT5maC5tMm1fY3R4LCBmLT50eXBlKTsNCj4gPiBA QCAtMzQzLDEwICs0OTksNyBAQCBzdGF0aWMgaW50IG10a19qcGVnX3NfZm10X21wbGFuZShzdHJ1 Y3QgbXRrX2pwZWdfY3R4ICpjdHgsDQo+ID4gIAkJcmV0dXJuIC1FQlVTWTsNCj4gPiAgCX0NCj4g PiAgDQo+ID4gLQlmX3R5cGUgPSBWNEwyX1RZUEVfSVNfT1VUUFVUKGYtPnR5cGUpID8NCj4gPiAt CQkJIE1US19KUEVHX0ZNVF9UWVBFX09VVFBVVCA6IE1US19KUEVHX0ZNVF9UWVBFX0NBUFRVUkU7 DQo+ID4gLQ0KPiA+IC0JcV9kYXRhLT5mbXQgPSBtdGtfanBlZ19maW5kX2Zvcm1hdChjdHgsIHBp eF9tcC0+cGl4ZWxmb3JtYXQsIGZfdHlwZSk7DQo+ID4gKwlxX2RhdGEtPmZtdCA9IG10a19qcGVn X2ZpbmRfZm9ybWF0KHBpeF9tcC0+cGl4ZWxmb3JtYXQsIGZtdF90eXBlKTsNCj4gPiAgCXFfZGF0 YS0+dyA9IHBpeF9tcC0+d2lkdGg7DQo+ID4gIAlxX2RhdGEtPmggPSBwaXhfbXAtPmhlaWdodDsN Cj4gPiAgCWN0eC0+Y29sb3JzcGFjZSA9IHBpeF9tcC0+Y29sb3JzcGFjZTsNCj4gPiBAQCAtMzc0 LDI4ICs1MjcsNTYgQEAgc3RhdGljIGludCBtdGtfanBlZ19zX2ZtdF9tcGxhbmUoc3RydWN0IG10 a19qcGVnX2N0eCAqY3R4LA0KPiA+ICAJcmV0dXJuIDA7DQo+ID4gIH0NCj4gPiAgDQo+ID4gLXN0 YXRpYyBpbnQgbXRrX2pwZWdfc19mbXRfdmlkX291dF9tcGxhbmUoc3RydWN0IGZpbGUgKmZpbGUs IHZvaWQgKnByaXYsDQo+ID4gLQkJCQkJIHN0cnVjdCB2NGwyX2Zvcm1hdCAqZikNCj4gPiArc3Rh dGljIGludCBtdGtfanBlZ19lbmNfc19mbXRfdmlkX291dF9tcGxhbmUoc3RydWN0IGZpbGUgKmZp bGUsIHZvaWQgKnByaXYsDQo+ID4gKwkJCQkJICAgICBzdHJ1Y3QgdjRsMl9mb3JtYXQgKmYpDQo+ ID4gK3sNCj4gPiArCWludCByZXQ7DQo+ID4gKw0KPiA+ICsJcmV0ID0gbXRrX2pwZWdfZW5jX3Ry eV9mbXRfdmlkX291dF9tcGxhbmUoZmlsZSwgcHJpdiwgZik7DQo+ID4gKwlpZiAocmV0KQ0KPiA+ ICsJCXJldHVybiByZXQ7DQo+ID4gKw0KPiA+ICsJcmV0dXJuIG10a19qcGVnX3NfZm10X21wbGFu ZShtdGtfanBlZ19maF90b19jdHgocHJpdiksIGYsDQo+ID4gKwkJCQkgICAgIE1US19KUEVHX0ZN VF9GTEFHX0VOQ19PVVRQVVQpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgaW50IG10a19q cGVnX2RlY19zX2ZtdF92aWRfb3V0X21wbGFuZShzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJp diwNCj4gPiArCQkJCQkgICAgIHN0cnVjdCB2NGwyX2Zvcm1hdCAqZikNCj4gPiAgew0KPiA+ICAJ aW50IHJldDsNCj4gPiAgDQo+ID4gLQlyZXQgPSBtdGtfanBlZ190cnlfZm10X3ZpZF9vdXRfbXBs YW5lKGZpbGUsIHByaXYsIGYpOw0KPiA+ICsJcmV0ID0gbXRrX2pwZWdfZGVjX3RyeV9mbXRfdmlk X291dF9tcGxhbmUoZmlsZSwgcHJpdiwgZik7DQo+ID4gIAlpZiAocmV0KQ0KPiA+ICAJCXJldHVy biByZXQ7DQo+ID4gIA0KPiA+IC0JcmV0dXJuIG10a19qcGVnX3NfZm10X21wbGFuZShtdGtfanBl Z19maF90b19jdHgocHJpdiksIGYpOw0KPiA+ICsJcmV0dXJuIG10a19qcGVnX3NfZm10X21wbGFu ZShtdGtfanBlZ19maF90b19jdHgocHJpdiksIGYsDQo+ID4gKwkJCQkgICAgIE1US19KUEVHX0ZN VF9GTEFHX0RFQ19PVVRQVVQpOw0KPiA+ICB9DQo+ID4gIA0KPiA+IC1zdGF0aWMgaW50IG10a19q cGVnX3NfZm10X3ZpZF9jYXBfbXBsYW5lKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LA0K PiA+IC0JCQkJCSBzdHJ1Y3QgdjRsMl9mb3JtYXQgKmYpDQo+ID4gK3N0YXRpYyBpbnQgbXRrX2pw ZWdfZW5jX3NfZm10X3ZpZF9jYXBfbXBsYW5lKHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2 LA0KPiA+ICsJCQkJCSAgICAgc3RydWN0IHY0bDJfZm9ybWF0ICpmKQ0KPiA+ICB7DQo+ID4gIAlp bnQgcmV0Ow0KPiA+ICANCj4gPiAtCXJldCA9IG10a19qcGVnX3RyeV9mbXRfdmlkX2NhcF9tcGxh bmUoZmlsZSwgcHJpdiwgZik7DQo+ID4gKwlyZXQgPSBtdGtfanBlZ19lbmNfdHJ5X2ZtdF92aWRf Y2FwX21wbGFuZShmaWxlLCBwcml2LCBmKTsNCj4gPiAgCWlmIChyZXQpDQo+ID4gIAkJcmV0dXJu IHJldDsNCj4gPiAgDQo+ID4gLQlyZXR1cm4gbXRrX2pwZWdfc19mbXRfbXBsYW5lKG10a19qcGVn X2ZoX3RvX2N0eChwcml2KSwgZik7DQo+ID4gKwlyZXR1cm4gbXRrX2pwZWdfc19mbXRfbXBsYW5l KG10a19qcGVnX2ZoX3RvX2N0eChwcml2KSwgZiwNCj4gPiArCQkJCSAgICAgTVRLX0pQRUdfRk1U X0ZMQUdfRU5DX0NBUFRVUkUpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgaW50IG10a19q cGVnX2RlY19zX2ZtdF92aWRfY2FwX21wbGFuZShzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJp diwNCj4gPiArCQkJCQkgICAgIHN0cnVjdCB2NGwyX2Zvcm1hdCAqZikNCj4gPiArew0KPiA+ICsJ aW50IHJldDsNCj4gPiArDQo+ID4gKwlyZXQgPSBtdGtfanBlZ19kZWNfdHJ5X2ZtdF92aWRfY2Fw X21wbGFuZShmaWxlLCBwcml2LCBmKTsNCj4gPiArCWlmIChyZXQpDQo+ID4gKwkJcmV0dXJuIHJl dDsNCj4gPiArDQo+ID4gKwlyZXR1cm4gbXRrX2pwZWdfc19mbXRfbXBsYW5lKG10a19qcGVnX2Zo X3RvX2N0eChwcml2KSwgZiwNCj4gPiArCQkJCSAgICAgTVRLX0pQRUdfRk1UX0ZMQUdfREVDX0NB UFRVUkUpOw0KPiA+ICB9DQo+ID4gIA0KPiA+ICBzdGF0aWMgdm9pZCBtdGtfanBlZ19xdWV1ZV9z cmNfY2hnX2V2ZW50KHN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCkNCj4gPiBAQCAtNDIwLDggKzYw MSwzMSBAQCBzdGF0aWMgaW50IG10a19qcGVnX3N1YnNjcmliZV9ldmVudChzdHJ1Y3QgdjRsMl9m aCAqZmgsDQo+ID4gIAlyZXR1cm4gdjRsMl9jdHJsX3N1YnNjcmliZV9ldmVudChmaCwgc3ViKTsN Cj4gPiAgfQ0KPiA+ICANCj4gPiAtc3RhdGljIGludCBtdGtfanBlZ19nX3NlbGVjdGlvbihzdHJ1 Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwNCj4gPiAtCQkJCXN0cnVjdCB2NGwyX3NlbGVjdGlv biAqcykNCj4gPiArc3RhdGljIGludCBtdGtfanBlZ19lbmNfZ19zZWxlY3Rpb24oc3RydWN0IGZp bGUgKmZpbGUsIHZvaWQgKnByaXYsDQo+ID4gKwkJCQkgICAgc3RydWN0IHY0bDJfc2VsZWN0aW9u ICpzKQ0KPiA+ICt7DQo+ID4gKwlzdHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHggPSBtdGtfanBlZ19m aF90b19jdHgocHJpdik7DQo+ID4gKw0KPiA+ICsJaWYgKHMtPnR5cGUgIT0gVjRMMl9CVUZfVFlQ RV9WSURFT19PVVRQVVQpDQo+ID4gKwkJcmV0dXJuIC1FSU5WQUw7DQo+ID4gKw0KPiA+ICsJc3dp dGNoIChzLT50YXJnZXQpIHsNCj4gPiArCWNhc2UgVjRMMl9TRUxfVEdUX0NST1A6DQo+ID4gKwlj YXNlIFY0TDJfU0VMX1RHVF9DUk9QX0JPVU5EUzoNCj4gPiArCWNhc2UgVjRMMl9TRUxfVEdUX0NS T1BfREVGQVVMVDoNCj4gPiArCQlzLT5yLndpZHRoID0gY3R4LT5vdXRfcS53Ow0KPiA+ICsJCXMt PnIuaGVpZ2h0ID0gY3R4LT5vdXRfcS5oOw0KPiA+ICsJCXMtPnIubGVmdCA9IDA7DQo+ID4gKwkJ cy0+ci50b3AgPSAwOw0KPiA+ICsJCWJyZWFrOw0KPiA+ICsJZGVmYXVsdDoNCj4gPiArCQlyZXR1 cm4gLUVJTlZBTDsNCj4gPiArCX0NCj4gPiArCXJldHVybiAwOw0KPiA+ICt9DQo+ID4gKw0KPiA+ ICtzdGF0aWMgaW50IG10a19qcGVnX2RlY19nX3NlbGVjdGlvbihzdHJ1Y3QgZmlsZSAqZmlsZSwg dm9pZCAqcHJpdiwNCj4gPiArCQkJCSAgICBzdHJ1Y3QgdjRsMl9zZWxlY3Rpb24gKnMpDQo+ID4g IHsNCj4gPiAgCXN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCA9IG10a19qcGVnX2ZoX3RvX2N0eChw cml2KTsNCj4gPiAgDQo+ID4gQEAgLTQ0NiwxMSArNjUwLDM0IEBAIHN0YXRpYyBpbnQgbXRrX2pw ZWdfZ19zZWxlY3Rpb24oc3RydWN0IGZpbGUgKmZpbGUsIHZvaWQgKnByaXYsDQo+ID4gIAlkZWZh dWx0Og0KPiA+ICAJCXJldHVybiAtRUlOVkFMOw0KPiA+ICAJfQ0KPiA+ICsNCj4gPiAgCXJldHVy biAwOw0KPiA+ICB9DQo+ID4gIA0KPiA+IC1zdGF0aWMgaW50IG10a19qcGVnX3Nfc2VsZWN0aW9u KHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpwcml2LA0KPiA+IC0JCQkJc3RydWN0IHY0bDJfc2Vs ZWN0aW9uICpzKQ0KPiA+ICtzdGF0aWMgaW50IG10a19qcGVnX2VuY19zX3NlbGVjdGlvbihzdHJ1 Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwNCj4gPiArCQkJCSAgICBzdHJ1Y3QgdjRsMl9zZWxl Y3Rpb24gKnMpDQo+ID4gK3sNCj4gPiArCXN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCA9IG10a19q cGVnX2ZoX3RvX2N0eChwcml2KTsNCj4gPiArDQo+ID4gKwlpZiAocy0+dHlwZSAhPSBWNEwyX0JV Rl9UWVBFX1ZJREVPX09VVFBVVCkNCj4gPiArCQlyZXR1cm4gLUVJTlZBTDsNCj4gPiArDQo+ID4g Kwlzd2l0Y2ggKHMtPnRhcmdldCkgew0KPiA+ICsJY2FzZSBWNEwyX1NFTF9UR1RfQ1JPUDoNCj4g PiArCQlzLT5yLmxlZnQgPSAwOw0KPiA+ICsJCXMtPnIudG9wID0gMDsNCj4gPiArCQljdHgtPm91 dF9xLncgPSBtaW4ocy0+ci53aWR0aCwgY3R4LT5vdXRfcS53KTsNCj4gPiArCQljdHgtPm91dF9x LmggPSBtaW4ocy0+ci5oZWlnaHQsIGN0eC0+b3V0X3EuaCk7DQo+ID4gKwkJYnJlYWs7DQo+ID4g KwlkZWZhdWx0Og0KPiA+ICsJCXJldHVybiAtRUlOVkFMOw0KPiA+ICsJfQ0KPiA+ICsNCj4gPiAr CXJldHVybiAwOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgaW50IG10a19qcGVnX2RlY19z X3NlbGVjdGlvbihzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqcHJpdiwNCj4gPiArCQkJCSAgICBz dHJ1Y3QgdjRsMl9zZWxlY3Rpb24gKnMpDQo+ID4gIHsNCj4gPiAgCXN0cnVjdCBtdGtfanBlZ19j dHggKmN0eCA9IG10a19qcGVnX2ZoX3RvX2N0eChwcml2KTsNCj4gPiAgDQo+ID4gQEAgLTQ2Nyw2 ICs2OTQsNyBAQCBzdGF0aWMgaW50IG10a19qcGVnX3Nfc2VsZWN0aW9uKHN0cnVjdCBmaWxlICpm aWxlLCB2b2lkICpwcml2LA0KPiA+ICAJZGVmYXVsdDoNCj4gPiAgCQlyZXR1cm4gLUVJTlZBTDsN Cj4gPiAgCX0NCj4gPiArDQo+ID4gIAlyZXR1cm4gMDsNCj4gPiAgfQ0KPiA+ICANCj4gPiBAQCAt NDk1LDIwICs3MjMsNDcgQEAgc3RhdGljIGludCBtdGtfanBlZ19xYnVmKHN0cnVjdCBmaWxlICpm aWxlLCB2b2lkICpwcml2LCBzdHJ1Y3QgdjRsMl9idWZmZXIgKmJ1ZikNCj4gPiAgCXJldHVybiB2 NGwyX20ybV9xYnVmKGZpbGUsIGZoLT5tMm1fY3R4LCBidWYpOw0KPiA+ICB9DQo+ID4gIA0KPiA+ IC1zdGF0aWMgY29uc3Qgc3RydWN0IHY0bDJfaW9jdGxfb3BzIG10a19qcGVnX2lvY3RsX29wcyA9 IHsNCj4gPiAtCS52aWRpb2NfcXVlcnljYXAgICAgICAgICAgICAgICAgPSBtdGtfanBlZ19xdWVy eWNhcCwNCj4gPiAtCS52aWRpb2NfZW51bV9mbXRfdmlkX2NhcAk9IG10a19qcGVnX2VudW1fZm10 X3ZpZF9jYXAsDQo+ID4gLQkudmlkaW9jX2VudW1fZm10X3ZpZF9vdXQJPSBtdGtfanBlZ19lbnVt X2ZtdF92aWRfb3V0LA0KPiA+IC0JLnZpZGlvY190cnlfZm10X3ZpZF9jYXBfbXBsYW5lCT0gbXRr X2pwZWdfdHJ5X2ZtdF92aWRfY2FwX21wbGFuZSwNCj4gPiAtCS52aWRpb2NfdHJ5X2ZtdF92aWRf b3V0X21wbGFuZQk9IG10a19qcGVnX3RyeV9mbXRfdmlkX291dF9tcGxhbmUsDQo+ID4gK3N0YXRp YyBjb25zdCBzdHJ1Y3QgdjRsMl9pb2N0bF9vcHMgbXRrX2pwZWdfZW5jX2lvY3RsX29wcyA9IHsN Cj4gPiArCS52aWRpb2NfcXVlcnljYXAgICAgICAgICAgICAgICAgPSBtdGtfanBlZ19lbmNfcXVl cnljYXAsDQo+ID4gKwkudmlkaW9jX2VudW1fZm10X3ZpZF9jYXAJPSBtdGtfanBlZ19lbmNfZW51 bV9mbXRfdmlkX2NhcCwNCj4gPiArCS52aWRpb2NfZW51bV9mbXRfdmlkX291dAk9IG10a19qcGVn X2VuY19lbnVtX2ZtdF92aWRfb3V0LA0KPiA+ICsJLnZpZGlvY190cnlfZm10X3ZpZF9jYXBfbXBs YW5lCT0gbXRrX2pwZWdfZW5jX3RyeV9mbXRfdmlkX2NhcF9tcGxhbmUsDQo+ID4gKwkudmlkaW9j X3RyeV9mbXRfdmlkX291dF9tcGxhbmUJPSBtdGtfanBlZ19lbmNfdHJ5X2ZtdF92aWRfb3V0X21w bGFuZSwNCj4gPiArCS52aWRpb2NfZ19mbXRfdmlkX2NhcF9tcGxhbmUgICAgPSBtdGtfanBlZ19n X2ZtdF92aWRfbXBsYW5lLA0KPiA+ICsJLnZpZGlvY19nX2ZtdF92aWRfb3V0X21wbGFuZSAgICA9 IG10a19qcGVnX2dfZm10X3ZpZF9tcGxhbmUsDQo+ID4gKwkudmlkaW9jX3NfZm10X3ZpZF9jYXBf bXBsYW5lICAgID0gbXRrX2pwZWdfZW5jX3NfZm10X3ZpZF9jYXBfbXBsYW5lLA0KPiA+ICsJLnZp ZGlvY19zX2ZtdF92aWRfb3V0X21wbGFuZSAgICA9IG10a19qcGVnX2VuY19zX2ZtdF92aWRfb3V0 X21wbGFuZSwNCj4gPiArCS52aWRpb2NfcWJ1ZiAgICAgICAgICAgICAgICAgICAgPSBtdGtfanBl Z19xYnVmLA0KPiA+ICsJLnZpZGlvY19zdWJzY3JpYmVfZXZlbnQgICAgICAgICA9IG10a19qcGVn X3N1YnNjcmliZV9ldmVudCwNCj4gPiArCS52aWRpb2NfZ19zZWxlY3Rpb24JCT0gbXRrX2pwZWdf ZW5jX2dfc2VsZWN0aW9uLA0KPiA+ICsJLnZpZGlvY19zX3NlbGVjdGlvbgkJPSBtdGtfanBlZ19l bmNfc19zZWxlY3Rpb24sDQo+ID4gKw0KPiA+ICsJLnZpZGlvY19jcmVhdGVfYnVmcwkJPSB2NGwy X20ybV9pb2N0bF9jcmVhdGVfYnVmcywNCj4gPiArCS52aWRpb2NfcHJlcGFyZV9idWYJCT0gdjRs Ml9tMm1faW9jdGxfcHJlcGFyZV9idWYsDQo+ID4gKwkudmlkaW9jX3JlcWJ1ZnMgICAgICAgICAg ICAgICAgID0gdjRsMl9tMm1faW9jdGxfcmVxYnVmcywNCj4gPiArCS52aWRpb2NfcXVlcnlidWYg ICAgICAgICAgICAgICAgPSB2NGwyX20ybV9pb2N0bF9xdWVyeWJ1ZiwNCj4gPiArCS52aWRpb2Nf ZHFidWYgICAgICAgICAgICAgICAgICAgPSB2NGwyX20ybV9pb2N0bF9kcWJ1ZiwNCj4gPiArCS52 aWRpb2NfZXhwYnVmICAgICAgICAgICAgICAgICAgPSB2NGwyX20ybV9pb2N0bF9leHBidWYsDQo+ ID4gKwkudmlkaW9jX3N0cmVhbW9uICAgICAgICAgICAgICAgID0gdjRsMl9tMm1faW9jdGxfc3Ry ZWFtb24sDQo+ID4gKwkudmlkaW9jX3N0cmVhbW9mZiAgICAgICAgICAgICAgID0gdjRsMl9tMm1f aW9jdGxfc3RyZWFtb2ZmLA0KPiA+ICsNCj4gPiArCS52aWRpb2NfdW5zdWJzY3JpYmVfZXZlbnQJ PSB2NGwyX2V2ZW50X3Vuc3Vic2NyaWJlLA0KPiA+ICt9Ow0KPiA+ICsNCj4gPiArc3RhdGljIGNv bnN0IHN0cnVjdCB2NGwyX2lvY3RsX29wcyBtdGtfanBlZ19kZWNfaW9jdGxfb3BzID0gew0KPiA+ ICsJLnZpZGlvY19xdWVyeWNhcCAgICAgICAgICAgICAgICA9IG10a19qcGVnX2RlY19xdWVyeWNh cCwNCj4gPiArCS52aWRpb2NfZW51bV9mbXRfdmlkX2NhcAk9IG10a19qcGVnX2RlY19lbnVtX2Zt dF92aWRfY2FwLA0KPiA+ICsJLnZpZGlvY19lbnVtX2ZtdF92aWRfb3V0CT0gbXRrX2pwZWdfZGVj X2VudW1fZm10X3ZpZF9vdXQsDQo+ID4gKwkudmlkaW9jX3RyeV9mbXRfdmlkX2NhcF9tcGxhbmUJ PSBtdGtfanBlZ19kZWNfdHJ5X2ZtdF92aWRfY2FwX21wbGFuZSwNCj4gPiArCS52aWRpb2NfdHJ5 X2ZtdF92aWRfb3V0X21wbGFuZQk9IG10a19qcGVnX2RlY190cnlfZm10X3ZpZF9vdXRfbXBsYW5l LA0KPiA+ICAJLnZpZGlvY19nX2ZtdF92aWRfY2FwX21wbGFuZSAgICA9IG10a19qcGVnX2dfZm10 X3ZpZF9tcGxhbmUsDQo+ID4gIAkudmlkaW9jX2dfZm10X3ZpZF9vdXRfbXBsYW5lICAgID0gbXRr X2pwZWdfZ19mbXRfdmlkX21wbGFuZSwNCj4gPiAtCS52aWRpb2Nfc19mbXRfdmlkX2NhcF9tcGxh bmUgICAgPSBtdGtfanBlZ19zX2ZtdF92aWRfY2FwX21wbGFuZSwNCj4gPiAtCS52aWRpb2Nfc19m bXRfdmlkX291dF9tcGxhbmUgICAgPSBtdGtfanBlZ19zX2ZtdF92aWRfb3V0X21wbGFuZSwNCj4g PiArCS52aWRpb2Nfc19mbXRfdmlkX2NhcF9tcGxhbmUgICAgPSBtdGtfanBlZ19kZWNfc19mbXRf dmlkX2NhcF9tcGxhbmUsDQo+ID4gKwkudmlkaW9jX3NfZm10X3ZpZF9vdXRfbXBsYW5lICAgID0g bXRrX2pwZWdfZGVjX3NfZm10X3ZpZF9vdXRfbXBsYW5lLA0KPiA+ICAJLnZpZGlvY19xYnVmICAg ICAgICAgICAgICAgICAgICA9IG10a19qcGVnX3FidWYsDQo+ID4gIAkudmlkaW9jX3N1YnNjcmli ZV9ldmVudCAgICAgICAgID0gbXRrX2pwZWdfc3Vic2NyaWJlX2V2ZW50LA0KPiA+IC0JLnZpZGlv Y19nX3NlbGVjdGlvbgkJPSBtdGtfanBlZ19nX3NlbGVjdGlvbiwNCj4gPiAtCS52aWRpb2Nfc19z ZWxlY3Rpb24JCT0gbXRrX2pwZWdfc19zZWxlY3Rpb24sDQo+ID4gKwkudmlkaW9jX2dfc2VsZWN0 aW9uCQk9IG10a19qcGVnX2RlY19nX3NlbGVjdGlvbiwNCj4gPiArCS52aWRpb2Nfc19zZWxlY3Rp b24JCT0gbXRrX2pwZWdfZGVjX3Nfc2VsZWN0aW9uLA0KPiA+ICANCj4gPiAgCS52aWRpb2NfY3Jl YXRlX2J1ZnMJCT0gdjRsMl9tMm1faW9jdGxfY3JlYXRlX2J1ZnMsDQo+ID4gIAkudmlkaW9jX3By ZXBhcmVfYnVmCQk9IHY0bDJfbTJtX2lvY3RsX3ByZXBhcmVfYnVmLA0KPiA+IEBAIC01ODYsOCAr ODQxLDkgQEAgc3RhdGljIGJvb2wgbXRrX2pwZWdfY2hlY2tfcmVzb2x1dGlvbl9jaGFuZ2Uoc3Ry dWN0IG10a19qcGVnX2N0eCAqY3R4LA0KPiA+ICAJfQ0KPiA+ICANCj4gPiAgCXFfZGF0YSA9ICZj dHgtPmNhcF9xOw0KPiA+IC0JaWYgKHFfZGF0YS0+Zm10ICE9IG10a19qcGVnX2ZpbmRfZm9ybWF0 KGN0eCwgcGFyYW0tPmRzdF9mb3VyY2MsDQo+ID4gLQkJCQkJCU1US19KUEVHX0ZNVF9UWVBFX0NB UFRVUkUpKSB7DQo+ID4gKwlpZiAocV9kYXRhLT5mbXQgIT0NCj4gPiArCSAgICBtdGtfanBlZ19m aW5kX2Zvcm1hdChwYXJhbS0+ZHN0X2ZvdXJjYywNCj4gPiArCQkJCSBNVEtfSlBFR19GTVRfRkxB R19ERUNfQ0FQVFVSRSkpIHsNCj4gPiAgCQl2NGwyX2RiZygxLCBkZWJ1ZywgJmpwZWctPnY0bDJf ZGV2LCAiZm9ybWF0IGNoYW5nZVxuIik7DQo+ID4gIAkJcmV0dXJuIHRydWU7DQo+ID4gIAl9DQo+ ID4gQEAgLTYwOCw5ICs4NjQsOCBAQCBzdGF0aWMgdm9pZCBtdGtfanBlZ19zZXRfcXVldWVfZGF0 YShzdHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHgsDQo+ID4gIAlxX2RhdGEgPSAmY3R4LT5jYXBfcTsN Cj4gPiAgCXFfZGF0YS0+dyA9IHBhcmFtLT5kZWNfdzsNCj4gPiAgCXFfZGF0YS0+aCA9IHBhcmFt LT5kZWNfaDsNCj4gPiAtCXFfZGF0YS0+Zm10ID0gbXRrX2pwZWdfZmluZF9mb3JtYXQoY3R4LA0K PiA+IC0JCQkJCSAgIHBhcmFtLT5kc3RfZm91cmNjLA0KPiA+IC0JCQkJCSAgIE1US19KUEVHX0ZN VF9UWVBFX0NBUFRVUkUpOw0KPiA+ICsJcV9kYXRhLT5mbXQgPSBtdGtfanBlZ19maW5kX2Zvcm1h dChwYXJhbS0+ZHN0X2ZvdXJjYywNCj4gPiArCQkJCQkgICBNVEtfSlBFR19GTVRfRkxBR19ERUNf Q0FQVFVSRSk7DQo+ID4gIA0KPiA+ICAJZm9yIChpID0gMDsgaSA8IHFfZGF0YS0+Zm10LT5jb2xw bGFuZXM7IGkrKykgew0KPiA+ICAJCXFfZGF0YS0+Ynl0ZXNwZXJsaW5lW2ldID0gcGFyYW0tPm1l bV9zdHJpZGVbaV07DQo+ID4gQEAgLTYyNyw3ICs4ODIsMTggQEAgc3RhdGljIHZvaWQgbXRrX2pw ZWdfc2V0X3F1ZXVlX2RhdGEoc3RydWN0IG10a19qcGVnX2N0eCAqY3R4LA0KPiA+ICAJCSBwYXJh bS0+ZGVjX3csIHBhcmFtLT5kZWNfaCk7DQo+ID4gIH0NCj4gPiAgDQo+ID4gLXN0YXRpYyB2b2lk IG10a19qcGVnX2J1Zl9xdWV1ZShzdHJ1Y3QgdmIyX2J1ZmZlciAqdmIpDQo+ID4gK3N0YXRpYyB2 b2lkIG10a19qcGVnX2VuY19idWZfcXVldWUoc3RydWN0IHZiMl9idWZmZXIgKnZiKQ0KPiA+ICt7 DQo+ID4gKwlzdHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHggPSB2YjJfZ2V0X2Rydl9wcml2KHZiLT52 YjJfcXVldWUpOw0KPiA+ICsJc3RydWN0IG10a19qcGVnX2RldiAqanBlZyA9IGN0eC0+anBlZzsN Cj4gPiArDQo+ID4gKwl2NGwyX2RiZygyLCBkZWJ1ZywgJmpwZWctPnY0bDJfZGV2LCAiKCVkKSBi dWZfcSBpZD0lZCwgdmI9JXBcbiIsDQo+ID4gKwkJIHZiLT52YjJfcXVldWUtPnR5cGUsIHZiLT5p bmRleCwgdmIpOw0KPiA+ICsNCj4gPiArCXY0bDJfbTJtX2J1Zl9xdWV1ZShjdHgtPmZoLm0ybV9j dHgsIHRvX3ZiMl92NGwyX2J1ZmZlcih2YikpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMg dm9pZCBtdGtfanBlZ19kZWNfYnVmX3F1ZXVlKHN0cnVjdCB2YjJfYnVmZmVyICp2YikNCj4gPiAg ew0KPiA+ICAJc3RydWN0IG10a19qcGVnX2N0eCAqY3R4ID0gdmIyX2dldF9kcnZfcHJpdih2Yi0+ dmIyX3F1ZXVlKTsNCj4gPiAgCXN0cnVjdCBtdGtfanBlZ19kZWNfcGFyYW0gKnBhcmFtOw0KPiA+ IEBAIC02NzksNyArOTQ1LDE2IEBAIHN0YXRpYyBzdHJ1Y3QgdmIyX3Y0bDJfYnVmZmVyICptdGtf anBlZ19idWZfcmVtb3ZlKHN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCwNCj4gPiAgCQlyZXR1cm4g djRsMl9tMm1fZHN0X2J1Zl9yZW1vdmUoY3R4LT5maC5tMm1fY3R4KTsNCj4gPiAgfQ0KPiA+ICAN Cj4gPiAtc3RhdGljIHZvaWQgbXRrX2pwZWdfc3RvcF9zdHJlYW1pbmcoc3RydWN0IHZiMl9xdWV1 ZSAqcSkNCj4gPiArc3RhdGljIHZvaWQgbXRrX2pwZWdfZW5jX3N0b3Bfc3RyZWFtaW5nKHN0cnVj dCB2YjJfcXVldWUgKnEpDQo+ID4gK3sNCj4gPiArCXN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCA9 IHZiMl9nZXRfZHJ2X3ByaXYocSk7DQo+ID4gKwlzdHJ1Y3QgdmIyX3Y0bDJfYnVmZmVyICp2YjsN Cj4gPiArDQo+ID4gKwl3aGlsZSAoKHZiID0gbXRrX2pwZWdfYnVmX3JlbW92ZShjdHgsIHEtPnR5 cGUpKSkNCj4gPiArCQl2NGwyX20ybV9idWZfZG9uZSh2YiwgVkIyX0JVRl9TVEFURV9FUlJPUik7 DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyB2b2lkIG10a19qcGVnX2RlY19zdG9wX3N0cmVh bWluZyhzdHJ1Y3QgdmIyX3F1ZXVlICpxKQ0KPiA+ICB7DQo+ID4gIAlzdHJ1Y3QgbXRrX2pwZWdf Y3R4ICpjdHggPSB2YjJfZ2V0X2Rydl9wcml2KHEpOw0KPiA+ICAJc3RydWN0IHZiMl92NGwyX2J1 ZmZlciAqdmI7DQo+ID4gQEAgLTcwNSwxMyArOTgwLDIyIEBAIHN0YXRpYyB2b2lkIG10a19qcGVn X3N0b3Bfc3RyZWFtaW5nKHN0cnVjdCB2YjJfcXVldWUgKnEpDQo+ID4gIAkJdjRsMl9tMm1fYnVm X2RvbmUodmIsIFZCMl9CVUZfU1RBVEVfRVJST1IpOw0KPiA+ICB9DQo+ID4gIA0KPiA+IC1zdGF0 aWMgY29uc3Qgc3RydWN0IHZiMl9vcHMgbXRrX2pwZWdfcW9wcyA9IHsNCj4gPiArc3RhdGljIGNv bnN0IHN0cnVjdCB2YjJfb3BzIG10a19qcGVnX2RlY19xb3BzID0gew0KPiA+ICAJLnF1ZXVlX3Nl dHVwICAgICAgICA9IG10a19qcGVnX3F1ZXVlX3NldHVwLA0KPiA+ICAJLmJ1Zl9wcmVwYXJlICAg ICAgICA9IG10a19qcGVnX2J1Zl9wcmVwYXJlLA0KPiA+IC0JLmJ1Zl9xdWV1ZSAgICAgICAgICA9 IG10a19qcGVnX2J1Zl9xdWV1ZSwNCj4gPiArCS5idWZfcXVldWUgICAgICAgICAgPSBtdGtfanBl Z19kZWNfYnVmX3F1ZXVlLA0KPiA+ICAJLndhaXRfcHJlcGFyZSAgICAgICA9IHZiMl9vcHNfd2Fp dF9wcmVwYXJlLA0KPiA+ICAJLndhaXRfZmluaXNoICAgICAgICA9IHZiMl9vcHNfd2FpdF9maW5p c2gsDQo+ID4gLQkuc3RvcF9zdHJlYW1pbmcgICAgID0gbXRrX2pwZWdfc3RvcF9zdHJlYW1pbmcs DQo+ID4gKwkuc3RvcF9zdHJlYW1pbmcgICAgID0gbXRrX2pwZWdfZGVjX3N0b3Bfc3RyZWFtaW5n LA0KPiA+ICt9Ow0KPiA+ICsNCj4gPiArc3RhdGljIGNvbnN0IHN0cnVjdCB2YjJfb3BzIG10a19q cGVnX2VuY19xb3BzID0gew0KPiA+ICsJLnF1ZXVlX3NldHVwICAgICAgICA9IG10a19qcGVnX3F1 ZXVlX3NldHVwLA0KPiA+ICsJLmJ1Zl9wcmVwYXJlICAgICAgICA9IG10a19qcGVnX2J1Zl9wcmVw YXJlLA0KPiA+ICsJLmJ1Zl9xdWV1ZSAgICAgICAgICA9IG10a19qcGVnX2VuY19idWZfcXVldWUs DQo+ID4gKwkud2FpdF9wcmVwYXJlICAgICAgID0gdmIyX29wc193YWl0X3ByZXBhcmUsDQo+ID4g Kwkud2FpdF9maW5pc2ggICAgICAgID0gdmIyX29wc193YWl0X2ZpbmlzaCwNCj4gPiArCS5zdG9w X3N0cmVhbWluZyAgICAgPSBtdGtfanBlZ19lbmNfc3RvcF9zdHJlYW1pbmcsDQo+ID4gIH07DQo+ ID4gIA0KPiA+ICBzdGF0aWMgdm9pZCBtdGtfanBlZ19zZXRfZGVjX3NyYyhzdHJ1Y3QgbXRrX2pw ZWdfY3R4ICpjdHgsDQo+ID4gQEAgLTc1MSw3ICsxMDM1LDg2IEBAIHN0YXRpYyBpbnQgbXRrX2pw ZWdfc2V0X2RlY19kc3Qoc3RydWN0IG10a19qcGVnX2N0eCAqY3R4LA0KPiA+ICAJcmV0dXJuIDA7 DQo+ID4gIH0NCj4gPiAgDQo+ID4gLXN0YXRpYyB2b2lkIG10a19qcGVnX2RldmljZV9ydW4odm9p ZCAqcHJpdikNCj4gPiArc3RhdGljIHZvaWQgbXRrX2pwZWdfc2V0X2VuY19kc3Qoc3RydWN0IG10 a19qcGVnX2N0eCAqY3R4LCB2b2lkIF9faW9tZW0gKmJhc2UsDQo+ID4gKwkJCQkgc3RydWN0IHZi Ml9idWZmZXIgKmRzdF9idWYsDQo+ID4gKwkJCQkgc3RydWN0IG10a19qcGVnX2VuY19icyAqYnMp DQo+ID4gK3sNCj4gPiArCWJzLT5kbWFfYWRkciA9IHZiMl9kbWFfY29udGlnX3BsYW5lX2RtYV9h ZGRyKGRzdF9idWYsIDApOw0KPiA+ICsJYnMtPmRtYV9hZGRyX29mZnNldCA9IGN0eC0+ZW5hYmxl X2V4aWYgPyBNVEtfSlBFR19ERUZBVUxUX0VYSUZfU0laRSA6IDA7DQo+ID4gKwlicy0+ZG1hX2Fk ZHJfb2Zmc2V0bWFzayA9IGJzLT5kbWFfYWRkciAmIEpQRUdfRU5DX0RTVF9BRERSX09GRlNFVF9N QVNLOw0KPiA+ICsJYnMtPnNpemUgPSB2YjJfcGxhbmVfc2l6ZShkc3RfYnVmLCAwKTsNCj4gPiAr DQo+ID4gKwltdGtfanBlZ19lbmNfc2V0X2RzdF9hZGRyKGJhc2UsIGJzLT5kbWFfYWRkciwgYnMt PnNpemUsDQo+ID4gKwkJCQkgIGJzLT5kbWFfYWRkcl9vZmZzZXQsDQo+ID4gKwkJCQkgIGJzLT5k bWFfYWRkcl9vZmZzZXRtYXNrKTsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIHZvaWQgbXRr X2pwZWdfc2V0X2VuY19zcmMoc3RydWN0IG10a19qcGVnX2N0eCAqY3R4LCB2b2lkIF9faW9tZW0g KmJhc2UsDQo+ID4gKwkJCQkgc3RydWN0IHZiMl9idWZmZXIgKnNyY19idWYpDQo+ID4gK3sNCj4g PiArCWludCBpOw0KPiA+ICsJZG1hX2FkZHJfdAlkbWFfYWRkcjsNCj4gPiArDQo+ID4gKwltdGtf anBlZ19lbmNfc2V0X2ltZ19zaXplKGJhc2UsIGN0eC0+b3V0X3EudywgY3R4LT5vdXRfcS5oKTsN Cj4gPiArCW10a19qcGVnX2VuY19zZXRfYmxrX251bShiYXNlLCBjdHgtPm91dF9xLmZtdC0+Zm91 cmNjLCBjdHgtPm91dF9xLncsDQo+ID4gKwkJCQkgY3R4LT5vdXRfcS5oKTsNCj4gPiArCW10a19q cGVnX2VuY19zZXRfc3RyaWRlKGJhc2UsIGN0eC0+b3V0X3EuZm10LT5mb3VyY2MsIGN0eC0+b3V0 X3EudywNCj4gPiArCQkJCWN0eC0+b3V0X3EuaCwgY3R4LT5vdXRfcS5ieXRlc3BlcmxpbmVbMF0p Ow0KPiA+ICsNCj4gPiArCWZvciAoaSA9IDA7IGkgPCBzcmNfYnVmLT5udW1fcGxhbmVzOyBpKysp IHsNCj4gPiArCQlkbWFfYWRkciA9IHZiMl9kbWFfY29udGlnX3BsYW5lX2RtYV9hZGRyKHNyY19i dWYsIGkpICsNCj4gPiArCQkJICAgc3JjX2J1Zi0+cGxhbmVzW2ldLmRhdGFfb2Zmc2V0Ow0KPiA+ ICsJCW10a19qcGVnX2VuY19zZXRfc3JjX2FkZHIoYmFzZSwgZG1hX2FkZHIsIGkpOw0KPiA+ICsJ fQ0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgdm9pZCBtdGtfanBlZ19lbmNfZGV2aWNlX3J1 bih2b2lkICpwcml2KQ0KPiA+ICt7DQo+ID4gKwlzdHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHggPSBw cml2Ow0KPiA+ICsJc3RydWN0IG10a19qcGVnX2RldiAqanBlZyA9IGN0eC0+anBlZzsNCj4gPiAr CXN0cnVjdCB2YjJfdjRsMl9idWZmZXIgKnNyY19idWYsICpkc3RfYnVmOw0KPiA+ICsJZW51bSB2 YjJfYnVmZmVyX3N0YXRlIGJ1Zl9zdGF0ZSA9IFZCMl9CVUZfU1RBVEVfRVJST1I7DQo+ID4gKwl1 bnNpZ25lZCBsb25nIGZsYWdzOw0KPiA+ICsJc3RydWN0IG10a19qcGVnX3NyY19idWYgKmpwZWdf c3JjX2J1ZjsNCj4gPiArCXN0cnVjdCBtdGtfanBlZ19lbmNfYnMgZW5jX2JzOw0KPiA+ICsJaW50 IGksIHJldDsNCj4gPiArDQo+ID4gKwlzcmNfYnVmID0gdjRsMl9tMm1fbmV4dF9zcmNfYnVmKGN0 eC0+ZmgubTJtX2N0eCk7DQo+ID4gKwlkc3RfYnVmID0gdjRsMl9tMm1fbmV4dF9kc3RfYnVmKGN0 eC0+ZmgubTJtX2N0eCk7DQo+ID4gKwlqcGVnX3NyY19idWYgPSBtdGtfanBlZ192YjJfdG9fc3Jj YnVmKCZzcmNfYnVmLT52YjJfYnVmKTsNCj4gPiArDQo+ID4gKwlpZiAoanBlZ19zcmNfYnVmLT5m bGFncyAmIE1US19KUEVHX0JVRl9GTEFHU19MQVNUX0ZSQU1FKSB7DQo+ID4gKwkJZm9yIChpID0g MDsgaSA8IGRzdF9idWYtPnZiMl9idWYubnVtX3BsYW5lczsgaSsrKQ0KPiA+ICsJCQl2YjJfc2V0 X3BsYW5lX3BheWxvYWQoJmRzdF9idWYtPnZiMl9idWYsIGksIDApOw0KPiA+ICsJCWJ1Zl9zdGF0 ZSA9IFZCMl9CVUZfU1RBVEVfRE9ORTsNCj4gPiArCQlnb3RvIGVuY19lbmQ7DQo+ID4gKwl9DQo+ ID4gKw0KPiA+ICsJcmV0ID0gcG1fcnVudGltZV9nZXRfc3luYyhqcGVnLT5kZXYpOw0KPiA+ICsJ aWYgKHJldCA8IDApDQo+ID4gKwkJZ290byBlbmNfZW5kOw0KPiA+ICsNCj4gPiArCXNwaW5fbG9j a19pcnFzYXZlKCZqcGVnLT5od19sb2NrLCBmbGFncyk7DQo+ID4gKwltdGtfanBlZ19lbmNfcmVz ZXQoanBlZy0+cmVnX2Jhc2UpOw0KPiA+ICsNCj4gPiArCW10a19qcGVnX3NldF9lbmNfZHN0KGN0 eCwganBlZy0+cmVnX2Jhc2UsICZkc3RfYnVmLT52YjJfYnVmLCAmZW5jX2JzKTsNCj4gPiArCW10 a19qcGVnX3NldF9lbmNfc3JjKGN0eCwganBlZy0+cmVnX2Jhc2UsICZzcmNfYnVmLT52YjJfYnVm KTsNCj4gPiArCW10a19qcGVnX2VuY19zZXRfY29uZmlnKGpwZWctPnJlZ19iYXNlLCBjdHgtPm91 dF9xLmZtdC0+aHdfZm9ybWF0LA0KPiA+ICsJCQkJY3R4LT5lbmFibGVfZXhpZiwgY3R4LT5lbmNf cXVhbGl0eSwNCj4gPiArCQkJCWN0eC0+cmVzdGFydF9pbnRlcnZhbCk7DQo+ID4gKwltdGtfanBl Z19lbmNfc3RhcnQoanBlZy0+cmVnX2Jhc2UpOw0KPiA+ICsJc3Bpbl91bmxvY2tfaXJxcmVzdG9y ZSgmanBlZy0+aHdfbG9jaywgZmxhZ3MpOw0KPiA+ICsJcmV0dXJuOw0KPiA+ICsNCj4gPiArZW5j X2VuZDoNCj4gPiArCXY0bDJfbTJtX3NyY19idWZfcmVtb3ZlKGN0eC0+ZmgubTJtX2N0eCk7DQo+ ID4gKwl2NGwyX20ybV9kc3RfYnVmX3JlbW92ZShjdHgtPmZoLm0ybV9jdHgpOw0KPiA+ICsJdjRs Ml9tMm1fYnVmX2RvbmUoc3JjX2J1ZiwgYnVmX3N0YXRlKTsNCj4gPiArCXY0bDJfbTJtX2J1Zl9k b25lKGRzdF9idWYsIGJ1Zl9zdGF0ZSk7DQo+ID4gKwl2NGwyX20ybV9qb2JfZmluaXNoKGpwZWct Pm0ybV9kZXYsIGN0eC0+ZmgubTJtX2N0eCk7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyB2 b2lkIG10a19qcGVnX2RlY19kZXZpY2VfcnVuKHZvaWQgKnByaXYpDQo+ID4gIHsNCj4gPiAgCXN0 cnVjdCBtdGtfanBlZ19jdHggKmN0eCA9IHByaXY7DQo+ID4gIAlzdHJ1Y3QgbXRrX2pwZWdfZGV2 ICpqcGVnID0gY3R4LT5qcGVnOw0KPiA+IEBAIC03ODYsMTUgKzExNDksMTYgQEAgc3RhdGljIHZv aWQgbXRrX2pwZWdfZGV2aWNlX3J1bih2b2lkICpwcml2KQ0KPiA+ICAJCWdvdG8gZGVjX2VuZDsN Cj4gPiAgDQo+ID4gIAltdGtfanBlZ19zZXRfZGVjX3NyYyhjdHgsICZzcmNfYnVmLT52YjJfYnVm LCAmYnMpOw0KPiA+IC0JaWYgKG10a19qcGVnX3NldF9kZWNfZHN0KGN0eCwgJmpwZWdfc3JjX2J1 Zi0+ZGVjX3BhcmFtLCAmZHN0X2J1Zi0+dmIyX2J1ZiwgJmZiKSkNCj4gPiArCWlmIChtdGtfanBl Z19zZXRfZGVjX2RzdChjdHgsICZqcGVnX3NyY19idWYtPmRlY19wYXJhbSwNCj4gPiArCQkJCSAm ZHN0X2J1Zi0+dmIyX2J1ZiwgJmZiKSkNCj4gPiAgCQlnb3RvIGRlY19lbmQ7DQo+ID4gIA0KPiA+ ICAJc3Bpbl9sb2NrX2lycXNhdmUoJmpwZWctPmh3X2xvY2ssIGZsYWdzKTsNCj4gPiAtCW10a19q cGVnX2RlY19yZXNldChqcGVnLT5kZWNfcmVnX2Jhc2UpOw0KPiA+IC0JbXRrX2pwZWdfZGVjX3Nl dF9jb25maWcoanBlZy0+ZGVjX3JlZ19iYXNlLA0KPiA+ICsJbXRrX2pwZWdfZGVjX3Jlc2V0KGpw ZWctPnJlZ19iYXNlKTsNCj4gPiArCW10a19qcGVnX2RlY19zZXRfY29uZmlnKGpwZWctPnJlZ19i YXNlLA0KPiA+ICAJCQkJJmpwZWdfc3JjX2J1Zi0+ZGVjX3BhcmFtLCAmYnMsICZmYik7DQo+ID4g IA0KPiA+IC0JbXRrX2pwZWdfZGVjX3N0YXJ0KGpwZWctPmRlY19yZWdfYmFzZSk7DQo+ID4gKwlt dGtfanBlZ19kZWNfc3RhcnQoanBlZy0+cmVnX2Jhc2UpOw0KPiA+ICAJc3Bpbl91bmxvY2tfaXJx cmVzdG9yZSgmanBlZy0+aHdfbG9jaywgZmxhZ3MpOw0KPiA+ICAJcmV0dXJuOw0KPiA+ICANCj4g PiBAQCAtODA2LDIwICsxMTcwLDMwIEBAIHN0YXRpYyB2b2lkIG10a19qcGVnX2RldmljZV9ydW4o dm9pZCAqcHJpdikNCj4gPiAgCXY0bDJfbTJtX2pvYl9maW5pc2goanBlZy0+bTJtX2RldiwgY3R4 LT5maC5tMm1fY3R4KTsNCj4gPiAgfQ0KPiA+ICANCj4gPiAtc3RhdGljIGludCBtdGtfanBlZ19q b2JfcmVhZHkodm9pZCAqcHJpdikNCj4gPiArc3RhdGljIGludCBtdGtfanBlZ19lbmNfam9iX3Jl YWR5KHZvaWQgKnByaXYpDQo+ID4gK3sNCj4gPiArCQlyZXR1cm4gMTsNCj4gPiArfQ0KPiA+ICsN Cj4gPiArc3RhdGljIGludCBtdGtfanBlZ19kZWNfam9iX3JlYWR5KHZvaWQgKnByaXYpDQo+ID4g IHsNCj4gPiAgCXN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCA9IHByaXY7DQo+ID4gIA0KPiA+ICAJ cmV0dXJuIChjdHgtPnN0YXRlID09IE1US19KUEVHX1JVTk5JTkcpID8gMSA6IDA7DQo+ID4gIH0N Cj4gPiAgDQo+ID4gLXN0YXRpYyBjb25zdCBzdHJ1Y3QgdjRsMl9tMm1fb3BzIG10a19qcGVnX20y bV9vcHMgPSB7DQo+ID4gLQkuZGV2aWNlX3J1biA9IG10a19qcGVnX2RldmljZV9ydW4sDQo+ID4g LQkuam9iX3JlYWR5ICA9IG10a19qcGVnX2pvYl9yZWFkeSwNCj4gPiArc3RhdGljIGNvbnN0IHN0 cnVjdCB2NGwyX20ybV9vcHMgbXRrX2pwZWdfZW5jX20ybV9vcHMgPSB7DQo+ID4gKwkuZGV2aWNl X3J1biA9IG10a19qcGVnX2VuY19kZXZpY2VfcnVuLA0KPiA+ICsJLmpvYl9yZWFkeSAgPSBtdGtf anBlZ19lbmNfam9iX3JlYWR5LA0KPiA+ICB9Ow0KPiA+ICANCj4gPiAtc3RhdGljIGludCBtdGtf anBlZ19xdWV1ZV9pbml0KHZvaWQgKnByaXYsIHN0cnVjdCB2YjJfcXVldWUgKnNyY192cSwNCj4g PiAtCQkJICAgICAgIHN0cnVjdCB2YjJfcXVldWUgKmRzdF92cSkNCj4gPiArc3RhdGljIGNvbnN0 IHN0cnVjdCB2NGwyX20ybV9vcHMgbXRrX2pwZWdfZGVjX20ybV9vcHMgPSB7DQo+ID4gKwkuZGV2 aWNlX3J1biA9IG10a19qcGVnX2RlY19kZXZpY2VfcnVuLA0KPiA+ICsJLmpvYl9yZWFkeSAgPSBt dGtfanBlZ19kZWNfam9iX3JlYWR5LA0KPiA+ICt9Ow0KPiA+ICsNCj4gPiArc3RhdGljIGludCBt dGtfanBlZ19kZWNfcXVldWVfaW5pdCh2b2lkICpwcml2LCBzdHJ1Y3QgdmIyX3F1ZXVlICpzcmNf dnEsDQo+ID4gKwkJCQkgICBzdHJ1Y3QgdmIyX3F1ZXVlICpkc3RfdnEpDQo+ID4gIHsNCj4gPiAg CXN0cnVjdCBtdGtfanBlZ19jdHggKmN0eCA9IHByaXY7DQo+ID4gIAlpbnQgcmV0Ow0KPiA+IEBA IC04MjgsNyArMTIwMiw3IEBAIHN0YXRpYyBpbnQgbXRrX2pwZWdfcXVldWVfaW5pdCh2b2lkICpw cml2LCBzdHJ1Y3QgdmIyX3F1ZXVlICpzcmNfdnEsDQo+ID4gIAlzcmNfdnEtPmlvX21vZGVzID0g VkIyX0RNQUJVRiB8IFZCMl9NTUFQOw0KPiA+ICAJc3JjX3ZxLT5kcnZfcHJpdiA9IGN0eDsNCj4g PiAgCXNyY192cS0+YnVmX3N0cnVjdF9zaXplID0gc2l6ZW9mKHN0cnVjdCBtdGtfanBlZ19zcmNf YnVmKTsNCj4gPiAtCXNyY192cS0+b3BzID0gJm10a19qcGVnX3FvcHM7DQo+ID4gKwlzcmNfdnEt Pm9wcyA9ICZtdGtfanBlZ19kZWNfcW9wczsNCj4gPiAgCXNyY192cS0+bWVtX29wcyA9ICZ2YjJf ZG1hX2NvbnRpZ19tZW1vcHM7DQo+ID4gIAlzcmNfdnEtPnRpbWVzdGFtcF9mbGFncyA9IFY0TDJf QlVGX0ZMQUdfVElNRVNUQU1QX0NPUFk7DQo+ID4gIAlzcmNfdnEtPmxvY2sgPSAmY3R4LT5qcGVn LT5sb2NrOw0KPiA+IEBAIC04NDEsNyArMTIxNSw3IEBAIHN0YXRpYyBpbnQgbXRrX2pwZWdfcXVl dWVfaW5pdCh2b2lkICpwcml2LCBzdHJ1Y3QgdmIyX3F1ZXVlICpzcmNfdnEsDQo+ID4gIAlkc3Rf dnEtPmlvX21vZGVzID0gVkIyX0RNQUJVRiB8IFZCMl9NTUFQOw0KPiA+ICAJZHN0X3ZxLT5kcnZf cHJpdiA9IGN0eDsNCj4gPiAgCWRzdF92cS0+YnVmX3N0cnVjdF9zaXplID0gc2l6ZW9mKHN0cnVj dCB2NGwyX20ybV9idWZmZXIpOw0KPiA+IC0JZHN0X3ZxLT5vcHMgPSAmbXRrX2pwZWdfcW9wczsN Cj4gPiArCWRzdF92cS0+b3BzID0gJm10a19qcGVnX2RlY19xb3BzOw0KPiA+ICAJZHN0X3ZxLT5t ZW1fb3BzID0gJnZiMl9kbWFfY29udGlnX21lbW9wczsNCj4gPiAgCWRzdF92cS0+dGltZXN0YW1w X2ZsYWdzID0gVjRMMl9CVUZfRkxBR19USU1FU1RBTVBfQ09QWTsNCj4gPiAgCWRzdF92cS0+bG9j ayA9ICZjdHgtPmpwZWctPmxvY2s7DQo+ID4gQEAgLTg1MSwyNCArMTIyNSwxMTIgQEAgc3RhdGlj IGludCBtdGtfanBlZ19xdWV1ZV9pbml0KHZvaWQgKnByaXYsIHN0cnVjdCB2YjJfcXVldWUgKnNy Y192cSwNCj4gPiAgCXJldHVybiByZXQ7DQo+ID4gIH0NCj4gPiAgDQo+ID4gLXN0YXRpYyB2b2lk IG10a19qcGVnX2Nsa19vbihzdHJ1Y3QgbXRrX2pwZWdfZGV2ICpqcGVnKQ0KPiA+ICtzdGF0aWMg aW50IG10a19qcGVnX2VuY19xdWV1ZV9pbml0KHZvaWQgKnByaXYsIHN0cnVjdCB2YjJfcXVldWUg KnNyY192cSwNCj4gPiArCQkJCSAgIHN0cnVjdCB2YjJfcXVldWUgKmRzdF92cSkNCj4gPiAgew0K PiA+ICsJc3RydWN0IG10a19qcGVnX2N0eCAqY3R4ID0gcHJpdjsNCj4gPiAgCWludCByZXQ7DQo+ ID4gIA0KPiA+ICsJc3JjX3ZxLT50eXBlID0gVjRMMl9CVUZfVFlQRV9WSURFT19PVVRQVVRfTVBM QU5FOw0KPiA+ICsJc3JjX3ZxLT5pb19tb2RlcyA9IFZCMl9ETUFCVUYgfCBWQjJfTU1BUDsNCj4g PiArCXNyY192cS0+ZHJ2X3ByaXYgPSBjdHg7DQo+ID4gKwlzcmNfdnEtPmJ1Zl9zdHJ1Y3Rfc2l6 ZSA9IHNpemVvZihzdHJ1Y3QgbXRrX2pwZWdfc3JjX2J1Zik7DQo+ID4gKwlzcmNfdnEtPm9wcyA9 ICZtdGtfanBlZ19lbmNfcW9wczsNCj4gPiArCXNyY192cS0+bWVtX29wcyA9ICZ2YjJfZG1hX2Nv bnRpZ19tZW1vcHM7DQo+ID4gKwlzcmNfdnEtPnRpbWVzdGFtcF9mbGFncyA9IFY0TDJfQlVGX0ZM QUdfVElNRVNUQU1QX0NPUFk7DQo+ID4gKwlzcmNfdnEtPmxvY2sgPSAmY3R4LT5qcGVnLT5sb2Nr Ow0KPiA+ICsJc3JjX3ZxLT5kZXYgPSBjdHgtPmpwZWctPmRldjsNCj4gPiArCXJldCA9IHZiMl9x dWV1ZV9pbml0KHNyY192cSk7DQo+ID4gKwlpZiAocmV0KQ0KPiA+ICsJCXJldHVybiByZXQ7DQo+ ID4gKw0KPiA+ICsJZHN0X3ZxLT50eXBlID0gVjRMMl9CVUZfVFlQRV9WSURFT19DQVBUVVJFX01Q TEFORTsNCj4gPiArCWRzdF92cS0+aW9fbW9kZXMgPSBWQjJfRE1BQlVGIHwgVkIyX01NQVA7DQo+ ID4gKwlkc3RfdnEtPmRydl9wcml2ID0gY3R4Ow0KPiA+ICsJZHN0X3ZxLT5idWZfc3RydWN0X3Np emUgPSBzaXplb2Yoc3RydWN0IHY0bDJfbTJtX2J1ZmZlcik7DQo+ID4gKwlkc3RfdnEtPm9wcyA9 ICZtdGtfanBlZ19lbmNfcW9wczsNCj4gPiArCWRzdF92cS0+bWVtX29wcyA9ICZ2YjJfZG1hX2Nv bnRpZ19tZW1vcHM7DQo+ID4gKwlkc3RfdnEtPnRpbWVzdGFtcF9mbGFncyA9IFY0TDJfQlVGX0ZM QUdfVElNRVNUQU1QX0NPUFk7DQo+ID4gKwlkc3RfdnEtPmxvY2sgPSAmY3R4LT5qcGVnLT5sb2Nr Ow0KPiA+ICsJZHN0X3ZxLT5kZXYgPSBjdHgtPmpwZWctPmRldjsNCj4gPiArCXJldCA9IHZiMl9x dWV1ZV9pbml0KGRzdF92cSk7DQo+ID4gKw0KPiA+ICsJcmV0dXJuIHJldDsNCj4gPiArfQ0KPiA+ ICsNCj4gPiArc3RhdGljIHZvaWQgbXRrX2pwZWdfY2xrX29uKHN0cnVjdCBtdGtfanBlZ19kZXYg KmpwZWcpDQo+ID4gK3sNCj4gPiArCWludCByZXQsIGk7DQo+ID4gKw0KPiA+ICAJcmV0ID0gbXRr X3NtaV9sYXJiX2dldChqcGVnLT5sYXJiKTsNCj4gPiAgCWlmIChyZXQpDQo+ID4gIAkJZGV2X2Vy cihqcGVnLT5kZXYsICJtdGtfc21pX2xhcmJfZ2V0IGxhcmJ2ZGVjIGZhaWwgJWRcbiIsIHJldCk7 DQo+ID4gLQljbGtfcHJlcGFyZV9lbmFibGUoanBlZy0+Y2xrX2pkZWNfc21pKTsNCj4gPiAtCWNs a19wcmVwYXJlX2VuYWJsZShqcGVnLT5jbGtfamRlYyk7DQo+ID4gKw0KPiA+ICsJZm9yIChpID0g MDsgaSA8IGpwZWctPnZhcmlhbnQtPm51bV9jbG9ja3M7IGkrKykgew0KPiA+ICsJCXJldCA9IGNs a19wcmVwYXJlX2VuYWJsZShqcGVnLT5jbG9ja3NbaV0pOw0KPiA+ICsJCWlmIChyZXQpIHsNCj4g PiArCQkJd2hpbGUgKC0taSA+PSAwKQ0KPiA+ICsJCQkJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGpw ZWctPmNsb2Nrc1tpXSk7DQo+ID4gKwkJfQ0KPiA+ICsJfQ0KPiA+ICB9DQo+ID4gIA0KPiA+ICBz dGF0aWMgdm9pZCBtdGtfanBlZ19jbGtfb2ZmKHN0cnVjdCBtdGtfanBlZ19kZXYgKmpwZWcpDQo+ ID4gIHsNCj4gPiAtCWNsa19kaXNhYmxlX3VucHJlcGFyZShqcGVnLT5jbGtfamRlYyk7DQo+ID4g LQljbGtfZGlzYWJsZV91bnByZXBhcmUoanBlZy0+Y2xrX2pkZWNfc21pKTsNCj4gPiArCWludCBp Ow0KPiA+ICsNCj4gPiArCWZvciAoaSA9IGpwZWctPnZhcmlhbnQtPm51bV9jbG9ja3MgLSAxOyBp ID49IDA7IGktLSkNCj4gPiArCQljbGtfZGlzYWJsZV91bnByZXBhcmUoanBlZy0+Y2xvY2tzW2ld KTsNCj4gPiAgCW10a19zbWlfbGFyYl9wdXQoanBlZy0+bGFyYik7DQo+ID4gIH0NCj4gPiAgDQo+ ID4gK3N0YXRpYyBpcnFyZXR1cm5fdCBtdGtfanBlZ19lbmNfaXJxKGludCBpcnEsIHZvaWQgKnBy aXYpDQo+ID4gK3sNCj4gPiArCXN0cnVjdCBtdGtfanBlZ19kZXYgKmpwZWcgPSBwcml2Ow0KPiA+ ICsJc3RydWN0IG10a19qcGVnX2N0eCAqY3R4Ow0KPiA+ICsJc3RydWN0IHZiMl92NGwyX2J1ZmZl ciAqc3JjX2J1ZiwgKmRzdF9idWY7DQo+ID4gKwlzdHJ1Y3QgbXRrX2pwZWdfc3JjX2J1ZiAqanBl Z19zcmNfYnVmOw0KPiA+ICsJZW51bSB2YjJfYnVmZmVyX3N0YXRlIGJ1Zl9zdGF0ZSA9IFZCMl9C VUZfU1RBVEVfRVJST1I7DQo+ID4gKwl1MzIgZW5jX2lycV9yZXQ7DQo+ID4gKwl1MzIgZW5jX3Jl dCwgcmVzdWx0X3NpemU7DQo+ID4gKw0KPiA+ICsJc3Bpbl9sb2NrKCZqcGVnLT5od19sb2NrKTsN Cj4gPiArDQo+ID4gKwljdHggPSB2NGwyX20ybV9nZXRfY3Vycl9wcml2KGpwZWctPm0ybV9kZXYp Ow0KPiA+ICsJaWYgKCFjdHgpIHsNCj4gPiArCQl2NGwyX2VycigmanBlZy0+djRsMl9kZXYsICJD b250ZXh0IGlzIE5VTExcbiIpOw0KPiA+ICsJCXJldHVybiBJUlFfSEFORExFRDsNCj4gPiArCX0N Cj4gPiArDQo+ID4gKwlzcmNfYnVmID0gdjRsMl9tMm1fc3JjX2J1Zl9yZW1vdmUoY3R4LT5maC5t Mm1fY3R4KTsNCj4gPiArCWRzdF9idWYgPSB2NGwyX20ybV9kc3RfYnVmX3JlbW92ZShjdHgtPmZo Lm0ybV9jdHgpOw0KPiA+ICsJanBlZ19zcmNfYnVmID0gbXRrX2pwZWdfdmIyX3RvX3NyY2J1Zigm c3JjX2J1Zi0+dmIyX2J1Zik7DQo+ID4gKw0KPiA+ICsJZW5jX3JldCA9IG10a19qcGVnX2VuY19n ZXRfYW5kX2NsZWFyX2ludF9zdGF0dXMoanBlZy0+cmVnX2Jhc2UpOw0KPiA+ICsJZW5jX2lycV9y ZXQgPSBtdGtfanBlZ19lbmNfZW51bV9yZXN1bHQoanBlZy0+cmVnX2Jhc2UsIGVuY19yZXQpOw0K PiA+ICsNCj4gPiArCWlmIChlbmNfaXJxX3JldCA+PSBNVEtfSlBFR19FTkNfUkVTVUxUX1NUQUxM KQ0KPiA+ICsJCW10a19qcGVnX2VuY19yZXNldChqcGVnLT5yZWdfYmFzZSk7DQo+ID4gKw0KPiA+ ICsJaWYgKGVuY19pcnFfcmV0ICE9IE1US19KUEVHX0VOQ19SRVNVTFRfRE9ORSkgew0KPiA+ICsJ CWRldl9lcnIoanBlZy0+ZGV2LCAiZW5jb2RlIGZhaWxlZFxuIik7DQo+ID4gKwkJZ290byBlbmNf ZW5kOw0KPiA+ICsJfQ0KPiA+ICsNCj4gPiArCXJlc3VsdF9zaXplID0gbXRrX2pwZWdfZW5jX2dl dF9maWxlX3NpemUoanBlZy0+cmVnX2Jhc2UpOw0KPiA+ICsJdmIyX3NldF9wbGFuZV9wYXlsb2Fk KCZkc3RfYnVmLT52YjJfYnVmLCAwLCByZXN1bHRfc2l6ZSk7DQo+ID4gKw0KPiA+ICsJYnVmX3N0 YXRlID0gVkIyX0JVRl9TVEFURV9ET05FOw0KPiA+ICsNCj4gPiArZW5jX2VuZDoNCj4gPiArCXY0 bDJfbTJtX2J1Zl9kb25lKHNyY19idWYsIGJ1Zl9zdGF0ZSk7DQo+ID4gKwl2NGwyX20ybV9idWZf ZG9uZShkc3RfYnVmLCBidWZfc3RhdGUpOw0KPiA+ICsJdjRsMl9tMm1fam9iX2ZpbmlzaChqcGVn LT5tMm1fZGV2LCBjdHgtPmZoLm0ybV9jdHgpOw0KPiA+ICsJc3Bpbl91bmxvY2soJmpwZWctPmh3 X2xvY2spOw0KPiA+ICsJcG1fcnVudGltZV9wdXRfc3luYyhjdHgtPmpwZWctPmRldik7DQo+ID4g KwlyZXR1cm4gSVJRX0hBTkRMRUQ7DQo+ID4gK30NCj4gPiArDQo+ID4gIHN0YXRpYyBpcnFyZXR1 cm5fdCBtdGtfanBlZ19kZWNfaXJxKGludCBpcnEsIHZvaWQgKnByaXYpDQo+ID4gIHsNCj4gPiAg CXN0cnVjdCBtdGtfanBlZ19kZXYgKmpwZWcgPSBwcml2Ow0KPiA+IEBAIC04NzYsMTMgKzEzMzgs MTMgQEAgc3RhdGljIGlycXJldHVybl90IG10a19qcGVnX2RlY19pcnEoaW50IGlycSwgdm9pZCAq cHJpdikNCj4gPiAgCXN0cnVjdCB2YjJfdjRsMl9idWZmZXIgKnNyY19idWYsICpkc3RfYnVmOw0K PiA+ICAJc3RydWN0IG10a19qcGVnX3NyY19idWYgKmpwZWdfc3JjX2J1ZjsNCj4gPiAgCWVudW0g dmIyX2J1ZmZlcl9zdGF0ZSBidWZfc3RhdGUgPSBWQjJfQlVGX1NUQVRFX0VSUk9SOw0KPiA+IC0J dTMyCWRlY19pcnFfcmV0Ow0KPiA+ICsJdTMyIGRlY19pcnFfcmV0Ow0KPiA+ICAJdTMyIGRlY19y ZXQ7DQo+ID4gIAlpbnQgaTsNCj4gPiAgDQo+ID4gIAlzcGluX2xvY2soJmpwZWctPmh3X2xvY2sp Ow0KPiA+ICANCj4gPiAtCWRlY19yZXQgPSBtdGtfanBlZ19kZWNfZ2V0X2ludF9zdGF0dXMoanBl Zy0+ZGVjX3JlZ19iYXNlKTsNCj4gPiArCWRlY19yZXQgPSBtdGtfanBlZ19kZWNfZ2V0X2ludF9z dGF0dXMoanBlZy0+cmVnX2Jhc2UpOw0KPiA+ICAJZGVjX2lycV9yZXQgPSBtdGtfanBlZ19kZWNf ZW51bV9yZXN1bHQoZGVjX3JldCk7DQo+ID4gIAljdHggPSB2NGwyX20ybV9nZXRfY3Vycl9wcml2 KGpwZWctPm0ybV9kZXYpOw0KPiA+ICAJaWYgKCFjdHgpIHsNCj4gPiBAQCAtODk1LDcgKzEzNTcs NyBAQCBzdGF0aWMgaXJxcmV0dXJuX3QgbXRrX2pwZWdfZGVjX2lycShpbnQgaXJxLCB2b2lkICpw cml2KQ0KPiA+ICAJanBlZ19zcmNfYnVmID0gbXRrX2pwZWdfdmIyX3RvX3NyY2J1Zigmc3JjX2J1 Zi0+dmIyX2J1Zik7DQo+ID4gIA0KPiA+ICAJaWYgKGRlY19pcnFfcmV0ID49IE1US19KUEVHX0RF Q19SRVNVTFRfVU5ERVJGTE9XKQ0KPiA+IC0JCW10a19qcGVnX2RlY19yZXNldChqcGVnLT5kZWNf cmVnX2Jhc2UpOw0KPiA+ICsJCW10a19qcGVnX2RlY19yZXNldChqcGVnLT5yZWdfYmFzZSk7DQo+ ID4gIA0KPiA+ICAJaWYgKGRlY19pcnFfcmV0ICE9IE1US19KUEVHX0RFQ19SRVNVTFRfRU9GX0RP TkUpIHsNCj4gPiAgCQlkZXZfZXJyKGpwZWctPmRldiwgImRlY29kZSBmYWlsZWRcbiIpOw0KPiA+ IEBAIC05MTcsMzkgKzEzNzksMTMxIEBAIHN0YXRpYyBpcnFyZXR1cm5fdCBtdGtfanBlZ19kZWNf aXJxKGludCBpcnEsIHZvaWQgKnByaXYpDQo+ID4gIAlyZXR1cm4gSVJRX0hBTkRMRUQ7DQo+ID4g IH0NCj4gPiAgDQo+ID4gLXN0YXRpYyB2b2lkIG10a19qcGVnX3NldF9kZWZhdWx0X3BhcmFtcyhz dHJ1Y3QgbXRrX2pwZWdfY3R4ICpjdHgpDQo+ID4gK3N0YXRpYyB2b2lkIG10a19qcGVnX3NldF9l bmNfZGVmYXVsdF9wYXJhbXMoc3RydWN0IG10a19qcGVnX2N0eCAqY3R4KQ0KPiA+ICB7DQo+ID4g IAlzdHJ1Y3QgbXRrX2pwZWdfcV9kYXRhICpxID0gJmN0eC0+b3V0X3E7DQo+ID4gLQlpbnQgaTsN Cj4gPiArCXN0cnVjdCB2NGwyX3BpeF9mb3JtYXRfbXBsYW5lICpwaXhfbXA7DQo+ID4gKw0KPiA+ ICsJcGl4X21wID0ga21hbGxvYyhzaXplb2YoKnBpeF9tcCksIEdGUF9LRVJORUwpOw0KPiA+ICAN Cj4gPiArCWN0eC0+ZmguY3RybF9oYW5kbGVyID0gJmN0eC0+Y3RybF9oZGw7DQo+ID4gIAljdHgt PmNvbG9yc3BhY2UgPSBWNEwyX0NPTE9SU1BBQ0VfSlBFRywNCj4gPiAgCWN0eC0+eWNiY3JfZW5j ID0gVjRMMl9ZQ0JDUl9FTkNfREVGQVVMVDsNCj4gPiAgCWN0eC0+cXVhbnRpemF0aW9uID0gVjRM Ml9RVUFOVElaQVRJT05fREVGQVVMVDsNCj4gPiAgCWN0eC0+eGZlcl9mdW5jID0gVjRMMl9YRkVS X0ZVTkNfREVGQVVMVDsNCj4gPiAtDQo+ID4gLQlxLT5mbXQgPSBtdGtfanBlZ19maW5kX2Zvcm1h dChjdHgsIFY0TDJfUElYX0ZNVF9KUEVHLA0KPiA+IC0JCQkJCSAgICAgIE1US19KUEVHX0ZNVF9U WVBFX09VVFBVVCk7DQo+ID4gLQlxLT53ID0gTVRLX0pQRUdfTUlOX1dJRFRIOw0KPiA+IC0JcS0+ aCA9IE1US19KUEVHX01JTl9IRUlHSFQ7DQo+ID4gLQlxLT5ieXRlc3BlcmxpbmVbMF0gPSAwOw0K PiA+IC0JcS0+c2l6ZWltYWdlWzBdID0gTVRLX0pQRUdfREVGQVVMVF9TSVpFSU1BR0U7DQo+ID4g KwlwaXhfbXAtPndpZHRoID0gTVRLX0pQRUdfTUlOX1dJRFRIOw0KPiA+ICsJcGl4X21wLT5oZWln aHQgPSBNVEtfSlBFR19NSU5fSEVJR0hUOw0KPiA+ICsNCj4gPiArCXEtPmZtdCA9IG10a19qcGVn X2ZpbmRfZm9ybWF0KFY0TDJfUElYX0ZNVF9ZVVlWLA0KPiA+ICsJCQkJICAgICAgTVRLX0pQRUdf Rk1UX0ZMQUdfRU5DX09VVFBVVCk7DQo+ID4gKwl2aWRpb2NfdHJ5X2ZtdChjb250YWluZXJfb2Yo cGl4X21wLCBzdHJ1Y3QgdjRsMl9mb3JtYXQsDQo+ID4gKwkJCQkgICAgZm10LnBpeF9tcCksIHEt PmZtdCk7DQo+ID4gKwlxLT53ID0gcGl4X21wLT53aWR0aDsNCj4gPiArCXEtPmggPSBwaXhfbXAt PmhlaWdodDsNCj4gPiArCXEtPnNpemVpbWFnZVswXSA9IHBpeF9tcC0+cGxhbmVfZm10WzBdLnNp emVpbWFnZTsNCj4gPiArCXEtPmJ5dGVzcGVybGluZVswXSA9IHBpeF9tcC0+cGxhbmVfZm10WzBd LmJ5dGVzcGVybGluZTsNCj4gPiAgDQo+ID4gIAlxID0gJmN0eC0+Y2FwX3E7DQo+ID4gLQlxLT5m bXQgPSBtdGtfanBlZ19maW5kX2Zvcm1hdChjdHgsIFY0TDJfUElYX0ZNVF9ZVVY0MjBNLA0KPiA+ IC0JCQkJCSAgICAgIE1US19KUEVHX0ZNVF9UWVBFX0NBUFRVUkUpOw0KPiA+IC0JcS0+dyA9IE1U S19KUEVHX01JTl9XSURUSDsNCj4gPiAtCXEtPmggPSBNVEtfSlBFR19NSU5fSEVJR0hUOw0KPiA+ ICsJcS0+Zm10ID0gbXRrX2pwZWdfZmluZF9mb3JtYXQoVjRMMl9QSVhfRk1UX0pQRUcsDQo+ID4g KwkJCQkgICAgICBNVEtfSlBFR19GTVRfRkxBR19FTkNfQ0FQVFVSRSk7DQo+ID4gKwlwaXhfbXAt PndpZHRoID0gTVRLX0pQRUdfTUlOX1dJRFRIOw0KPiA+ICsJcGl4X21wLT5oZWlnaHQgPSBNVEtf SlBFR19NSU5fSEVJR0hUOw0KPiA+ICsJdmlkaW9jX3RyeV9mbXQoY29udGFpbmVyX29mKHBpeF9t cCwgc3RydWN0IHY0bDJfZm9ybWF0LA0KPiA+ICsJCQkJICAgIGZtdC5waXhfbXApLCBxLT5mbXQp Ow0KPiA+ICsJcS0+dyA9IHBpeF9tcC0+d2lkdGg7DQo+ID4gKwlxLT5oID0gcGl4X21wLT5oZWln aHQ7DQo+ID4gKwlxLT5zaXplaW1hZ2VbMF0gPSBwaXhfbXAtPnBsYW5lX2ZtdFswXS5zaXplaW1h Z2U7DQo+ID4gKwlxLT5ieXRlc3BlcmxpbmVbMF0gPSBwaXhfbXAtPnBsYW5lX2ZtdFswXS5ieXRl c3BlcmxpbmU7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyB2b2lkIG10a19qcGVnX3NldF9k ZWNfZGVmYXVsdF9wYXJhbXMoc3RydWN0IG10a19qcGVnX2N0eCAqY3R4KQ0KPiA+ICt7DQo+ID4g KwlzdHJ1Y3QgbXRrX2pwZWdfcV9kYXRhICpxID0gJmN0eC0+b3V0X3E7DQo+ID4gKwlzdHJ1Y3Qg djRsMl9waXhfZm9ybWF0X21wbGFuZSAqcGl4X21wOw0KPiA+ICsJaW50IGk7DQo+ID4gKw0KPiA+ ICsJcGl4X21wID0ga21hbGxvYyhzaXplb2YoKnBpeF9tcCksIEdGUF9LRVJORUwpOw0KPiA+ICAN Cj4gPiArCWN0eC0+ZmguY3RybF9oYW5kbGVyID0gJmN0eC0+Y3RybF9oZGw7DQo+ID4gKwljdHgt PmNvbG9yc3BhY2UgPSBWNEwyX0NPTE9SU1BBQ0VfSlBFRywNCj4gPiArCWN0eC0+eWNiY3JfZW5j ID0gVjRMMl9ZQ0JDUl9FTkNfREVGQVVMVDsNCj4gPiArCWN0eC0+cXVhbnRpemF0aW9uID0gVjRM Ml9RVUFOVElaQVRJT05fREVGQVVMVDsNCj4gPiArCWN0eC0+eGZlcl9mdW5jID0gVjRMMl9YRkVS X0ZVTkNfREVGQVVMVDsNCj4gPiArCXBpeF9tcC0+d2lkdGggPSBNVEtfSlBFR19NSU5fV0lEVEg7 DQo+ID4gKwlwaXhfbXAtPmhlaWdodCA9IE1US19KUEVHX01JTl9IRUlHSFQ7DQo+ID4gKw0KPiA+ ICsJcS0+Zm10ID0gbXRrX2pwZWdfZmluZF9mb3JtYXQoVjRMMl9QSVhfRk1UX0pQRUcsDQo+ID4g KwkJCQkgICAgICBNVEtfSlBFR19GTVRfRkxBR19ERUNfT1VUUFVUKTsNCj4gPiArCXZpZGlvY190 cnlfZm10KGNvbnRhaW5lcl9vZihwaXhfbXAsIHN0cnVjdCB2NGwyX2Zvcm1hdCwNCj4gPiArCQkJ CSAgICBmbXQucGl4X21wKSwgcS0+Zm10KTsNCj4gPiArCXEtPncgPSBwaXhfbXAtPndpZHRoOw0K PiA+ICsJcS0+aCA9IHBpeF9tcC0+aGVpZ2h0Ow0KPiA+ICsJcS0+c2l6ZWltYWdlWzBdID0gcGl4 X21wLT5wbGFuZV9mbXRbMF0uc2l6ZWltYWdlOw0KPiA+ICsJcS0+Ynl0ZXNwZXJsaW5lWzBdID0g cGl4X21wLT5wbGFuZV9mbXRbMF0uYnl0ZXNwZXJsaW5lOw0KPiA+ICsNCj4gPiArCXEgPSAmY3R4 LT5jYXBfcTsNCj4gPiArCXEtPmZtdCA9IG10a19qcGVnX2ZpbmRfZm9ybWF0KFY0TDJfUElYX0ZN VF9ZVVY0MjBNLA0KPiA+ICsJCQkJICAgICAgTVRLX0pQRUdfRk1UX0ZMQUdfREVDX0NBUFRVUkUp Ow0KPiA+ICsJcGl4X21wLT53aWR0aCA9IE1US19KUEVHX01JTl9XSURUSDsNCj4gPiArCXBpeF9t cC0+aGVpZ2h0ID0gTVRLX0pQRUdfTUlOX0hFSUdIVDsNCj4gPiArCXZpZGlvY190cnlfZm10KGNv bnRhaW5lcl9vZihwaXhfbXAsIHN0cnVjdCB2NGwyX2Zvcm1hdCwNCj4gPiArCQkJCSAgICBmbXQu cGl4X21wKSwgcS0+Zm10KTsNCj4gPiArCXEtPncgPSBwaXhfbXAtPndpZHRoOw0KPiA+ICsJcS0+ aCA9IHBpeF9tcC0+aGVpZ2h0Ow0KPiA+ICAJZm9yIChpID0gMDsgaSA8IHEtPmZtdC0+Y29scGxh bmVzOyBpKyspIHsNCj4gPiAtCQl1MzIgc3RyaWRlID0gcS0+dyAqIHEtPmZtdC0+aF9zYW1wbGVb aV0gLyA0Ow0KPiA+IC0JCXUzMiBoID0gcS0+aCAqIHEtPmZtdC0+dl9zYW1wbGVbaV0gLyA0Ow0K PiA+ICsJCXEtPnNpemVpbWFnZVtpXSA9IHBpeF9tcC0+cGxhbmVfZm10W2ldLnNpemVpbWFnZTsN Cj4gPiArCQlxLT5ieXRlc3BlcmxpbmVbaV0gPSBwaXhfbXAtPnBsYW5lX2ZtdFtpXS5ieXRlc3Bl cmxpbmU7DQo+ID4gKwl9DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyBpbnQgbXRrX2pwZWdf ZW5jX29wZW4oc3RydWN0IGZpbGUgKmZpbGUpDQo+ID4gK3sNCj4gPiArCXN0cnVjdCBtdGtfanBl Z19kZXYgKmpwZWcgPSB2aWRlb19kcnZkYXRhKGZpbGUpOw0KPiA+ICsJc3RydWN0IHZpZGVvX2Rl dmljZSAqdmZkID0gdmlkZW9fZGV2ZGF0YShmaWxlKTsNCj4gPiArCXN0cnVjdCBtdGtfanBlZ19j dHggKmN0eDsNCj4gPiArCWludCByZXQgPSAwOw0KPiA+ICANCj4gPiAtCQlxLT5ieXRlc3Blcmxp bmVbaV0gPSBzdHJpZGU7DQo+ID4gLQkJcS0+c2l6ZWltYWdlW2ldID0gc3RyaWRlICogaDsNCj4g PiArCWN0eCA9IGt6YWxsb2Moc2l6ZW9mKCpjdHgpLCBHRlBfS0VSTkVMKTsNCj4gPiArCWlmICgh Y3R4KQ0KPiA+ICsJCXJldHVybiAtRU5PTUVNOw0KPiA+ICsNCj4gPiArCWlmIChtdXRleF9sb2Nr X2ludGVycnVwdGlibGUoJmpwZWctPmxvY2spKSB7DQo+ID4gKwkJcmV0ID0gLUVSRVNUQVJUU1lT Ow0KPiA+ICsJCWdvdG8gZnJlZTsNCj4gPiArCX0NCj4gPiArDQo+ID4gKwl2NGwyX2ZoX2luaXQo JmN0eC0+ZmgsIHZmZCk7DQo+ID4gKwlmaWxlLT5wcml2YXRlX2RhdGEgPSAmY3R4LT5maDsNCj4g PiArCXY0bDJfZmhfYWRkKCZjdHgtPmZoKTsNCj4gPiArDQo+ID4gKwljdHgtPmpwZWcgPSBqcGVn Ow0KPiA+ICsJY3R4LT5maC5tMm1fY3R4ID0gdjRsMl9tMm1fY3R4X2luaXQoanBlZy0+bTJtX2Rl diwgY3R4LA0KPiA+ICsJCQkJCSAgICBtdGtfanBlZ19lbmNfcXVldWVfaW5pdCk7DQo+ID4gKwlp ZiAoSVNfRVJSKGN0eC0+ZmgubTJtX2N0eCkpIHsNCj4gPiArCQlyZXQgPSBQVFJfRVJSKGN0eC0+ ZmgubTJtX2N0eCk7DQo+ID4gKwkJZ290byBlcnJvcjsNCj4gPiAgCX0NCj4gPiArDQo+ID4gKwly ZXQgPSBtdGtfanBlZ19lbmNfY3RybHNfc2V0dXAoY3R4KTsNCj4gPiArCWlmIChyZXQpIHsNCj4g PiArCQl2NGwyX2VycigmanBlZy0+djRsMl9kZXYsICJGYWlsZWQgdG8gc2V0dXAganBlZyBlbmMg Y29udHJvbHNcbiIpOw0KPiA+ICsJCWdvdG8gZXJyb3I7DQo+ID4gKwl9DQo+ID4gKwltdGtfanBl Z19zZXRfZW5jX2RlZmF1bHRfcGFyYW1zKGN0eCk7DQo+ID4gKw0KPiA+ICsJbXV0ZXhfdW5sb2Nr KCZqcGVnLT5sb2NrKTsNCj4gPiArCXJldHVybiAwOw0KPiA+ICsNCj4gPiArZXJyb3I6DQo+ID4g Kwl2NGwyX2ZoX2RlbCgmY3R4LT5maCk7DQo+ID4gKwl2NGwyX2ZoX2V4aXQoJmN0eC0+ZmgpOw0K PiA+ICsJbXV0ZXhfdW5sb2NrKCZqcGVnLT5sb2NrKTsNCj4gPiArZnJlZToNCj4gPiArCWtmcmVl KGN0eCk7DQo+ID4gKwlyZXR1cm4gcmV0Ow0KPiA+ICB9DQo+ID4gIA0KPiA+IC1zdGF0aWMgaW50 IG10a19qcGVnX29wZW4oc3RydWN0IGZpbGUgKmZpbGUpDQo+ID4gK3N0YXRpYyBpbnQgbXRrX2pw ZWdfZGVjX29wZW4oc3RydWN0IGZpbGUgKmZpbGUpDQo+ID4gIHsNCj4gPiAgCXN0cnVjdCBtdGtf anBlZ19kZXYgKmpwZWcgPSB2aWRlb19kcnZkYXRhKGZpbGUpOw0KPiA+ICAJc3RydWN0IHZpZGVv X2RldmljZSAqdmZkID0gdmlkZW9fZGV2ZGF0YShmaWxlKTsNCj4gPiBAQCAtOTcxLDEzICsxNTI1 LDIwIEBAIHN0YXRpYyBpbnQgbXRrX2pwZWdfb3BlbihzdHJ1Y3QgZmlsZSAqZmlsZSkNCj4gPiAg DQo+ID4gIAljdHgtPmpwZWcgPSBqcGVnOw0KPiA+ICAJY3R4LT5maC5tMm1fY3R4ID0gdjRsMl9t Mm1fY3R4X2luaXQoanBlZy0+bTJtX2RldiwgY3R4LA0KPiA+IC0JCQkJCSAgICBtdGtfanBlZ19x dWV1ZV9pbml0KTsNCj4gPiArCQkJCQkgICAgbXRrX2pwZWdfZGVjX3F1ZXVlX2luaXQpOw0KPiA+ ICAJaWYgKElTX0VSUihjdHgtPmZoLm0ybV9jdHgpKSB7DQo+ID4gIAkJcmV0ID0gUFRSX0VSUihj dHgtPmZoLm0ybV9jdHgpOw0KPiA+ICAJCWdvdG8gZXJyb3I7DQo+ID4gIAl9DQo+ID4gIA0KPiA+ IC0JbXRrX2pwZWdfc2V0X2RlZmF1bHRfcGFyYW1zKGN0eCk7DQo+ID4gKwl2NGwyX2N0cmxfaGFu ZGxlcl9pbml0KCZjdHgtPmN0cmxfaGRsLCAwKTsNCj4gPiArCXJldCA9IHY0bDJfY3RybF9oYW5k bGVyX3NldHVwKCZjdHgtPmN0cmxfaGRsKTsNCj4gPiArCWlmIChyZXQpIHsNCj4gPiArCQl2NGwy X2VycigmanBlZy0+djRsMl9kZXYsICJGYWlsZWQgdG8gc2V0dXAganBlZyBkZWMgY29udHJvbHNc biIpOw0KPiA+ICsJCWdvdG8gZXJyb3I7DQo+ID4gKwl9DQo+ID4gKwltdGtfanBlZ19zZXRfZGVj X2RlZmF1bHRfcGFyYW1zKGN0eCk7DQo+ID4gKw0KPiA+ICAJbXV0ZXhfdW5sb2NrKCZqcGVnLT5s b2NrKTsNCj4gPiAgCXJldHVybiAwOw0KPiA+ICANCj4gPiBAQCAtOTk3LDYgKzE1NTgsNyBAQCBz dGF0aWMgaW50IG10a19qcGVnX3JlbGVhc2Uoc3RydWN0IGZpbGUgKmZpbGUpDQo+ID4gIA0KPiA+ ICAJbXV0ZXhfbG9jaygmanBlZy0+bG9jayk7DQo+ID4gIAl2NGwyX20ybV9jdHhfcmVsZWFzZShj dHgtPmZoLm0ybV9jdHgpOw0KPiA+ICsJdjRsMl9jdHJsX2hhbmRsZXJfZnJlZSgmY3R4LT5jdHJs X2hkbCk7DQo+ID4gIAl2NGwyX2ZoX2RlbCgmY3R4LT5maCk7DQo+ID4gIAl2NGwyX2ZoX2V4aXQo JmN0eC0+ZmgpOw0KPiA+ICAJa2ZyZWUoY3R4KTsNCj4gPiBAQCAtMTAwNCw5ICsxNTY2LDE4IEBA IHN0YXRpYyBpbnQgbXRrX2pwZWdfcmVsZWFzZShzdHJ1Y3QgZmlsZSAqZmlsZSkNCj4gPiAgCXJl dHVybiAwOw0KPiA+ICB9DQo+ID4gIA0KPiA+IC1zdGF0aWMgY29uc3Qgc3RydWN0IHY0bDJfZmls ZV9vcGVyYXRpb25zIG10a19qcGVnX2ZvcHMgPSB7DQo+ID4gK3N0YXRpYyBjb25zdCBzdHJ1Y3Qg djRsMl9maWxlX29wZXJhdGlvbnMgbXRrX2pwZWdfZW5jX2ZvcHMgPSB7DQo+ID4gIAkub3duZXIg ICAgICAgICAgPSBUSElTX01PRFVMRSwNCj4gPiAtCS5vcGVuICAgICAgICAgICA9IG10a19qcGVn X29wZW4sDQo+ID4gKwkub3BlbiAgICAgICAgICAgPSBtdGtfanBlZ19lbmNfb3BlbiwNCj4gPiAr CS5yZWxlYXNlICAgICAgICA9IG10a19qcGVnX3JlbGVhc2UsDQo+ID4gKwkucG9sbCAgICAgICAg ICAgPSB2NGwyX20ybV9mb3BfcG9sbCwNCj4gPiArCS51bmxvY2tlZF9pb2N0bCA9IHZpZGVvX2lv Y3RsMiwNCj4gPiArCS5tbWFwICAgICAgICAgICA9IHY0bDJfbTJtX2ZvcF9tbWFwLA0KPiA+ICt9 Ow0KPiA+ICsNCj4gPiArc3RhdGljIGNvbnN0IHN0cnVjdCB2NGwyX2ZpbGVfb3BlcmF0aW9ucyBt dGtfanBlZ19kZWNfZm9wcyA9IHsNCj4gPiArCS5vd25lciAgICAgICAgICA9IFRISVNfTU9EVUxF LA0KPiA+ICsJLm9wZW4gICAgICAgICAgID0gbXRrX2pwZWdfZGVjX29wZW4sDQo+ID4gIAkucmVs ZWFzZSAgICAgICAgPSBtdGtfanBlZ19yZWxlYXNlLA0KPiA+ICAJLnBvbGwgICAgICAgICAgID0g djRsMl9tMm1fZm9wX3BvbGwsDQo+ID4gIAkudW5sb2NrZWRfaW9jdGwgPSB2aWRlb19pb2N0bDIs DQo+ID4gQEAgLTEwMTcsNiArMTU4OCw3IEBAIHN0YXRpYyBpbnQgbXRrX2pwZWdfY2xrX2luaXQo c3RydWN0IG10a19qcGVnX2RldiAqanBlZykNCj4gPiAgew0KPiA+ICAJc3RydWN0IGRldmljZV9u b2RlICpub2RlOw0KPiA+ICAJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldjsNCj4gPiArCWlu dCBpOw0KPiA+ICANCj4gPiAgCW5vZGUgPSBvZl9wYXJzZV9waGFuZGxlKGpwZWctPmRldi0+b2Zf bm9kZSwgIm1lZGlhdGVrLGxhcmIiLCAwKTsNCj4gPiAgCWlmICghbm9kZSkNCj4gPiBAQCAtMTAz MCwxOSArMTYwMiwyNCBAQCBzdGF0aWMgaW50IG10a19qcGVnX2Nsa19pbml0KHN0cnVjdCBtdGtf anBlZ19kZXYgKmpwZWcpDQo+ID4gIA0KPiA+ICAJanBlZy0+bGFyYiA9ICZwZGV2LT5kZXY7DQo+ ID4gIA0KPiA+IC0JanBlZy0+Y2xrX2pkZWMgPSBkZXZtX2Nsa19nZXQoanBlZy0+ZGV2LCAianBn ZGVjIik7DQo+ID4gLQlpZiAoSVNfRVJSKGpwZWctPmNsa19qZGVjKSkNCj4gPiAtCQlyZXR1cm4g UFRSX0VSUihqcGVnLT5jbGtfamRlYyk7DQo+ID4gKwlmb3IgKGkgPSAwOyBpIDwganBlZy0+dmFy aWFudC0+bnVtX2Nsb2NrczsgaSsrKSB7DQo+ID4gKwkJanBlZy0+Y2xvY2tzW2ldID0gZGV2bV9j bGtfZ2V0KGpwZWctPmRldiwNCj4gPiArCQkJCQkgICAgICAganBlZy0+dmFyaWFudC0+Y2xrX25h bWVzW2ldKTsNCj4gPiArCQlpZiAoSVNfRVJSKGpwZWctPmNsb2Nrc1tpXSkpIHsNCj4gPiArCQkJ ZGV2X2VycigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBjbG9jazogJXNcbiIsDQo+ID4gKwkJ CQlqcGVnLT52YXJpYW50LT5jbGtfbmFtZXNbaV0pOw0KPiA+ICsJCQlyZXR1cm4gUFRSX0VSUihq cGVnLT5jbG9ja3NbaV0pOw0KPiA+ICsJCX0NCj4gPiArCX0NCj4gPiAgDQo+ID4gLQlqcGVnLT5j bGtfamRlY19zbWkgPSBkZXZtX2Nsa19nZXQoanBlZy0+ZGV2LCAianBnZGVjLXNtaSIpOw0KPiA+ IC0JcmV0dXJuIFBUUl9FUlJfT1JfWkVSTyhqcGVnLT5jbGtfamRlY19zbWkpOw0KPiA+ICsJcmV0 dXJuIDA7DQo+ID4gIH0NCj4gPiAgDQo+ID4gIHN0YXRpYyBpbnQgbXRrX2pwZWdfcHJvYmUoc3Ry dWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikNCj4gPiAgew0KPiA+ICAJc3RydWN0IG10a19qcGVn X2RldiAqanBlZzsNCj4gPiAgCXN0cnVjdCByZXNvdXJjZSAqcmVzOw0KPiA+IC0JaW50IGRlY19p cnE7DQo+ID4gKwlpbnQganBlZ19pcnE7DQo+ID4gIAlpbnQgcmV0Ow0KPiA+ICANCj4gPiAgCWpw ZWcgPSBkZXZtX2t6YWxsb2MoJnBkZXYtPmRldiwgc2l6ZW9mKCpqcGVnKSwgR0ZQX0tFUk5FTCk7 DQo+ID4gQEAgLTEwNTIsMjUgKzE2MjksMzAgQEAgc3RhdGljIGludCBtdGtfanBlZ19wcm9iZShz dHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KPiA+ICAJbXV0ZXhfaW5pdCgmanBlZy0+bG9j ayk7DQo+ID4gIAlzcGluX2xvY2tfaW5pdCgmanBlZy0+aHdfbG9jayk7DQo+ID4gIAlqcGVnLT5k ZXYgPSAmcGRldi0+ZGV2Ow0KPiA+ICsJanBlZy0+dmFyaWFudCA9IG9mX2RldmljZV9nZXRfbWF0 Y2hfZGF0YShqcGVnLT5kZXYpOw0KPiA+ICANCj4gPiAgCXJlcyA9IHBsYXRmb3JtX2dldF9yZXNv dXJjZShwZGV2LCBJT1JFU09VUkNFX01FTSwgMCk7DQo+ID4gLQlqcGVnLT5kZWNfcmVnX2Jhc2Ug PSBkZXZtX2lvcmVtYXBfcmVzb3VyY2UoJnBkZXYtPmRldiwgcmVzKTsNCj4gPiAtCWlmIChJU19F UlIoanBlZy0+ZGVjX3JlZ19iYXNlKSkgew0KPiA+IC0JCXJldCA9IFBUUl9FUlIoanBlZy0+ZGVj X3JlZ19iYXNlKTsNCj4gPiArCWpwZWctPnJlZ19iYXNlID0gZGV2bV9pb3JlbWFwX3Jlc291cmNl KCZwZGV2LT5kZXYsIHJlcyk7DQo+ID4gKwlpZiAoSVNfRVJSKGpwZWctPnJlZ19iYXNlKSkgew0K PiA+ICsJCXJldCA9IFBUUl9FUlIoanBlZy0+cmVnX2Jhc2UpOw0KPiA+ICAJCXJldHVybiByZXQ7 DQo+ID4gIAl9DQo+ID4gIA0KPiA+IC0JZGVjX2lycSA9IHBsYXRmb3JtX2dldF9pcnEocGRldiwg MCk7DQo+ID4gLQlpZiAoZGVjX2lycSA8IDApIHsNCj4gPiAtCQlkZXZfZXJyKCZwZGV2LT5kZXYs ICJGYWlsZWQgdG8gZ2V0IGRlY19pcnEgJWQuXG4iLCBkZWNfaXJxKTsNCj4gPiAtCQlyZXR1cm4g ZGVjX2lycTsNCj4gPiArCWpwZWdfaXJxID0gcGxhdGZvcm1fZ2V0X2lycShwZGV2LCAwKTsNCj4g PiArCWlmIChqcGVnX2lycSA8IDApIHsNCj4gPiArCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJGYWls ZWQgdG8gZ2V0IGpwZWdfaXJxICVkLlxuIiwganBlZ19pcnEpOw0KPiA+ICsJCXJldHVybiBqcGVn X2lycTsNCj4gPiAgCX0NCj4gPiAgDQo+ID4gLQlyZXQgPSBkZXZtX3JlcXVlc3RfaXJxKCZwZGV2 LT5kZXYsIGRlY19pcnEsIG10a19qcGVnX2RlY19pcnEsIDAsDQo+ID4gLQkJCSAgICAgICBwZGV2 LT5uYW1lLCBqcGVnKTsNCj4gPiArCWlmIChqcGVnLT52YXJpYW50LT5pc19lbmNvZGVyKQ0KPiA+ ICsJCXJldCA9IGRldm1fcmVxdWVzdF9pcnEoJnBkZXYtPmRldiwganBlZ19pcnEsIG10a19qcGVn X2VuY19pcnEsDQo+ID4gKwkJCQkgICAgICAgMCwgcGRldi0+bmFtZSwganBlZyk7DQo+ID4gKwll bHNlDQo+ID4gKwkJcmV0ID0gZGV2bV9yZXF1ZXN0X2lycSgmcGRldi0+ZGV2LCBqcGVnX2lycSwg bXRrX2pwZWdfZGVjX2lycSwNCj4gPiArCQkJCSAgICAgICAwLCBwZGV2LT5uYW1lLCBqcGVnKTsN Cj4gPiAgCWlmIChyZXQpIHsNCj4gPiAtCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJGYWlsZWQgdG8g cmVxdWVzdCBkZWNfaXJxICVkICglZClcbiIsDQo+ID4gLQkJCWRlY19pcnEsIHJldCk7DQo+ID4g KwkJZGV2X2VycigmcGRldi0+ZGV2LCAiRmFpbGVkIHRvIHJlcXVlc3QganBlZ19pcnEgJWQgKCVk KVxuIiwNCj4gPiArCQkJanBlZ19pcnEsIHJldCk7DQo+ID4gIAkJZ290byBlcnJfcmVxX2lycTsN Cj4gPiAgCX0NCj4gPiAgDQo+ID4gQEAgLTEwODcsNDAgKzE2NjksNTAgQEAgc3RhdGljIGludCBt dGtfanBlZ19wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KPiA+ICAJCWdvdG8g ZXJyX2Rldl9yZWdpc3RlcjsNCj4gPiAgCX0NCj4gPiAgDQo+ID4gLQlqcGVnLT5tMm1fZGV2ID0g djRsMl9tMm1faW5pdCgmbXRrX2pwZWdfbTJtX29wcyk7DQo+ID4gKwlpZiAoanBlZy0+dmFyaWFu dC0+aXNfZW5jb2RlcikNCj4gPiArCQlqcGVnLT5tMm1fZGV2ID0gdjRsMl9tMm1faW5pdCgmbXRr X2pwZWdfZW5jX20ybV9vcHMpOw0KPiA+ICsJZWxzZQ0KPiA+ICsJCWpwZWctPm0ybV9kZXYgPSB2 NGwyX20ybV9pbml0KCZtdGtfanBlZ19kZWNfbTJtX29wcyk7DQo+ID4gIAlpZiAoSVNfRVJSKGpw ZWctPm0ybV9kZXYpKSB7DQo+ID4gIAkJdjRsMl9lcnIoJmpwZWctPnY0bDJfZGV2LCAiRmFpbGVk IHRvIGluaXQgbWVtMm1lbSBkZXZpY2VcbiIpOw0KPiA+ICAJCXJldCA9IFBUUl9FUlIoanBlZy0+ bTJtX2Rldik7DQo+ID4gIAkJZ290byBlcnJfbTJtX2luaXQ7DQo+ID4gIAl9DQo+ID4gIA0KPiA+ IC0JanBlZy0+ZGVjX3ZkZXYgPSB2aWRlb19kZXZpY2VfYWxsb2MoKTsNCj4gPiAtCWlmICghanBl Zy0+ZGVjX3ZkZXYpIHsNCj4gPiArCWpwZWctPnZkZXYgPSB2aWRlb19kZXZpY2VfYWxsb2MoKTsN Cj4gPiArCWlmICghanBlZy0+dmRldikgew0KPiA+ICAJCXJldCA9IC1FTk9NRU07DQo+ID4gLQkJ Z290byBlcnJfZGVjX3ZkZXZfYWxsb2M7DQo+ID4gKwkJZ290byBlcnJfdmZkX2pwZWdfYWxsb2M7 DQo+ID4gIAl9DQo+ID4gLQlzbnByaW50ZihqcGVnLT5kZWNfdmRldi0+bmFtZSwgc2l6ZW9mKGpw ZWctPmRlY192ZGV2LT5uYW1lKSwNCj4gPiAtCQkgIiVzLWRlYyIsIE1US19KUEVHX05BTUUpOw0K PiA+IC0JanBlZy0+ZGVjX3ZkZXYtPmZvcHMgPSAmbXRrX2pwZWdfZm9wczsNCj4gPiAtCWpwZWct PmRlY192ZGV2LT5pb2N0bF9vcHMgPSAmbXRrX2pwZWdfaW9jdGxfb3BzOw0KPiA+IC0JanBlZy0+ ZGVjX3ZkZXYtPm1pbm9yID0gLTE7DQo+ID4gLQlqcGVnLT5kZWNfdmRldi0+cmVsZWFzZSA9IHZp ZGVvX2RldmljZV9yZWxlYXNlOw0KPiA+IC0JanBlZy0+ZGVjX3ZkZXYtPmxvY2sgPSAmanBlZy0+ bG9jazsNCj4gPiAtCWpwZWctPmRlY192ZGV2LT52NGwyX2RldiA9ICZqcGVnLT52NGwyX2RldjsN Cj4gPiAtCWpwZWctPmRlY192ZGV2LT52ZmxfZGlyID0gVkZMX0RJUl9NMk07DQo+ID4gLQlqcGVn LT5kZWNfdmRldi0+ZGV2aWNlX2NhcHMgPSBWNEwyX0NBUF9TVFJFQU1JTkcgfA0KPiA+ICsJc25w cmludGYoanBlZy0+dmRldi0+bmFtZSwgc2l6ZW9mKGpwZWctPnZkZXYtPm5hbWUpLA0KPiA+ICsJ CSAiJXMtJXMiLCBNVEtfSlBFR19OQU1FLA0KPiA+ICsJCSBqcGVnLT52YXJpYW50LT5pc19lbmNv ZGVyID8gImVuYyIgOiAiZGVjIik7DQo+ID4gKwlpZiAoanBlZy0+dmFyaWFudC0+aXNfZW5jb2Rl cikgew0KPiA+ICsJCWpwZWctPnZkZXYtPmZvcHMgPSAmbXRrX2pwZWdfZW5jX2ZvcHM7DQo+ID4g KwkJanBlZy0+dmRldi0+aW9jdGxfb3BzID0gJm10a19qcGVnX2VuY19pb2N0bF9vcHM7DQo+ID4g Kwl9IGVsc2Ugew0KPiA+ICsJCWpwZWctPnZkZXYtPmZvcHMgPSAmbXRrX2pwZWdfZGVjX2ZvcHM7 DQo+ID4gKwkJanBlZy0+dmRldi0+aW9jdGxfb3BzID0gJm10a19qcGVnX2RlY19pb2N0bF9vcHM7 DQo+ID4gKwl9DQo+ID4gKwlqcGVnLT52ZGV2LT5taW5vciA9IC0xOw0KPiA+ICsJanBlZy0+dmRl di0+cmVsZWFzZSA9IHZpZGVvX2RldmljZV9yZWxlYXNlOw0KPiA+ICsJanBlZy0+dmRldi0+bG9j ayA9ICZqcGVnLT5sb2NrOw0KPiA+ICsJanBlZy0+dmRldi0+djRsMl9kZXYgPSAmanBlZy0+djRs Ml9kZXY7DQo+ID4gKwlqcGVnLT52ZGV2LT52ZmxfZGlyID0gVkZMX0RJUl9NMk07DQo+ID4gKwlq cGVnLT52ZGV2LT5kZXZpY2VfY2FwcyA9IFY0TDJfQ0FQX1NUUkVBTUlORyB8DQo+ID4gIAkJCQkg ICAgICBWNEwyX0NBUF9WSURFT19NMk1fTVBMQU5FOw0KPiA+ICANCj4gPiAtCXJldCA9IHZpZGVv X3JlZ2lzdGVyX2RldmljZShqcGVnLT5kZWNfdmRldiwgVkZMX1RZUEVfR1JBQkJFUiwgLTEpOw0K PiA+ICsJcmV0ID0gdmlkZW9fcmVnaXN0ZXJfZGV2aWNlKGpwZWctPnZkZXYsIFZGTF9UWVBFX0dS QUJCRVIsIC0xKTsNCj4gPiAgCWlmIChyZXQpIHsNCj4gPiAgCQl2NGwyX2VycigmanBlZy0+djRs Ml9kZXYsICJGYWlsZWQgdG8gcmVnaXN0ZXIgdmlkZW8gZGV2aWNlXG4iKTsNCj4gPiAtCQlnb3Rv IGVycl9kZWNfdmRldl9yZWdpc3RlcjsNCj4gPiArCQlnb3RvIGVycl92ZmRfanBlZ19yZWdpc3Rl cjsNCj4gPiAgCX0NCj4gPiAgDQo+ID4gLQl2aWRlb19zZXRfZHJ2ZGF0YShqcGVnLT5kZWNfdmRl diwganBlZyk7DQo+ID4gKwl2aWRlb19zZXRfZHJ2ZGF0YShqcGVnLT52ZGV2LCBqcGVnKTsNCj4g PiAgCXY0bDJfaW5mbygmanBlZy0+djRsMl9kZXYsDQo+ID4gLQkJICAiZGVjb2RlciBkZXZpY2Ug cmVnaXN0ZXJlZCBhcyAvZGV2L3ZpZGVvJWQgKCVkLCVkKVxuIiwNCj4gPiAtCQkgIGpwZWctPmRl Y192ZGV2LT5udW0sIFZJREVPX01BSk9SLCBqcGVnLT5kZWNfdmRldi0+bWlub3IpOw0KPiA+ICsJ CSAgImpwZWcgJXMgZGV2aWNlIHJlZ2lzdGVyZWQgYXMgL2Rldi92aWRlbyVkICglZCwlZClcbiIs DQo+ID4gKwkJICBqcGVnLT52YXJpYW50LT5pc19lbmNvZGVyID8gImVuYyIgOiAiZGVjIiwganBl Zy0+dmRldi0+bnVtLA0KPiA+ICsJCSAgVklERU9fTUFKT1IsIGpwZWctPnZkZXYtPm1pbm9yKTsN Cj4gPiAgDQo+ID4gIAlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBqcGVnKTsNCj4gPiAgDQo+ ID4gQEAgLTExMjgsMTAgKzE3MjAsMTAgQEAgc3RhdGljIGludCBtdGtfanBlZ19wcm9iZShzdHJ1 Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KPiA+ICANCj4gPiAgCXJldHVybiAwOw0KPiA+ICAN Cj4gPiAtZXJyX2RlY192ZGV2X3JlZ2lzdGVyOg0KPiA+IC0JdmlkZW9fZGV2aWNlX3JlbGVhc2Uo anBlZy0+ZGVjX3ZkZXYpOw0KPiA+ICtlcnJfdmZkX2pwZWdfcmVnaXN0ZXI6DQo+ID4gKwl2aWRl b19kZXZpY2VfcmVsZWFzZShqcGVnLT52ZGV2KTsNCj4gPiAgDQo+ID4gLWVycl9kZWNfdmRldl9h bGxvYzoNCj4gPiArZXJyX3ZmZF9qcGVnX2FsbG9jOg0KPiA+ICAJdjRsMl9tMm1fcmVsZWFzZShq cGVnLT5tMm1fZGV2KTsNCj4gPiAgDQo+ID4gIGVycl9tMm1faW5pdDoNCj4gPiBAQCAtMTE1MSw4 ICsxNzQzLDggQEAgc3RhdGljIGludCBtdGtfanBlZ19yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikNCj4gPiAgCXN0cnVjdCBtdGtfanBlZ19kZXYgKmpwZWcgPSBwbGF0Zm9ybV9n ZXRfZHJ2ZGF0YShwZGV2KTsNCj4gPiAgDQo+ID4gIAlwbV9ydW50aW1lX2Rpc2FibGUoJnBkZXYt PmRldik7DQo+ID4gLQl2aWRlb191bnJlZ2lzdGVyX2RldmljZShqcGVnLT5kZWNfdmRldik7DQo+ ID4gLQl2aWRlb19kZXZpY2VfcmVsZWFzZShqcGVnLT5kZWNfdmRldik7DQo+ID4gKwl2aWRlb191 bnJlZ2lzdGVyX2RldmljZShqcGVnLT52ZGV2KTsNCj4gPiArCXZpZGVvX2RldmljZV9yZWxlYXNl KGpwZWctPnZkZXYpOw0KPiA+ICAJdjRsMl9tMm1fcmVsZWFzZShqcGVnLT5tMm1fZGV2KTsNCj4g PiAgCXY0bDJfZGV2aWNlX3VucmVnaXN0ZXIoJmpwZWctPnY0bDJfZGV2KTsNCj4gPiAgDQo+ID4g QEAgLTEyMTEsMTQgKzE4MDMsMzYgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIG10 a19qcGVnX3BtX29wcyA9IHsNCj4gPiAgCVNFVF9SVU5USU1FX1BNX09QUyhtdGtfanBlZ19wbV9z dXNwZW5kLCBtdGtfanBlZ19wbV9yZXN1bWUsIE5VTEwpDQo+ID4gIH07DQo+ID4gIA0KPiA+ICtz dGF0aWMgc3RydWN0IG10a19qcGVnX3ZhcmlhbnQgbXQ4MTczX2pwZWdfZHJ2ZGF0YSA9IHsNCj4g PiArCS5pc19lbmNvZGVyCT0gZmFsc2UsDQo+ID4gKwkuY2xrX25hbWVzCT0geyJqcGdkZWMtc21p IiwgImpwZ2RlYyJ9LA0KPiA+ICsJLm51bV9jbG9ja3MJPSAyLA0KPiA+ICt9Ow0KPiA+ICsNCj4g PiArc3RhdGljIHN0cnVjdCBtdGtfanBlZ192YXJpYW50IG10MjcwMV9qcGVnX2RydmRhdGEgPSB7 DQo+ID4gKwkuaXNfZW5jb2Rlcgk9IGZhbHNlLA0KPiA+ICsJLmNsa19uYW1lcwk9IHsianBnZGVj LXNtaSIsICJqcGdkZWMifSwNCj4gPiArCS5udW1fY2xvY2tzCT0gMiwNCj4gPiArfTsNCj4gPiAr DQo+ID4gK3N0YXRpYyBzdHJ1Y3QgbXRrX2pwZWdfdmFyaWFudCBtdGtfanBlZ19kcnZkYXRhID0g ew0KPiA+ICsJLmlzX2VuY29kZXIJPSB0cnVlLA0KPiA+ICsJLmNsa19uYW1lcwk9IHsianBnZW5j In0sDQo+ID4gKwkubnVtX2Nsb2Nrcwk9IDEsDQo+ID4gK307DQo+ID4gKw0KPiA+ICBzdGF0aWMg Y29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBtdGtfanBlZ19tYXRjaFtdID0gew0KPiA+ICAJew0K PiA+ICAJCS5jb21wYXRpYmxlID0gIm1lZGlhdGVrLG10ODE3My1qcGdkZWMiLA0KPiA+IC0JCS5k YXRhICAgICAgID0gTlVMTCwNCj4gPiArCQkuZGF0YSA9ICZtdDgxNzNfanBlZ19kcnZkYXRhLA0K PiA+ICAJfSwNCj4gPiAgCXsNCj4gPiAgCQkuY29tcGF0aWJsZSA9ICJtZWRpYXRlayxtdDI3MDEt anBnZGVjIiwNCj4gPiAtCQkuZGF0YSAgICAgICA9IE5VTEwsDQo+ID4gKwkJLmRhdGEgPSAmbXQy NzAxX2pwZWdfZHJ2ZGF0YSwNCj4gPiArCX0sDQo+ID4gKwl7DQo+ID4gKwkJLmNvbXBhdGlibGUg PSAibWVkaWF0ZWssbXRrLWpwZ2VuYyIsDQo+ID4gKwkJLmRhdGEgPSAmbXRrX2pwZWdfZHJ2ZGF0 YSwNCj4gPiAgCX0sDQo+ID4gIAl7fSwNCj4gPiAgfTsNCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS9tdGstanBlZy9tdGtfanBlZ19jb3JlLmggYi9kcml2ZXJzL21lZGlh L3BsYXRmb3JtL210ay1qcGVnL210a19qcGVnX2NvcmUuaA0KPiA+IGluZGV4IDliYmQ2MTViMTA2 Ny4uOGY4MGYyYTY5ZDQ1IDEwMDY0NA0KPiA+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0v bXRrLWpwZWcvbXRrX2pwZWdfY29yZS5oDQo+ID4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS9tdGstanBlZy9tdGtfanBlZ19jb3JlLmgNCj4gPiBAQCAtMyw2ICszLDcgQEANCj4gPiAgICog Q29weXJpZ2h0IChjKSAyMDE2IE1lZGlhVGVrIEluYy4NCj4gPiAgICogQXV0aG9yOiBNaW5nIEhz aXUgVHNhaSA8bWluZ2hzaXUudHNhaUBtZWRpYXRlay5jb20+DQo+ID4gICAqICAgICAgICAgUmlj ayBDaGFuZyA8cmljay5jaGFuZ0BtZWRpYXRlay5jb20+DQo+ID4gKyAqICAgICAgICAgWGlhIEpp YW5nIDx4aWEuamlhbmdAbWVkaWF0ZWsuY29tPg0KPiA+ICAgKi8NCj4gPiAgDQo+ID4gICNpZm5k ZWYgX01US19KUEVHX0NPUkVfSA0KPiA+IEBAIC0xNiwxOSArMTcsMjEgQEANCj4gPiAgI2RlZmlu ZSBNVEtfSlBFR19OQU1FCQkibXRrLWpwZWciDQo+ID4gIA0KPiA+ICAjZGVmaW5lIE1US19KUEVH X0NPTVBfTUFYCQkzDQo+ID4gKyNkZWZpbmUgTVRLX0pQRUdfTUFYX0NMT0NLUwkJMg0KPiA+ICsN Cj4gPiAgDQo+ID4gICNkZWZpbmUgTVRLX0pQRUdfRk1UX0ZMQUdfREVDX09VVFBVVAlCSVQoMCkN Cj4gPiAgI2RlZmluZSBNVEtfSlBFR19GTVRfRkxBR19ERUNfQ0FQVFVSRQlCSVQoMSkNCj4gPiAt DQo+ID4gLSNkZWZpbmUgTVRLX0pQRUdfRk1UX1RZUEVfT1VUUFVUCTENCj4gPiAtI2RlZmluZSBN VEtfSlBFR19GTVRfVFlQRV9DQVBUVVJFCTINCj4gPiArI2RlZmluZSBNVEtfSlBFR19GTVRfRkxB R19FTkNfT1VUUFVUCUJJVCgyKQ0KPiA+ICsjZGVmaW5lIE1US19KUEVHX0ZNVF9GTEFHX0VOQ19D QVBUVVJFCUJJVCgzKQ0KPiA+ICANCj4gPiAgI2RlZmluZSBNVEtfSlBFR19NSU5fV0lEVEgJMzJV DQo+ID4gICNkZWZpbmUgTVRLX0pQRUdfTUlOX0hFSUdIVAkzMlUNCj4gPiAtI2RlZmluZSBNVEtf SlBFR19NQVhfV0lEVEgJODE5MlUNCj4gPiAtI2RlZmluZSBNVEtfSlBFR19NQVhfSEVJR0hUCTgx OTJVDQo+ID4gKyNkZWZpbmUgTVRLX0pQRUdfTUFYX1dJRFRICTY1NTM1VQ0KPiA+ICsjZGVmaW5l IE1US19KUEVHX01BWF9IRUlHSFQJNjU1MzVVDQo+ID4gIA0KPiA+ICAjZGVmaW5lIE1US19KUEVH X0RFRkFVTFRfU0laRUlNQUdFCSgxICogMTAyNCAqIDEwMjQpDQo+ID4gKyNkZWZpbmUgTVRLX0pQ RUdfREVGQVVMVF9FWElGX1NJWkUJKDY0ICogMTAyNCkNCj4gPiAgDQo+ID4gIC8qKg0KPiA+ICAg KiBlbnVtIG10a19qcGVnX2N0eF9zdGF0ZSAtIGNvbnRleCBzdGF0ZSBvZiBqcGVnDQo+ID4gQEAg LTM5LDYgKzQyLDE4IEBAIGVudW0gbXRrX2pwZWdfY3R4X3N0YXRlIHsNCj4gPiAgCU1US19KUEVH X1NPVVJDRV9DSEFOR0UsDQo+ID4gIH07DQo+ID4gIA0KPiA+ICsvKioNCj4gPiArICogbXRrX2pw ZWdfdmFyaWFudCAtIG10ayBqcGVnIGRyaXZlciB2YXJpYW50DQo+ID4gKyAqIEBpc19lbmNvZGVy OgkJZHJpdmVyIG1vZGUgaXMganBlZyBlbmNvZGVyDQo+ID4gKyAqIEBjbGtfbmFtZXM6CQljbG9j ayBuYW1lcw0KPiA+ICsgKiBAbnVtX2Nsb2NrczoJCW51bWJlcnMgb2YgY2xvY2sNCj4gPiArICov DQo+ID4gK3N0cnVjdCBtdGtfanBlZ192YXJpYW50IHsNCj4gPiArCWJvb2wgaXNfZW5jb2RlcjsN Cj4gPiArCWNvbnN0IGNoYXIJCSpjbGtfbmFtZXNbTVRLX0pQRUdfTUFYX0NMT0NLU107DQo+ID4g KwlpbnQJCQludW1fY2xvY2tzOw0KPiA+ICt9Ow0KPiA+ICsNCj4gPiAgLyoqDQo+ID4gICAqIHN0 cnVjdCBtdF9qcGVnIC0gSlBFRyBJUCBhYnN0cmFjdGlvbg0KPiA+ICAgKiBAbG9jazoJCXRoZSBt dXRleCBwcm90ZWN0aW5nIHRoaXMgc3RydWN0dXJlDQo+ID4gQEAgLTQ4LDExICs2MywxMSBAQCBl bnVtIG10a19qcGVnX2N0eF9zdGF0ZSB7DQo+ID4gICAqIEB2NGwyX2RldjoJCXY0bDIgZGV2aWNl IGZvciBtZW0ybWVtIG1vZGUNCj4gPiAgICogQG0ybV9kZXY6CQl2NGwyIG1lbTJtZW0gZGV2aWNl IGRhdGENCj4gPiAgICogQGFsbG9jX2N0eDoJCXZpZGVvYnVmMiBtZW1vcnkgYWxsb2NhdG9yJ3Mg Y29udGV4dA0KPiA+IC0gKiBAZGVjX3ZkZXY6CQl2aWRlbyBkZXZpY2Ugbm9kZSBmb3IgZGVjb2Rl ciBtZW0ybWVtIG1vZGUNCj4gPiAtICogQGRlY19yZWdfYmFzZToJSlBFRyByZWdpc3RlcnMgbWFw cGluZw0KPiA+IC0gKiBAY2xrX2pkZWM6CQlKUEVHIGh3IHdvcmtpbmcgY2xvY2sNCj4gPiAtICog QGNsa19qZGVjX3NtaToJSlBFRyBTTUkgYnVzIGNsb2NrDQo+ID4gKyAqIEB2ZGV2OgkJdmlkZW8g ZGV2aWNlIG5vZGUgZm9yIGpwZWcgbWVtMm1lbSBtb2RlDQo+ID4gKyAqIEByZWdfYmFzZToJCUpQ RUcgcmVnaXN0ZXJzIG1hcHBpbmcNCj4gPiAgICogQGxhcmI6CQlTTUkgZGV2aWNlDQo+ID4gKyAq IEBjbG9ja3M6CQlKUEVHIElQIGNsb2NrKHMpDQo+ID4gKyAqIEB2YXJpYW50OgkJZHJpdmVyIHZh cmlhbnQgdG8gYmUgdXNlZA0KPiA+ICAgKi8NCj4gPiAgc3RydWN0IG10a19qcGVnX2RldiB7DQo+ ID4gIAlzdHJ1Y3QgbXV0ZXgJCWxvY2s7DQo+ID4gQEAgLTYyLDE2ICs3NywxNyBAQCBzdHJ1Y3Qg bXRrX2pwZWdfZGV2IHsNCj4gPiAgCXN0cnVjdCB2NGwyX2RldmljZQl2NGwyX2RldjsNCj4gPiAg CXN0cnVjdCB2NGwyX20ybV9kZXYJKm0ybV9kZXY7DQo+ID4gIAl2b2lkCQkJKmFsbG9jX2N0eDsN Cj4gPiAtCXN0cnVjdCB2aWRlb19kZXZpY2UJKmRlY192ZGV2Ow0KPiA+IC0Jdm9pZCBfX2lvbWVt CQkqZGVjX3JlZ19iYXNlOw0KPiA+IC0Jc3RydWN0IGNsawkJKmNsa19qZGVjOw0KPiA+IC0Jc3Ry dWN0IGNsawkJKmNsa19qZGVjX3NtaTsNCj4gPiArCXN0cnVjdCB2aWRlb19kZXZpY2UJKnZkZXY7 DQo+ID4gKwl2b2lkIF9faW9tZW0JCSpyZWdfYmFzZTsNCj4gPiAgCXN0cnVjdCBkZXZpY2UJCSps YXJiOw0KPiA+ICsJc3RydWN0IGNsawkJKmNsb2Nrc1tNVEtfSlBFR19NQVhfQ0xPQ0tTXTsNCj4g PiArCWNvbnN0IHN0cnVjdCBtdGtfanBlZ192YXJpYW50ICp2YXJpYW50Ow0KPiA+ICB9Ow0KPiA+ ICANCj4gPiAgLyoqDQo+ID4gICAqIHN0cnVjdCBqcGVnX2ZtdCAtIGRyaXZlcidzIGludGVybmFs IGNvbG9yIGZvcm1hdCBkYXRhDQo+ID4gICAqIEBmb3VyY2M6CXRoZSBmb3VyY2MgY29kZSwgMCBp ZiBub3QgYXBwbGljYWJsZQ0KPiA+ICsgKiBAaHdfZm9ybWF0OgloYXJkd2FyZSBmb3JtYXQgdmFs dWUNCj4gPiAgICogQGhfc2FtcGxlOglob3Jpem9udGFsIHNhbXBsZSBjb3VudCBvZiBwbGFuZSBp biA0ICogNCBwaXhlbCBpbWFnZQ0KPiA+ICAgKiBAdl9zYW1wbGU6CXZlcnRpY2FsIHNhbXBsZSBj b3VudCBvZiBwbGFuZSBpbiA0ICogNCBwaXhlbCBpbWFnZQ0KPiA+ICAgKiBAY29scGxhbmVzOglu dW1iZXIgb2YgY29sb3IgcGxhbmVzICgxIGZvciBwYWNrZWQgZm9ybWF0cykNCj4gPiBAQCAtODEs NiArOTcsNyBAQCBzdHJ1Y3QgbXRrX2pwZWdfZGV2IHsNCj4gPiAgICovDQo+ID4gIHN0cnVjdCBt dGtfanBlZ19mbXQgew0KPiA+ICAJdTMyCWZvdXJjYzsNCj4gPiArCXUzMglod19mb3JtYXQ7DQo+ ID4gIAlpbnQJaF9zYW1wbGVbVklERU9fTUFYX1BMQU5FU107DQo+ID4gIAlpbnQJdl9zYW1wbGVb VklERU9fTUFYX1BMQU5FU107DQo+ID4gIAlpbnQJY29scGxhbmVzOw0KPiA+IEBAIC0xMTMsNiAr MTMwLDEwIEBAIHN0cnVjdCBtdGtfanBlZ19xX2RhdGEgew0KPiA+ICAgKiBAY2FwX3E6CQlkZXN0 aW5hdGlvbiAoY2FwdHVyZSkgcXVldWUgcXVldWUgaW5mb3JtYXRpb24NCj4gPiAgICogQGZoOgkJ CVY0TDIgZmlsZSBoYW5kbGUNCj4gPiAgICogQHN0YXRlOgkJc3RhdGUgb2YgdGhlIGNvbnRleHQN Cj4gPiArICogQGVuYWJsZV9leGlmOgllbmFibGUgZXhpZiBtb2RlIG9mIGpwZWcgZW5jb2Rlcg0K PiA+ICsgKiBAZW5jX3F1YWxpdHk6CWpwZWcgZW5jb2RlciBxdWFsaXR5DQo+ID4gKyAqIEByZXN0 YXJ0X2ludGVydmFsOglqcGVnIGVuY29kZXIgcmVzdGFydCBpbnRlcnZhbA0KPiA+ICsgKiBAY3Ry bF9oZGw6CQljb250cm9scyBoYW5kbGVyDQo+ID4gICAqIEBjb2xvcnNwYWNlOiBlbnVtIHY0bDJf Y29sb3JzcGFjZTsgc3VwcGxlbWVudGFsIHRvIHBpeGVsZm9ybWF0DQo+ID4gICAqIEB5Y2Jjcl9l bmM6IGVudW0gdjRsMl95Y2Jjcl9lbmNvZGluZywgWSdDYkNyIGVuY29kaW5nDQo+ID4gICAqIEBx dWFudGl6YXRpb246IGVudW0gdjRsMl9xdWFudGl6YXRpb24sIGNvbG9yc3BhY2UgcXVhbnRpemF0 aW9uDQo+ID4gQEAgLTEyNCw2ICsxNDUsMTAgQEAgc3RydWN0IG10a19qcGVnX2N0eCB7DQo+ID4g IAlzdHJ1Y3QgbXRrX2pwZWdfcV9kYXRhCQljYXBfcTsNCj4gPiAgCXN0cnVjdCB2NGwyX2ZoCQkJ Zmg7DQo+ID4gIAllbnVtIG10a19qcGVnX2N0eF9zdGF0ZQkJc3RhdGU7DQo+ID4gKwlib29sCQkJ CWVuYWJsZV9leGlmOw0KPiA+ICsJdTgJCQkJZW5jX3F1YWxpdHk7DQo+ID4gKwl1OAkJCQlyZXN0 YXJ0X2ludGVydmFsOw0KPiA+ICsJc3RydWN0IHY0bDJfY3RybF9oYW5kbGVyCWN0cmxfaGRsOw0K PiA+ICANCj4gPiAgCWVudW0gdjRsMl9jb2xvcnNwYWNlIGNvbG9yc3BhY2U7DQo+ID4gIAllbnVt IHY0bDJfeWNiY3JfZW5jb2RpbmcgeWNiY3JfZW5jOw0KPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJz L21lZGlhL3BsYXRmb3JtL210ay1qcGVnL210a19qcGVnX2RlY19ody5oIGIvZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS9tdGstanBlZy9tdGtfanBlZ19kZWNfaHcuaA0KPiA+IGluZGV4IDFjYzM3ZGJm YzhlNy4uY2UyNjNkYjVmMzBhIDEwMDY0NA0KPiA+IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZv cm0vbXRrLWpwZWcvbXRrX2pwZWdfZGVjX2h3LmgNCj4gPiArKysgYi9kcml2ZXJzL21lZGlhL3Bs YXRmb3JtL210ay1qcGVnL210a19qcGVnX2RlY19ody5oDQo+ID4gQEAgLTMsMTAgKzMsMTEgQEAN Cj4gPiAgICogQ29weXJpZ2h0IChjKSAyMDE2IE1lZGlhVGVrIEluYy4NCj4gPiAgICogQXV0aG9y OiBNaW5nIEhzaXUgVHNhaSA8bWluZ2hzaXUudHNhaUBtZWRpYXRlay5jb20+DQo+ID4gICAqICAg ICAgICAgUmljayBDaGFuZyA8cmljay5jaGFuZ0BtZWRpYXRlay5jb20+DQo+ID4gKyAqICAgICAg ICAgWGlhIEppYW5nIDx4aWEuamlhbmdAbWVkaWF0ZWsuY29tPg0KPiA+ICAgKi8NCj4gPiAgDQo+ ID4gLSNpZm5kZWYgX01US19KUEVHX0hXX0gNCj4gPiAtI2RlZmluZSBfTVRLX0pQRUdfSFdfSA0K PiA+ICsjaWZuZGVmIF9NVEtfSlBFR19ERUNfSFdfSA0KPiA+ICsjZGVmaW5lIF9NVEtfSlBFR19E RUNfSFdfSA0KPiA+ICANCj4gPiAgI2luY2x1ZGUgPG1lZGlhL3ZpZGVvYnVmMi1jb3JlLmg+DQo+ ID4gIA0KPiA+IEBAIC03NSw0ICs3Niw0IEBAIHZvaWQgbXRrX2pwZWdfZGVjX3NldF9jb25maWco dm9pZCBfX2lvbWVtICpiYXNlLA0KPiA+ICB2b2lkIG10a19qcGVnX2RlY19yZXNldCh2b2lkIF9f aW9tZW0gKmRlY19yZWdfYmFzZSk7DQo+ID4gIHZvaWQgbXRrX2pwZWdfZGVjX3N0YXJ0KHZvaWQg X19pb21lbSAqZGVjX3JlZ19iYXNlKTsNCj4gPiAgDQo+ID4gLSNlbmRpZiAvKiBfTVRLX0pQRUdf SFdfSCAqLw0KPiA+ICsjZW5kaWYgLyogX01US19KUEVHX0RFQ19IV19IICovDQo+ID4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfZW5jX2h3LmMg Yi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210ay1qcGVnL210a19qcGVnX2VuY19ody5jDQo+ID4g bmV3IGZpbGUgbW9kZSAxMDA2NDQNCj4gPiBpbmRleCAwMDAwMDAwMDAwMDAuLjdmYzFkZTkyMGE3 NQ0KPiA+IC0tLSAvZGV2L251bGwNCj4gPiArKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL210 ay1qcGVnL210a19qcGVnX2VuY19ody5jDQo+ID4gQEAgLTAsMCArMSwxOTMgQEANCj4gPiArLy8g U1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb25seQ0KPiA+ICsvKg0KPiA+ICsgKiBD b3B5cmlnaHQgKGMpIDIwMTkgTWVkaWFUZWsgSW5jLg0KPiA+ICsgKiBBdXRob3I6IFhpYSBKaWFu ZyA8eGlhLmppYW5nQG1lZGlhdGVrLmNvbT4NCj4gPiArICoNCj4gPiArICovDQo+ID4gKw0KPiA+ ICsjaW5jbHVkZSA8bGludXgvaW8uaD4NCj4gPiArI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPg0K PiA+ICsjaW5jbHVkZSA8bWVkaWEvdmlkZW9idWYyLWNvcmUuaD4NCj4gPiArDQo+ID4gKyNpbmNs dWRlICJtdGtfanBlZ19lbmNfaHcuaCINCj4gPiArDQo+ID4gK3N0YXRpYyBjb25zdCBzdHJ1Y3Qg bXRrX2pwZWdfZW5jX3FsdCBtdGtfanBlZ19lbmNfcXVhbGl0eVtdID0gew0KPiA+ICsJey5xdWFs aXR5X3BhcmFtID0gMzQsIC5oYXJkd2FyZV92YWx1ZSA9IEpQRUdfRU5DX1FVQUxJVFlfUTM0fSwN Cj4gPiArCXsucXVhbGl0eV9wYXJhbSA9IDM5LCAuaGFyZHdhcmVfdmFsdWUgPSBKUEVHX0VOQ19R VUFMSVRZX1EzOX0sDQo+ID4gKwl7LnF1YWxpdHlfcGFyYW0gPSA0OCwgLmhhcmR3YXJlX3ZhbHVl ID0gSlBFR19FTkNfUVVBTElUWV9RNDh9LA0KPiA+ICsJey5xdWFsaXR5X3BhcmFtID0gNjAsIC5o YXJkd2FyZV92YWx1ZSA9IEpQRUdfRU5DX1FVQUxJVFlfUTYwfSwNCj4gPiArCXsucXVhbGl0eV9w YXJhbSA9IDY0LCAuaGFyZHdhcmVfdmFsdWUgPSBKUEVHX0VOQ19RVUFMSVRZX1E2NH0sDQo+ID4g Kwl7LnF1YWxpdHlfcGFyYW0gPSA2OCwgLmhhcmR3YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVBTElU WV9RNjh9LA0KPiA+ICsJey5xdWFsaXR5X3BhcmFtID0gNzQsIC5oYXJkd2FyZV92YWx1ZSA9IEpQ RUdfRU5DX1FVQUxJVFlfUTc0fSwNCj4gPiArCXsucXVhbGl0eV9wYXJhbSA9IDgwLCAuaGFyZHdh cmVfdmFsdWUgPSBKUEVHX0VOQ19RVUFMSVRZX1E4MH0sDQo+ID4gKwl7LnF1YWxpdHlfcGFyYW0g PSA4MiwgLmhhcmR3YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVBTElUWV9RODJ9LA0KPiA+ICsJey5x dWFsaXR5X3BhcmFtID0gODQsIC5oYXJkd2FyZV92YWx1ZSA9IEpQRUdfRU5DX1FVQUxJVFlfUTg0 fSwNCj4gPiArCXsucXVhbGl0eV9wYXJhbSA9IDg3LCAuaGFyZHdhcmVfdmFsdWUgPSBKUEVHX0VO Q19RVUFMSVRZX1E4N30sDQo+ID4gKwl7LnF1YWxpdHlfcGFyYW0gPSA5MCwgLmhhcmR3YXJlX3Zh bHVlID0gSlBFR19FTkNfUVVBTElUWV9ROTB9LA0KPiA+ICsJey5xdWFsaXR5X3BhcmFtID0gOTIs IC5oYXJkd2FyZV92YWx1ZSA9IEpQRUdfRU5DX1FVQUxJVFlfUTkyfSwNCj4gPiArCXsucXVhbGl0 eV9wYXJhbSA9IDk1LCAuaGFyZHdhcmVfdmFsdWUgPSBKUEVHX0VOQ19RVUFMSVRZX1E5NX0sDQo+ ID4gKwl7LnF1YWxpdHlfcGFyYW0gPSA5NywgLmhhcmR3YXJlX3ZhbHVlID0gSlBFR19FTkNfUVVB TElUWV9ROTd9LA0KPiA+ICt9Ow0KPiA+ICsNCj4gPiArdm9pZCBtdGtfanBlZ19lbmNfcmVzZXQo dm9pZCBfX2lvbWVtICpiYXNlKQ0KPiA+ICt7DQo+ID4gKwl3cml0ZWwoMHgwMCwgYmFzZSArIEpQ RUdfRU5DX1JTVEIpOw0KPiA+ICsJd3JpdGVsKEpQRUdfRU5DX1JFU0VUX0JJVCwgYmFzZSArIEpQ RUdfRU5DX1JTVEIpOw0KPiA+ICsJd3JpdGVsKDB4MDAsIGJhc2UgKyBKUEVHX0VOQ19DT0RFQ19T RUwpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICt1MzIgbXRrX2pwZWdfZW5jX2dldF9hbmRfY2xlYXJf aW50X3N0YXR1cyh2b2lkIF9faW9tZW0gKmJhc2UpDQo+ID4gK3sNCj4gPiArCXUzMiByZXQ7DQo+ ID4gKw0KPiA+ICsJcmV0ID0gcmVhZGwoYmFzZSArIEpQRUdfRU5DX0lOVF9TVFMpICYNCj4gPiAr CQkgICAgSlBFR19FTkNfSU5UX1NUQVRVU19NQVNLX0FMTElSUTsNCj4gPiArCWlmIChyZXQpDQo+ ID4gKwkJd3JpdGVsKDAsIGJhc2UgKyBKUEVHX0VOQ19JTlRfU1RTKTsNCj4gPiArDQo+ID4gKwly ZXR1cm4gcmV0Ow0KPiA+ICt9DQo+ID4gKw0KPiA+ICt1MzIgbXRrX2pwZWdfZW5jX2dldF9maWxl X3NpemUodm9pZCBfX2lvbWVtICpiYXNlKQ0KPiA+ICt7DQo+ID4gKwlyZXR1cm4gcmVhZGwoYmFz ZSArIEpQRUdfRU5DX0RNQV9BRERSMCkgLQ0KPiA+ICsJICAgICAgIHJlYWRsKGJhc2UgKyBKUEVH X0VOQ19EU1RfQUREUjApOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICt1MzIgbXRrX2pwZWdfZW5jX2Vu dW1fcmVzdWx0KHZvaWQgX19pb21lbSAqYmFzZSwgdTMyIGlycV9zdGF0dXMpDQo+ID4gK3sNCj4g PiArCWlmIChpcnFfc3RhdHVzICYgSlBFR19FTkNfSU5UX1NUQVRVU19ET05FKQ0KPiA+ICsJCXJl dHVybiBNVEtfSlBFR19FTkNfUkVTVUxUX0RPTkU7DQo+ID4gKwllbHNlIGlmIChpcnFfc3RhdHVz ICYgSlBFR19FTkNfSU5UX1NUQVRVU19TVEFMTCkNCj4gPiArCQlyZXR1cm4gTVRLX0pQRUdfRU5D X1JFU1VMVF9TVEFMTDsNCj4gPiArCWVsc2UNCj4gPiArCQlyZXR1cm4gTVRLX0pQRUdfRU5DX1JF U1VMVF9WQ09ERUNfSVJROw0KPiA+ICt9DQo+ID4gKw0KPiA+ICt2b2lkIG10a19qcGVnX2VuY19z ZXRfaW1nX3NpemUodm9pZCBfX2lvbWVtICpiYXNlLCB1MzIgd2lkdGgsIHUzMiBoZWlnaHQpDQo+ ID4gK3sNCj4gPiArCXUzMiB2YWx1ZTsNCj4gPiArDQo+ID4gKwl2YWx1ZSA9IHdpZHRoIDw8IDE2 IHwgaGVpZ2h0Ow0KPiA+ICsJd3JpdGVsKHZhbHVlLCBiYXNlICsgSlBFR19FTkNfSU1HX1NJWkUp Ow0KPiA+ICt9DQo+ID4gKw0KPiA+ICt2b2lkIG10a19qcGVnX2VuY19zZXRfYmxrX251bSh2b2lk IF9faW9tZW0gKmJhc2UsIHUzMiBlbmNfZm9ybWF0LCB1MzIgd2lkdGgsDQo+ID4gKwkJCSAgICAg IHUzMiBoZWlnaHQpDQo+ID4gK3sNCj4gPiArCXUzMiBibGtfbnVtOw0KPiA+ICsJdTMyIGlzXzQy MDsNCj4gPiArCXUzMiBwYWRkaW5nX3dpZHRoOw0KPiA+ICsJdTMyIHBhZGRpbmdfaGVpZ2h0Ow0K PiA+ICsJdTMyIGx1bWFfYmxvY2tzOw0KPiA+ICsJdTMyIGNocm9tYV9ibG9ja3M7DQo+ID4gKw0K PiA+ICsJaXNfNDIwID0gKGVuY19mb3JtYXQgPT0gVjRMMl9QSVhfRk1UX05WMTJNIHx8DQo+ID4g KwkJICBlbmNfZm9ybWF0ID09IFY0TDJfUElYX0ZNVF9OVjIxTSkgPyAxIDogMDsNCj4gPiArCXBh ZGRpbmdfd2lkdGggPSByb3VuZF91cCh3aWR0aCwgMTYpOw0KPiA+ICsJcGFkZGluZ19oZWlnaHQg PSByb3VuZF91cChoZWlnaHQsIGlzXzQyMCA/IDE2IDogOCk7DQo+ID4gKw0KPiA+ICsJbHVtYV9i bG9ja3MgPSBwYWRkaW5nX3dpZHRoIC8gOCAqIHBhZGRpbmdfaGVpZ2h0IC8gODsNCj4gPiArCWlm IChpc180MjApDQo+ID4gKwkJY2hyb21hX2Jsb2NrcyA9IGx1bWFfYmxvY2tzIC8gNDsNCj4gPiAr CWVsc2UNCj4gPiArCQljaHJvbWFfYmxvY2tzID0gbHVtYV9ibG9ja3MgLyAyOw0KPiA+ICsNCj4g PiArCWJsa19udW0gPSBsdW1hX2Jsb2NrcyArIDIgKiBjaHJvbWFfYmxvY2tzIC0gMTsNCj4gPiAr DQo+ID4gKwl3cml0ZWwoYmxrX251bSwgYmFzZSArIEpQRUdfRU5DX0JMS19OVU0pOw0KPiA+ICt9 DQo+ID4gKw0KPiA+ICt2b2lkIG10a19qcGVnX2VuY19zZXRfc3RyaWRlKHZvaWQgX19pb21lbSAq YmFzZSwgdTMyIGVuY19mb3JtYXQsIHUzMiB3aWR0aCwNCj4gPiArCQkJICAgICB1MzIgaGVpZ2h0 LCB1MzIgYnl0ZXNwZXJsaW5lKQ0KPiA+ICt7DQo+ID4gKwl1MzIgaW1nX3N0cmlkZTsNCj4gPiAr CXUzMiBtZW1fc3RyaWRlOw0KPiA+ICsNCj4gPiArCWlmIChlbmNfZm9ybWF0ID09IFY0TDJfUElY X0ZNVF9OVjEyTSB8fA0KPiA+ICsJICAgIGVuY19mb3JtYXQgPT0gVjRMMl9QSVhfRk1UX05WMjFN KSB7DQo+ID4gKwkJaW1nX3N0cmlkZSA9IHJvdW5kX3VwKHdpZHRoLCAxNik7DQo+ID4gKwkJbWVt X3N0cmlkZSA9IGJ5dGVzcGVybGluZTsNCj4gPiArCX0gZWxzZSB7DQo+ID4gKwkJaW1nX3N0cmlk ZSA9IHJvdW5kX3VwKHdpZHRoICogMiwgMzIpOw0KPiA+ICsJCW1lbV9zdHJpZGUgPSBpbWdfc3Ry aWRlOw0KPiA+ICsJfQ0KPiA+ICsNCj4gPiArCXdyaXRlbChpbWdfc3RyaWRlLCBiYXNlICsgSlBF R19FTkNfSU1HX1NUUklERSk7DQo+ID4gKwl3cml0ZWwobWVtX3N0cmlkZSwgYmFzZSArIEpQRUdf RU5DX1NUUklERSk7DQo+ID4gK30NCj4gPiArDQo+ID4gK3ZvaWQgbXRrX2pwZWdfZW5jX3NldF9z cmNfYWRkcih2b2lkIF9faW9tZW0gKmJhc2UsIHUzMiBzcmNfYWRkciwNCj4gPiArCQkJICAgICAg IHUzMiBwbGFuZV9pbmRleCkNCj4gPiArew0KPiA+ICsJaWYgKCFwbGFuZV9pbmRleCkNCj4gPiAr CQl3cml0ZWwoc3JjX2FkZHIsIGJhc2UgKyBKUEVHX0VOQ19TUkNfTFVNQV9BRERSKTsNCj4gPiAr CWVsc2UNCj4gPiArCQl3cml0ZWwoc3JjX2FkZHIsIGJhc2UgKyBKUEVHX0VOQ19TUkNfQ0hST01B X0FERFIpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICt2b2lkIG10a19qcGVnX2VuY19zZXRfZHN0X2Fk ZHIodm9pZCBfX2lvbWVtICpiYXNlLCB1MzIgZHN0X2FkZHIsDQo+ID4gKwkJCSAgICAgICB1MzIg c3RhbGxfc2l6ZSwgdTMyIGluaXRfb2Zmc2V0LA0KPiA+ICsJCQkgICAgICAgdTMyIG9mZnNldF9t YXNrKQ0KPiA+ICt7DQo+ID4gKwl3cml0ZWwoaW5pdF9vZmZzZXQgJiB+MHhmLCBiYXNlICsgSlBF R19FTkNfT0ZGU0VUX0FERFIpOw0KPiA+ICsJd3JpdGVsKG9mZnNldF9tYXNrICYgMHhmLCBiYXNl ICsgSlBFR19FTkNfQllURV9PRkZTRVRfTUFTSyk7DQo+ID4gKwl3cml0ZWwoZHN0X2FkZHIgJiB+ MHhmLCBiYXNlICsgSlBFR19FTkNfRFNUX0FERFIwKTsNCj4gPiArCXdyaXRlbCgoZHN0X2FkZHIg KyBzdGFsbF9zaXplKSAmIH4weGYsIGJhc2UgKyBKUEVHX0VOQ19TVEFMTF9BRERSMCk7DQo+ID4g K30NCj4gPiArDQo+ID4gK3N0YXRpYyB2b2lkIG10a19qcGVnX2VuY19zZXRfcXVhbGl0eSh2b2lk IF9faW9tZW0gKmJhc2UsIHUzMiBxdWFsaXR5KQ0KPiA+ICt7DQo+ID4gKwl1MzIgdmFsdWU7DQo+ ID4gKwl1MzIgaSwgZW5jX3F1YWxpdHk7DQo+ID4gKw0KPiA+ICsJZW5jX3F1YWxpdHkgPSBtdGtf anBlZ19lbmNfcXVhbGl0eVswXS5oYXJkd2FyZV92YWx1ZTsNCj4gPiArCWZvciAoaSA9IDA7IGkg PCBBUlJBWV9TSVpFKG10a19qcGVnX2VuY19xdWFsaXR5KTsgaSsrKSB7DQo+ID4gKwkJaWYgKHF1 YWxpdHkgPD0gbXRrX2pwZWdfZW5jX3F1YWxpdHlbaV0ucXVhbGl0eV9wYXJhbSkgew0KPiA+ICsJ CQllbmNfcXVhbGl0eSA9IG10a19qcGVnX2VuY19xdWFsaXR5W2ldLmhhcmR3YXJlX3ZhbHVlOw0K PiA+ICsJCQlicmVhazsNCj4gPiArCQl9DQo+ID4gKwl9DQo+ID4gKw0KPiA+ICsJdmFsdWUgPSBy ZWFkbChiYXNlICsgSlBFR19FTkNfUVVBTElUWSk7DQo+ID4gKwl2YWx1ZSA9ICh2YWx1ZSAmIEpQ RUdfRU5DX1FVQUxJVFlfTUFTSykgfCBlbmNfcXVhbGl0eTsNCj4gPiArCXdyaXRlbCh2YWx1ZSwg YmFzZSArIEpQRUdfRU5DX1FVQUxJVFkpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgdm9p ZCBtdGtfanBlZ19lbmNfc2V0X2N0cmwodm9pZCBfX2lvbWVtICpiYXNlLCB1MzIgZW5jX2Zvcm1h dCwNCj4gPiArCQkJCSAgYm9vbCBleGlmX2VuLCB1MzIgcmVzdGFydF9pbnRlcnZhbCkNCj4gPiAr ew0KPiA+ICsJdTMyIHZhbHVlOw0KPiA+ICsNCj4gPiArCXZhbHVlID0gcmVhZGwoYmFzZSArIEpQ RUdfRU5DX0NUUkwpOw0KPiA+ICsJdmFsdWUgJj0gfkpQRUdfRU5DX0NUUkxfWVVWX0ZPUk1BVF9N QVNLOw0KPiA+ICsJdmFsdWUgfD0gKGVuY19mb3JtYXQgJiAzKSA8PCAzOw0KPiA+ICsJaWYgKGV4 aWZfZW4pDQo+ID4gKwkJdmFsdWUgfD0gSlBFR19FTkNfQ1RSTF9GSUxFX0ZPUk1BVF9CSVQ7DQo+ ID4gKwllbHNlDQo+ID4gKwkJdmFsdWUgJj0gfkpQRUdfRU5DX0NUUkxfRklMRV9GT1JNQVRfQklU Ow0KPiA+ICsJaWYgKHJlc3RhcnRfaW50ZXJ2YWwpDQo+ID4gKwkJdmFsdWUgfD0gSlBFR19FTkNf Q1RSTF9SRVNUQVJUX0VOX0JJVDsNCj4gPiArCWVsc2UNCj4gPiArCQl2YWx1ZSAmPSB+SlBFR19F TkNfQ1RSTF9SRVNUQVJUX0VOX0JJVDsNCj4gPiArCXdyaXRlbCh2YWx1ZSwgYmFzZSArIEpQRUdf RU5DX0NUUkwpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICt2b2lkIG10a19qcGVnX2VuY19zZXRfY29u ZmlnKHZvaWQgX19pb21lbSAqYmFzZSwgdTMyIGVuY19mb3JtYXQsIGJvb2wgZXhpZl9lbiwNCj4g PiArCQkJICAgICB1MzIgcXVhbGl0eSwgdTMyIHJlc3RhcnRfaW50ZXJ2YWwpDQo+ID4gK3sNCj4g PiArCW10a19qcGVnX2VuY19zZXRfcXVhbGl0eShiYXNlLCBxdWFsaXR5KTsNCj4gPiArDQo+ID4g KwltdGtfanBlZ19lbmNfc2V0X2N0cmwoYmFzZSwgZW5jX2Zvcm1hdCwgZXhpZl9lbiwgcmVzdGFy dF9pbnRlcnZhbCk7DQo+ID4gKw0KPiA+ICsJd3JpdGVsKHJlc3RhcnRfaW50ZXJ2YWwsIGJhc2Ug KyBKUEVHX0VOQ19SU1RfTUNVX05VTSk7DQo+ID4gK30NCj4gPiArDQo+ID4gK3ZvaWQgbXRrX2pw ZWdfZW5jX3N0YXJ0KHZvaWQgX19pb21lbSAqYmFzZSkNCj4gPiArew0KPiA+ICsJdTMyIHZhbHVl Ow0KPiA+ICsNCj4gPiArCXZhbHVlID0gcmVhZGwoYmFzZSArIEpQRUdfRU5DX0NUUkwpOw0KPiA+ ICsJdmFsdWUgfD0gSlBFR19FTkNfQ1RSTF9JTlRfRU5fQklUIHwgSlBFR19FTkNfQ1RSTF9FTkFC TEVfQklUOw0KPiA+ICsJd3JpdGVsKHZhbHVlLCBiYXNlICsgSlBFR19FTkNfQ1RSTCk7DQo+ID4g K30NCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9tdGstanBlZy9tdGtf anBlZ19lbmNfaHcuaCBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdf ZW5jX2h3LmgNCj4gPiBuZXcgZmlsZSBtb2RlIDEwMDY0NA0KPiA+IGluZGV4IDAwMDAwMDAwMDAw MC4uNzNmYWY0OWI2NjdjDQo+ID4gLS0tIC9kZXYvbnVsbA0KPiA+ICsrKyBiL2RyaXZlcnMvbWVk aWEvcGxhdGZvcm0vbXRrLWpwZWcvbXRrX2pwZWdfZW5jX2h3LmgNCj4gPiBAQCAtMCwwICsxLDEy MyBAQA0KPiA+ICsvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5ICovDQo+ ID4gKy8qDQo+ID4gKyAqIENvcHlyaWdodCAoYykgMjAxOSBNZWRpYVRlayBJbmMuDQo+ID4gKyAq IEF1dGhvcjogWGlhIEppYW5nIDx4aWEuamlhbmdAbWVkaWF0ZWsuY29tPg0KPiA+ICsgKg0KPiA+ ICsgKi8NCj4gPiArDQo+ID4gKyNpZm5kZWYgX01US19KUEVHX0VOQ19IV19IDQo+ID4gKyNkZWZp bmUgX01US19KUEVHX0VOQ19IV19IDQo+ID4gKw0KPiA+ICsjaW5jbHVkZSA8bWVkaWEvdmlkZW9i dWYyLWNvcmUuaD4NCj4gPiArDQo+ID4gKyNpbmNsdWRlICJtdGtfanBlZ19jb3JlLmgiDQo+ID4g Kw0KPiA+ICsjZGVmaW5lIEpQRUdfRU5DX0lOVF9TVEFUVVNfRE9ORQlCSVQoMCkNCj4gPiArI2Rl ZmluZSBKUEVHX0VOQ19JTlRfU1RBVFVTX1NUQUxMCUJJVCgxKQ0KPiA+ICsjZGVmaW5lIEpQRUdf RU5DX0lOVF9TVEFUVVNfVkNPREVDX0lSUQlCSVQoNCkNCj4gPiArI2RlZmluZSBKUEVHX0VOQ19J TlRfU1RBVFVTX01BU0tfQUxMSVJRCTB4MTMNCj4gPiArDQo+ID4gKyNkZWZpbmUgSlBFR19FTkNf RFNUX0FERFJfT0ZGU0VUX01BU0sJR0VOTUFTSygzLCAwKQ0KPiA+ICsjZGVmaW5lIEpQRUdfRU5D X1FVQUxJVFlfTUFTSwkJR0VOTUFTSygzMSwgMTYpDQo+ID4gKw0KPiA+ICsjZGVmaW5lIEpQRUdf RU5DX0NUUkxfWVVWX0ZPUk1BVF9NQVNLCTB4MTgNCj4gPiArI2RlZmluZSBKUEVHX0VOQ19DVFJM X1JFU1RBUlRfRU5fQklUCUJJVCgxMCkNCj4gPiArI2RlZmluZSBKUEVHX0VOQ19DVFJMX0ZJTEVf Rk9STUFUX0JJVAlCSVQoNSkNCj4gPiArI2RlZmluZSBKUEVHX0VOQ19DVFJMX0lOVF9FTl9CSVQJ QklUKDIpDQo+ID4gKyNkZWZpbmUgSlBFR19FTkNfQ1RSTF9FTkFCTEVfQklUCUJJVCgwKQ0KPiA+ ICsjZGVmaW5lIEpQRUdfRU5DX1JFU0VUX0JJVAkJQklUKDApDQo+ID4gKw0KPiA+ICsjZGVmaW5l IEpQRUdfRU5DX1lVVl9GT1JNQVRfWVVZVgkwDQo+ID4gKyNkZWZpbmUgSlBFR19FTkNfWVVWX0ZP Uk1BVF9ZVllVCTENCj4gPiArI2RlZmluZSBKUEVHX0VOQ19ZVVZfRk9STUFUX05WMTIJMg0KPiA+ ICsjZGVmaW5lIEpFUEdfRU5DX1lVVl9GT1JNQVRfTlYyMQkzDQo+ID4gKw0KPiA+ICsjZGVmaW5l IEpQRUdfRU5DX1FVQUxJVFlfUTYwCQkweDANCj4gPiArI2RlZmluZSBKUEVHX0VOQ19RVUFMSVRZ X1E4MAkJMHgxDQo+ID4gKyNkZWZpbmUgSlBFR19FTkNfUVVBTElUWV9ROTAJCTB4Mg0KPiA+ICsj ZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlfUTk1CQkweDMNCj4gPiArI2RlZmluZSBKUEVHX0VOQ19R VUFMSVRZX1EzOQkJMHg0DQo+ID4gKyNkZWZpbmUgSlBFR19FTkNfUVVBTElUWV9RNjgJCTB4NQ0K PiA+ICsjZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlfUTg0CQkweDYNCj4gPiArI2RlZmluZSBKUEVH X0VOQ19RVUFMSVRZX1E5MgkJMHg3DQo+ID4gKyNkZWZpbmUgSlBFR19FTkNfUVVBTElUWV9RNDgJ CTB4OA0KPiA+ICsjZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlfUTc0CQkweGENCj4gPiArI2RlZmlu ZSBKUEVHX0VOQ19RVUFMSVRZX1E4NwkJMHhiDQo+ID4gKyNkZWZpbmUgSlBFR19FTkNfUVVBTElU WV9RMzQJCTB4Yw0KPiA+ICsjZGVmaW5lIEpQRUdfRU5DX1FVQUxJVFlfUTY0CQkweGUNCj4gPiAr I2RlZmluZSBKUEVHX0VOQ19RVUFMSVRZX1E4MgkJMHhmDQo+ID4gKyNkZWZpbmUgSlBFR19FTkNf UVVBTElUWV9ROTcJCTB4MTANCj4gPiArDQo+ID4gKyNkZWZpbmUgSlBFR19FTkNfUlNUQgkJCTB4 MTAwDQo+ID4gKyNkZWZpbmUgSlBFR19FTkNfQ1RSTAkJCTB4MTA0DQo+ID4gKyNkZWZpbmUgSlBF R19FTkNfUVVBTElUWQkJMHgxMDgNCj4gPiArI2RlZmluZSBKUEVHX0VOQ19CTEtfTlVNCQkweDEw Qw0KPiA+ICsjZGVmaW5lIEpQRUdfRU5DX0JMS19DTlQJCTB4MTEwDQo+ID4gKyNkZWZpbmUgSlBF R19FTkNfSU5UX1NUUwkJMHgxMWMNCj4gPiArI2RlZmluZSBKUEVHX0VOQ19EU1RfQUREUjAJCTB4 MTIwDQo+ID4gKyNkZWZpbmUgSlBFR19FTkNfRE1BX0FERFIwCQkweDEyNA0KPiA+ICsjZGVmaW5l IEpQRUdfRU5DX1NUQUxMX0FERFIwCQkweDEyOA0KPiA+ICsjZGVmaW5lIEpQRUdfRU5DX09GRlNF VF9BRERSCQkweDEzOA0KPiA+ICsjZGVmaW5lIEpQRUdfRU5DX1JTVF9NQ1VfTlVNCQkweDE1MA0K PiA+ICsjZGVmaW5lIEpQRUdfRU5DX0lNR19TSVpFCQkweDE1NA0KPiA+ICsjZGVmaW5lIEpQRUdf RU5DX0RFQlVHX0lORk8wCQkweDE2MA0KPiA+ICsjZGVmaW5lIEpQRUdfRU5DX0RFQlVHX0lORk8x CQkweDE2NA0KPiA+ICsjZGVmaW5lIEpQRUdfRU5DX1RPVEFMX0NZQ0xFCQkweDE2OA0KPiA+ICsj ZGVmaW5lIEpQRUdfRU5DX0JZVEVfT0ZGU0VUX01BU0sJMHgxNmMNCj4gPiArI2RlZmluZSBKUEVH X0VOQ19TUkNfTFVNQV9BRERSCQkweDE3MA0KPiA+ICsjZGVmaW5lIEpQRUdfRU5DX1NSQ19DSFJP TUFfQUREUgkweDE3NA0KPiA+ICsjZGVmaW5lIEpQRUdfRU5DX1NUUklERQkJCTB4MTc4DQo+ID4g KyNkZWZpbmUgSlBFR19FTkNfSU1HX1NUUklERQkJMHgxN2MNCj4gPiArI2RlZmluZSBKUEVHX0VO Q19EQ01fQ1RSTAkJMHgzMDANCj4gPiArI2RlZmluZSBKUEVHX0VOQ19DT0RFQ19TRUwJCTB4MzE0 DQo+ID4gKyNkZWZpbmUgSlBFR19FTkNfVUxUUkFfVEhSRVMJCTB4MzE4DQo+ID4gKw0KPiA+ICtl bnVtIHsNCj4gPiArCU1US19KUEVHX0VOQ19SRVNVTFRfRE9ORSwNCj4gPiArCU1US19KUEVHX0VO Q19SRVNVTFRfU1RBTEwsDQo+ID4gKwlNVEtfSlBFR19FTkNfUkVTVUxUX1ZDT0RFQ19JUlENCj4g PiArfTsNCj4gPiArDQo+ID4gKy8qKg0KPiA+ICsgKiBzdHJ1Y3QgbXRrX2pwZWdfZW5jX3FsdCAt IEpQRUcgZW5jb2RlciBxdWFsaXR5IGRhdGENCj4gPiArICogQHF1YWxpdHlfcGFyYW06CXF1YWxp dHkgdmFsdWUNCj4gPiArICogQGhhcmR3YXJlX3ZhbHVlOgloYXJkd2FyZSB2YWx1ZSBvZiBxdWFs aXR5DQo+ID4gKyAqLw0KPiA+ICtzdHJ1Y3QgbXRrX2pwZWdfZW5jX3FsdCB7DQo+ID4gKwl1OAlx dWFsaXR5X3BhcmFtOw0KPiA+ICsJdTgJaGFyZHdhcmVfdmFsdWU7DQo+ID4gK307DQo+ID4gKw0K PiA+ICsvKioNCj4gPiArICogc3RydWN0IG10X2pwZWdfZW5jX2JzIC0gSlBFRyBlbmNvZGVyIGJp dHN0cmVhbSAgYnVmZmVyDQo+ID4gKyAqIEBkbWFfYWRkcjoJCQlKUEVHIGVuY29kZXIgZGVzdGlu YXRpb24gYWRkcmVzcw0KPiA+ICsgKiBAc2l6ZToJCQlKUEVHIGVuY29kZXIgYmlzdHJlYW0gc2l6 ZQ0KPiA+ICsgKiBAZG1hX2FkZHJfb2Zmc2V0OgkJSlBFRyBlbmNvZGVyIG9mZnNldCBhZGRyZXNz DQo+ID4gKyAqIEBkbWFfYWRkcl9vZmZzZXRtYXNrOglKUEVHIGVuY29kZXIgZGVzdGluYXRpb24g YWRkcmVzcyBvZmZzZXQgbWFzaw0KPiA+ICsgKi8NCj4gPiArc3RydWN0IG10a19qcGVnX2VuY19i cyB7DQo+ID4gKwlkbWFfYWRkcl90CWRtYV9hZGRyOw0KPiA+ICsJc2l6ZV90CQlzaXplOw0KPiA+ ICsJdTMyCQlkbWFfYWRkcl9vZmZzZXQ7DQo+ID4gKwl1MzIJCWRtYV9hZGRyX29mZnNldG1hc2s7 DQo+ID4gK307DQo+ID4gKw0KPiA+ICt2b2lkIG10a19qcGVnX2VuY19yZXNldCh2b2lkIF9faW9t ZW0gKmJhc2UpOw0KPiA+ICt1MzIgbXRrX2pwZWdfZW5jX2dldF9hbmRfY2xlYXJfaW50X3N0YXR1 cyh2b2lkIF9faW9tZW0gKmJhc2UpOw0KPiA+ICt1MzIgbXRrX2pwZWdfZW5jX2dldF9maWxlX3Np emUodm9pZCBfX2lvbWVtICpiYXNlKTsNCj4gPiArdTMyIG10a19qcGVnX2VuY19lbnVtX3Jlc3Vs dCh2b2lkIF9faW9tZW0gKmJhc2UsIHUzMiBpcnFfc3RhdHVzKTsNCj4gPiArdm9pZCBtdGtfanBl Z19lbmNfc2V0X2ltZ19zaXplKHZvaWQgX19pb21lbSAqYmFzZSwgdTMyIHdpZHRoLCB1MzIgaGVp Z2h0KTsNCj4gPiArdm9pZCBtdGtfanBlZ19lbmNfc2V0X2Jsa19udW0odm9pZCBfX2lvbWVtICpi YXNlLCB1MzIgZW5jX2Zvcm1hdCwgdTMyIHdpZHRoLA0KPiA+ICsJCQkgICAgICB1MzIgaGVpZ2h0 KTsNCj4gPiArdm9pZCBtdGtfanBlZ19lbmNfc2V0X3N0cmlkZSh2b2lkIF9faW9tZW0gKmJhc2Us IHUzMiBlbmNfZm9ybWF0LCB1MzIgd2lkdGgsDQo+ID4gKwkJCSAgICAgdTMyIGhlaWdodCwgdTMy IGJ5dGVzcGVybGluZSk7DQo+ID4gK3ZvaWQgbXRrX2pwZWdfZW5jX3NldF9zcmNfYWRkcih2b2lk IF9faW9tZW0gKmJhc2UsIHUzMiBzcmNfYWRkciwNCj4gPiArCQkJICAgICAgIHUzMiBwbGFuZV9p bmRleCk7DQo+ID4gK3ZvaWQgbXRrX2pwZWdfZW5jX3NldF9kc3RfYWRkcih2b2lkIF9faW9tZW0g KmJhc2UsIHUzMiBkc3RfYWRkciwNCj4gPiArCQkJICAgICAgIHUzMiBzdGFsbF9zaXplLCB1MzIg aW5pdF9vZmZzZXQsDQo+ID4gKwkJCSAgICAgICB1MzIgb2Zmc2V0X21hc2spOw0KPiA+ICt2b2lk IG10a19qcGVnX2VuY19zZXRfY29uZmlnKHZvaWQgX19pb21lbSAqYmFzZSwgdTMyIGVuY19mb3Jt YXQsIGJvb2wgZXhpZl9lbiwNCj4gPiArCQkJICAgICB1MzIgcXVhbGl0eSwgdTMyIHJlc3RhcnRf aW50ZXJ2YWwpOw0KPiA+ICt2b2lkIG10a19qcGVnX2VuY19zdGFydCh2b2lkIF9faW9tZW0gKmVu Y19yZWdfYmFzZSk7DQo+ID4gKw0KPiA+ICsjZW5kaWYgLyogX01US19KUEVHX0VOQ19IV19IICov DQo+ID4gDQo+IA0KDQo= 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=-8.3 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY,USER_AGENT_SANE_2 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 17ADBC433E0 for ; Fri, 5 Jun 2020 08:09:38 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id D3A2320810 for ; Fri, 5 Jun 2020 08:09:37 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="jRtnb+Qp"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="dmjTU2jI" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D3A2320810 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mediatek.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Date:To:From:Subject:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=x58on6aEw9z/7A6xw6X62E+XiXO614cxN4shPBpJ210=; b=jRtnb+QppB1Ut9 PbsAKBgUgwRRZaTWawe1ZG5q7IZfoDPEjHc18XBlvOfuQ31+dE436gC2Rp4t9AyISIr9cLQ+nFcw/ hG3k07hAgY9iY9ze+qISMvfCwtYErH+SUSsiOHPuZzpEjfxVRWzomr9t666qFHTwa+egeW1Dt1e/3 3pLGPEWhlYq6RbOO81cwQVMElxRlM6RA2Bq3TzbJmqHqpF1oiFLQvfcc1MmkupPtvqKEtqKh7hx44 co14sydhx0BCVoDv6hBeeNfMfn4Va8TXAp3Tnq9HtV1Wd4+yjABuZORxm2J++eSY2shXBWdZv3lQ0 2mTsmotbMqFc6pSsvjdw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jh7Pr-0004XO-Ur; Fri, 05 Jun 2020 08:09:27 +0000 Received: from mailgw02.mediatek.com ([216.200.240.185]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jh7Pn-0004Wa-AZ; Fri, 05 Jun 2020 08:09:27 +0000 X-UUID: 559c32ca6e19405a87ccbe25887c6986-20200605 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:MIME-Version:Content-Type:References:In-Reply-To:Date:CC:To:From:Subject:Message-ID; bh=K9DWCE9KJeNyNvYHMZZ4SJRiB40zAPO4hL6uIU8WVks=; b=dmjTU2jIkzYZj9yasqmpHYIBS0ii4lIAIXtspjHQeLkioS9yQh+ycz7/rXwHLjQHGUw2Te4Y+mfn/ldcR6AIbmbEeTyIFxGP4vXIU9P5yGDq1zPPGFnDlqZcmureQ2mSzpyS66k5NSkgzjkb8GdO+WxDzXiUdy5Qv1k8u/1l9k4=; X-UUID: 559c32ca6e19405a87ccbe25887c6986-20200605 Received: from mtkcas68.mediatek.inc [(172.29.94.19)] by mailgw02.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 56928914; Fri, 05 Jun 2020 00:09:07 -0800 Received: from MTKMBS31N2.mediatek.inc (172.27.4.87) by MTKMBS62N2.mediatek.inc (172.29.193.42) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 5 Jun 2020 01:09:10 -0700 Received: from MTKCAS36.mediatek.inc (172.27.4.186) by MTKMBS31N2.mediatek.inc (172.27.4.87) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Fri, 5 Jun 2020 16:09:05 +0800 Received: from [10.17.3.153] (10.17.3.153) by MTKCAS36.mediatek.inc (172.27.4.170) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Fri, 5 Jun 2020 16:09:06 +0800 Message-ID: <1591344422.32607.13.camel@mhfsdcap03> Subject: Re: [PATCH v8 14/14] media: platform: Add jpeg dec/enc feature From: Xia Jiang To: Hans Verkuil Date: Fri, 5 Jun 2020 16:07:02 +0800 In-Reply-To: References: <20200403094033.8288-1-xia.jiang@mediatek.com> <20200403094033.8288-15-xia.jiang@mediatek.com> X-Mailer: Evolution 3.10.4-0ubuntu2 MIME-Version: 1.0 X-TM-SNTS-SMTP: 585C4E924FF11749F8A6AD7FA9C27571F9413ABEC86FA721C800E77F328703592000:8 X-MTK: N X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: drinkcat@chromium.org, devicetree@vger.kernel.org, mojahsu@chromium.org, srv_heupstream@mediatek.com, Rick Chang , senozhatsky@chromium.org, linux-kernel@vger.kernel.org, Tomasz Figa , maoguang.meng@mediatek.com, Matthias Brugger , sj.huang@mediatek.com, Rob Herring , linux-mediatek@lists.infradead.org, Mauro Carvalho Chehab , Marek Szyprowski , linux-arm-kernel@lists.infradead.org, linux-media@vger.kernel.org Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org On Mon, 2020-05-11 at 11:04 +0200, Hans Verkuil wrote: > On 03/04/2020 11:40, Xia Jiang wrote: > > Add mtk jpeg encode v4l2 driver based on jpeg decode, because that jpeg > > decode and encode have great similarities with function operation. > > > > Signed-off-by: Xia Jiang > > --- > > v8:jpeg encoder and decoder use separate callbacks instead of repeating > > the if/else in every callback. > > improve vidioc_try_fmt() implementation that can be shared by jpeg > > encoder and decoder. > > fix the bug of jpeg encoder s_selection implementation. > > cancel the state of the jpeg encoder. > > improve jpeg encoder and decoder set default params flow. > > put the clock names and other datas in a match_data struct. > > fix the bug of geting correctly quality value. > > do the all the bits' settings of one register in one function. > > move the code of mtk_jpeg_enc_reg.h to mtk_jpeg_enc_hw.h and delete > > mtk_jpeg_enc_reg.h. > > > > v7: reverse spin lock and unlock operation in device run function for > > multi-instance. > > > > v6: add space to arounding '+'. > > alignment 'struct mtk_jpeg_fmt *fmt' match open parenthesis. > > change 'mtk_jpeg_enc_set_encFormat' to 'mtk_jpeg_enc_set_enc_format'. > > make 'mtk_jpeg_ctrls_setup' to static prototype. > > delete unused variables 'jpeg'/'align_h'/'align_w'/'flags'. > > initialize 'yuv_format'/'enc_quality' variables. > > > > v5: support crop for encoder and compose for decoder in s_selection and > > g_selection function. > > use clamp() to replace mtk_jpeg_bound_align_image() and round_up() > > to replace mtk_jpeg_align(). > > delete jpeg_enc_param/mtk_jpeg_enc_param structure and > > mtk_jpeg_set_param(), program the registers directly based on > > the original V4L2 values. > > move macro definition about hw to mtk_jpeg_enc_reg.h. > > delete unnecessary V4L2 logs in driver. > > cancel spin lock and unlock operation in deviec run function. > > change jpeg enc register offset hex numberals from upercase to lowercase. > > > > v4: split mtk_jpeg_try_fmt_mplane() to two functions, one for encoder, > > one for decoder. > > split mtk_jpeg_set_default_params() to two functions, one for > > encoder, one for decoder. > > add cropping support for encoder in g/s_selection ioctls. > > change exif mode support by using V4L2_JPEG_ACTIVE_MARKER_APP1. > > change MTK_JPEG_MAX_WIDTH/MTK_JPEG_MAX_HEIGH from 8192 to 65535 by > > specification. > > move width shifting operation behind aligning operation in > > mtk_jpeg_try_enc_fmt_mplane() for bug fix. > > fix user abuseing data_offset issue for DMABUF in > > mtk_jpeg_set_enc_src(). > > fix kbuild warings: change MTK_JPEG_MIN_HEIGHT/MTK_JPEG_MAX_HEIGHT > > and MTK_JPEG_MIN_WIDTH/MTK_JPEG_MAX_WIDTH from > > 'int' type to 'unsigned int' type. > > fix msleadingly indented of 'else'. > > v3: delete Change-Id. > > only test once handler->error after the last v4l2_ctrl_new_std(). > > seperate changes of v4l2-ctrls.c and v4l2-controls.h to new patch. > > v2: fix compliance test fail, check created buffer size in driver. > > --- > > drivers/media/platform/mtk-jpeg/Makefile | 5 +- > > .../media/platform/mtk-jpeg/mtk_jpeg_core.c | 1038 +++++++++++++---- > > .../media/platform/mtk-jpeg/mtk_jpeg_core.h | 51 +- > > .../media/platform/mtk-jpeg/mtk_jpeg_dec_hw.h | 7 +- > > .../media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c | 193 +++ > > .../media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h | 123 ++ > > 6 files changed, 1188 insertions(+), 229 deletions(-) > > create mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c > > create mode 100644 drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h > > > > diff --git a/drivers/media/platform/mtk-jpeg/Makefile b/drivers/media/platform/mtk-jpeg/Makefile > > index 48516dcf96e6..76c33aad0f3f 100644 > > --- a/drivers/media/platform/mtk-jpeg/Makefile > > +++ b/drivers/media/platform/mtk-jpeg/Makefile > > @@ -1,3 +1,6 @@ > > # SPDX-License-Identifier: GPL-2.0-only > > -mtk_jpeg-objs := mtk_jpeg_core.o mtk_jpeg_dec_hw.o mtk_jpeg_dec_parse.o > > +mtk_jpeg-objs := mtk_jpeg_core.o \ > > + mtk_jpeg_dec_hw.o \ > > + mtk_jpeg_dec_parse.o \ > > + mtk_jpeg_enc_hw.o > > obj-$(CONFIG_VIDEO_MEDIATEK_JPEG) += mtk_jpeg.o > > diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c > > index 77a95185584c..18a759ce2c46 100644 > > --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c > > +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c > > @@ -3,6 +3,7 @@ > > * Copyright (c) 2016 MediaTek Inc. > > * Author: Ming Hsiu Tsai > > * Rick Chang > > + * Xia Jiang > > */ > > > > #include > > @@ -23,11 +24,60 @@ > > #include > > #include > > > > +#include "mtk_jpeg_enc_hw.h" > > #include "mtk_jpeg_dec_hw.h" > > #include "mtk_jpeg_core.h" > > #include "mtk_jpeg_dec_parse.h" > > > > -static struct mtk_jpeg_fmt mtk_jpeg_formats[] = { > > +static struct mtk_jpeg_fmt mtk_jpeg_enc_formats[] = { > > + { > > + .fourcc = V4L2_PIX_FMT_JPEG, > > + .colplanes = 1, > > + .flags = MTK_JPEG_FMT_FLAG_ENC_CAPTURE, > > + }, > > + { > > + .fourcc = V4L2_PIX_FMT_NV12M, > > + .hw_format = JPEG_ENC_YUV_FORMAT_NV12, > > + .h_sample = {4, 4}, > > + .v_sample = {4, 2}, > > + .colplanes = 2, > > + .h_align = 4, > > + .v_align = 4, > > + .flags = MTK_JPEG_FMT_FLAG_ENC_OUTPUT, > > + }, > > + { > > + .fourcc = V4L2_PIX_FMT_NV21M, > > + .hw_format = JEPG_ENC_YUV_FORMAT_NV21, > > + .h_sample = {4, 4}, > > + .v_sample = {4, 2}, > > + .colplanes = 2, > > + .h_align = 4, > > + .v_align = 4, > > + .flags = MTK_JPEG_FMT_FLAG_ENC_OUTPUT, > > + }, > > + { > > + .fourcc = V4L2_PIX_FMT_YUYV, > > + .hw_format = JPEG_ENC_YUV_FORMAT_YUYV, > > + .h_sample = {8}, > > + .v_sample = {4}, > > + .colplanes = 1, > > + .h_align = 5, > > + .v_align = 3, > > + .flags = MTK_JPEG_FMT_FLAG_ENC_OUTPUT, > > + }, > > + { > > + .fourcc = V4L2_PIX_FMT_YVYU, > > + .hw_format = JPEG_ENC_YUV_FORMAT_YVYU, > > + .h_sample = {8}, > > + .v_sample = {4}, > > + .colplanes = 1, > > + .h_align = 5, > > + .v_align = 3, > > + .flags = MTK_JPEG_FMT_FLAG_ENC_OUTPUT, > > + }, > > +}; > > + > > +static struct mtk_jpeg_fmt mtk_jpeg_dec_formats[] = { > > { > > .fourcc = V4L2_PIX_FMT_JPEG, > > .colplanes = 1, > > @@ -53,7 +103,8 @@ static struct mtk_jpeg_fmt mtk_jpeg_formats[] = { > > }, > > }; > > > > -#define MTK_JPEG_NUM_FORMATS ARRAY_SIZE(mtk_jpeg_formats) > > +#define MTK_JPEG_ENC_NUM_FORMATS ARRAY_SIZE(mtk_jpeg_enc_formats) > > +#define MTK_JPEG_DEC_NUM_FORMATS ARRAY_SIZE(mtk_jpeg_dec_formats) > > > > enum { > > MTK_JPEG_BUF_FLAGS_INIT = 0, > > @@ -70,6 +121,11 @@ struct mtk_jpeg_src_buf { > > static int debug; > > module_param(debug, int, 0644); > > > > +static inline struct mtk_jpeg_ctx *ctrl_to_ctx(struct v4l2_ctrl *ctrl) > > +{ > > + return container_of(ctrl->handler, struct mtk_jpeg_ctx, ctrl_hdl); > > +} > > + > > static inline struct mtk_jpeg_ctx *mtk_jpeg_fh_to_ctx(struct v4l2_fh *fh) > > { > > return container_of(fh, struct mtk_jpeg_ctx, fh); > > @@ -81,12 +137,25 @@ static inline struct mtk_jpeg_src_buf *mtk_jpeg_vb2_to_srcbuf( > > return container_of(to_vb2_v4l2_buffer(vb), struct mtk_jpeg_src_buf, b); > > } > > > > -static int mtk_jpeg_querycap(struct file *file, void *priv, > > - struct v4l2_capability *cap) > > +static int mtk_jpeg_enc_querycap(struct file *file, void *priv, > > + struct v4l2_capability *cap) > > +{ > > + struct mtk_jpeg_dev *jpeg = video_drvdata(file); > > + > > + strscpy(cap->driver, MTK_JPEG_NAME, sizeof(cap->driver)); > > + strscpy(cap->card, MTK_JPEG_NAME " encoder", sizeof(cap->card)); > > + snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", > > + dev_name(jpeg->dev)); > > + > > + return 0; > > +} > > + > > +static int mtk_jpeg_dec_querycap(struct file *file, void *priv, > > + struct v4l2_capability *cap) > > { > > struct mtk_jpeg_dev *jpeg = video_drvdata(file); > > > > - strscpy(cap->driver, MTK_JPEG_NAME " decoder", sizeof(cap->driver)); > > + strscpy(cap->driver, MTK_JPEG_NAME, sizeof(cap->driver)); > > strscpy(cap->card, MTK_JPEG_NAME " decoder", sizeof(cap->card)); > > snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", > > dev_name(jpeg->dev)); > > @@ -94,6 +163,54 @@ static int mtk_jpeg_querycap(struct file *file, void *priv, > > return 0; > > } > > > > +static int vidioc_jpeg_enc_s_ctrl(struct v4l2_ctrl *ctrl) > > +{ > > + struct mtk_jpeg_ctx *ctx = ctrl_to_ctx(ctrl); > > + > > + switch (ctrl->id) { > > + case V4L2_CID_JPEG_RESTART_INTERVAL: > > + ctx->restart_interval = ctrl->val; > > + break; > > + case V4L2_CID_JPEG_COMPRESSION_QUALITY: > > + ctx->enc_quality = ctrl->val; > > + break; > > + case V4L2_CID_JPEG_ACTIVE_MARKER: > > + ctx->enable_exif = ctrl->val & V4L2_JPEG_ACTIVE_MARKER_APP1 ? > > + true : false; > > + break; > > + } > > + > > + return 0; > > +} > > + > > +static const struct v4l2_ctrl_ops mtk_jpeg_enc_ctrl_ops = { > > + .s_ctrl = vidioc_jpeg_enc_s_ctrl, > > +}; > > + > > +static int mtk_jpeg_enc_ctrls_setup(struct mtk_jpeg_ctx *ctx) > > +{ > > + const struct v4l2_ctrl_ops *ops = &mtk_jpeg_enc_ctrl_ops; > > + struct v4l2_ctrl_handler *handler = &ctx->ctrl_hdl; > > + > > + v4l2_ctrl_handler_init(handler, 3); > > + > > + v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_RESTART_INTERVAL, 0, 100, > > + 1, 0); > > + v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_COMPRESSION_QUALITY, 48, > > + 100, 1, 90); > > + v4l2_ctrl_new_std(handler, ops, V4L2_CID_JPEG_ACTIVE_MARKER, 0, > > + V4L2_JPEG_ACTIVE_MARKER_APP1, 0, 0); > > + > > + if (handler->error) { > > + v4l2_ctrl_handler_free(&ctx->ctrl_hdl); > > + return handler->error; > > + } > > + > > + v4l2_ctrl_handler_setup(&ctx->ctrl_hdl); > > + > > + return 0; > > +} > > + > > static int mtk_jpeg_enum_fmt(struct mtk_jpeg_fmt *mtk_jpeg_formats, int n, > > struct v4l2_fmtdesc *f, u32 type) > > { > > @@ -115,117 +232,105 @@ static int mtk_jpeg_enum_fmt(struct mtk_jpeg_fmt *mtk_jpeg_formats, int n, > > return 0; > > } > > > > -static int mtk_jpeg_enum_fmt_vid_cap(struct file *file, void *priv, > > - struct v4l2_fmtdesc *f) > > +static int mtk_jpeg_enc_enum_fmt_vid_cap(struct file *file, void *priv, > > + struct v4l2_fmtdesc *f) > > { > > - return mtk_jpeg_enum_fmt(mtk_jpeg_formats, MTK_JPEG_NUM_FORMATS, f, > > + return mtk_jpeg_enum_fmt(mtk_jpeg_enc_formats, > > + MTK_JPEG_ENC_NUM_FORMATS, f, > > + MTK_JPEG_FMT_FLAG_ENC_CAPTURE); > > +} > > + > > +static int mtk_jpeg_dec_enum_fmt_vid_cap(struct file *file, void *priv, > > + struct v4l2_fmtdesc *f) > > +{ > > + return mtk_jpeg_enum_fmt(mtk_jpeg_dec_formats, > > + MTK_JPEG_DEC_NUM_FORMATS, f, > > MTK_JPEG_FMT_FLAG_DEC_CAPTURE); > > } > > > > -static int mtk_jpeg_enum_fmt_vid_out(struct file *file, void *priv, > > - struct v4l2_fmtdesc *f) > > +static int mtk_jpeg_enc_enum_fmt_vid_out(struct file *file, void *priv, > > + struct v4l2_fmtdesc *f) > > +{ > > + return mtk_jpeg_enum_fmt(mtk_jpeg_enc_formats, > > + MTK_JPEG_ENC_NUM_FORMATS, f, > > + MTK_JPEG_FMT_FLAG_ENC_OUTPUT); > > +} > > + > > +static int mtk_jpeg_dec_enum_fmt_vid_out(struct file *file, void *priv, > > + struct v4l2_fmtdesc *f) > > { > > - return mtk_jpeg_enum_fmt(mtk_jpeg_formats, MTK_JPEG_NUM_FORMATS, f, > > - MTK_JPEG_FMT_FLAG_DEC_OUTPUT); > > + return mtk_jpeg_enum_fmt(mtk_jpeg_dec_formats, MTK_JPEG_DEC_NUM_FORMATS, > > + f, MTK_JPEG_FMT_FLAG_DEC_OUTPUT); > > } > > OK, so this patch is very hard to read because there are two independent changes > taking place: > > 1) rename existing functions/defines/variables with a _dec prefix to prepare > for the addition of the encoder feature. > > 2) add the encoder feature. > > Please split up this patch into two parts: one that does the rename and as much of > the preparation to support both decoder and encoder without changing the > functionality, and a second one that actually adds the new encoder feature. > > In fact, once that's done it is likely that most of this patch series can be > merged, even if there are still things that need to be changed for the last > patch adding the encoder support. I see nothing objectionable in patches 1-10 > and 13. So merging those together with a new rename patch wouldn't be an issue, > I think. > > In any case, the diffs should be a lot cleaner and easier to review by splitting > it up like that. Dear Hans, Thanks for your good advice. I have splited up this patch into two patches in v9. Best Regards, Xia Jiang > > Regards, > > Hans > > > > > -static struct mtk_jpeg_q_data *mtk_jpeg_get_q_data(struct mtk_jpeg_ctx *ctx, > > - enum v4l2_buf_type type) > > +static struct mtk_jpeg_q_data * > > +mtk_jpeg_get_q_data(struct mtk_jpeg_ctx *ctx, enum v4l2_buf_type type) > > { > > if (V4L2_TYPE_IS_OUTPUT(type)) > > return &ctx->out_q; > > return &ctx->cap_q; > > } > > > > -static struct mtk_jpeg_fmt *mtk_jpeg_find_format(struct mtk_jpeg_ctx *ctx, > > - u32 pixelformat, > > +static struct mtk_jpeg_fmt *mtk_jpeg_find_format(u32 pixelformat, > > unsigned int fmt_type) > > { > > - unsigned int k, fmt_flag; > > - > > - fmt_flag = (fmt_type == MTK_JPEG_FMT_TYPE_OUTPUT) ? > > - MTK_JPEG_FMT_FLAG_DEC_OUTPUT : > > - MTK_JPEG_FMT_FLAG_DEC_CAPTURE; > > + unsigned int k; > > + struct mtk_jpeg_fmt *fmt; > > > > - for (k = 0; k < MTK_JPEG_NUM_FORMATS; k++) { > > - struct mtk_jpeg_fmt *fmt = &mtk_jpeg_formats[k]; > > + for (k = 0; k < MTK_JPEG_ENC_NUM_FORMATS; k++) { > > + fmt = &mtk_jpeg_enc_formats[k]; > > > > - if (fmt->fourcc == pixelformat && fmt->flags & fmt_flag) > > + if (fmt->fourcc == pixelformat && fmt->flags & fmt_type) > > return fmt; > > } > > > > - return NULL; > > -} > > + for (k = 0; k < MTK_JPEG_DEC_NUM_FORMATS; k++) { > > + fmt = &mtk_jpeg_dec_formats[k]; > > > > -static void mtk_jpeg_adjust_fmt_mplane(struct mtk_jpeg_ctx *ctx, > > - struct v4l2_format *f) > > -{ > > - struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; > > - struct mtk_jpeg_q_data *q_data; > > - int i; > > - > > - q_data = mtk_jpeg_get_q_data(ctx, f->type); > > - > > - pix_mp->width = q_data->w; > > - pix_mp->height = q_data->h; > > - pix_mp->pixelformat = q_data->fmt->fourcc; > > - pix_mp->num_planes = q_data->fmt->colplanes; > > - > > - for (i = 0; i < pix_mp->num_planes; i++) { > > - pix_mp->plane_fmt[i].bytesperline = q_data->bytesperline[i]; > > - pix_mp->plane_fmt[i].sizeimage = q_data->sizeimage[i]; > > + if (fmt->fourcc == pixelformat && fmt->flags & fmt_type) > > + return fmt; > > } > > + > > + return NULL; > > } > > > > -static int mtk_jpeg_try_fmt_mplane(struct v4l2_format *f, > > - struct mtk_jpeg_fmt *fmt, > > - struct mtk_jpeg_ctx *ctx, int q_type) > > +static int vidioc_try_fmt(struct v4l2_format *f, struct mtk_jpeg_fmt *fmt) > > { > > struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; > > int i; > > > > - memset(pix_mp->reserved, 0, sizeof(pix_mp->reserved)); > > pix_mp->field = V4L2_FIELD_NONE; > > - > > - if (ctx->state != MTK_JPEG_INIT) { > > - mtk_jpeg_adjust_fmt_mplane(ctx, f); > > - return 0; > > - } > > - > > pix_mp->num_planes = fmt->colplanes; > > pix_mp->pixelformat = fmt->fourcc; > > > > - if (q_type == MTK_JPEG_FMT_TYPE_OUTPUT) { > > - struct v4l2_plane_pix_format *pfmt = &pix_mp->plane_fmt[0]; > > - > > + if (fmt->fourcc == V4L2_PIX_FMT_JPEG) { > > pix_mp->height = clamp(pix_mp->height, MTK_JPEG_MIN_HEIGHT, > > MTK_JPEG_MAX_HEIGHT); > > pix_mp->width = clamp(pix_mp->width, MTK_JPEG_MIN_WIDTH, > > MTK_JPEG_MAX_WIDTH); > > - > > - memset(pfmt->reserved, 0, sizeof(pfmt->reserved)); > > - pfmt->bytesperline = 0; > > - /* Source size must be aligned to 128 */ > > - pfmt->sizeimage = round_up(pfmt->sizeimage, 128); > > - if (pfmt->sizeimage == 0) > > - pfmt->sizeimage = MTK_JPEG_DEFAULT_SIZEIMAGE; > > - return 0; > > + pix_mp->plane_fmt[0].bytesperline = 0; > > + pix_mp->plane_fmt[0].sizeimage = > > + round_up(pix_mp->plane_fmt[0].sizeimage, 128); > > + if (pix_mp->plane_fmt[0].sizeimage == 0) > > + pix_mp->plane_fmt[0].sizeimage = > > + MTK_JPEG_DEFAULT_SIZEIMAGE; > > + } else { > > + pix_mp->height = clamp(round_up(pix_mp->height, fmt->v_align), > > + MTK_JPEG_MIN_HEIGHT, > > + MTK_JPEG_MAX_HEIGHT); > > + pix_mp->width = clamp(round_up(pix_mp->width, fmt->h_align), > > + MTK_JPEG_MIN_WIDTH, MTK_JPEG_MAX_WIDTH); > > + for (i = 0; i < pix_mp->num_planes; i++) { > > + struct v4l2_plane_pix_format *pfmt = > > + &pix_mp->plane_fmt[i]; > > + u32 stride = pix_mp->width * fmt->h_sample[i] / 4; > > + u32 h = pix_mp->height * fmt->v_sample[i] / 4; > > + > > + pfmt->bytesperline = stride; > > + pfmt->sizeimage = stride * h; > > + } > > } > > > > - /* type is MTK_JPEG_FMT_TYPE_CAPTURE */ > > - pix_mp->height = clamp(round_up(pix_mp->height, fmt->v_align), > > - MTK_JPEG_MIN_HEIGHT, MTK_JPEG_MAX_HEIGHT); > > - pix_mp->width = clamp(round_up(pix_mp->width, fmt->h_align), > > - MTK_JPEG_MIN_WIDTH, MTK_JPEG_MAX_WIDTH); > > - > > - for (i = 0; i < fmt->colplanes; i++) { > > - struct v4l2_plane_pix_format *pfmt = &pix_mp->plane_fmt[i]; > > - u32 stride = pix_mp->width * fmt->h_sample[i] / 4; > > - u32 h = pix_mp->height * fmt->v_sample[i] / 4; > > - > > - pfmt->bytesperline = stride; > > - pfmt->sizeimage = stride * h; > > - } > > return 0; > > } > > > > @@ -280,14 +385,35 @@ static int mtk_jpeg_g_fmt_vid_mplane(struct file *file, void *priv, > > return 0; > > } > > > > -static int mtk_jpeg_try_fmt_vid_cap_mplane(struct file *file, void *priv, > > - struct v4l2_format *f) > > +static int mtk_jpeg_enc_try_fmt_vid_cap_mplane(struct file *file, void *priv, > > + struct v4l2_format *f) > > +{ > > + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); > > + struct mtk_jpeg_fmt *fmt; > > + > > + fmt = mtk_jpeg_find_format(f->fmt.pix_mp.pixelformat, > > + MTK_JPEG_FMT_FLAG_ENC_CAPTURE); > > + if (!fmt) > > + fmt = ctx->cap_q.fmt; > > + > > + v4l2_dbg(2, debug, &ctx->jpeg->v4l2_dev, "(%d) try_fmt:%c%c%c%c\n", > > + f->type, > > + (fmt->fourcc & 0xff), > > + (fmt->fourcc >> 8 & 0xff), > > + (fmt->fourcc >> 16 & 0xff), > > + (fmt->fourcc >> 24 & 0xff)); > > + > > + return vidioc_try_fmt(f, fmt); > > +} > > + > > +static int mtk_jpeg_dec_try_fmt_vid_cap_mplane(struct file *file, void *priv, > > + struct v4l2_format *f) > > { > > struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); > > struct mtk_jpeg_fmt *fmt; > > > > - fmt = mtk_jpeg_find_format(ctx, f->fmt.pix_mp.pixelformat, > > - MTK_JPEG_FMT_TYPE_CAPTURE); > > + fmt = mtk_jpeg_find_format(f->fmt.pix_mp.pixelformat, > > + MTK_JPEG_FMT_FLAG_DEC_CAPTURE); > > if (!fmt) > > fmt = ctx->cap_q.fmt; > > > > @@ -298,17 +424,43 @@ static int mtk_jpeg_try_fmt_vid_cap_mplane(struct file *file, void *priv, > > (fmt->fourcc >> 16 & 0xff), > > (fmt->fourcc >> 24 & 0xff)); > > > > - return mtk_jpeg_try_fmt_mplane(f, fmt, ctx, MTK_JPEG_FMT_TYPE_CAPTURE); > > + if (ctx->state != MTK_JPEG_INIT) { > > + mtk_jpeg_g_fmt_vid_mplane(file, priv, f); > > + return 0; > > + } > > + > > + return vidioc_try_fmt(f, fmt); > > +} > > + > > +static int mtk_jpeg_enc_try_fmt_vid_out_mplane(struct file *file, void *priv, > > + struct v4l2_format *f) > > +{ > > + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); > > + struct mtk_jpeg_fmt *fmt; > > + > > + fmt = mtk_jpeg_find_format(f->fmt.pix_mp.pixelformat, > > + MTK_JPEG_FMT_FLAG_ENC_OUTPUT); > > + if (!fmt) > > + fmt = ctx->out_q.fmt; > > + > > + v4l2_dbg(2, debug, &ctx->jpeg->v4l2_dev, "(%d) try_fmt:%c%c%c%c\n", > > + f->type, > > + (fmt->fourcc & 0xff), > > + (fmt->fourcc >> 8 & 0xff), > > + (fmt->fourcc >> 16 & 0xff), > > + (fmt->fourcc >> 24 & 0xff)); > > + > > + return vidioc_try_fmt(f, fmt); > > } > > > > -static int mtk_jpeg_try_fmt_vid_out_mplane(struct file *file, void *priv, > > - struct v4l2_format *f) > > +static int mtk_jpeg_dec_try_fmt_vid_out_mplane(struct file *file, void *priv, > > + struct v4l2_format *f) > > { > > struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); > > struct mtk_jpeg_fmt *fmt; > > > > - fmt = mtk_jpeg_find_format(ctx, f->fmt.pix_mp.pixelformat, > > - MTK_JPEG_FMT_TYPE_OUTPUT); > > + fmt = mtk_jpeg_find_format(f->fmt.pix_mp.pixelformat, > > + MTK_JPEG_FMT_FLAG_DEC_OUTPUT); > > if (!fmt) > > fmt = ctx->out_q.fmt; > > > > @@ -319,17 +471,21 @@ static int mtk_jpeg_try_fmt_vid_out_mplane(struct file *file, void *priv, > > (fmt->fourcc >> 16 & 0xff), > > (fmt->fourcc >> 24 & 0xff)); > > > > - return mtk_jpeg_try_fmt_mplane(f, fmt, ctx, MTK_JPEG_FMT_TYPE_OUTPUT); > > + if (ctx->state != MTK_JPEG_INIT) { > > + mtk_jpeg_g_fmt_vid_mplane(file, priv, f); > > + return 0; > > + } > > + > > + return vidioc_try_fmt(f, fmt); > > } > > > > static int mtk_jpeg_s_fmt_mplane(struct mtk_jpeg_ctx *ctx, > > - struct v4l2_format *f) > > + struct v4l2_format *f, unsigned int fmt_type) > > { > > struct vb2_queue *vq; > > struct mtk_jpeg_q_data *q_data = NULL; > > struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp; > > struct mtk_jpeg_dev *jpeg = ctx->jpeg; > > - unsigned int f_type; > > int i; > > > > vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type); > > @@ -343,10 +499,7 @@ static int mtk_jpeg_s_fmt_mplane(struct mtk_jpeg_ctx *ctx, > > return -EBUSY; > > } > > > > - f_type = V4L2_TYPE_IS_OUTPUT(f->type) ? > > - MTK_JPEG_FMT_TYPE_OUTPUT : MTK_JPEG_FMT_TYPE_CAPTURE; > > - > > - q_data->fmt = mtk_jpeg_find_format(ctx, pix_mp->pixelformat, f_type); > > + q_data->fmt = mtk_jpeg_find_format(pix_mp->pixelformat, fmt_type); > > q_data->w = pix_mp->width; > > q_data->h = pix_mp->height; > > ctx->colorspace = pix_mp->colorspace; > > @@ -374,28 +527,56 @@ static int mtk_jpeg_s_fmt_mplane(struct mtk_jpeg_ctx *ctx, > > return 0; > > } > > > > -static int mtk_jpeg_s_fmt_vid_out_mplane(struct file *file, void *priv, > > - struct v4l2_format *f) > > +static int mtk_jpeg_enc_s_fmt_vid_out_mplane(struct file *file, void *priv, > > + struct v4l2_format *f) > > +{ > > + int ret; > > + > > + ret = mtk_jpeg_enc_try_fmt_vid_out_mplane(file, priv, f); > > + if (ret) > > + return ret; > > + > > + return mtk_jpeg_s_fmt_mplane(mtk_jpeg_fh_to_ctx(priv), f, > > + MTK_JPEG_FMT_FLAG_ENC_OUTPUT); > > +} > > + > > +static int mtk_jpeg_dec_s_fmt_vid_out_mplane(struct file *file, void *priv, > > + struct v4l2_format *f) > > { > > int ret; > > > > - ret = mtk_jpeg_try_fmt_vid_out_mplane(file, priv, f); > > + ret = mtk_jpeg_dec_try_fmt_vid_out_mplane(file, priv, f); > > if (ret) > > return ret; > > > > - return mtk_jpeg_s_fmt_mplane(mtk_jpeg_fh_to_ctx(priv), f); > > + return mtk_jpeg_s_fmt_mplane(mtk_jpeg_fh_to_ctx(priv), f, > > + MTK_JPEG_FMT_FLAG_DEC_OUTPUT); > > } > > > > -static int mtk_jpeg_s_fmt_vid_cap_mplane(struct file *file, void *priv, > > - struct v4l2_format *f) > > +static int mtk_jpeg_enc_s_fmt_vid_cap_mplane(struct file *file, void *priv, > > + struct v4l2_format *f) > > { > > int ret; > > > > - ret = mtk_jpeg_try_fmt_vid_cap_mplane(file, priv, f); > > + ret = mtk_jpeg_enc_try_fmt_vid_cap_mplane(file, priv, f); > > if (ret) > > return ret; > > > > - return mtk_jpeg_s_fmt_mplane(mtk_jpeg_fh_to_ctx(priv), f); > > + return mtk_jpeg_s_fmt_mplane(mtk_jpeg_fh_to_ctx(priv), f, > > + MTK_JPEG_FMT_FLAG_ENC_CAPTURE); > > +} > > + > > +static int mtk_jpeg_dec_s_fmt_vid_cap_mplane(struct file *file, void *priv, > > + struct v4l2_format *f) > > +{ > > + int ret; > > + > > + ret = mtk_jpeg_dec_try_fmt_vid_cap_mplane(file, priv, f); > > + if (ret) > > + return ret; > > + > > + return mtk_jpeg_s_fmt_mplane(mtk_jpeg_fh_to_ctx(priv), f, > > + MTK_JPEG_FMT_FLAG_DEC_CAPTURE); > > } > > > > static void mtk_jpeg_queue_src_chg_event(struct mtk_jpeg_ctx *ctx) > > @@ -420,8 +601,31 @@ static int mtk_jpeg_subscribe_event(struct v4l2_fh *fh, > > return v4l2_ctrl_subscribe_event(fh, sub); > > } > > > > -static int mtk_jpeg_g_selection(struct file *file, void *priv, > > - struct v4l2_selection *s) > > +static int mtk_jpeg_enc_g_selection(struct file *file, void *priv, > > + struct v4l2_selection *s) > > +{ > > + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); > > + > > + if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) > > + return -EINVAL; > > + > > + switch (s->target) { > > + case V4L2_SEL_TGT_CROP: > > + case V4L2_SEL_TGT_CROP_BOUNDS: > > + case V4L2_SEL_TGT_CROP_DEFAULT: > > + s->r.width = ctx->out_q.w; > > + s->r.height = ctx->out_q.h; > > + s->r.left = 0; > > + s->r.top = 0; > > + break; > > + default: > > + return -EINVAL; > > + } > > + return 0; > > +} > > + > > +static int mtk_jpeg_dec_g_selection(struct file *file, void *priv, > > + struct v4l2_selection *s) > > { > > struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); > > > > @@ -446,11 +650,34 @@ static int mtk_jpeg_g_selection(struct file *file, void *priv, > > default: > > return -EINVAL; > > } > > + > > return 0; > > } > > > > -static int mtk_jpeg_s_selection(struct file *file, void *priv, > > - struct v4l2_selection *s) > > +static int mtk_jpeg_enc_s_selection(struct file *file, void *priv, > > + struct v4l2_selection *s) > > +{ > > + struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); > > + > > + if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) > > + return -EINVAL; > > + > > + switch (s->target) { > > + case V4L2_SEL_TGT_CROP: > > + s->r.left = 0; > > + s->r.top = 0; > > + ctx->out_q.w = min(s->r.width, ctx->out_q.w); > > + ctx->out_q.h = min(s->r.height, ctx->out_q.h); > > + break; > > + default: > > + return -EINVAL; > > + } > > + > > + return 0; > > +} > > + > > +static int mtk_jpeg_dec_s_selection(struct file *file, void *priv, > > + struct v4l2_selection *s) > > { > > struct mtk_jpeg_ctx *ctx = mtk_jpeg_fh_to_ctx(priv); > > > > @@ -467,6 +694,7 @@ static int mtk_jpeg_s_selection(struct file *file, void *priv, > > default: > > return -EINVAL; > > } > > + > > return 0; > > } > > > > @@ -495,20 +723,47 @@ static int mtk_jpeg_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf) > > return v4l2_m2m_qbuf(file, fh->m2m_ctx, buf); > > } > > > > -static const struct v4l2_ioctl_ops mtk_jpeg_ioctl_ops = { > > - .vidioc_querycap = mtk_jpeg_querycap, > > - .vidioc_enum_fmt_vid_cap = mtk_jpeg_enum_fmt_vid_cap, > > - .vidioc_enum_fmt_vid_out = mtk_jpeg_enum_fmt_vid_out, > > - .vidioc_try_fmt_vid_cap_mplane = mtk_jpeg_try_fmt_vid_cap_mplane, > > - .vidioc_try_fmt_vid_out_mplane = mtk_jpeg_try_fmt_vid_out_mplane, > > +static const struct v4l2_ioctl_ops mtk_jpeg_enc_ioctl_ops = { > > + .vidioc_querycap = mtk_jpeg_enc_querycap, > > + .vidioc_enum_fmt_vid_cap = mtk_jpeg_enc_enum_fmt_vid_cap, > > + .vidioc_enum_fmt_vid_out = mtk_jpeg_enc_enum_fmt_vid_out, > > + .vidioc_try_fmt_vid_cap_mplane = mtk_jpeg_enc_try_fmt_vid_cap_mplane, > > + .vidioc_try_fmt_vid_out_mplane = mtk_jpeg_enc_try_fmt_vid_out_mplane, > > + .vidioc_g_fmt_vid_cap_mplane = mtk_jpeg_g_fmt_vid_mplane, > > + .vidioc_g_fmt_vid_out_mplane = mtk_jpeg_g_fmt_vid_mplane, > > + .vidioc_s_fmt_vid_cap_mplane = mtk_jpeg_enc_s_fmt_vid_cap_mplane, > > + .vidioc_s_fmt_vid_out_mplane = mtk_jpeg_enc_s_fmt_vid_out_mplane, > > + .vidioc_qbuf = mtk_jpeg_qbuf, > > + .vidioc_subscribe_event = mtk_jpeg_subscribe_event, > > + .vidioc_g_selection = mtk_jpeg_enc_g_selection, > > + .vidioc_s_selection = mtk_jpeg_enc_s_selection, > > + > > + .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, > > + .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, > > + .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs, > > + .vidioc_querybuf = v4l2_m2m_ioctl_querybuf, > > + .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf, > > + .vidioc_expbuf = v4l2_m2m_ioctl_expbuf, > > + .vidioc_streamon = v4l2_m2m_ioctl_streamon, > > + .vidioc_streamoff = v4l2_m2m_ioctl_streamoff, > > + > > + .vidioc_unsubscribe_event = v4l2_event_unsubscribe, > > +}; > > + > > +static const struct v4l2_ioctl_ops mtk_jpeg_dec_ioctl_ops = { > > + .vidioc_querycap = mtk_jpeg_dec_querycap, > > + .vidioc_enum_fmt_vid_cap = mtk_jpeg_dec_enum_fmt_vid_cap, > > + .vidioc_enum_fmt_vid_out = mtk_jpeg_dec_enum_fmt_vid_out, > > + .vidioc_try_fmt_vid_cap_mplane = mtk_jpeg_dec_try_fmt_vid_cap_mplane, > > + .vidioc_try_fmt_vid_out_mplane = mtk_jpeg_dec_try_fmt_vid_out_mplane, > > .vidioc_g_fmt_vid_cap_mplane = mtk_jpeg_g_fmt_vid_mplane, > > .vidioc_g_fmt_vid_out_mplane = mtk_jpeg_g_fmt_vid_mplane, > > - .vidioc_s_fmt_vid_cap_mplane = mtk_jpeg_s_fmt_vid_cap_mplane, > > - .vidioc_s_fmt_vid_out_mplane = mtk_jpeg_s_fmt_vid_out_mplane, > > + .vidioc_s_fmt_vid_cap_mplane = mtk_jpeg_dec_s_fmt_vid_cap_mplane, > > + .vidioc_s_fmt_vid_out_mplane = mtk_jpeg_dec_s_fmt_vid_out_mplane, > > .vidioc_qbuf = mtk_jpeg_qbuf, > > .vidioc_subscribe_event = mtk_jpeg_subscribe_event, > > - .vidioc_g_selection = mtk_jpeg_g_selection, > > - .vidioc_s_selection = mtk_jpeg_s_selection, > > + .vidioc_g_selection = mtk_jpeg_dec_g_selection, > > + .vidioc_s_selection = mtk_jpeg_dec_s_selection, > > > > .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs, > > .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf, > > @@ -586,8 +841,9 @@ static bool mtk_jpeg_check_resolution_change(struct mtk_jpeg_ctx *ctx, > > } > > > > q_data = &ctx->cap_q; > > - if (q_data->fmt != mtk_jpeg_find_format(ctx, param->dst_fourcc, > > - MTK_JPEG_FMT_TYPE_CAPTURE)) { > > + if (q_data->fmt != > > + mtk_jpeg_find_format(param->dst_fourcc, > > + MTK_JPEG_FMT_FLAG_DEC_CAPTURE)) { > > v4l2_dbg(1, debug, &jpeg->v4l2_dev, "format change\n"); > > return true; > > } > > @@ -608,9 +864,8 @@ static void mtk_jpeg_set_queue_data(struct mtk_jpeg_ctx *ctx, > > q_data = &ctx->cap_q; > > q_data->w = param->dec_w; > > q_data->h = param->dec_h; > > - q_data->fmt = mtk_jpeg_find_format(ctx, > > - param->dst_fourcc, > > - MTK_JPEG_FMT_TYPE_CAPTURE); > > + q_data->fmt = mtk_jpeg_find_format(param->dst_fourcc, > > + MTK_JPEG_FMT_FLAG_DEC_CAPTURE); > > > > for (i = 0; i < q_data->fmt->colplanes; i++) { > > q_data->bytesperline[i] = param->mem_stride[i]; > > @@ -627,7 +882,18 @@ static void mtk_jpeg_set_queue_data(struct mtk_jpeg_ctx *ctx, > > param->dec_w, param->dec_h); > > } > > > > -static void mtk_jpeg_buf_queue(struct vb2_buffer *vb) > > +static void mtk_jpeg_enc_buf_queue(struct vb2_buffer *vb) > > +{ > > + struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); > > + struct mtk_jpeg_dev *jpeg = ctx->jpeg; > > + > > + v4l2_dbg(2, debug, &jpeg->v4l2_dev, "(%d) buf_q id=%d, vb=%p\n", > > + vb->vb2_queue->type, vb->index, vb); > > + > > + v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, to_vb2_v4l2_buffer(vb)); > > +} > > + > > +static void mtk_jpeg_dec_buf_queue(struct vb2_buffer *vb) > > { > > struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue); > > struct mtk_jpeg_dec_param *param; > > @@ -679,7 +945,16 @@ static struct vb2_v4l2_buffer *mtk_jpeg_buf_remove(struct mtk_jpeg_ctx *ctx, > > return v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); > > } > > > > -static void mtk_jpeg_stop_streaming(struct vb2_queue *q) > > +static void mtk_jpeg_enc_stop_streaming(struct vb2_queue *q) > > +{ > > + struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(q); > > + struct vb2_v4l2_buffer *vb; > > + > > + while ((vb = mtk_jpeg_buf_remove(ctx, q->type))) > > + v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR); > > +} > > + > > +static void mtk_jpeg_dec_stop_streaming(struct vb2_queue *q) > > { > > struct mtk_jpeg_ctx *ctx = vb2_get_drv_priv(q); > > struct vb2_v4l2_buffer *vb; > > @@ -705,13 +980,22 @@ static void mtk_jpeg_stop_streaming(struct vb2_queue *q) > > v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR); > > } > > > > -static const struct vb2_ops mtk_jpeg_qops = { > > +static const struct vb2_ops mtk_jpeg_dec_qops = { > > .queue_setup = mtk_jpeg_queue_setup, > > .buf_prepare = mtk_jpeg_buf_prepare, > > - .buf_queue = mtk_jpeg_buf_queue, > > + .buf_queue = mtk_jpeg_dec_buf_queue, > > .wait_prepare = vb2_ops_wait_prepare, > > .wait_finish = vb2_ops_wait_finish, > > - .stop_streaming = mtk_jpeg_stop_streaming, > > + .stop_streaming = mtk_jpeg_dec_stop_streaming, > > +}; > > + > > +static const struct vb2_ops mtk_jpeg_enc_qops = { > > + .queue_setup = mtk_jpeg_queue_setup, > > + .buf_prepare = mtk_jpeg_buf_prepare, > > + .buf_queue = mtk_jpeg_enc_buf_queue, > > + .wait_prepare = vb2_ops_wait_prepare, > > + .wait_finish = vb2_ops_wait_finish, > > + .stop_streaming = mtk_jpeg_enc_stop_streaming, > > }; > > > > static void mtk_jpeg_set_dec_src(struct mtk_jpeg_ctx *ctx, > > @@ -751,7 +1035,86 @@ static int mtk_jpeg_set_dec_dst(struct mtk_jpeg_ctx *ctx, > > return 0; > > } > > > > -static void mtk_jpeg_device_run(void *priv) > > +static void mtk_jpeg_set_enc_dst(struct mtk_jpeg_ctx *ctx, void __iomem *base, > > + struct vb2_buffer *dst_buf, > > + struct mtk_jpeg_enc_bs *bs) > > +{ > > + bs->dma_addr = vb2_dma_contig_plane_dma_addr(dst_buf, 0); > > + bs->dma_addr_offset = ctx->enable_exif ? MTK_JPEG_DEFAULT_EXIF_SIZE : 0; > > + bs->dma_addr_offsetmask = bs->dma_addr & JPEG_ENC_DST_ADDR_OFFSET_MASK; > > + bs->size = vb2_plane_size(dst_buf, 0); > > + > > + mtk_jpeg_enc_set_dst_addr(base, bs->dma_addr, bs->size, > > + bs->dma_addr_offset, > > + bs->dma_addr_offsetmask); > > +} > > + > > +static void mtk_jpeg_set_enc_src(struct mtk_jpeg_ctx *ctx, void __iomem *base, > > + struct vb2_buffer *src_buf) > > +{ > > + int i; > > + dma_addr_t dma_addr; > > + > > + mtk_jpeg_enc_set_img_size(base, ctx->out_q.w, ctx->out_q.h); > > + mtk_jpeg_enc_set_blk_num(base, ctx->out_q.fmt->fourcc, ctx->out_q.w, > > + ctx->out_q.h); > > + mtk_jpeg_enc_set_stride(base, ctx->out_q.fmt->fourcc, ctx->out_q.w, > > + ctx->out_q.h, ctx->out_q.bytesperline[0]); > > + > > + for (i = 0; i < src_buf->num_planes; i++) { > > + dma_addr = vb2_dma_contig_plane_dma_addr(src_buf, i) + > > + src_buf->planes[i].data_offset; > > + mtk_jpeg_enc_set_src_addr(base, dma_addr, i); > > + } > > +} > > + > > +static void mtk_jpeg_enc_device_run(void *priv) > > +{ > > + struct mtk_jpeg_ctx *ctx = priv; > > + struct mtk_jpeg_dev *jpeg = ctx->jpeg; > > + struct vb2_v4l2_buffer *src_buf, *dst_buf; > > + enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; > > + unsigned long flags; > > + struct mtk_jpeg_src_buf *jpeg_src_buf; > > + struct mtk_jpeg_enc_bs enc_bs; > > + int i, ret; > > + > > + src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx); > > + dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx); > > + jpeg_src_buf = mtk_jpeg_vb2_to_srcbuf(&src_buf->vb2_buf); > > + > > + if (jpeg_src_buf->flags & MTK_JPEG_BUF_FLAGS_LAST_FRAME) { > > + for (i = 0; i < dst_buf->vb2_buf.num_planes; i++) > > + vb2_set_plane_payload(&dst_buf->vb2_buf, i, 0); > > + buf_state = VB2_BUF_STATE_DONE; > > + goto enc_end; > > + } > > + > > + ret = pm_runtime_get_sync(jpeg->dev); > > + if (ret < 0) > > + goto enc_end; > > + > > + spin_lock_irqsave(&jpeg->hw_lock, flags); > > + mtk_jpeg_enc_reset(jpeg->reg_base); > > + > > + mtk_jpeg_set_enc_dst(ctx, jpeg->reg_base, &dst_buf->vb2_buf, &enc_bs); > > + mtk_jpeg_set_enc_src(ctx, jpeg->reg_base, &src_buf->vb2_buf); > > + mtk_jpeg_enc_set_config(jpeg->reg_base, ctx->out_q.fmt->hw_format, > > + ctx->enable_exif, ctx->enc_quality, > > + ctx->restart_interval); > > + mtk_jpeg_enc_start(jpeg->reg_base); > > + spin_unlock_irqrestore(&jpeg->hw_lock, flags); > > + return; > > + > > +enc_end: > > + v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); > > + v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); > > + v4l2_m2m_buf_done(src_buf, buf_state); > > + v4l2_m2m_buf_done(dst_buf, buf_state); > > + v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); > > +} > > + > > +static void mtk_jpeg_dec_device_run(void *priv) > > { > > struct mtk_jpeg_ctx *ctx = priv; > > struct mtk_jpeg_dev *jpeg = ctx->jpeg; > > @@ -786,15 +1149,16 @@ static void mtk_jpeg_device_run(void *priv) > > goto dec_end; > > > > mtk_jpeg_set_dec_src(ctx, &src_buf->vb2_buf, &bs); > > - if (mtk_jpeg_set_dec_dst(ctx, &jpeg_src_buf->dec_param, &dst_buf->vb2_buf, &fb)) > > + if (mtk_jpeg_set_dec_dst(ctx, &jpeg_src_buf->dec_param, > > + &dst_buf->vb2_buf, &fb)) > > goto dec_end; > > > > spin_lock_irqsave(&jpeg->hw_lock, flags); > > - mtk_jpeg_dec_reset(jpeg->dec_reg_base); > > - mtk_jpeg_dec_set_config(jpeg->dec_reg_base, > > + mtk_jpeg_dec_reset(jpeg->reg_base); > > + mtk_jpeg_dec_set_config(jpeg->reg_base, > > &jpeg_src_buf->dec_param, &bs, &fb); > > > > - mtk_jpeg_dec_start(jpeg->dec_reg_base); > > + mtk_jpeg_dec_start(jpeg->reg_base); > > spin_unlock_irqrestore(&jpeg->hw_lock, flags); > > return; > > > > @@ -806,20 +1170,30 @@ static void mtk_jpeg_device_run(void *priv) > > v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); > > } > > > > -static int mtk_jpeg_job_ready(void *priv) > > +static int mtk_jpeg_enc_job_ready(void *priv) > > +{ > > + return 1; > > +} > > + > > +static int mtk_jpeg_dec_job_ready(void *priv) > > { > > struct mtk_jpeg_ctx *ctx = priv; > > > > return (ctx->state == MTK_JPEG_RUNNING) ? 1 : 0; > > } > > > > -static const struct v4l2_m2m_ops mtk_jpeg_m2m_ops = { > > - .device_run = mtk_jpeg_device_run, > > - .job_ready = mtk_jpeg_job_ready, > > +static const struct v4l2_m2m_ops mtk_jpeg_enc_m2m_ops = { > > + .device_run = mtk_jpeg_enc_device_run, > > + .job_ready = mtk_jpeg_enc_job_ready, > > }; > > > > -static int mtk_jpeg_queue_init(void *priv, struct vb2_queue *src_vq, > > - struct vb2_queue *dst_vq) > > +static const struct v4l2_m2m_ops mtk_jpeg_dec_m2m_ops = { > > + .device_run = mtk_jpeg_dec_device_run, > > + .job_ready = mtk_jpeg_dec_job_ready, > > +}; > > + > > +static int mtk_jpeg_dec_queue_init(void *priv, struct vb2_queue *src_vq, > > + struct vb2_queue *dst_vq) > > { > > struct mtk_jpeg_ctx *ctx = priv; > > int ret; > > @@ -828,7 +1202,7 @@ static int mtk_jpeg_queue_init(void *priv, struct vb2_queue *src_vq, > > src_vq->io_modes = VB2_DMABUF | VB2_MMAP; > > src_vq->drv_priv = ctx; > > src_vq->buf_struct_size = sizeof(struct mtk_jpeg_src_buf); > > - src_vq->ops = &mtk_jpeg_qops; > > + src_vq->ops = &mtk_jpeg_dec_qops; > > src_vq->mem_ops = &vb2_dma_contig_memops; > > src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; > > src_vq->lock = &ctx->jpeg->lock; > > @@ -841,7 +1215,7 @@ static int mtk_jpeg_queue_init(void *priv, struct vb2_queue *src_vq, > > dst_vq->io_modes = VB2_DMABUF | VB2_MMAP; > > dst_vq->drv_priv = ctx; > > dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); > > - dst_vq->ops = &mtk_jpeg_qops; > > + dst_vq->ops = &mtk_jpeg_dec_qops; > > dst_vq->mem_ops = &vb2_dma_contig_memops; > > dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; > > dst_vq->lock = &ctx->jpeg->lock; > > @@ -851,24 +1225,112 @@ static int mtk_jpeg_queue_init(void *priv, struct vb2_queue *src_vq, > > return ret; > > } > > > > -static void mtk_jpeg_clk_on(struct mtk_jpeg_dev *jpeg) > > +static int mtk_jpeg_enc_queue_init(void *priv, struct vb2_queue *src_vq, > > + struct vb2_queue *dst_vq) > > { > > + struct mtk_jpeg_ctx *ctx = priv; > > int ret; > > > > + src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; > > + src_vq->io_modes = VB2_DMABUF | VB2_MMAP; > > + src_vq->drv_priv = ctx; > > + src_vq->buf_struct_size = sizeof(struct mtk_jpeg_src_buf); > > + src_vq->ops = &mtk_jpeg_enc_qops; > > + src_vq->mem_ops = &vb2_dma_contig_memops; > > + src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; > > + src_vq->lock = &ctx->jpeg->lock; > > + src_vq->dev = ctx->jpeg->dev; > > + ret = vb2_queue_init(src_vq); > > + if (ret) > > + return ret; > > + > > + dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; > > + dst_vq->io_modes = VB2_DMABUF | VB2_MMAP; > > + dst_vq->drv_priv = ctx; > > + dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer); > > + dst_vq->ops = &mtk_jpeg_enc_qops; > > + dst_vq->mem_ops = &vb2_dma_contig_memops; > > + dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; > > + dst_vq->lock = &ctx->jpeg->lock; > > + dst_vq->dev = ctx->jpeg->dev; > > + ret = vb2_queue_init(dst_vq); > > + > > + return ret; > > +} > > + > > +static void mtk_jpeg_clk_on(struct mtk_jpeg_dev *jpeg) > > +{ > > + int ret, i; > > + > > ret = mtk_smi_larb_get(jpeg->larb); > > if (ret) > > dev_err(jpeg->dev, "mtk_smi_larb_get larbvdec fail %d\n", ret); > > - clk_prepare_enable(jpeg->clk_jdec_smi); > > - clk_prepare_enable(jpeg->clk_jdec); > > + > > + for (i = 0; i < jpeg->variant->num_clocks; i++) { > > + ret = clk_prepare_enable(jpeg->clocks[i]); > > + if (ret) { > > + while (--i >= 0) > > + clk_disable_unprepare(jpeg->clocks[i]); > > + } > > + } > > } > > > > static void mtk_jpeg_clk_off(struct mtk_jpeg_dev *jpeg) > > { > > - clk_disable_unprepare(jpeg->clk_jdec); > > - clk_disable_unprepare(jpeg->clk_jdec_smi); > > + int i; > > + > > + for (i = jpeg->variant->num_clocks - 1; i >= 0; i--) > > + clk_disable_unprepare(jpeg->clocks[i]); > > mtk_smi_larb_put(jpeg->larb); > > } > > > > +static irqreturn_t mtk_jpeg_enc_irq(int irq, void *priv) > > +{ > > + struct mtk_jpeg_dev *jpeg = priv; > > + struct mtk_jpeg_ctx *ctx; > > + struct vb2_v4l2_buffer *src_buf, *dst_buf; > > + struct mtk_jpeg_src_buf *jpeg_src_buf; > > + enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; > > + u32 enc_irq_ret; > > + u32 enc_ret, result_size; > > + > > + spin_lock(&jpeg->hw_lock); > > + > > + ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); > > + if (!ctx) { > > + v4l2_err(&jpeg->v4l2_dev, "Context is NULL\n"); > > + return IRQ_HANDLED; > > + } > > + > > + src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx); > > + dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx); > > + jpeg_src_buf = mtk_jpeg_vb2_to_srcbuf(&src_buf->vb2_buf); > > + > > + enc_ret = mtk_jpeg_enc_get_and_clear_int_status(jpeg->reg_base); > > + enc_irq_ret = mtk_jpeg_enc_enum_result(jpeg->reg_base, enc_ret); > > + > > + if (enc_irq_ret >= MTK_JPEG_ENC_RESULT_STALL) > > + mtk_jpeg_enc_reset(jpeg->reg_base); > > + > > + if (enc_irq_ret != MTK_JPEG_ENC_RESULT_DONE) { > > + dev_err(jpeg->dev, "encode failed\n"); > > + goto enc_end; > > + } > > + > > + result_size = mtk_jpeg_enc_get_file_size(jpeg->reg_base); > > + vb2_set_plane_payload(&dst_buf->vb2_buf, 0, result_size); > > + > > + buf_state = VB2_BUF_STATE_DONE; > > + > > +enc_end: > > + v4l2_m2m_buf_done(src_buf, buf_state); > > + v4l2_m2m_buf_done(dst_buf, buf_state); > > + v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx); > > + spin_unlock(&jpeg->hw_lock); > > + pm_runtime_put_sync(ctx->jpeg->dev); > > + return IRQ_HANDLED; > > +} > > + > > static irqreturn_t mtk_jpeg_dec_irq(int irq, void *priv) > > { > > struct mtk_jpeg_dev *jpeg = priv; > > @@ -876,13 +1338,13 @@ static irqreturn_t mtk_jpeg_dec_irq(int irq, void *priv) > > struct vb2_v4l2_buffer *src_buf, *dst_buf; > > struct mtk_jpeg_src_buf *jpeg_src_buf; > > enum vb2_buffer_state buf_state = VB2_BUF_STATE_ERROR; > > - u32 dec_irq_ret; > > + u32 dec_irq_ret; > > u32 dec_ret; > > int i; > > > > spin_lock(&jpeg->hw_lock); > > > > - dec_ret = mtk_jpeg_dec_get_int_status(jpeg->dec_reg_base); > > + dec_ret = mtk_jpeg_dec_get_int_status(jpeg->reg_base); > > dec_irq_ret = mtk_jpeg_dec_enum_result(dec_ret); > > ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev); > > if (!ctx) { > > @@ -895,7 +1357,7 @@ static irqreturn_t mtk_jpeg_dec_irq(int irq, void *priv) > > jpeg_src_buf = mtk_jpeg_vb2_to_srcbuf(&src_buf->vb2_buf); > > > > if (dec_irq_ret >= MTK_JPEG_DEC_RESULT_UNDERFLOW) > > - mtk_jpeg_dec_reset(jpeg->dec_reg_base); > > + mtk_jpeg_dec_reset(jpeg->reg_base); > > > > if (dec_irq_ret != MTK_JPEG_DEC_RESULT_EOF_DONE) { > > dev_err(jpeg->dev, "decode failed\n"); > > @@ -917,39 +1379,131 @@ static irqreturn_t mtk_jpeg_dec_irq(int irq, void *priv) > > return IRQ_HANDLED; > > } > > > > -static void mtk_jpeg_set_default_params(struct mtk_jpeg_ctx *ctx) > > +static void mtk_jpeg_set_enc_default_params(struct mtk_jpeg_ctx *ctx) > > { > > struct mtk_jpeg_q_data *q = &ctx->out_q; > > - int i; > > + struct v4l2_pix_format_mplane *pix_mp; > > + > > + pix_mp = kmalloc(sizeof(*pix_mp), GFP_KERNEL); > > > > + ctx->fh.ctrl_handler = &ctx->ctrl_hdl; > > ctx->colorspace = V4L2_COLORSPACE_JPEG, > > ctx->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; > > ctx->quantization = V4L2_QUANTIZATION_DEFAULT; > > ctx->xfer_func = V4L2_XFER_FUNC_DEFAULT; > > - > > - q->fmt = mtk_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG, > > - MTK_JPEG_FMT_TYPE_OUTPUT); > > - q->w = MTK_JPEG_MIN_WIDTH; > > - q->h = MTK_JPEG_MIN_HEIGHT; > > - q->bytesperline[0] = 0; > > - q->sizeimage[0] = MTK_JPEG_DEFAULT_SIZEIMAGE; > > + pix_mp->width = MTK_JPEG_MIN_WIDTH; > > + pix_mp->height = MTK_JPEG_MIN_HEIGHT; > > + > > + q->fmt = mtk_jpeg_find_format(V4L2_PIX_FMT_YUYV, > > + MTK_JPEG_FMT_FLAG_ENC_OUTPUT); > > + vidioc_try_fmt(container_of(pix_mp, struct v4l2_format, > > + fmt.pix_mp), q->fmt); > > + q->w = pix_mp->width; > > + q->h = pix_mp->height; > > + q->sizeimage[0] = pix_mp->plane_fmt[0].sizeimage; > > + q->bytesperline[0] = pix_mp->plane_fmt[0].bytesperline; > > > > q = &ctx->cap_q; > > - q->fmt = mtk_jpeg_find_format(ctx, V4L2_PIX_FMT_YUV420M, > > - MTK_JPEG_FMT_TYPE_CAPTURE); > > - q->w = MTK_JPEG_MIN_WIDTH; > > - q->h = MTK_JPEG_MIN_HEIGHT; > > + q->fmt = mtk_jpeg_find_format(V4L2_PIX_FMT_JPEG, > > + MTK_JPEG_FMT_FLAG_ENC_CAPTURE); > > + pix_mp->width = MTK_JPEG_MIN_WIDTH; > > + pix_mp->height = MTK_JPEG_MIN_HEIGHT; > > + vidioc_try_fmt(container_of(pix_mp, struct v4l2_format, > > + fmt.pix_mp), q->fmt); > > + q->w = pix_mp->width; > > + q->h = pix_mp->height; > > + q->sizeimage[0] = pix_mp->plane_fmt[0].sizeimage; > > + q->bytesperline[0] = pix_mp->plane_fmt[0].bytesperline; > > +} > > + > > +static void mtk_jpeg_set_dec_default_params(struct mtk_jpeg_ctx *ctx) > > +{ > > + struct mtk_jpeg_q_data *q = &ctx->out_q; > > + struct v4l2_pix_format_mplane *pix_mp; > > + int i; > > + > > + pix_mp = kmalloc(sizeof(*pix_mp), GFP_KERNEL); > > > > + ctx->fh.ctrl_handler = &ctx->ctrl_hdl; > > + ctx->colorspace = V4L2_COLORSPACE_JPEG, > > + ctx->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; > > + ctx->quantization = V4L2_QUANTIZATION_DEFAULT; > > + ctx->xfer_func = V4L2_XFER_FUNC_DEFAULT; > > + pix_mp->width = MTK_JPEG_MIN_WIDTH; > > + pix_mp->height = MTK_JPEG_MIN_HEIGHT; > > + > > + q->fmt = mtk_jpeg_find_format(V4L2_PIX_FMT_JPEG, > > + MTK_JPEG_FMT_FLAG_DEC_OUTPUT); > > + vidioc_try_fmt(container_of(pix_mp, struct v4l2_format, > > + fmt.pix_mp), q->fmt); > > + q->w = pix_mp->width; > > + q->h = pix_mp->height; > > + q->sizeimage[0] = pix_mp->plane_fmt[0].sizeimage; > > + q->bytesperline[0] = pix_mp->plane_fmt[0].bytesperline; > > + > > + q = &ctx->cap_q; > > + q->fmt = mtk_jpeg_find_format(V4L2_PIX_FMT_YUV420M, > > + MTK_JPEG_FMT_FLAG_DEC_CAPTURE); > > + pix_mp->width = MTK_JPEG_MIN_WIDTH; > > + pix_mp->height = MTK_JPEG_MIN_HEIGHT; > > + vidioc_try_fmt(container_of(pix_mp, struct v4l2_format, > > + fmt.pix_mp), q->fmt); > > + q->w = pix_mp->width; > > + q->h = pix_mp->height; > > for (i = 0; i < q->fmt->colplanes; i++) { > > - u32 stride = q->w * q->fmt->h_sample[i] / 4; > > - u32 h = q->h * q->fmt->v_sample[i] / 4; > > + q->sizeimage[i] = pix_mp->plane_fmt[i].sizeimage; > > + q->bytesperline[i] = pix_mp->plane_fmt[i].bytesperline; > > + } > > +} > > + > > +static int mtk_jpeg_enc_open(struct file *file) > > +{ > > + struct mtk_jpeg_dev *jpeg = video_drvdata(file); > > + struct video_device *vfd = video_devdata(file); > > + struct mtk_jpeg_ctx *ctx; > > + int ret = 0; > > > > - q->bytesperline[i] = stride; > > - q->sizeimage[i] = stride * h; > > + ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); > > + if (!ctx) > > + return -ENOMEM; > > + > > + if (mutex_lock_interruptible(&jpeg->lock)) { > > + ret = -ERESTARTSYS; > > + goto free; > > + } > > + > > + v4l2_fh_init(&ctx->fh, vfd); > > + file->private_data = &ctx->fh; > > + v4l2_fh_add(&ctx->fh); > > + > > + ctx->jpeg = jpeg; > > + ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(jpeg->m2m_dev, ctx, > > + mtk_jpeg_enc_queue_init); > > + if (IS_ERR(ctx->fh.m2m_ctx)) { > > + ret = PTR_ERR(ctx->fh.m2m_ctx); > > + goto error; > > } > > + > > + ret = mtk_jpeg_enc_ctrls_setup(ctx); > > + if (ret) { > > + v4l2_err(&jpeg->v4l2_dev, "Failed to setup jpeg enc controls\n"); > > + goto error; > > + } > > + mtk_jpeg_set_enc_default_params(ctx); > > + > > + mutex_unlock(&jpeg->lock); > > + return 0; > > + > > +error: > > + v4l2_fh_del(&ctx->fh); > > + v4l2_fh_exit(&ctx->fh); > > + mutex_unlock(&jpeg->lock); > > +free: > > + kfree(ctx); > > + return ret; > > } > > > > -static int mtk_jpeg_open(struct file *file) > > +static int mtk_jpeg_dec_open(struct file *file) > > { > > struct mtk_jpeg_dev *jpeg = video_drvdata(file); > > struct video_device *vfd = video_devdata(file); > > @@ -971,13 +1525,20 @@ static int mtk_jpeg_open(struct file *file) > > > > ctx->jpeg = jpeg; > > ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(jpeg->m2m_dev, ctx, > > - mtk_jpeg_queue_init); > > + mtk_jpeg_dec_queue_init); > > if (IS_ERR(ctx->fh.m2m_ctx)) { > > ret = PTR_ERR(ctx->fh.m2m_ctx); > > goto error; > > } > > > > - mtk_jpeg_set_default_params(ctx); > > + v4l2_ctrl_handler_init(&ctx->ctrl_hdl, 0); > > + ret = v4l2_ctrl_handler_setup(&ctx->ctrl_hdl); > > + if (ret) { > > + v4l2_err(&jpeg->v4l2_dev, "Failed to setup jpeg dec controls\n"); > > + goto error; > > + } > > + mtk_jpeg_set_dec_default_params(ctx); > > + > > mutex_unlock(&jpeg->lock); > > return 0; > > > > @@ -997,6 +1558,7 @@ static int mtk_jpeg_release(struct file *file) > > > > mutex_lock(&jpeg->lock); > > v4l2_m2m_ctx_release(ctx->fh.m2m_ctx); > > + v4l2_ctrl_handler_free(&ctx->ctrl_hdl); > > v4l2_fh_del(&ctx->fh); > > v4l2_fh_exit(&ctx->fh); > > kfree(ctx); > > @@ -1004,9 +1566,18 @@ static int mtk_jpeg_release(struct file *file) > > return 0; > > } > > > > -static const struct v4l2_file_operations mtk_jpeg_fops = { > > +static const struct v4l2_file_operations mtk_jpeg_enc_fops = { > > .owner = THIS_MODULE, > > - .open = mtk_jpeg_open, > > + .open = mtk_jpeg_enc_open, > > + .release = mtk_jpeg_release, > > + .poll = v4l2_m2m_fop_poll, > > + .unlocked_ioctl = video_ioctl2, > > + .mmap = v4l2_m2m_fop_mmap, > > +}; > > + > > +static const struct v4l2_file_operations mtk_jpeg_dec_fops = { > > + .owner = THIS_MODULE, > > + .open = mtk_jpeg_dec_open, > > .release = mtk_jpeg_release, > > .poll = v4l2_m2m_fop_poll, > > .unlocked_ioctl = video_ioctl2, > > @@ -1017,6 +1588,7 @@ static int mtk_jpeg_clk_init(struct mtk_jpeg_dev *jpeg) > > { > > struct device_node *node; > > struct platform_device *pdev; > > + int i; > > > > node = of_parse_phandle(jpeg->dev->of_node, "mediatek,larb", 0); > > if (!node) > > @@ -1030,19 +1602,24 @@ static int mtk_jpeg_clk_init(struct mtk_jpeg_dev *jpeg) > > > > jpeg->larb = &pdev->dev; > > > > - jpeg->clk_jdec = devm_clk_get(jpeg->dev, "jpgdec"); > > - if (IS_ERR(jpeg->clk_jdec)) > > - return PTR_ERR(jpeg->clk_jdec); > > + for (i = 0; i < jpeg->variant->num_clocks; i++) { > > + jpeg->clocks[i] = devm_clk_get(jpeg->dev, > > + jpeg->variant->clk_names[i]); > > + if (IS_ERR(jpeg->clocks[i])) { > > + dev_err(&pdev->dev, "failed to get clock: %s\n", > > + jpeg->variant->clk_names[i]); > > + return PTR_ERR(jpeg->clocks[i]); > > + } > > + } > > > > - jpeg->clk_jdec_smi = devm_clk_get(jpeg->dev, "jpgdec-smi"); > > - return PTR_ERR_OR_ZERO(jpeg->clk_jdec_smi); > > + return 0; > > } > > > > static int mtk_jpeg_probe(struct platform_device *pdev) > > { > > struct mtk_jpeg_dev *jpeg; > > struct resource *res; > > - int dec_irq; > > + int jpeg_irq; > > int ret; > > > > jpeg = devm_kzalloc(&pdev->dev, sizeof(*jpeg), GFP_KERNEL); > > @@ -1052,25 +1629,30 @@ static int mtk_jpeg_probe(struct platform_device *pdev) > > mutex_init(&jpeg->lock); > > spin_lock_init(&jpeg->hw_lock); > > jpeg->dev = &pdev->dev; > > + jpeg->variant = of_device_get_match_data(jpeg->dev); > > > > res = platform_get_resource(pdev, IORESOURCE_MEM, 0); > > - jpeg->dec_reg_base = devm_ioremap_resource(&pdev->dev, res); > > - if (IS_ERR(jpeg->dec_reg_base)) { > > - ret = PTR_ERR(jpeg->dec_reg_base); > > + jpeg->reg_base = devm_ioremap_resource(&pdev->dev, res); > > + if (IS_ERR(jpeg->reg_base)) { > > + ret = PTR_ERR(jpeg->reg_base); > > return ret; > > } > > > > - dec_irq = platform_get_irq(pdev, 0); > > - if (dec_irq < 0) { > > - dev_err(&pdev->dev, "Failed to get dec_irq %d.\n", dec_irq); > > - return dec_irq; > > + jpeg_irq = platform_get_irq(pdev, 0); > > + if (jpeg_irq < 0) { > > + dev_err(&pdev->dev, "Failed to get jpeg_irq %d.\n", jpeg_irq); > > + return jpeg_irq; > > } > > > > - ret = devm_request_irq(&pdev->dev, dec_irq, mtk_jpeg_dec_irq, 0, > > - pdev->name, jpeg); > > + if (jpeg->variant->is_encoder) > > + ret = devm_request_irq(&pdev->dev, jpeg_irq, mtk_jpeg_enc_irq, > > + 0, pdev->name, jpeg); > > + else > > + ret = devm_request_irq(&pdev->dev, jpeg_irq, mtk_jpeg_dec_irq, > > + 0, pdev->name, jpeg); > > if (ret) { > > - dev_err(&pdev->dev, "Failed to request dec_irq %d (%d)\n", > > - dec_irq, ret); > > + dev_err(&pdev->dev, "Failed to request jpeg_irq %d (%d)\n", > > + jpeg_irq, ret); > > goto err_req_irq; > > } > > > > @@ -1087,40 +1669,50 @@ static int mtk_jpeg_probe(struct platform_device *pdev) > > goto err_dev_register; > > } > > > > - jpeg->m2m_dev = v4l2_m2m_init(&mtk_jpeg_m2m_ops); > > + if (jpeg->variant->is_encoder) > > + jpeg->m2m_dev = v4l2_m2m_init(&mtk_jpeg_enc_m2m_ops); > > + else > > + jpeg->m2m_dev = v4l2_m2m_init(&mtk_jpeg_dec_m2m_ops); > > if (IS_ERR(jpeg->m2m_dev)) { > > v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n"); > > ret = PTR_ERR(jpeg->m2m_dev); > > goto err_m2m_init; > > } > > > > - jpeg->dec_vdev = video_device_alloc(); > > - if (!jpeg->dec_vdev) { > > + jpeg->vdev = video_device_alloc(); > > + if (!jpeg->vdev) { > > ret = -ENOMEM; > > - goto err_dec_vdev_alloc; > > + goto err_vfd_jpeg_alloc; > > } > > - snprintf(jpeg->dec_vdev->name, sizeof(jpeg->dec_vdev->name), > > - "%s-dec", MTK_JPEG_NAME); > > - jpeg->dec_vdev->fops = &mtk_jpeg_fops; > > - jpeg->dec_vdev->ioctl_ops = &mtk_jpeg_ioctl_ops; > > - jpeg->dec_vdev->minor = -1; > > - jpeg->dec_vdev->release = video_device_release; > > - jpeg->dec_vdev->lock = &jpeg->lock; > > - jpeg->dec_vdev->v4l2_dev = &jpeg->v4l2_dev; > > - jpeg->dec_vdev->vfl_dir = VFL_DIR_M2M; > > - jpeg->dec_vdev->device_caps = V4L2_CAP_STREAMING | > > + snprintf(jpeg->vdev->name, sizeof(jpeg->vdev->name), > > + "%s-%s", MTK_JPEG_NAME, > > + jpeg->variant->is_encoder ? "enc" : "dec"); > > + if (jpeg->variant->is_encoder) { > > + jpeg->vdev->fops = &mtk_jpeg_enc_fops; > > + jpeg->vdev->ioctl_ops = &mtk_jpeg_enc_ioctl_ops; > > + } else { > > + jpeg->vdev->fops = &mtk_jpeg_dec_fops; > > + jpeg->vdev->ioctl_ops = &mtk_jpeg_dec_ioctl_ops; > > + } > > + jpeg->vdev->minor = -1; > > + jpeg->vdev->release = video_device_release; > > + jpeg->vdev->lock = &jpeg->lock; > > + jpeg->vdev->v4l2_dev = &jpeg->v4l2_dev; > > + jpeg->vdev->vfl_dir = VFL_DIR_M2M; > > + jpeg->vdev->device_caps = V4L2_CAP_STREAMING | > > V4L2_CAP_VIDEO_M2M_MPLANE; > > > > - ret = video_register_device(jpeg->dec_vdev, VFL_TYPE_GRABBER, -1); > > + ret = video_register_device(jpeg->vdev, VFL_TYPE_GRABBER, -1); > > if (ret) { > > v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n"); > > - goto err_dec_vdev_register; > > + goto err_vfd_jpeg_register; > > } > > > > - video_set_drvdata(jpeg->dec_vdev, jpeg); > > + video_set_drvdata(jpeg->vdev, jpeg); > > v4l2_info(&jpeg->v4l2_dev, > > - "decoder device registered as /dev/video%d (%d,%d)\n", > > - jpeg->dec_vdev->num, VIDEO_MAJOR, jpeg->dec_vdev->minor); > > + "jpeg %s device registered as /dev/video%d (%d,%d)\n", > > + jpeg->variant->is_encoder ? "enc" : "dec", jpeg->vdev->num, > > + VIDEO_MAJOR, jpeg->vdev->minor); > > > > platform_set_drvdata(pdev, jpeg); > > > > @@ -1128,10 +1720,10 @@ static int mtk_jpeg_probe(struct platform_device *pdev) > > > > return 0; > > > > -err_dec_vdev_register: > > - video_device_release(jpeg->dec_vdev); > > +err_vfd_jpeg_register: > > + video_device_release(jpeg->vdev); > > > > -err_dec_vdev_alloc: > > +err_vfd_jpeg_alloc: > > v4l2_m2m_release(jpeg->m2m_dev); > > > > err_m2m_init: > > @@ -1151,8 +1743,8 @@ static int mtk_jpeg_remove(struct platform_device *pdev) > > struct mtk_jpeg_dev *jpeg = platform_get_drvdata(pdev); > > > > pm_runtime_disable(&pdev->dev); > > - video_unregister_device(jpeg->dec_vdev); > > - video_device_release(jpeg->dec_vdev); > > + video_unregister_device(jpeg->vdev); > > + video_device_release(jpeg->vdev); > > v4l2_m2m_release(jpeg->m2m_dev); > > v4l2_device_unregister(&jpeg->v4l2_dev); > > > > @@ -1211,14 +1803,36 @@ static const struct dev_pm_ops mtk_jpeg_pm_ops = { > > SET_RUNTIME_PM_OPS(mtk_jpeg_pm_suspend, mtk_jpeg_pm_resume, NULL) > > }; > > > > +static struct mtk_jpeg_variant mt8173_jpeg_drvdata = { > > + .is_encoder = false, > > + .clk_names = {"jpgdec-smi", "jpgdec"}, > > + .num_clocks = 2, > > +}; > > + > > +static struct mtk_jpeg_variant mt2701_jpeg_drvdata = { > > + .is_encoder = false, > > + .clk_names = {"jpgdec-smi", "jpgdec"}, > > + .num_clocks = 2, > > +}; > > + > > +static struct mtk_jpeg_variant mtk_jpeg_drvdata = { > > + .is_encoder = true, > > + .clk_names = {"jpgenc"}, > > + .num_clocks = 1, > > +}; > > + > > static const struct of_device_id mtk_jpeg_match[] = { > > { > > .compatible = "mediatek,mt8173-jpgdec", > > - .data = NULL, > > + .data = &mt8173_jpeg_drvdata, > > }, > > { > > .compatible = "mediatek,mt2701-jpgdec", > > - .data = NULL, > > + .data = &mt2701_jpeg_drvdata, > > + }, > > + { > > + .compatible = "mediatek,mtk-jpgenc", > > + .data = &mtk_jpeg_drvdata, > > }, > > {}, > > }; > > diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h > > index 9bbd615b1067..8f80f2a69d45 100644 > > --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h > > +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_core.h > > @@ -3,6 +3,7 @@ > > * Copyright (c) 2016 MediaTek Inc. > > * Author: Ming Hsiu Tsai > > * Rick Chang > > + * Xia Jiang > > */ > > > > #ifndef _MTK_JPEG_CORE_H > > @@ -16,19 +17,21 @@ > > #define MTK_JPEG_NAME "mtk-jpeg" > > > > #define MTK_JPEG_COMP_MAX 3 > > +#define MTK_JPEG_MAX_CLOCKS 2 > > + > > > > #define MTK_JPEG_FMT_FLAG_DEC_OUTPUT BIT(0) > > #define MTK_JPEG_FMT_FLAG_DEC_CAPTURE BIT(1) > > - > > -#define MTK_JPEG_FMT_TYPE_OUTPUT 1 > > -#define MTK_JPEG_FMT_TYPE_CAPTURE 2 > > +#define MTK_JPEG_FMT_FLAG_ENC_OUTPUT BIT(2) > > +#define MTK_JPEG_FMT_FLAG_ENC_CAPTURE BIT(3) > > > > #define MTK_JPEG_MIN_WIDTH 32U > > #define MTK_JPEG_MIN_HEIGHT 32U > > -#define MTK_JPEG_MAX_WIDTH 8192U > > -#define MTK_JPEG_MAX_HEIGHT 8192U > > +#define MTK_JPEG_MAX_WIDTH 65535U > > +#define MTK_JPEG_MAX_HEIGHT 65535U > > > > #define MTK_JPEG_DEFAULT_SIZEIMAGE (1 * 1024 * 1024) > > +#define MTK_JPEG_DEFAULT_EXIF_SIZE (64 * 1024) > > > > /** > > * enum mtk_jpeg_ctx_state - contex state of jpeg > > @@ -39,6 +42,18 @@ enum mtk_jpeg_ctx_state { > > MTK_JPEG_SOURCE_CHANGE, > > }; > > > > +/** > > + * mtk_jpeg_variant - mtk jpeg driver variant > > + * @is_encoder: driver mode is jpeg encoder > > + * @clk_names: clock names > > + * @num_clocks: numbers of clock > > + */ > > +struct mtk_jpeg_variant { > > + bool is_encoder; > > + const char *clk_names[MTK_JPEG_MAX_CLOCKS]; > > + int num_clocks; > > +}; > > + > > /** > > * struct mt_jpeg - JPEG IP abstraction > > * @lock: the mutex protecting this structure > > @@ -48,11 +63,11 @@ enum mtk_jpeg_ctx_state { > > * @v4l2_dev: v4l2 device for mem2mem mode > > * @m2m_dev: v4l2 mem2mem device data > > * @alloc_ctx: videobuf2 memory allocator's context > > - * @dec_vdev: video device node for decoder mem2mem mode > > - * @dec_reg_base: JPEG registers mapping > > - * @clk_jdec: JPEG hw working clock > > - * @clk_jdec_smi: JPEG SMI bus clock > > + * @vdev: video device node for jpeg mem2mem mode > > + * @reg_base: JPEG registers mapping > > * @larb: SMI device > > + * @clocks: JPEG IP clock(s) > > + * @variant: driver variant to be used > > */ > > struct mtk_jpeg_dev { > > struct mutex lock; > > @@ -62,16 +77,17 @@ struct mtk_jpeg_dev { > > struct v4l2_device v4l2_dev; > > struct v4l2_m2m_dev *m2m_dev; > > void *alloc_ctx; > > - struct video_device *dec_vdev; > > - void __iomem *dec_reg_base; > > - struct clk *clk_jdec; > > - struct clk *clk_jdec_smi; > > + struct video_device *vdev; > > + void __iomem *reg_base; > > struct device *larb; > > + struct clk *clocks[MTK_JPEG_MAX_CLOCKS]; > > + const struct mtk_jpeg_variant *variant; > > }; > > > > /** > > * struct jpeg_fmt - driver's internal color format data > > * @fourcc: the fourcc code, 0 if not applicable > > + * @hw_format: hardware format value > > * @h_sample: horizontal sample count of plane in 4 * 4 pixel image > > * @v_sample: vertical sample count of plane in 4 * 4 pixel image > > * @colplanes: number of color planes (1 for packed formats) > > @@ -81,6 +97,7 @@ struct mtk_jpeg_dev { > > */ > > struct mtk_jpeg_fmt { > > u32 fourcc; > > + u32 hw_format; > > int h_sample[VIDEO_MAX_PLANES]; > > int v_sample[VIDEO_MAX_PLANES]; > > int colplanes; > > @@ -113,6 +130,10 @@ struct mtk_jpeg_q_data { > > * @cap_q: destination (capture) queue queue information > > * @fh: V4L2 file handle > > * @state: state of the context > > + * @enable_exif: enable exif mode of jpeg encoder > > + * @enc_quality: jpeg encoder quality > > + * @restart_interval: jpeg encoder restart interval > > + * @ctrl_hdl: controls handler > > * @colorspace: enum v4l2_colorspace; supplemental to pixelformat > > * @ycbcr_enc: enum v4l2_ycbcr_encoding, Y'CbCr encoding > > * @quantization: enum v4l2_quantization, colorspace quantization > > @@ -124,6 +145,10 @@ struct mtk_jpeg_ctx { > > struct mtk_jpeg_q_data cap_q; > > struct v4l2_fh fh; > > enum mtk_jpeg_ctx_state state; > > + bool enable_exif; > > + u8 enc_quality; > > + u8 restart_interval; > > + struct v4l2_ctrl_handler ctrl_hdl; > > > > enum v4l2_colorspace colorspace; > > enum v4l2_ycbcr_encoding ycbcr_enc; > > diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.h > > index 1cc37dbfc8e7..ce263db5f30a 100644 > > --- a/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.h > > +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_dec_hw.h > > @@ -3,10 +3,11 @@ > > * Copyright (c) 2016 MediaTek Inc. > > * Author: Ming Hsiu Tsai > > * Rick Chang > > + * Xia Jiang > > */ > > > > -#ifndef _MTK_JPEG_HW_H > > -#define _MTK_JPEG_HW_H > > +#ifndef _MTK_JPEG_DEC_HW_H > > +#define _MTK_JPEG_DEC_HW_H > > > > #include > > > > @@ -75,4 +76,4 @@ void mtk_jpeg_dec_set_config(void __iomem *base, > > void mtk_jpeg_dec_reset(void __iomem *dec_reg_base); > > void mtk_jpeg_dec_start(void __iomem *dec_reg_base); > > > > -#endif /* _MTK_JPEG_HW_H */ > > +#endif /* _MTK_JPEG_DEC_HW_H */ > > diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c > > new file mode 100644 > > index 000000000000..7fc1de920a75 > > --- /dev/null > > +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.c > > @@ -0,0 +1,193 @@ > > +// SPDX-License-Identifier: GPL-2.0-only > > +/* > > + * Copyright (c) 2019 MediaTek Inc. > > + * Author: Xia Jiang > > + * > > + */ > > + > > +#include > > +#include > > +#include > > + > > +#include "mtk_jpeg_enc_hw.h" > > + > > +static const struct mtk_jpeg_enc_qlt mtk_jpeg_enc_quality[] = { > > + {.quality_param = 34, .hardware_value = JPEG_ENC_QUALITY_Q34}, > > + {.quality_param = 39, .hardware_value = JPEG_ENC_QUALITY_Q39}, > > + {.quality_param = 48, .hardware_value = JPEG_ENC_QUALITY_Q48}, > > + {.quality_param = 60, .hardware_value = JPEG_ENC_QUALITY_Q60}, > > + {.quality_param = 64, .hardware_value = JPEG_ENC_QUALITY_Q64}, > > + {.quality_param = 68, .hardware_value = JPEG_ENC_QUALITY_Q68}, > > + {.quality_param = 74, .hardware_value = JPEG_ENC_QUALITY_Q74}, > > + {.quality_param = 80, .hardware_value = JPEG_ENC_QUALITY_Q80}, > > + {.quality_param = 82, .hardware_value = JPEG_ENC_QUALITY_Q82}, > > + {.quality_param = 84, .hardware_value = JPEG_ENC_QUALITY_Q84}, > > + {.quality_param = 87, .hardware_value = JPEG_ENC_QUALITY_Q87}, > > + {.quality_param = 90, .hardware_value = JPEG_ENC_QUALITY_Q90}, > > + {.quality_param = 92, .hardware_value = JPEG_ENC_QUALITY_Q92}, > > + {.quality_param = 95, .hardware_value = JPEG_ENC_QUALITY_Q95}, > > + {.quality_param = 97, .hardware_value = JPEG_ENC_QUALITY_Q97}, > > +}; > > + > > +void mtk_jpeg_enc_reset(void __iomem *base) > > +{ > > + writel(0x00, base + JPEG_ENC_RSTB); > > + writel(JPEG_ENC_RESET_BIT, base + JPEG_ENC_RSTB); > > + writel(0x00, base + JPEG_ENC_CODEC_SEL); > > +} > > + > > +u32 mtk_jpeg_enc_get_and_clear_int_status(void __iomem *base) > > +{ > > + u32 ret; > > + > > + ret = readl(base + JPEG_ENC_INT_STS) & > > + JPEG_ENC_INT_STATUS_MASK_ALLIRQ; > > + if (ret) > > + writel(0, base + JPEG_ENC_INT_STS); > > + > > + return ret; > > +} > > + > > +u32 mtk_jpeg_enc_get_file_size(void __iomem *base) > > +{ > > + return readl(base + JPEG_ENC_DMA_ADDR0) - > > + readl(base + JPEG_ENC_DST_ADDR0); > > +} > > + > > +u32 mtk_jpeg_enc_enum_result(void __iomem *base, u32 irq_status) > > +{ > > + if (irq_status & JPEG_ENC_INT_STATUS_DONE) > > + return MTK_JPEG_ENC_RESULT_DONE; > > + else if (irq_status & JPEG_ENC_INT_STATUS_STALL) > > + return MTK_JPEG_ENC_RESULT_STALL; > > + else > > + return MTK_JPEG_ENC_RESULT_VCODEC_IRQ; > > +} > > + > > +void mtk_jpeg_enc_set_img_size(void __iomem *base, u32 width, u32 height) > > +{ > > + u32 value; > > + > > + value = width << 16 | height; > > + writel(value, base + JPEG_ENC_IMG_SIZE); > > +} > > + > > +void mtk_jpeg_enc_set_blk_num(void __iomem *base, u32 enc_format, u32 width, > > + u32 height) > > +{ > > + u32 blk_num; > > + u32 is_420; > > + u32 padding_width; > > + u32 padding_height; > > + u32 luma_blocks; > > + u32 chroma_blocks; > > + > > + is_420 = (enc_format == V4L2_PIX_FMT_NV12M || > > + enc_format == V4L2_PIX_FMT_NV21M) ? 1 : 0; > > + padding_width = round_up(width, 16); > > + padding_height = round_up(height, is_420 ? 16 : 8); > > + > > + luma_blocks = padding_width / 8 * padding_height / 8; > > + if (is_420) > > + chroma_blocks = luma_blocks / 4; > > + else > > + chroma_blocks = luma_blocks / 2; > > + > > + blk_num = luma_blocks + 2 * chroma_blocks - 1; > > + > > + writel(blk_num, base + JPEG_ENC_BLK_NUM); > > +} > > + > > +void mtk_jpeg_enc_set_stride(void __iomem *base, u32 enc_format, u32 width, > > + u32 height, u32 bytesperline) > > +{ > > + u32 img_stride; > > + u32 mem_stride; > > + > > + if (enc_format == V4L2_PIX_FMT_NV12M || > > + enc_format == V4L2_PIX_FMT_NV21M) { > > + img_stride = round_up(width, 16); > > + mem_stride = bytesperline; > > + } else { > > + img_stride = round_up(width * 2, 32); > > + mem_stride = img_stride; > > + } > > + > > + writel(img_stride, base + JPEG_ENC_IMG_STRIDE); > > + writel(mem_stride, base + JPEG_ENC_STRIDE); > > +} > > + > > +void mtk_jpeg_enc_set_src_addr(void __iomem *base, u32 src_addr, > > + u32 plane_index) > > +{ > > + if (!plane_index) > > + writel(src_addr, base + JPEG_ENC_SRC_LUMA_ADDR); > > + else > > + writel(src_addr, base + JPEG_ENC_SRC_CHROMA_ADDR); > > +} > > + > > +void mtk_jpeg_enc_set_dst_addr(void __iomem *base, u32 dst_addr, > > + u32 stall_size, u32 init_offset, > > + u32 offset_mask) > > +{ > > + writel(init_offset & ~0xf, base + JPEG_ENC_OFFSET_ADDR); > > + writel(offset_mask & 0xf, base + JPEG_ENC_BYTE_OFFSET_MASK); > > + writel(dst_addr & ~0xf, base + JPEG_ENC_DST_ADDR0); > > + writel((dst_addr + stall_size) & ~0xf, base + JPEG_ENC_STALL_ADDR0); > > +} > > + > > +static void mtk_jpeg_enc_set_quality(void __iomem *base, u32 quality) > > +{ > > + u32 value; > > + u32 i, enc_quality; > > + > > + enc_quality = mtk_jpeg_enc_quality[0].hardware_value; > > + for (i = 0; i < ARRAY_SIZE(mtk_jpeg_enc_quality); i++) { > > + if (quality <= mtk_jpeg_enc_quality[i].quality_param) { > > + enc_quality = mtk_jpeg_enc_quality[i].hardware_value; > > + break; > > + } > > + } > > + > > + value = readl(base + JPEG_ENC_QUALITY); > > + value = (value & JPEG_ENC_QUALITY_MASK) | enc_quality; > > + writel(value, base + JPEG_ENC_QUALITY); > > +} > > + > > +static void mtk_jpeg_enc_set_ctrl(void __iomem *base, u32 enc_format, > > + bool exif_en, u32 restart_interval) > > +{ > > + u32 value; > > + > > + value = readl(base + JPEG_ENC_CTRL); > > + value &= ~JPEG_ENC_CTRL_YUV_FORMAT_MASK; > > + value |= (enc_format & 3) << 3; > > + if (exif_en) > > + value |= JPEG_ENC_CTRL_FILE_FORMAT_BIT; > > + else > > + value &= ~JPEG_ENC_CTRL_FILE_FORMAT_BIT; > > + if (restart_interval) > > + value |= JPEG_ENC_CTRL_RESTART_EN_BIT; > > + else > > + value &= ~JPEG_ENC_CTRL_RESTART_EN_BIT; > > + writel(value, base + JPEG_ENC_CTRL); > > +} > > + > > +void mtk_jpeg_enc_set_config(void __iomem *base, u32 enc_format, bool exif_en, > > + u32 quality, u32 restart_interval) > > +{ > > + mtk_jpeg_enc_set_quality(base, quality); > > + > > + mtk_jpeg_enc_set_ctrl(base, enc_format, exif_en, restart_interval); > > + > > + writel(restart_interval, base + JPEG_ENC_RST_MCU_NUM); > > +} > > + > > +void mtk_jpeg_enc_start(void __iomem *base) > > +{ > > + u32 value; > > + > > + value = readl(base + JPEG_ENC_CTRL); > > + value |= JPEG_ENC_CTRL_INT_EN_BIT | JPEG_ENC_CTRL_ENABLE_BIT; > > + writel(value, base + JPEG_ENC_CTRL); > > +} > > diff --git a/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h > > new file mode 100644 > > index 000000000000..73faf49b667c > > --- /dev/null > > +++ b/drivers/media/platform/mtk-jpeg/mtk_jpeg_enc_hw.h > > @@ -0,0 +1,123 @@ > > +/* SPDX-License-Identifier: GPL-2.0-only */ > > +/* > > + * Copyright (c) 2019 MediaTek Inc. > > + * Author: Xia Jiang > > + * > > + */ > > + > > +#ifndef _MTK_JPEG_ENC_HW_H > > +#define _MTK_JPEG_ENC_HW_H > > + > > +#include > > + > > +#include "mtk_jpeg_core.h" > > + > > +#define JPEG_ENC_INT_STATUS_DONE BIT(0) > > +#define JPEG_ENC_INT_STATUS_STALL BIT(1) > > +#define JPEG_ENC_INT_STATUS_VCODEC_IRQ BIT(4) > > +#define JPEG_ENC_INT_STATUS_MASK_ALLIRQ 0x13 > > + > > +#define JPEG_ENC_DST_ADDR_OFFSET_MASK GENMASK(3, 0) > > +#define JPEG_ENC_QUALITY_MASK GENMASK(31, 16) > > + > > +#define JPEG_ENC_CTRL_YUV_FORMAT_MASK 0x18 > > +#define JPEG_ENC_CTRL_RESTART_EN_BIT BIT(10) > > +#define JPEG_ENC_CTRL_FILE_FORMAT_BIT BIT(5) > > +#define JPEG_ENC_CTRL_INT_EN_BIT BIT(2) > > +#define JPEG_ENC_CTRL_ENABLE_BIT BIT(0) > > +#define JPEG_ENC_RESET_BIT BIT(0) > > + > > +#define JPEG_ENC_YUV_FORMAT_YUYV 0 > > +#define JPEG_ENC_YUV_FORMAT_YVYU 1 > > +#define JPEG_ENC_YUV_FORMAT_NV12 2 > > +#define JEPG_ENC_YUV_FORMAT_NV21 3 > > + > > +#define JPEG_ENC_QUALITY_Q60 0x0 > > +#define JPEG_ENC_QUALITY_Q80 0x1 > > +#define JPEG_ENC_QUALITY_Q90 0x2 > > +#define JPEG_ENC_QUALITY_Q95 0x3 > > +#define JPEG_ENC_QUALITY_Q39 0x4 > > +#define JPEG_ENC_QUALITY_Q68 0x5 > > +#define JPEG_ENC_QUALITY_Q84 0x6 > > +#define JPEG_ENC_QUALITY_Q92 0x7 > > +#define JPEG_ENC_QUALITY_Q48 0x8 > > +#define JPEG_ENC_QUALITY_Q74 0xa > > +#define JPEG_ENC_QUALITY_Q87 0xb > > +#define JPEG_ENC_QUALITY_Q34 0xc > > +#define JPEG_ENC_QUALITY_Q64 0xe > > +#define JPEG_ENC_QUALITY_Q82 0xf > > +#define JPEG_ENC_QUALITY_Q97 0x10 > > + > > +#define JPEG_ENC_RSTB 0x100 > > +#define JPEG_ENC_CTRL 0x104 > > +#define JPEG_ENC_QUALITY 0x108 > > +#define JPEG_ENC_BLK_NUM 0x10C > > +#define JPEG_ENC_BLK_CNT 0x110 > > +#define JPEG_ENC_INT_STS 0x11c > > +#define JPEG_ENC_DST_ADDR0 0x120 > > +#define JPEG_ENC_DMA_ADDR0 0x124 > > +#define JPEG_ENC_STALL_ADDR0 0x128 > > +#define JPEG_ENC_OFFSET_ADDR 0x138 > > +#define JPEG_ENC_RST_MCU_NUM 0x150 > > +#define JPEG_ENC_IMG_SIZE 0x154 > > +#define JPEG_ENC_DEBUG_INFO0 0x160 > > +#define JPEG_ENC_DEBUG_INFO1 0x164 > > +#define JPEG_ENC_TOTAL_CYCLE 0x168 > > +#define JPEG_ENC_BYTE_OFFSET_MASK 0x16c > > +#define JPEG_ENC_SRC_LUMA_ADDR 0x170 > > +#define JPEG_ENC_SRC_CHROMA_ADDR 0x174 > > +#define JPEG_ENC_STRIDE 0x178 > > +#define JPEG_ENC_IMG_STRIDE 0x17c > > +#define JPEG_ENC_DCM_CTRL 0x300 > > +#define JPEG_ENC_CODEC_SEL 0x314 > > +#define JPEG_ENC_ULTRA_THRES 0x318 > > + > > +enum { > > + MTK_JPEG_ENC_RESULT_DONE, > > + MTK_JPEG_ENC_RESULT_STALL, > > + MTK_JPEG_ENC_RESULT_VCODEC_IRQ > > +}; > > + > > +/** > > + * struct mtk_jpeg_enc_qlt - JPEG encoder quality data > > + * @quality_param: quality value > > + * @hardware_value: hardware value of quality > > + */ > > +struct mtk_jpeg_enc_qlt { > > + u8 quality_param; > > + u8 hardware_value; > > +}; > > + > > +/** > > + * struct mt_jpeg_enc_bs - JPEG encoder bitstream buffer > > + * @dma_addr: JPEG encoder destination address > > + * @size: JPEG encoder bistream size > > + * @dma_addr_offset: JPEG encoder offset address > > + * @dma_addr_offsetmask: JPEG encoder destination address offset mask > > + */ > > +struct mtk_jpeg_enc_bs { > > + dma_addr_t dma_addr; > > + size_t size; > > + u32 dma_addr_offset; > > + u32 dma_addr_offsetmask; > > +}; > > + > > +void mtk_jpeg_enc_reset(void __iomem *base); > > +u32 mtk_jpeg_enc_get_and_clear_int_status(void __iomem *base); > > +u32 mtk_jpeg_enc_get_file_size(void __iomem *base); > > +u32 mtk_jpeg_enc_enum_result(void __iomem *base, u32 irq_status); > > +void mtk_jpeg_enc_set_img_size(void __iomem *base, u32 width, u32 height); > > +void mtk_jpeg_enc_set_blk_num(void __iomem *base, u32 enc_format, u32 width, > > + u32 height); > > +void mtk_jpeg_enc_set_stride(void __iomem *base, u32 enc_format, u32 width, > > + u32 height, u32 bytesperline); > > +void mtk_jpeg_enc_set_src_addr(void __iomem *base, u32 src_addr, > > + u32 plane_index); > > +void mtk_jpeg_enc_set_dst_addr(void __iomem *base, u32 dst_addr, > > + u32 stall_size, u32 init_offset, > > + u32 offset_mask); > > +void mtk_jpeg_enc_set_config(void __iomem *base, u32 enc_format, bool exif_en, > > + u32 quality, u32 restart_interval); > > +void mtk_jpeg_enc_start(void __iomem *enc_reg_base); > > + > > +#endif /* _MTK_JPEG_ENC_HW_H */ > > > _______________________________________________ Linux-mediatek mailing list Linux-mediatek@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-mediatek