From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 321FAC04EB9 for ; Thu, 6 Dec 2018 09:23:07 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 96C3121479 for ; Thu, 6 Dec 2018 09:23:06 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 96C3121479 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=kontron.de Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729320AbeLFJXF (ORCPT ); Thu, 6 Dec 2018 04:23:05 -0500 Received: from skedge04.snt-world.com ([91.208.41.69]:39064 "EHLO skedge04.snt-world.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727806AbeLFJXE (ORCPT ); Thu, 6 Dec 2018 04:23:04 -0500 Received: from sntmail10s.snt-is.com (unknown [10.203.32.183]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by skedge04.snt-world.com (Postfix) with ESMTPS id 0945C67A7D5; Thu, 6 Dec 2018 10:22:53 +0100 (CET) Received: from sntmail12r.snt-is.com (10.203.32.182) by sntmail10s.snt-is.com (10.203.32.183) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.1466.3; Thu, 6 Dec 2018 10:22:52 +0100 Received: from sntmail12r.snt-is.com ([fe80::e551:8750:7bba:3305]) by sntmail12r.snt-is.com ([fe80::e551:8750:7bba:3305%5]) with mapi id 15.01.1466.003; Thu, 6 Dec 2018 10:22:52 +0100 From: Schrempf Frieder To: Yogesh Narayan Gaur , "linux-mtd@lists.infradead.org" , "boris.brezillon@bootlin.com" , "marek.vasut@gmail.com" , "broonie@kernel.org" , "linux-spi@vger.kernel.org" , "devicetree@vger.kernel.org" CC: "robh@kernel.org" , "mark.rutland@arm.com" , "shawnguo@kernel.org" , "linux-arm-kernel@lists.infradead.org" , "computersforpeace@gmail.com" , "linux-kernel@vger.kernel.org" Subject: Re: [PATCH v5 1/5] spi: spi-mem: Add driver for NXP FlexSPI controller Thread-Topic: [PATCH v5 1/5] spi: spi-mem: Add driver for NXP FlexSPI controller Thread-Index: AQHUfZ16K+V2Xzw84ki+MmwTwSKgB6VxfoaA Date: Thu, 6 Dec 2018 09:22:52 +0000 Message-ID: References: <1542366701-16065-1-git-send-email-yogeshnarayan.gaur@nxp.com> <1542366701-16065-2-git-send-email-yogeshnarayan.gaur@nxp.com> In-Reply-To: <1542366701-16065-2-git-send-email-yogeshnarayan.gaur@nxp.com> Accept-Language: de-DE, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [172.25.9.43] x-c2processedorg: 51b406b7-48a2-4d03-b652-521f56ac89f3 Content-Type: text/plain; charset="utf-8" Content-ID: <70157C6BFF32D04889CA366D5BC29377@snt-world.com> Content-Transfer-Encoding: base64 MIME-Version: 1.0 X-SnT-MailScanner-Information: Please contact the ISP for more information X-SnT-MailScanner-ID: 0945C67A7D5.A6035 X-SnT-MailScanner: Found to be clean X-SnT-MailScanner-SpamCheck: X-SnT-MailScanner-From: frieder.schrempf@kontron.de X-SnT-MailScanner-To: boris.brezillon@bootlin.com, broonie@kernel.org, computersforpeace@gmail.com, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-mtd@lists.infradead.org, linux-spi@vger.kernel.org, marek.vasut@gmail.com, mark.rutland@arm.com, robh@kernel.org, shawnguo@kernel.org, yogeshnarayan.gaur@nxp.com Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org SGkgWW9nZXNoLA0KDQpJJ3ZlIGhhZCBhIGNsb3NlciBsb29rIGF0IHlvdXIgdjUuIFNlZSBteSBj b21tZW50cyBiZWxvdy4NCg0KT24gMTYuMTEuMTggMTI6MTMsIFlvZ2VzaCBOYXJheWFuIEdhdXIg d3JvdGU6DQo+IC0gQWRkIGRyaXZlciBmb3IgTlhQIEZsZXhTUEkgaG9zdCBjb250cm9sbGVyDQo+ IA0KPiAoMCkgV2hhdCBpcyB0aGUgRmxleFNQSSBjb250cm9sbGVyPw0KPiAgIEZsZXhTUEkgaXMg YSBmbGV4c2libGUgU1BJIGhvc3QgY29udHJvbGxlciB3aGljaCBzdXBwb3J0cyB0d28gU1BJDQo+ ICAgY2hhbm5lbHMgYW5kIHVwIHRvIDQgZXh0ZXJuYWwgZGV2aWNlcy4gRWFjaCBjaGFubmVsIHN1 cHBvcnRzDQo+ICAgU2luZ2xlL0R1YWwvUXVhZC9PY3RhbCBtb2RlIGRhdGEgdHJhbnNmZXIgKDEv Mi80LzggYmlkaXJlY3Rpb25hbA0KPiAgIGRhdGEgbGluZXMpIGkuZS4gRmxleFNQSSBhY3RzIGFz IGFuIGludGVyZmFjZSB0byBleHRlcm5hbCBkZXZpY2VzLA0KPiAgIG1heGltdW0gNCwgZWFjaCB3 aXRoIHVwIHRvIDggYmlkaXJlY3Rpb25hbCBkYXRhIGxpbmVzLg0KPiANCj4gICBJdCB1c2VzIG5l dyBTUEkgbWVtb3J5IGludGVyZmFjZSBvZiB0aGUgU1BJIGZyYW1ld29yayB0byBpc3N1ZQ0KPiAg IGZsYXNoIG1lbW9yeSBvcGVyYXRpb25zIHRvIHVwIHRvIGZvdXIgY29ubmVjdGVkIGZsYXNoDQo+ ICAgZGV2aWNlcyAoMiBidXNlcyB3aXRoIDIgQ1MgZWFjaCkuDQo+IA0KPiAoMSkgVGVzdGVkIHRo aXMgZHJpdmVyIHdpdGggdGhlIG10ZF9kZWJ1ZyBhbmQgSkZGUzIgZmlsZXN5c3RlbSB1dGlsaXR5 DQo+ICAgb24gTlhQIExYMjE2MEFSREIgYW5kIExYMjE2MEFRRFMgdGFyZ2V0cy4NCj4gICBMWDIx NjBBUkRCIGlzIGhhdmluZyB0d28gTk9SIHNsYXZlIGRldmljZSBjb25uZWN0ZWQgb24gc2luZ2xl IGJ1cyBBDQo+ICAgaS5lLiBBMCBhbmQgQTEgKENTMCBhbmQgQ1MxKS4NCj4gICBMWDIxNjBBUURT IGlzIGhhdmluZyB0d28gTk9SIHNsYXZlIGRldmljZSBjb25uZWN0ZWQgb24gc2VwYXJhdGUgYnVz ZXMNCj4gICBvbmUgZmxhc2ggb24gQTAgYW5kIHNlY29uZCBvbiBCMSBpLmUuIChDUzAgYW5kIENT MykuDQo+ICAgVmVyaWZpZWQgdGhpcyBkcml2ZXIgb24gZm9sbG93aW5nIFNQSSBOT1IgZmxhc2hl czoNCj4gICAgICBNaWNyb24sIG10MzV4dTUxMmFiLCBbUmVhZCAtIDEgYml0IG1vZGVdDQo+ICAg ICAgQ3lwcmVzcywgczI1Zmw1MTJzLCBbUmVhZCAtIDEvMi80IGJpdCBtb2RlXQ0KPiANCj4gU2ln bmVkLW9mZi1ieTogWW9nZXNoIEdhdXIgPHlvZ2VzaG5hcmF5YW4uZ2F1ckBueHAuY29tPg0KPiAt LS0NCj4gQ2hhbmdlcyBmb3IgdjU6DQo+IC0gUmViYXNlIG9uIHRvcCBvZiB2NC4yMC1yYzINCj4g LSBNb2RpZmllZCBmc3BpX3JlYWRsX3BvbGxfdG91dCgpIGFzIHBlciByZXZpZXcgY29tbWVudHMN Cj4gLSBBcnJhbmdlIGhlYWRlciBmaWxlIGluIGFscGhhYmV0aWNhbCBvcmRlcg0KPiAtIFJlbW92 ZWQgdXNhZ2Ugb2YgcmVhZCgpL3dyaXRlKCkgZnVuY3Rpb24gY2FsbGJhY2sgcG9pbnRlcg0KPiAt IEFkZCBzdXBwb3J0IGZvciAxIGFuZCAyIGJ5dGUgYWRkcmVzcyBsZW5ndGgNCj4gLSBDaGFuZ2Ug RnJpZWRlciBlLW1haWwgdG8gbmV3IGUtbWFpbCBhZGRyZXNzDQo+IENoYW5nZXMgZm9yIHY0Og0K PiAtIEluY29ycG9yYXRlIEJvcmlzIHJldmlldyBjb21tZW50cw0KPiAgICAqIFVzZSByZWFkbF9w b2xsX3RpbWVvdXQoKSBpbnN0ZWFkIG9mIGJ1c3kgbG9vcGluZy4NCj4gICAgKiBSZS1kZWZpbmUg cmVnaXN0ZXIgbWFza2luZyBhcyBwZXIgY29tbWVudC4NCj4gICAgKiBEcm9wIGZzcGlfZGV2dHlw ZSBlbnVtLg0KPiBDaGFuZ2VzIGZvciB2MzoNCj4gLSBBZGRlZCBlbmRpYW5uZXNzIGZsYWcgaW4g cGxhdGZvcm0gc3BlY2lmaWMgc3RydWN0dXJlIGluc3RlYWQgb2YgRFRTLg0KPiAtIE1vZGlmaWVk IG54cF9mc3BpX3JlYWRfYWhiKCksIHJlbW92ZWQgcmVtYXBwaW5nIGNvZGUuDQo+IC0gQWRkZWQg Qm9yaXMgYW5kIEZyaWVkZXIgYXMgQXV0aG9yIGFuZCBwcm92aWRlZCByZWZlcmVuY2Ugb2Ygc3Bp LWZzbC1xc3BpLmMNCj4gQ2hhbmdlcyBmb3IgdjI6DQo+IC0gSW5jb3Jwb3JhdGVkIEJvcmlzIHJl dmlldyBjb21tZW50cy4NCj4gLSBSZW1vdmUgZGVwZW5kZW5jeSBvZiBkcml2ZXIgb3ZlciBjb25u ZWN0ZWQgZmxhc2ggZGV2aWNlIHNpemUuDQo+IC0gTW9kaWZpZWQgdGhlIGxvZ2ljIHRvIHNlbGVj dCByZXF1ZXN0ZWQgQ1MuDQo+IC0gUmVtb3ZlIFNQSS1PY3RhbCBNYWNyb3MuDQo+IA0KPiAgIGRy aXZlcnMvc3BpL0tjb25maWcgICAgICAgIHwgICAxMCArDQo+ICAgZHJpdmVycy9zcGkvTWFrZWZp bGUgICAgICAgfCAgICAxICsNCj4gICBkcml2ZXJzL3NwaS9zcGktbnhwLWZzcGkuYyB8IDExNDUg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysNCj4gICAzIGZpbGVz IGNoYW5nZWQsIDExNTYgaW5zZXJ0aW9ucygrKQ0KPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL3NwaS9zcGktbnhwLWZzcGkuYw0KPiANCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL0tj b25maWcgYi9kcml2ZXJzL3NwaS9LY29uZmlnDQo+IGluZGV4IDdkM2E1YzkuLjM2NjMwYTEgMTAw NjQ0DQo+IC0tLSBhL2RyaXZlcnMvc3BpL0tjb25maWcNCj4gKysrIGIvZHJpdmVycy9zcGkvS2Nv bmZpZw0KPiBAQCAtMjU5LDYgKzI1OSwxNiBAQCBjb25maWcgU1BJX0ZTTF9MUFNQSQ0KPiAgIAlo ZWxwDQo+ICAgCSAgVGhpcyBlbmFibGVzIEZyZWVzY2FsZSBpLk1YIExQU1BJIGNvbnRyb2xsZXJz IGluIG1hc3RlciBtb2RlLg0KPiAgIA0KPiArY29uZmlnIFNQSV9OWFBfRkxFWFNQSQ0KPiArCXRy aXN0YXRlICJOWFAgRmxleCBTUEkgY29udHJvbGxlciINCj4gKwlkZXBlbmRzIG9uIEFSQ0hfTEFZ RVJTQ0FQRSB8fCBIQVNfSU9NRU0NCj4gKwloZWxwDQo+ICsJICBUaGlzIGVuYWJsZXMgc3VwcG9y dCBmb3IgdGhlIEZsZXggU1BJIGNvbnRyb2xsZXIgaW4gbWFzdGVyIG1vZGUuDQo+ICsJICBVcCB0 byBmb3VyIHNsYXZlIGRldmljZXMgY2FuIGJlIGNvbm5lY3RlZCBvbiB0d28gYnVzZXMgd2l0aCB0 d28NCj4gKwkgIGNoaXBzZWxlY3RzIGVhY2guDQo+ICsJICBUaGlzIGNvbnRyb2xsZXIgZG9lcyBu b3Qgc3VwcG9ydCBnZW5lcmljIFNQSSBtZXNzYWdlcyBhbmQgb25seQ0KPiArCSAgc3VwcG9ydHMg dGhlIGhpZ2gtbGV2ZWwgU1BJIG1lbW9yeSBpbnRlcmZhY2UuDQo+ICsNCj4gICBjb25maWcgU1BJ X0dQSU8NCj4gICAJdHJpc3RhdGUgIkdQSU8tYmFzZWQgYml0YmFuZ2luZyBTUEkgTWFzdGVyIg0K PiAgIAlkZXBlbmRzIG9uIEdQSU9MSUIgfHwgQ09NUElMRV9URVNUDQo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL3NwaS9NYWtlZmlsZSBiL2RyaXZlcnMvc3BpL01ha2VmaWxlDQo+IGluZGV4IDM1NzUy MDUuLjU1ZmVjNWMgMTAwNjQ0DQo+IC0tLSBhL2RyaXZlcnMvc3BpL01ha2VmaWxlDQo+ICsrKyBi L2RyaXZlcnMvc3BpL01ha2VmaWxlDQo+IEBAIC02MCw2ICs2MCw3IEBAIG9iai0kKENPTkZJR19T UElfTVBDNTJ4eCkJCSs9IHNwaS1tcGM1Mnh4Lm8NCj4gICBvYmotJChDT05GSUdfU1BJX01UNjVY WCkgICAgICAgICAgICAgICAgKz0gc3BpLW10NjV4eC5vDQo+ICAgb2JqLSQoQ09ORklHX1NQSV9N WFMpCQkJKz0gc3BpLW14cy5vDQo+ICAgb2JqLSQoQ09ORklHX1NQSV9OVUM5MDApCQkrPSBzcGkt bnVjOTAwLm8NCj4gK29iai0kKENPTkZJR19TUElfTlhQX0ZMRVhTUEkpCQkrPSBzcGktbnhwLWZz cGkubw0KPiAgIG9iai0kKENPTkZJR19TUElfT0NfVElOWSkJCSs9IHNwaS1vYy10aW55Lm8NCj4g ICBzcGktb2N0ZW9uLW9ianMJCQkJOj0gc3BpLWNhdml1bS5vIHNwaS1jYXZpdW0tb2N0ZW9uLm8N Cj4gICBvYmotJChDT05GSUdfU1BJX09DVEVPTikJCSs9IHNwaS1vY3Rlb24ubw0KPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9zcGkvc3BpLW54cC1mc3BpLmMgYi9kcml2ZXJzL3NwaS9zcGktbnhwLWZz cGkuYw0KPiBuZXcgZmlsZSBtb2RlIDEwMDY0NA0KPiBpbmRleCAwMDAwMDAwLi5hMzUwMTNiDQo+ IC0tLSAvZGV2L251bGwNCj4gKysrIGIvZHJpdmVycy9zcGkvc3BpLW54cC1mc3BpLmMNCj4gQEAg LTAsMCArMSwxMTQ1IEBADQo+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsN Cj4gKw0KPiArLyoNCj4gKyAqIE5YUCBGbGV4U1BJKEZTUEkpIGNvbnRyb2xsZXIgZHJpdmVyLg0K PiArICoNCj4gKyAqIENvcHlyaWdodCAyMDE4IE5YUC4NCj4gKyAqDQo+ICsgKiBGbGV4U1BJIGlz IGEgZmxleHNpYmxlIFNQSSBob3N0IGNvbnRyb2xsZXIgd2hpY2ggc3VwcG9ydHMgdHdvIFNQSQ0K PiArICogY2hhbm5lbHMgYW5kIHVwIHRvIDQgZXh0ZXJuYWwgZGV2aWNlcy4gRWFjaCBjaGFubmVs IHN1cHBvcnRzDQo+ICsgKiBTaW5nbGUvRHVhbC9RdWFkL09jdGFsIG1vZGUgZGF0YSB0cmFuc2Zl ciAoMS8yLzQvOCBiaWRpcmVjdGlvbmFsDQo+ICsgKiBkYXRhIGxpbmVzKS4NCj4gKyAqDQo+ICsg KiBGbGV4U1BJIGNvbnRyb2xsZXIgaXMgZHJpdmVuIGJ5IHRoZSBMVVQoTG9vay11cCBUYWJsZSkg cmVnaXN0ZXJzDQo+ICsgKiBMVVQgcmVnaXN0ZXJzIGFyZSBhIGxvb2stdXAtdGFibGUgZm9yIHNl cXVlbmNlcyBvZiBpbnN0cnVjdGlvbnMuDQo+ICsgKiBBIHZhbGlkIHNlcXVlbmNlIGNvbnNpc3Rz IG9mIGZvdXIgTFVUIHJlZ2lzdGVycy4NCj4gKyAqIE1heGltdW0gMzIgTFVUIHNlcXVlbmNlcyBj YW4gYmUgcHJvZ3JhbW1lZCBzaW11bHRhbmVvdXNseS4NCj4gKyAqDQo+ICsgKiBMVVRzIGFyZSBi ZWluZyBjcmVhdGVkIGF0IHJ1bi10aW1lIGJhc2VkIG9uIHRoZSBjb21tYW5kcyBwYXNzZWQNCj4g KyAqIGZyb20gdGhlIHNwaS1tZW0gZnJhbWV3b3JrLCB0aHVzIHVzaW5nIHNpbmdsZSBMVVQgaW5k ZXguDQo+ICsgKg0KPiArICogU29mdHdhcmUgdHJpZ2dlcmVkIEZsYXNoIHJlYWQvd3JpdGUgYWNj ZXNzIGJ5IElQIEJ1cy4NCj4gKyAqDQo+ICsgKiBNZW1vcnkgbWFwcGVkIHJlYWQgYWNjZXNzIGJ5 IEFIQiBCdXMuDQo+ICsgKg0KPiArICogQmFzZWQgb24gU1BJIE1FTSBpbnRlcmZhY2UgYW5kIHNw aS1mc2wtcXNwaS5jIGRyaXZlci4NCj4gKyAqDQo+ICsgKiBBdXRob3I6DQo+ICsgKiAgICAgWW9n ZXNoIEdhdXIgPHlvZ2VzaG5hcmF5YW4uZ2F1ckBueHAuY29tPg0KPiArICogICAgIEJvcmlzIEJy ZXppbGxpb24gPGJvcmlzLmJyZXppbGxvbkBib290bGluLmNvbT4NCj4gKyAqICAgICBGcmllZGVy IFNjaHJlbXBmIDxmcmllZGVyLnNjaHJlbXBmQGtvbnRyb24uZGU+DQo+ICsgKi8NCj4gKw0KPiAr I2luY2x1ZGUgPGxpbnV4L2JpdG9wcy5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L2Nsay5oPg0KPiAr I2luY2x1ZGUgPGxpbnV4L2NvbXBsZXRpb24uaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9kZWxheS5o Pg0KPiArI2luY2x1ZGUgPGxpbnV4L2Vyci5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+ DQo+ICsjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+DQo+ICsjaW5jbHVkZSA8bGludXgvaW8u aD4NCj4gKyNpbmNsdWRlIDxsaW51eC9pb3BvbGwuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9qaWZm aWVzLmg+DQo+ICsjaW5jbHVkZSA8bGludXgva2VybmVsLmg+DQo+ICsjaW5jbHVkZSA8bGludXgv bW9kdWxlLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4NCj4gKyNpbmNsdWRlIDxsaW51 eC9vZi5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L29mX2RldmljZS5oPg0KPiArI2luY2x1ZGUgPGxp bnV4L3BsYXRmb3JtX2RldmljZS5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L3BtX3Fvcy5oPg0KPiAr I2luY2x1ZGUgPGxpbnV4L3NpemVzLmg+DQo+ICsNCj4gKyNpbmNsdWRlIDxsaW51eC9zcGkvc3Bp Lmg+DQo+ICsjaW5jbHVkZSA8bGludXgvc3BpL3NwaS1tZW0uaD4NCj4gKw0KPiArLyoNCj4gKyAq IFRoZSBkcml2ZXIgb25seSB1c2VzIG9uZSBzaW5nbGUgTFVUIGVudHJ5LCB0aGF0IGlzIHVwZGF0 ZWQgb24NCj4gKyAqIGVhY2ggY2FsbCBvZiBleGVjX29wKCkuIEluZGV4IDAgaXMgcHJlc2V0IGF0 IGJvb3Qgd2l0aCBhIGJhc2ljDQo+ICsgKiByZWFkIG9wZXJhdGlvbiwgc28gbGV0J3MgdXNlIHRo ZSBsYXN0IGVudHJ5ICgzMSkuDQo+ICsgKi8NCj4gKyNkZWZpbmUJU0VRSURfTFVUCQkJMzENCj4g Kw0KPiArLyogUmVnaXN0ZXJzIHVzZWQgYnkgdGhlIGRyaXZlciAqLw0KPiArI2RlZmluZSBGU1BJ X01DUjAJCQkweDAwDQo+ICsjZGVmaW5lIEZTUElfTUNSMF9BSEJfVElNRU9VVCh4KQkoKHgpIDw8 IDI0KQ0KPiArI2RlZmluZSBGU1BJX01DUjBfSVBfVElNRU9VVCh4KQkJKCh4KSA8PCAxNikNCj4g KyNkZWZpbmUgRlNQSV9NQ1IwX0xFQVJOX0VOCQlCSVQoMTUpDQo+ICsjZGVmaW5lIEZTUElfTUNS MF9TQ1JGUlVOX0VOCQlCSVQoMTQpDQo+ICsjZGVmaW5lIEZTUElfTUNSMF9PQ1RDT01CX0VOCQlC SVQoMTMpDQo+ICsjZGVmaW5lIEZTUElfTUNSMF9ET1pFX0VOCQlCSVQoMTIpDQo+ICsjZGVmaW5l IEZTUElfTUNSMF9IU0VOCQkJQklUKDExKQ0KPiArI2RlZmluZSBGU1BJX01DUjBfU0VSQ0xLRElW CQlCSVQoOCkNCj4gKyNkZWZpbmUgRlNQSV9NQ1IwX0FUREZfRU4JCUJJVCg3KQ0KPiArI2RlZmlu ZSBGU1BJX01DUjBfQVJERl9FTgkJQklUKDYpDQo+ICsjZGVmaW5lIEZTUElfTUNSMF9SWENMS1NS Qyh4KQkJKCh4KSA8PCA0KQ0KPiArI2RlZmluZSBGU1BJX01DUjBfRU5EX0NGRyh4KQkJKCh4KSA8 PCAyKQ0KPiArI2RlZmluZSBGU1BJX01DUjBfTURJUwkJCUJJVCgxKQ0KPiArI2RlZmluZSBGU1BJ X01DUjBfU1dSU1QJCQlCSVQoMCkNCj4gKw0KPiArI2RlZmluZSBGU1BJX01DUjEJCQkweDA0DQo+ ICsjZGVmaW5lIEZTUElfTUNSMV9TRVFfVElNRU9VVCh4KQkoKHgpIDw8IDE2KQ0KPiArI2RlZmlu ZSBGU1BJX01DUjFfQUhCX1RJTUVPVVQoeCkJKHgpDQo+ICsNCj4gKyNkZWZpbmUgRlNQSV9NQ1Iy CQkJMHgwOA0KPiArI2RlZmluZSBGU1BJX01DUjJfSURMRV9XQUlUKHgpCQkoKHgpIDw8IDI0KQ0K PiArI2RlZmluZSBGU1BJX01DUjJfU0FNRURFVklDRUVOCQlCSVQoMTUpDQo+ICsjZGVmaW5lIEZT UElfTUNSMl9DTFJMUlBIUwkJQklUKDE0KQ0KPiArI2RlZmluZSBGU1BJX01DUjJfQUJSREFUU1oJ CUJJVCg4KQ0KPiArI2RlZmluZSBGU1BJX01DUjJfQUJSTEVBUk4JCUJJVCg3KQ0KPiArI2RlZmlu ZSBGU1BJX01DUjJfQUJSX1JFQUQJCUJJVCg2KQ0KPiArI2RlZmluZSBGU1BJX01DUjJfQUJSV1JJ VEUJCUJJVCg1KQ0KPiArI2RlZmluZSBGU1BJX01DUjJfQUJSRFVNTVkJCUJJVCg0KQ0KPiArI2Rl ZmluZSBGU1BJX01DUjJfQUJSX01PREUJCUJJVCgzKQ0KPiArI2RlZmluZSBGU1BJX01DUjJfQUJS Q0FERFIJCUJJVCgyKQ0KPiArI2RlZmluZSBGU1BJX01DUjJfQUJSUkFERFIJCUJJVCgxKQ0KPiAr I2RlZmluZSBGU1BJX01DUjJfQUJSX0NNRAkJQklUKDApDQo+ICsNCj4gKyNkZWZpbmUgRlNQSV9B SEJDUgkJCTB4MGMNCj4gKyNkZWZpbmUgRlNQSV9BSEJDUl9SREFERFJPUFQJCUJJVCg2KQ0KPiAr I2RlZmluZSBGU1BJX0FIQkNSX1BSRUZfRU4JCUJJVCg1KQ0KPiArI2RlZmluZSBGU1BJX0FIQkNS X0JVRkZfRU4JCUJJVCg0KQ0KPiArI2RlZmluZSBGU1BJX0FIQkNSX0NBQ0hfRU4JCUJJVCgzKQ0K PiArI2RlZmluZSBGU1BJX0FIQkNSX0NMUlRYQlVGCQlCSVQoMikNCj4gKyNkZWZpbmUgRlNQSV9B SEJDUl9DTFJSWEJVRgkJQklUKDEpDQo+ICsjZGVmaW5lIEZTUElfQUhCQ1JfUEFSX0VOCQlCSVQo MCkNCj4gKw0KPiArI2RlZmluZSBGU1BJX0lOVEVOCQkJMHgxMA0KPiArI2RlZmluZSBGU1BJX0lO VEVOX1NDTEtTQldSCQlCSVQoOSkNCj4gKyNkZWZpbmUgRlNQSV9JTlRFTl9TQ0xLU0JSRAkJQklU KDgpDQo+ICsjZGVmaW5lIEZTUElfSU5URU5fREFUQUxSTkZMCQlCSVQoNykNCj4gKyNkZWZpbmUg RlNQSV9JTlRFTl9JUFRYV0UJCUJJVCg2KQ0KPiArI2RlZmluZSBGU1BJX0lOVEVOX0lQUlhXQQkJ QklUKDUpDQo+ICsjZGVmaW5lIEZTUElfSU5URU5fQUhCQ01ERVJSCQlCSVQoNCkNCj4gKyNkZWZp bmUgRlNQSV9JTlRFTl9JUENNREVSUgkJQklUKDMpDQo+ICsjZGVmaW5lIEZTUElfSU5URU5fQUhC Q01ER0UJCUJJVCgyKQ0KPiArI2RlZmluZSBGU1BJX0lOVEVOX0lQQ01ER0UJCUJJVCgxKQ0KPiAr I2RlZmluZSBGU1BJX0lOVEVOX0lQQ01ERE9ORQkJQklUKDApDQo+ICsNCj4gKyNkZWZpbmUgRlNQ SV9JTlRSCQkJMHgxNA0KPiArI2RlZmluZSBGU1BJX0lOVFJfU0NMS1NCV1IJCUJJVCg5KQ0KPiAr I2RlZmluZSBGU1BJX0lOVFJfU0NMS1NCUkQJCUJJVCg4KQ0KPiArI2RlZmluZSBGU1BJX0lOVFJf REFUQUxSTkZMCQlCSVQoNykNCj4gKyNkZWZpbmUgRlNQSV9JTlRSX0lQVFhXRQkJQklUKDYpDQo+ ICsjZGVmaW5lIEZTUElfSU5UUl9JUFJYV0EJCUJJVCg1KQ0KPiArI2RlZmluZSBGU1BJX0lOVFJf QUhCQ01ERVJSCQlCSVQoNCkNCj4gKyNkZWZpbmUgRlNQSV9JTlRSX0lQQ01ERVJSCQlCSVQoMykN Cj4gKyNkZWZpbmUgRlNQSV9JTlRSX0FIQkNNREdFCQlCSVQoMikNCj4gKyNkZWZpbmUgRlNQSV9J TlRSX0lQQ01ER0UJCUJJVCgxKQ0KPiArI2RlZmluZSBGU1BJX0lOVFJfSVBDTURET05FCQlCSVQo MCkNCj4gKw0KPiArI2RlZmluZSBGU1BJX0xVVEtFWQkJCTB4MTgNCj4gKyNkZWZpbmUgRlNQSV9M VVRLRVlfVkFMVUUJCTB4NUFGMDVBRjANCj4gKw0KPiArI2RlZmluZSBGU1BJX0xDS0NSCQkJMHgx Qw0KPiArDQo+ICsjZGVmaW5lIEZTUElfTENLRVJfTE9DSwkJCTB4MQ0KPiArI2RlZmluZSBGU1BJ X0xDS0VSX1VOTE9DSwkJMHgyDQo+ICsNCj4gKyNkZWZpbmUgRlNQSV9CVUZYQ1JfSU5WQUxJRF9N U1RSSUQJMHhFDQo+ICsjZGVmaW5lIEZTUElfQUhCUlhfQlVGMENSMAkJMHgyMA0KPiArI2RlZmlu ZSBGU1BJX0FIQlJYX0JVRjFDUjAJCTB4MjQNCj4gKyNkZWZpbmUgRlNQSV9BSEJSWF9CVUYyQ1Iw CQkweDI4DQo+ICsjZGVmaW5lIEZTUElfQUhCUlhfQlVGM0NSMAkJMHgyQw0KPiArI2RlZmluZSBG U1BJX0FIQlJYX0JVRjRDUjAJCTB4MzANCj4gKyNkZWZpbmUgRlNQSV9BSEJSWF9CVUY1Q1IwCQkw eDM0DQo+ICsjZGVmaW5lIEZTUElfQUhCUlhfQlVGNkNSMAkJMHgzOA0KPiArI2RlZmluZSBGU1BJ X0FIQlJYX0JVRjdDUjAJCTB4M0MNCj4gKyNkZWZpbmUgRlNQSV9BSEJSWEJVRjBDUjdfUFJFRgkJ QklUKDMxKQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfQUhCUlhfQlVGMENSMQkJMHg0MA0KPiArI2Rl ZmluZSBGU1BJX0FIQlJYX0JVRjFDUjEJCTB4NDQNCj4gKyNkZWZpbmUgRlNQSV9BSEJSWF9CVUYy Q1IxCQkweDQ4DQo+ICsjZGVmaW5lIEZTUElfQUhCUlhfQlVGM0NSMQkJMHg0Qw0KPiArI2RlZmlu ZSBGU1BJX0FIQlJYX0JVRjRDUjEJCTB4NTANCj4gKyNkZWZpbmUgRlNQSV9BSEJSWF9CVUY1Q1Ix CQkweDU0DQo+ICsjZGVmaW5lIEZTUElfQUhCUlhfQlVGNkNSMQkJMHg1OA0KPiArI2RlZmluZSBG U1BJX0FIQlJYX0JVRjdDUjEJCTB4NUMNCj4gKw0KPiArI2RlZmluZSBGU1BJX0ZMU0hBMUNSMAkJ CTB4NjANCj4gKyNkZWZpbmUgRlNQSV9GTFNIQTJDUjAJCQkweDY0DQo+ICsjZGVmaW5lIEZTUElf RkxTSEIxQ1IwCQkJMHg2OA0KPiArI2RlZmluZSBGU1BJX0ZMU0hCMkNSMAkJCTB4NkMNCj4gKyNk ZWZpbmUgRlNQSV9GTFNIWENSMF9TWl9LQgkJMTANCj4gKyNkZWZpbmUgRlNQSV9GTFNIWENSMF9T Wih4KQkJKCh4KSA+PiBGU1BJX0ZMU0hYQ1IwX1NaX0tCKQ0KPiArDQo+ICsjZGVmaW5lIEZTUElf RkxTSEExQ1IxCQkJMHg3MA0KPiArI2RlZmluZSBGU1BJX0ZMU0hBMkNSMQkJCTB4NzQNCj4gKyNk ZWZpbmUgRlNQSV9GTFNIQjFDUjEJCQkweDc4DQo+ICsjZGVmaW5lIEZTUElfRkxTSEIyQ1IxCQkJ MHg3Qw0KPiArI2RlZmluZSBGU1BJX0ZMU0hYQ1IxX0NTSU5UUih4KQkJKCh4KSA8PCAxNikNCj4g KyNkZWZpbmUgRlNQSV9GTFNIWENSMV9DQVMoeCkJCSgoeCkgPDwgMTEpDQo+ICsjZGVmaW5lIEZT UElfRkxTSFhDUjFfV0EJCUJJVCgxMCkNCj4gKyNkZWZpbmUgRlNQSV9GTFNIWENSMV9UQ1NIKHgp CQkoKHgpIDw8IDUpDQo+ICsjZGVmaW5lIEZTUElfRkxTSFhDUjFfVENTUyh4KQkJKHgpDQo+ICsN Cj4gKyNkZWZpbmUgRlNQSV9GTFNIQTFDUjIJCQkweDgwDQo+ICsjZGVmaW5lIEZTUElfRkxTSEEy Q1IyCQkJMHg4NA0KPiArI2RlZmluZSBGU1BJX0ZMU0hCMUNSMgkJCTB4ODgNCj4gKyNkZWZpbmUg RlNQSV9GTFNIQjJDUjIJCQkweDhDDQo+ICsjZGVmaW5lIEZTUElfRkxTSFhDUjJfQ0xSSU5TUAkJ QklUKDI0KQ0KPiArI2RlZmluZSBGU1BJX0ZMU0hYQ1IyX0FXUldBSVQJCUJJVCgxNikNCj4gKyNk ZWZpbmUgRlNQSV9GTFNIWENSMl9BV1JTRVFOX1NISUZUCTEzDQo+ICsjZGVmaW5lIEZTUElfRkxT SFhDUjJfQVdSU0VRSV9TSElGVAk4DQo+ICsjZGVmaW5lIEZTUElfRkxTSFhDUjJfQVJEU0VRTl9T SElGVAk1DQo+ICsjZGVmaW5lIEZTUElfRkxTSFhDUjJfQVJEU0VRSV9TSElGVAkwDQo+ICsNCj4g KyNkZWZpbmUgRlNQSV9JUENSMAkJCTB4QTANCj4gKw0KPiArI2RlZmluZSBGU1BJX0lQQ1IxCQkJ MHhBNA0KPiArI2RlZmluZSBGU1BJX0lQQ1IxX0lQQVJFTgkJQklUKDMxKQ0KPiArI2RlZmluZSBG U1BJX0lQQ1IxX1NFUU5VTV9TSElGVAkJMjQNCj4gKyNkZWZpbmUgRlNQSV9JUENSMV9TRVFJRF9T SElGVAkJMTYNCj4gKyNkZWZpbmUgRlNQSV9JUENSMV9JREFUU1ooeCkJCSh4KQ0KPiArDQo+ICsj ZGVmaW5lIEZTUElfSVBDTUQJCQkweEIwDQo+ICsjZGVmaW5lIEZTUElfSVBDTURfVFJHCQkJQklU KDApDQo+ICsNCj4gKyNkZWZpbmUgRlNQSV9ETFBSCQkJMHhCNA0KPiArDQo+ICsjZGVmaW5lIEZT UElfSVBSWEZDUgkJCTB4QjgNCj4gKyNkZWZpbmUgRlNQSV9JUFJYRkNSX0NMUgkJQklUKDApDQo+ ICsjZGVmaW5lIEZTUElfSVBSWEZDUl9ETUFfRU4JCUJJVCgxKQ0KPiArI2RlZmluZSBGU1BJX0lQ UlhGQ1JfV01SSyh4KQkJKCh4KSA8PCAyKQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfSVBUWEZDUgkJ CTB4QkMNCj4gKyNkZWZpbmUgRlNQSV9JUFRYRkNSX0NMUgkJQklUKDApDQo+ICsjZGVmaW5lIEZT UElfSVBUWEZDUl9ETUFfRU4JCUJJVCgxKQ0KPiArI2RlZmluZSBGU1BJX0lQVFhGQ1JfV01SSyh4 KQkJKCh4KSA8PCAyKQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfRExMQUNSCQkJMHhDMA0KPiArI2Rl ZmluZSBGU1BJX0RMTEFDUl9PVlJERU4JCUJJVCg4KQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfRExM QkNSCQkJMHhDNA0KPiArI2RlZmluZSBGU1BJX0RMTEJDUl9PVlJERU4JCUJJVCg4KQ0KPiArDQo+ ICsjZGVmaW5lIEZTUElfU1RTMAkJCTB4RTANCj4gKyNkZWZpbmUgRlNQSV9TVFMwX0RMUEhCKHgp CQkoKHgpIDw8IDgpDQo+ICsjZGVmaW5lIEZTUElfU1RTMF9ETFBIQSh4KQkJKCh4KSA8PCA0KQ0K PiArI2RlZmluZSBGU1BJX1NUUzBfQ01EX1NSQyh4KQkJKCh4KSA8PCAyKQ0KPiArI2RlZmluZSBG U1BJX1NUUzBfQVJCX0lETEUJCUJJVCgxKQ0KPiArI2RlZmluZSBGU1BJX1NUUzBfU0VRX0lETEUJ CUJJVCgwKQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfU1RTMQkJCTB4RTQNCj4gKyNkZWZpbmUgRlNQ SV9TVFMxX0lQX0VSUkNEKHgpCQkoKHgpIDw8IDI0KQ0KPiArI2RlZmluZSBGU1BJX1NUUzFfSVBf RVJSSUQoeCkJCSgoeCkgPDwgMTYpDQo+ICsjZGVmaW5lIEZTUElfU1RTMV9BSEJfRVJSQ0QoeCkJ CSgoeCkgPDwgOCkNCj4gKyNkZWZpbmUgRlNQSV9TVFMxX0FIQl9FUlJJRCh4KQkJKHgpDQo+ICsN Cj4gKyNkZWZpbmUgRlNQSV9BSEJTUE5TVAkJCTB4RUMNCj4gKyNkZWZpbmUgRlNQSV9BSEJTUE5T VF9EQVRMRlQoeCkJCSgoeCkgPDwgMTYpDQo+ICsjZGVmaW5lIEZTUElfQUhCU1BOU1RfQlVGSUQo eCkJCSgoeCkgPDwgMSkNCj4gKyNkZWZpbmUgRlNQSV9BSEJTUE5TVF9BQ1RJVkUJCUJJVCgwKQ0K PiArDQo+ICsjZGVmaW5lIEZTUElfSVBSWEZTVFMJCQkweEYwDQo+ICsjZGVmaW5lIEZTUElfSVBS WEZTVFNfUkRDTlRSKHgpCQkoKHgpIDw8IDE2KQ0KPiArI2RlZmluZSBGU1BJX0lQUlhGU1RTX0ZJ TEwoeCkJCSh4KQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfSVBUWEZTVFMJCQkweEY0DQo+ICsjZGVm aW5lIEZTUElfSVBUWEZTVFNfV1JDTlRSKHgpCQkoKHgpIDw8IDE2KQ0KPiArI2RlZmluZSBGU1BJ X0lQVFhGU1RTX0ZJTEwoeCkJCSh4KQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfUkZEUgkJCTB4MTAw DQo+ICsjZGVmaW5lIEZTUElfVEZEUgkJCTB4MTgwDQo+ICsNCj4gKyNkZWZpbmUgRlNQSV9MVVRf QkFTRQkJCTB4MjAwDQo+ICsjZGVmaW5lIEZTUElfTFVUX09GRlNFVAkJCShTRVFJRF9MVVQgKiA0 ICogNCkNCj4gKyNkZWZpbmUgRlNQSV9MVVRfUkVHKGlkeCkgXA0KPiArCShGU1BJX0xVVF9CQVNF ICsgRlNQSV9MVVRfT0ZGU0VUICsgKGlkeCkgKiA0KQ0KPiArDQo+ICsvKiByZWdpc3RlciBtYXAg ZW5kICovDQo+ICsNCj4gKy8qIEluc3RydWN0aW9uIHNldCBmb3IgdGhlIExVVCByZWdpc3Rlci4g Ki8NCj4gKyNkZWZpbmUgTFVUX1NUT1AJCQkweDAwDQo+ICsjZGVmaW5lIExVVF9DTUQJCQkJMHgw MQ0KPiArI2RlZmluZSBMVVRfQUREUgkJCTB4MDINCj4gKyNkZWZpbmUgTFVUX0NBRERSX1NEUgkJ CTB4MDMNCj4gKyNkZWZpbmUgTFVUX01PREUJCQkweDA0DQo+ICsjZGVmaW5lIExVVF9NT0RFMgkJ CTB4MDUNCj4gKyNkZWZpbmUgTFVUX01PREU0CQkJMHgwNg0KPiArI2RlZmluZSBMVVRfTU9ERTgJ CQkweDA3DQo+ICsjZGVmaW5lIExVVF9OWFBfV1JJVEUJCQkweDA4DQo+ICsjZGVmaW5lIExVVF9O WFBfUkVBRAkJCTB4MDkNCj4gKyNkZWZpbmUgTFVUX0xFQVJOX1NEUgkJCTB4MEENCj4gKyNkZWZp bmUgTFVUX0RBVFNaX1NEUgkJCTB4MEINCj4gKyNkZWZpbmUgTFVUX0RVTU1ZCQkJMHgwQw0KPiAr I2RlZmluZSBMVVRfRFVNTVlfUldEU19TRFIJCTB4MEQNCj4gKyNkZWZpbmUgTFVUX0pNUF9PTl9D UwkJCTB4MUYNCj4gKyNkZWZpbmUgTFVUX0NNRF9ERFIJCQkweDIxDQo+ICsjZGVmaW5lIExVVF9B RERSX0REUgkJCTB4MjINCj4gKyNkZWZpbmUgTFVUX0NBRERSX0REUgkJCTB4MjMNCj4gKyNkZWZp bmUgTFVUX01PREVfRERSCQkJMHgyNA0KPiArI2RlZmluZSBMVVRfTU9ERTJfRERSCQkJMHgyNQ0K PiArI2RlZmluZSBMVVRfTU9ERTRfRERSCQkJMHgyNg0KPiArI2RlZmluZSBMVVRfTU9ERThfRERS CQkJMHgyNw0KPiArI2RlZmluZSBMVVRfV1JJVEVfRERSCQkJMHgyOA0KPiArI2RlZmluZSBMVVRf UkVBRF9ERFIJCQkweDI5DQo+ICsjZGVmaW5lIExVVF9MRUFSTl9ERFIJCQkweDJBDQo+ICsjZGVm aW5lIExVVF9EQVRTWl9ERFIJCQkweDJCDQo+ICsjZGVmaW5lIExVVF9EVU1NWV9ERFIJCQkweDJD DQo+ICsjZGVmaW5lIExVVF9EVU1NWV9SV0RTX0REUgkJMHgyRA0KPiArDQo+ICsvKg0KPiArICog Q2FsY3VsYXRlIG51bWJlciBvZiByZXF1aXJlZCBQQUQgYml0cyBmb3IgTFVUIHJlZ2lzdGVyLg0K PiArICoNCj4gKyAqIFRoZSBwYWQgc3RhbmRzIGZvciB0aGUgbnVtYmVyIG9mIElPIGxpbmVzIFsw OjddLg0KPiArICogRm9yIGV4YW1wbGUsIHRoZSBvY3RhbCByZWFkIG5lZWRzIGVpZ2h0IElPIGxp bmVzLA0KPiArICogc28geW91IHNob3VsZCB1c2UgTFVUX1BBRCg4KS4gVGhpcyBtYWNybw0KPiAr ICogcmV0dXJucyAzIGkuZS4gdXNlIGVpZ2h0ICgyXjMpIElQIGxpbmVzIGZvciByZWFkLg0KPiAr ICovDQo+ICsjZGVmaW5lIExVVF9QQUQoeCkgKGZscyh4KSAtIDEpDQo+ICsNCj4gKy8qDQo+ICsg KiBNYWNybyBmb3IgY29uc3RydWN0aW5nIHRoZSBMVVQgZW50cmllcyB3aXRoIHRoZSBmb2xsb3dp bmcNCj4gKyAqIHJlZ2lzdGVyIGxheW91dDoNCj4gKyAqDQo+ICsgKiAgLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tDQo+ICsgKiAgfCBJTlNUUjEgfCBQ QUQxIHwgT1BSTkQxIHwgSU5TVFIwIHwgUEFEMCB8IE9QUk5EMCB8DQo+ICsgKiAgLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tDQo+ICsgKi8NCj4gKyNk ZWZpbmUgUEFEX1NISUZUCQk4DQo+ICsjZGVmaW5lIElOU1RSX1NISUZUCQkxMA0KPiArI2RlZmlu ZSBPUFJORF9TSElGVAkJMTYNCj4gKw0KPiArLyogTWFjcm9zIGZvciBjb25zdHJ1Y3RpbmcgdGhl IExVVCByZWdpc3Rlci4gKi8NCj4gKyNkZWZpbmUgTFVUX0RFRihpZHgsIGlucywgcGFkLCBvcHIp CQkJICBcDQo+ICsJKCgoKGlucykgPDwgSU5TVFJfU0hJRlQpIHwgKChwYWQpIDw8IFBBRF9TSElG VCkgfCBcDQo+ICsJKG9wcikpIDw8ICgoKGlkeCkgJSAyKSAqIE9QUk5EX1NISUZUKSkNCj4gKw0K PiArLyogT3BlcmFuZHMgZm9yIHRoZSBMVVQgcmVnaXN0ZXIuICovDQo+ICsjZGVmaW5lIEFERFI4 QklUCQkweDA4DQo+ICsjZGVmaW5lIEFERFIxNkJJVAkJMHgxMA0KPiArI2RlZmluZSBBRERSMjRC SVQJCTB4MTgNCj4gKyNkZWZpbmUgQUREUjMyQklUCQkweDIwDQoNCllvdSBjYW4gZHJvcCB0aGVz ZSBBRERSWEJJVCBkZWZpbml0aW9ucywgc2VlIGJlbG93Li4uDQoNCj4gKw0KPiArI2RlZmluZSBQ T0xMX1RPVVQJCTUwMDANCj4gKyNkZWZpbmUgTlhQX0ZTUElfTUFYX0NISVBTRUxFQ1QJCTQNCj4g Kw0KPiArc3RydWN0IG54cF9mc3BpX2RldnR5cGVfZGF0YSB7DQo+ICsJdW5zaWduZWQgaW50IHJ4 ZmlmbzsNCj4gKwl1bnNpZ25lZCBpbnQgdHhmaWZvOw0KPiArCXVuc2lnbmVkIGludCBhaGJfYnVm X3NpemU7DQo+ICsJdW5zaWduZWQgaW50IHF1aXJrczsNCj4gKwlib29sIGxpdHRsZV9lbmRpYW47 DQo+ICt9Ow0KPiArDQo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG54cF9mc3BpX2RldnR5cGVfZGF0 YSBseDIxNjBhX2RhdGEgPSB7DQo+ICsJLnJ4ZmlmbyA9IFNaXzUxMiwgICAgICAgLyogKDY0ICAq IDY0IGJpdHMpICAqLw0KPiArCS50eGZpZm8gPSBTWl8xSywgICAgICAgIC8qICgxMjggKiA2NCBi aXRzKSAgKi8NCj4gKwkuYWhiX2J1Zl9zaXplID0gU1pfMkssICAvKiAoMjU2ICogNjQgYml0cykg ICovDQo+ICsJLnF1aXJrcyA9IDAsDQo+ICsJLmxpdHRsZV9lbmRpYW4gPSB0cnVlLCAgLyogbGl0 dGxlLWVuZGlhbiAgICAqLw0KPiArfTsNCj4gKw0KPiArc3RydWN0IG54cF9mc3BpIHsNCj4gKwl2 b2lkIF9faW9tZW0gKmlvYmFzZTsNCj4gKwl2b2lkIF9faW9tZW0gKmFoYl9hZGRyOw0KPiArCXUz MiBtZW1tYXBfcGh5Ow0KPiArCXUzMiBtZW1tYXBfcGh5X3NpemU7DQo+ICsJc3RydWN0IGNsayAq Y2xrLCAqY2xrX2VuOw0KPiArCXN0cnVjdCBkZXZpY2UgKmRldjsNCj4gKwlzdHJ1Y3QgY29tcGxl dGlvbiBjOw0KPiArCWNvbnN0IHN0cnVjdCBueHBfZnNwaV9kZXZ0eXBlX2RhdGEgKmRldnR5cGVf ZGF0YTsNCj4gKwlzdHJ1Y3QgbXV0ZXggbG9jazsNCj4gKwlzdHJ1Y3QgcG1fcW9zX3JlcXVlc3Qg cG1fcW9zX3JlcTsNCj4gKwlpbnQgc2VsZWN0ZWQ7DQo+ICt9Ow0KPiArDQo+ICsvKg0KPiArICog Ui9XIGZ1bmN0aW9ucyBmb3IgYmlnLSBvciBsaXR0bGUtZW5kaWFuIHJlZ2lzdGVyczoNCj4gKyAq IFRoZSBGU1BJIGNvbnRyb2xsZXIncyBlbmRpYW5uZXNzIGlzIGluZGVwZW5kZW50IG9mDQo+ICsg KiB0aGUgQ1BVIGNvcmUncyBlbmRpYW5uZXNzLiBTbyBmYXIsIGFsdGhvdWdoIHRoZSBDUFUNCj4g KyAqIGNvcmUgaXMgbGl0dGxlLWVuZGlhbiB0aGUgRlNQSSBjb250cm9sbGVyIGNhbiB1c2UNCj4g KyAqIGJpZy1lbmRpYW4gb3IgbGl0dGxlLWVuZGlhbi4NCj4gKyAqLw0KPiArc3RhdGljIHZvaWQg ZnNwaV93cml0ZWwoc3RydWN0IG54cF9mc3BpICpmLCB1MzIgdmFsLCB2b2lkIF9faW9tZW0gKmFk ZHIpDQo+ICt7DQo+ICsJaWYgKGYtPmRldnR5cGVfZGF0YS0+bGl0dGxlX2VuZGlhbikNCj4gKwkJ aW93cml0ZTMyKHZhbCwgYWRkcik7DQo+ICsJZWxzZQ0KPiArCQlpb3dyaXRlMzJiZSh2YWwsIGFk ZHIpOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgdTMyIGZzcGlfcmVhZGwoc3RydWN0IG54cF9mc3Bp ICpmLCB2b2lkIF9faW9tZW0gKmFkZHIpDQo+ICt7DQo+ICsJaWYgKGYtPmRldnR5cGVfZGF0YS0+ bGl0dGxlX2VuZGlhbikNCj4gKwkJcmV0dXJuIGlvcmVhZDMyKGFkZHIpOw0KPiArCWVsc2UNCj4g KwkJcmV0dXJuIGlvcmVhZDMyYmUoYWRkcik7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpcnFyZXR1 cm5fdCBueHBfZnNwaV9pcnFfaGFuZGxlcihpbnQgaXJxLCB2b2lkICpkZXZfaWQpDQo+ICt7DQo+ ICsJc3RydWN0IG54cF9mc3BpICpmID0gZGV2X2lkOw0KPiArCXUzMiByZWc7DQo+ICsNCj4gKwkv KiBjbGVhciBpbnRlcnJ1cHQgKi8NCj4gKwlyZWcgPSBmc3BpX3JlYWRsKGYsIGYtPmlvYmFzZSAr IEZTUElfSU5UUik7DQo+ICsJZnNwaV93cml0ZWwoZiwgRlNQSV9JTlRSX0lQQ01ERE9ORSwgZi0+ aW9iYXNlICsgRlNQSV9JTlRSKTsNCj4gKw0KPiArCWlmIChyZWcgJiBGU1BJX0lOVFJfSVBDTURE T05FKQ0KPiArCQljb21wbGV0ZSgmZi0+Yyk7DQo+ICsNCj4gKwlyZXR1cm4gSVJRX0hBTkRMRUQ7 DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpbnQgbnhwX2ZzcGlfY2hlY2tfYnVzd2lkdGgoc3RydWN0 IG54cF9mc3BpICpmLCB1OCB3aWR0aCkNCj4gK3sNCj4gKwlzd2l0Y2ggKHdpZHRoKSB7DQo+ICsJ Y2FzZSAxOg0KPiArCWNhc2UgMjoNCj4gKwljYXNlIDQ6DQo+ICsJY2FzZSA4Og0KPiArCQlyZXR1 cm4gMDsNCj4gKwl9DQo+ICsNCj4gKwlyZXR1cm4gLUVOT1RTVVBQOw0KPiArfQ0KPiArDQo+ICtz dGF0aWMgYm9vbCBueHBfZnNwaV9zdXBwb3J0c19vcChzdHJ1Y3Qgc3BpX21lbSAqbWVtLA0KPiAr CQkJCSBjb25zdCBzdHJ1Y3Qgc3BpX21lbV9vcCAqb3ApDQo+ICt7DQo+ICsJc3RydWN0IG54cF9m c3BpICpmID0gc3BpX2NvbnRyb2xsZXJfZ2V0X2RldmRhdGEobWVtLT5zcGktPm1hc3Rlcik7DQo+ ICsJaW50IHJldDsNCj4gKw0KPiArCXJldCA9IG54cF9mc3BpX2NoZWNrX2J1c3dpZHRoKGYsIG9w LT5jbWQuYnVzd2lkdGgpOw0KPiArDQo+ICsJaWYgKG9wLT5hZGRyLm5ieXRlcykNCj4gKwkJcmV0 IHw9IG54cF9mc3BpX2NoZWNrX2J1c3dpZHRoKGYsIG9wLT5hZGRyLmJ1c3dpZHRoKTsNCj4gKw0K PiArCWlmIChvcC0+ZHVtbXkubmJ5dGVzKQ0KPiArCQlyZXQgfD0gbnhwX2ZzcGlfY2hlY2tfYnVz d2lkdGgoZiwgb3AtPmR1bW15LmJ1c3dpZHRoKTsNCj4gKw0KPiArCWlmIChvcC0+ZGF0YS5uYnl0 ZXMpDQo+ICsJCXJldCB8PSBueHBfZnNwaV9jaGVja19idXN3aWR0aChmLCBvcC0+ZGF0YS5idXN3 aWR0aCk7DQo+ICsNCj4gKwlpZiAocmV0KQ0KPiArCQlyZXR1cm4gZmFsc2U7DQo+ICsNCj4gKwkv Kg0KPiArCSAqIFRoZSBudW1iZXIgb2YgaW5zdHJ1Y3Rpb25zIG5lZWRlZCBmb3IgdGhlIG9wLCBu ZWVkcw0KPiArCSAqIHRvIGZpdCBpbnRvIGEgc2luZ2xlIExVVCBlbnRyeS4NCj4gKwkgKi8NCj4g KwlpZiAob3AtPmFkZHIubmJ5dGVzICsNCj4gKwkgICAob3AtPmR1bW15Lm5ieXRlcyA/IDE6MCkg Kw0KPiArCSAgIChvcC0+ZGF0YS5uYnl0ZXMgPyAxOjApID4gNikNCj4gKwkJcmV0dXJuIGZhbHNl Ow0KPiArDQo+ICsJLyogTWF4IDY0IGR1bW15IGNsb2NrIGN5Y2xlcyBzdXBwb3J0ZWQgKi8NCj4g KwlpZiAob3AtPmR1bW15LmJ1c3dpZHRoICYmDQo+ICsJICAgIChvcC0+ZHVtbXkubmJ5dGVzICog OCAvIG9wLT5kdW1teS5idXN3aWR0aCA+IDY0KSkNCj4gKwkJcmV0dXJuIGZhbHNlOw0KPiArDQo+ ICsJLyogTWF4IGRhdGEgbGVuZ3RoLCBjaGVjayBjb250cm9sbGVyIGxpbWl0cyBhbmQgYWxpZ25t ZW50ICovDQo+ICsJaWYgKG9wLT5kYXRhLmRpciA9PSBTUElfTUVNX0RBVEFfSU4gJiYNCj4gKwkg ICAgKG9wLT5kYXRhLm5ieXRlcyA+IGYtPmRldnR5cGVfZGF0YS0+YWhiX2J1Zl9zaXplIHx8DQo+ ICsJICAgICAob3AtPmRhdGEubmJ5dGVzID4gZi0+ZGV2dHlwZV9kYXRhLT5yeGZpZm8gLSA0ICYm DQo+ICsJICAgICAgIUlTX0FMSUdORUQob3AtPmRhdGEubmJ5dGVzLCA4KSkpKQ0KPiArCQlyZXR1 cm4gZmFsc2U7DQo+ICsNCj4gKwlpZiAob3AtPmRhdGEuZGlyID09IFNQSV9NRU1fREFUQV9PVVQg JiYNCj4gKwkgICAgb3AtPmRhdGEubmJ5dGVzID4gZi0+ZGV2dHlwZV9kYXRhLT50eGZpZm8pDQo+ ICsJCXJldHVybiBmYWxzZTsNCj4gKw0KPiArCXJldHVybiB0cnVlOw0KPiArfQ0KPiArDQo+ICsv KiBJbnN0ZWFkIG9mIGJ1c3kgbG9vcGluZyBpbnZva2UgcmVhZGxfcG9sbF90aW1lb3V0IGZ1bmN0 aW9uYWxpdHkuICovDQo+ICtzdGF0aWMgaW50IGZzcGlfcmVhZGxfcG9sbF90b3V0KHN0cnVjdCBu eHBfZnNwaSAqZiwgdm9pZCBfX2lvbWVtICpiYXNlLA0KPiArCQkJCXUzMiBtYXNrLCB1MzIgZGVs YXlfdXMsDQo+ICsJCQkJdTMyIHRpbWVvdXRfdXMsIGJvb2wgY29uZGl0aW9uKQ0KPiArew0KPiAr CXUzMiByZWc7DQo+ICsNCj4gKwlpZiAoIWYtPmRldnR5cGVfZGF0YS0+bGl0dGxlX2VuZGlhbikN Cj4gKwkJbWFzayA9ICh1MzIpY3B1X3RvX2JlMzIobWFzayk7DQo+ICsNCj4gKwlpZiAoY29uZGl0 aW9uKQ0KPiArCQlyZXR1cm4gcmVhZGxfcG9sbF90aW1lb3V0KGJhc2UsIHJlZywgKHJlZyAmIG1h c2spLA0KPiArCQkJCQkgIGRlbGF5X3VzLCB0aW1lb3V0X3VzKTsNCj4gKwllbHNlDQo+ICsJCXJl dHVybiByZWFkbF9wb2xsX3RpbWVvdXQoYmFzZSwgcmVnLCAhKHJlZyAmIG1hc2spLA0KPiArCQkJ CQkgIGRlbGF5X3VzLCB0aW1lb3V0X3VzKTsNCg0KSSB3b3VsZCByYXRoZXIgdXNlIGEgbG9jYWwg dmFyaWFibGUgdG8gc3RvcmUgdGhlIGNvbmRpdGlvbjoNCg0KYm9vbCBjID0gY29uZGl0aW9uID8g KHJlZyAmIG1hc2spOiEocmVnICYgbWFzayk7DQoNCnJldHVybiByZWFkbF9wb2xsX3RpbWVvdXQo YmFzZSwgcmVnLCBjLCBkZWxheV91cywgdGltZW91dF91cyk7DQoNCj4gK30NCj4gKw0KPiArLyoN Cj4gKyAqIElmIHRoZSBzbGF2ZSBkZXZpY2UgY29udGVudCBiZWluZyBjaGFuZ2VkIGJ5IFdyaXRl L0VyYXNlLCBuZWVkIHRvDQo+ICsgKiBpbnZhbGlkYXRlIHRoZSBBSEIgYnVmZmVyLiBUaGlzIGNh biBiZSBhY2hpZXZlZCBieSBkb2luZyB0aGUgcmVzZXQNCj4gKyAqIG9mIGNvbnRyb2xsZXIgYWZ0 ZXIgc2V0dGluZyBNQ1IwW1NXUkVTRVRdIGJpdC4NCj4gKyAqLw0KPiArc3RhdGljIGlubGluZSB2 b2lkIG54cF9mc3BpX2ludmFsaWQoc3RydWN0IG54cF9mc3BpICpmKQ0KPiArew0KPiArCXUzMiBy ZWc7DQo+ICsJaW50IHJldDsNCj4gKw0KPiArCXJlZyA9IGZzcGlfcmVhZGwoZiwgZi0+aW9iYXNl ICsgRlNQSV9NQ1IwKTsNCj4gKwlmc3BpX3dyaXRlbChmLCByZWcgfCBGU1BJX01DUjBfU1dSU1Qs IGYtPmlvYmFzZSArIEZTUElfTUNSMCk7DQo+ICsNCj4gKwkvKiB3MWMgcmVnaXN0ZXIsIHdhaXQg dW5pdCBjbGVhciAqLw0KPiArCXJldCA9IGZzcGlfcmVhZGxfcG9sbF90b3V0KGYsIGYtPmlvYmFz ZSArIEZTUElfTUNSMCwNCj4gKwkJCQkgICBGU1BJX01DUjBfU1dSU1QsIDAsIFBPTExfVE9VVCwg ZmFsc2UpOw0KPiArCVdBUk5fT04ocmV0KTsNCj4gK30NCj4gKw0KPiArc3RhdGljIHZvaWQgbnhw X2ZzcGlfcHJlcGFyZV9sdXQoc3RydWN0IG54cF9mc3BpICpmLA0KPiArCQkJCSBjb25zdCBzdHJ1 Y3Qgc3BpX21lbV9vcCAqb3ApDQo+ICt7DQo+ICsJdm9pZCBfX2lvbWVtICpiYXNlID0gZi0+aW9i YXNlOw0KPiArCXUzMiBsdXR2YWxbNF0gPSB7fTsNCj4gKwlpbnQgbHV0aWR4ID0gMSwgaTsNCj4g Kw0KPiArCS8qIGNtZCAqLw0KPiArCWx1dHZhbFswXSB8PSBMVVRfREVGKDAsIExVVF9DTUQsIExV VF9QQUQob3AtPmNtZC5idXN3aWR0aCksDQo+ICsJCQkgICAgIG9wLT5jbWQub3Bjb2RlKTsNCj4g Kw0KPiArCS8qIGFkZHIgYnVzIHdpZHRoICovDQo+ICsJaWYgKG9wLT5hZGRyLm5ieXRlcykgew0K PiArCQl1MzIgYWRkcmxlbiA9IDA7DQo+ICsNCj4gKwkJc3dpdGNoIChvcC0+YWRkci5uYnl0ZXMp IHsNCj4gKwkJY2FzZSAxOg0KPiArCQkJYWRkcmxlbiA9IEFERFI4QklUOw0KPiArCQkJYnJlYWs7 DQo+ICsJCWNhc2UgMjoNCj4gKwkJCWFkZHJsZW4gPSBBRERSMTZCSVQ7DQo+ICsJCQlicmVhazsN Cj4gKwkJY2FzZSAzOg0KPiArCQkJYWRkcmxlbiA9IEFERFIyNEJJVDsNCj4gKwkJCWJyZWFrOw0K PiArCQljYXNlIDQ6DQo+ICsJCQlhZGRybGVuID0gQUREUjMyQklUOw0KPiArCQkJYnJlYWs7DQo+ ICsJCWRlZmF1bHQ6DQo+ICsJCQlkZXZfZXJyKGYtPmRldiwgIkluLWNvcnJlY3QgYWRkcmVzcyBs ZW5ndGhcbiIpOw0KPiArCQkJcmV0dXJuOw0KPiArCQl9DQoNCllvdSBkb24ndCBuZWVkIHRvIHZh bGlkYXRlIG9wLT5hZGRyLm5ieXRlcyBoZXJlLCB0aGlzIGlzIGFscmVhZHkgZG9uZSBpbiANCm54 cF9mc3BpX3N1cHBvcnRzX29wKCkuDQoNCj4gKw0KPiArCQlsdXR2YWxbbHV0aWR4IC8gMl0gfD0g TFVUX0RFRihsdXRpZHgsIExVVF9BRERSLA0KPiArCQkJCQkgICAgICBMVVRfUEFEKG9wLT5hZGRy LmJ1c3dpZHRoKSwNCj4gKwkJCQkJICAgICAgYWRkcmxlbik7DQoNCllvdSBjYW4gYWxzbyBqdXN0 IHJlbW92ZSB0aGUgd2hvbGUgc3dpdGNoIHN0YXRlbWVudCBhYm92ZSBhbmQgdXNlIHRoaXM6DQoN Cmx1dHZhbFtsdXRpZHggLyAyXSB8PSBMVVRfREVGKGx1dGlkeCwgTFVUX0FERFIsDQoJCQkgICAg ICBMVVRfUEFEKG9wLT5hZGRyLmJ1c3dpZHRoKSwNCgkJCSAgICAgIG9wLT5hZGRyLm5ieXRlcyAq IDgpOw0KDQo+ICsJCWx1dGlkeCsrOw0KPiArCX0NCj4gKw0KPiArCS8qIGR1bW15IGJ5dGVzLCBp ZiBuZWVkZWQgKi8NCj4gKwlpZiAob3AtPmR1bW15Lm5ieXRlcykgew0KPiArCQlsdXR2YWxbbHV0 aWR4IC8gMl0gfD0gTFVUX0RFRihsdXRpZHgsIExVVF9EVU1NWSwNCj4gKwkJLyoNCj4gKwkJICog RHVlIHRvIEZsZXhTUEkgY29udHJvbGxlciBsaW1pdGF0aW9uIG51bWJlciBvZiBQQUQgZm9yIGR1 bW15DQo+ICsJCSAqIGJ1c3dpZHRoIG5lZWRzIHRvIGJlIHByb2dyYW1tZWQgYXMgZXF1YWwgdG8g ZGF0YSBidXN3aWR0aC4NCj4gKwkJICovDQo+ICsJCQkJCSAgICAgIExVVF9QQUQob3AtPmRhdGEu YnVzd2lkdGgpLA0KPiArCQkJCQkgICAgICBvcC0+ZHVtbXkubmJ5dGVzICogOCAvDQo+ICsJCQkJ CSAgICAgIG9wLT5kdW1teS5idXN3aWR0aCk7DQo+ICsJCWx1dGlkeCsrOw0KPiArCX0NCj4gKw0K PiArCS8qIHJlYWQvd3JpdGUgZGF0YSBieXRlcyAqLw0KPiArCWlmIChvcC0+ZGF0YS5uYnl0ZXMp IHsNCj4gKwkJbHV0dmFsW2x1dGlkeCAvIDJdIHw9IExVVF9ERUYobHV0aWR4LA0KPiArCQkJCQkg ICAgICBvcC0+ZGF0YS5kaXIgPT0gU1BJX01FTV9EQVRBX0lOID8NCj4gKwkJCQkJICAgICAgTFVU X05YUF9SRUFEIDogTFVUX05YUF9XUklURSwNCj4gKwkJCQkJICAgICAgTFVUX1BBRChvcC0+ZGF0 YS5idXN3aWR0aCksDQo+ICsJCQkJCSAgICAgIDApOw0KPiArCQlsdXRpZHgrKzsNCj4gKwl9DQo+ ICsNCj4gKwkvKiBzdG9wIGNvbmRpdGlvbi4gKi8NCj4gKwlsdXR2YWxbbHV0aWR4IC8gMl0gfD0g TFVUX0RFRihsdXRpZHgsIExVVF9TVE9QLCAwLCAwKTsNCj4gKw0KPiArCS8qIHVubG9jayBMVVQg Ki8NCj4gKwlmc3BpX3dyaXRlbChmLCBGU1BJX0xVVEtFWV9WQUxVRSwgZi0+aW9iYXNlICsgRlNQ SV9MVVRLRVkpOw0KPiArCWZzcGlfd3JpdGVsKGYsIEZTUElfTENLRVJfVU5MT0NLLCBmLT5pb2Jh c2UgKyBGU1BJX0xDS0NSKTsNCj4gKw0KPiArCS8qIGZpbGwgTFVUICovDQo+ICsJZm9yIChpID0g MDsgaSA8IEFSUkFZX1NJWkUobHV0dmFsKTsgaSsrKQ0KPiArCQlmc3BpX3dyaXRlbChmLCBsdXR2 YWxbaV0sIGJhc2UgKyBGU1BJX0xVVF9SRUcoaSkpOw0KPiArDQo+ICsJZGV2X2RiZyhmLT5kZXYs ICJDTURbJXhdIGx1dHZhbFswOiV4IFx0IDE6JXggXHQgMjoleCBcdCAzOiV4XVxuIiwNCj4gKwkJ b3AtPmNtZC5vcGNvZGUsIGx1dHZhbFswXSwgbHV0dmFsWzFdLCBsdXR2YWxbMl0sIGx1dHZhbFsz XSk7DQo+ICsNCj4gKwkvKiBsb2NrIExVVCAqLw0KPiArCWZzcGlfd3JpdGVsKGYsIEZTUElfTFVU S0VZX1ZBTFVFLCBmLT5pb2Jhc2UgKyBGU1BJX0xVVEtFWSk7DQo+ICsJZnNwaV93cml0ZWwoZiwg RlNQSV9MQ0tFUl9MT0NLLCBmLT5pb2Jhc2UgKyBGU1BJX0xDS0NSKTsNCj4gK30NCj4gKw0KPiAr c3RhdGljIGludCBueHBfZnNwaV9jbGtfcHJlcF9lbmFibGUoc3RydWN0IG54cF9mc3BpICpmKQ0K PiArew0KPiArCWludCByZXQ7DQo+ICsNCj4gKwlyZXQgPSBjbGtfcHJlcGFyZV9lbmFibGUoZi0+ Y2xrX2VuKTsNCj4gKwlpZiAocmV0KQ0KPiArCQlyZXR1cm4gcmV0Ow0KPiArDQo+ICsJcmV0ID0g Y2xrX3ByZXBhcmVfZW5hYmxlKGYtPmNsayk7DQo+ICsJaWYgKHJldCkgew0KPiArCQljbGtfZGlz YWJsZV91bnByZXBhcmUoZi0+Y2xrX2VuKTsNCj4gKwkJcmV0dXJuIHJldDsNCj4gKwl9DQo+ICsN Cj4gKwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiArc3RhdGljIHZvaWQgbnhwX2ZzcGlfY2xrX2Rp c2FibGVfdW5wcmVwKHN0cnVjdCBueHBfZnNwaSAqZikNCj4gK3sNCj4gKwljbGtfZGlzYWJsZV91 bnByZXBhcmUoZi0+Y2xrKTsNCj4gKwljbGtfZGlzYWJsZV91bnByZXBhcmUoZi0+Y2xrX2VuKTsN Cj4gK30NCj4gKw0KPiArLyoNCj4gKyAqIEluIEZsZXhTUEkgY29udHJvbGxlciwgZmxhc2ggYWNj ZXNzIGlzIGJhc2VkIG9uIHZhbHVlIG9mIEZTUElfRkxTSFhYQ1IwDQo+ICsgKiByZWdpc3RlciBh bmQgc3RhcnQgYmFzZSBhZGRyZXNzIG9mIHRoZSBzbGF2ZSBkZXZpY2UuDQo+ICsgKg0KPiArICoJ CQkJCQkJICAgIChIaWdoZXIgYWRkcmVzcykNCj4gKyAqCQkJCS0tLS0tLS0tICAgIDwtLSBGTFNI QjJDUjANCj4gKyAqCQkJCXwgIEIyICB8DQo+ICsgKgkJCQl8ICAgICAgfA0KPiArICoJQjIgc3Rh cnQgYWRkcmVzcyAtLT4JLS0tLS0tLS0gICAgPC0tIEZMU0hCMUNSMA0KPiArICoJCQkJfCAgQjEg IHwNCj4gKyAqCQkJCXwgICAgICB8DQo+ICsgKglCMSBzdGFydCBhZGRyZXNzIC0tPgktLS0tLS0t LSAgICA8LS0gRkxTSEEyQ1IwDQo+ICsgKgkJCQl8ICBBMiAgfA0KPiArICoJCQkJfCAgICAgIHwN Cj4gKyAqCUEyIHN0YXJ0IGFkZHJlc3MgLS0+CS0tLS0tLS0tICAgIDwtLSBGTFNIQTFDUjANCj4g KyAqCQkJCXwgIEExICB8DQo+ICsgKgkJCQl8ICAgICAgfA0KPiArICoJQTEgc3RhcnQgYWRkcmVz cyAtLT4JLS0tLS0tLS0JCSAgICAoTG93ZXIgYWRkcmVzcykNCj4gKyAqDQo+ICsgKg0KPiArICog U3RhcnQgYmFzZSBhZGRyZXNzIGRlZmluZXMgdGhlIHN0YXJ0aW5nIGFkZHJlc3MgcmFuZ2UgZm9y IGdpdmVuIENTIGFuZA0KPiArICogRlNQSV9GTFNIWFhDUjAgZGVmaW5lcyB0aGUgc2l6ZSBvZiB0 aGUgc2xhdmUgZGV2aWNlIGNvbm5lY3RlZCBhdCBnaXZlbiBDUy4NCj4gKyAqDQo+ICsgKiBCdXQs IGRpZmZlcmVudCB0YXJnZXRzIGFyZSBoYXZpbmcgZGlmZmVyZW50IGNvbWJpbmF0aW9ucyBvZiBu dW1iZXIgb2YgQ1MsDQo+ICsgKiBzb21lIHRhcmdldHMgb25seSBoYXZlIHNpbmdsZSBDUyBvciB0 d28gQ1MgY292ZXJpbmcgY29udHJvbGxlcidzIGZ1bGwNCj4gKyAqIG1lbW9yeSBtYXBwZWQgc3Bh Y2UgYXJlYS4NCj4gKyAqIFRodXMsIGltcGxlbWVudGF0aW9uIGlzIGJlaW5nIGRvbmUgYXMgaW5k ZXBlbmRlbnQgb2YgdGhlIHNpemUgYW5kIG51bWJlcg0KPiArICogb2YgdGhlIGNvbm5lY3RlZCBz bGF2ZSBkZXZpY2UuDQo+ICsgKiBBc3NpZ24gY29udHJvbGxlciBtZW1vcnkgbWFwcGVkIHNwYWNl IHNpemUgYXMgdGhlIHNpemUgdG8gdGhlIGNvbm5lY3RlZA0KPiArICogc2xhdmUgZGV2aWNlLg0K PiArICogTWFyayBGTFNIeHhDUjAgYXMgemVybyBpbml0aWFsbHkgYW5kIHRoZW4gYXNzaWduIHZh bHVlIG9ubHkgdG8gdGhlIHNlbGVjdGVkDQo+ICsgKiBjaGlwLXNlbGVjdCBGbGFzaCBjb25maWd1 cmF0aW9uIHJlZ2lzdGVyLg0KPiArICoNCj4gKyAqIEZvciBlLmcuIHRvIGFjY2VzcyBDUzIgKEIx KSwgRkxTSEIxQ1IwIHJlZ2lzdGVyIHdvdWxkIGJlIGVxdWFsIHRvIHRoZQ0KPiArICogbWVtb3J5 IG1hcHBlZCBzaXplIG9mIHRoZSBjb250cm9sbGVyLg0KPiArICogVmFsdWUgZm9yIHJlc3Qgb2Yg dGhlIENTIEZMU0h4eENSMCByZWdpc3RlciB3b3VsZCBiZSB6ZXJvLg0KPiArICoNCj4gKyAqLw0K PiArc3RhdGljIHZvaWQgbnhwX2ZzcGlfc2VsZWN0X21lbShzdHJ1Y3QgbnhwX2ZzcGkgKmYsIHN0 cnVjdCBzcGlfZGV2aWNlICpzcGkpDQo+ICt7DQo+ICsJdW5zaWduZWQgbG9uZyByYXRlID0gc3Bp LT5tYXhfc3BlZWRfaHo7DQo+ICsJaW50IHJldDsNCj4gKwl1aW50NjRfdCBzaXplX2tiOw0KPiAr DQo+ICsJLyoNCj4gKwkgKiBSZXR1cm4sIGlmIHByZXZpb3VzbHkgc2VsZWN0ZWQgc2xhdmUgZGV2 aWNlIGlzIHNhbWUgYXMgY3VycmVudA0KPiArCSAqIHJlcXVlc3RlZCBzbGF2ZSBkZXZpY2UuDQo+ ICsJICovDQo+ICsJaWYgKGYtPnNlbGVjdGVkID09IHNwaS0+Y2hpcF9zZWxlY3QpDQo+ICsJCXJl dHVybjsNCj4gKw0KPiArCS8qIFJlc2V0IEZMU0h4eENSMCByZWdpc3RlcnMgKi8NCj4gKwlmc3Bp X3dyaXRlbChmLCAwLCBmLT5pb2Jhc2UgKyBGU1BJX0ZMU0hBMUNSMCk7DQo+ICsJZnNwaV93cml0 ZWwoZiwgMCwgZi0+aW9iYXNlICsgRlNQSV9GTFNIQTJDUjApOw0KPiArCWZzcGlfd3JpdGVsKGYs IDAsIGYtPmlvYmFzZSArIEZTUElfRkxTSEIxQ1IwKTsNCj4gKwlmc3BpX3dyaXRlbChmLCAwLCBm LT5pb2Jhc2UgKyBGU1BJX0ZMU0hCMkNSMCk7DQo+ICsNCj4gKwkvKiBBc3NpZ24gY29udHJvbGxl ciBtZW1vcnkgbWFwcGVkIHNwYWNlIGFzIHNpemUsIEtCeXRlcywgb2YgZmxhc2guICovDQo+ICsJ c2l6ZV9rYiA9IEZTUElfRkxTSFhDUjBfU1ooZi0+bWVtbWFwX3BoeV9zaXplKTsNCg0KWW91IGFy ZSBzdGlsbCB1c2luZyBtZW1vcnkgb2YgYXJiaXRyYXJ5IHNpemUgKG1lbW1hcF9waHlfc2l6ZSkg Zm9yIA0KbWFwcGluZyB0aGUgZmxhc2guIFdoeSBub3QgdXNlIHRoZSBzYW1lIGFwcHJvYWNoIGFz IGluIHRoZSBRU1BJIGRyaXZlciANCmFuZCBqdXN0IG1hcCBhaGJfYnVmX3NpemUgdW50aWwgd2Ug aW1wbGVtZW50IHRoZSBkaXJtYXAgQVBJPw0KWW91IGFyZSBhbHJlYWR5IGFsaWduaW5nIHRoZSBB SEIgcmVhZHMgZm9yIHRoaXMgaW4gDQpueHBfZnNwaV9hZGp1c3Rfb3Bfc2l6ZSgpLg0KDQo+ICsN Cj4gKwlzd2l0Y2ggKHNwaS0+Y2hpcF9zZWxlY3QpIHsNCj4gKwljYXNlIDA6DQo+ICsJCWZzcGlf d3JpdGVsKGYsIHNpemVfa2IsIGYtPmlvYmFzZSArIEZTUElfRkxTSEExQ1IwKTsNCj4gKwkJYnJl YWs7DQo+ICsJY2FzZSAxOg0KPiArCQlmc3BpX3dyaXRlbChmLCBzaXplX2tiLCBmLT5pb2Jhc2Ug KyBGU1BJX0ZMU0hBMkNSMCk7DQo+ICsJCWJyZWFrOw0KPiArCWNhc2UgMjoNCj4gKwkJZnNwaV93 cml0ZWwoZiwgc2l6ZV9rYiwgZi0+aW9iYXNlICsgRlNQSV9GTFNIQjFDUjApOw0KPiArCQlicmVh azsNCj4gKwljYXNlIDM6DQo+ICsJCWZzcGlfd3JpdGVsKGYsIHNpemVfa2IsIGYtPmlvYmFzZSAr IEZTUElfRkxTSEIyQ1IwKTsNCj4gKwkJYnJlYWs7DQo+ICsJZGVmYXVsdDoNCj4gKwkJZGV2X2Vy cihmLT5kZXYsICJJbi1jb3JyZWN0IENTIHByb3ZpZGVkXG4iKTsNCj4gKwkJcmV0dXJuOw0KDQpZ b3UgZG9uJ3QgbmVlZCB0byB2YWxpZGF0ZSBzcGktPmNoaXBfc2VsZWN0IGhlcmUuIFRoaXMgc2hv dWxkIG5ldmVyIGJlIA0KaW52YWxpZCBhbmQgaWYgaXQgaXMsIHNvbWV0aGluZyBpcyByZWFsbHkg d3JvbmcgYW5kIHlvdXIgY2hlY2sgd29uJ3QgaGVscC4NCg0KPiArCX0NCj4gKw0KPiArCWRldl9k YmcoZi0+ZGV2LCAiU2xhdmUgZGV2aWNlIFtDUzoleF0gc2VsZWN0ZWRcbiIsIHNwaS0+Y2hpcF9z ZWxlY3QpOw0KPiArDQo+ICsJbnhwX2ZzcGlfY2xrX2Rpc2FibGVfdW5wcmVwKGYpOw0KPiArDQo+ ICsJcmV0ID0gY2xrX3NldF9yYXRlKGYtPmNsaywgcmF0ZSk7DQo+ICsJaWYgKHJldCkNCj4gKwkJ cmV0dXJuOw0KPiArDQo+ICsJcmV0ID0gbnhwX2ZzcGlfY2xrX3ByZXBfZW5hYmxlKGYpOw0KPiAr CWlmIChyZXQpDQo+ICsJCXJldHVybjsNCg0KTWlzc2luZyBuZXdsaW5lIGxpbmUgaGVyZS4NCg0K PiArCWYtPnNlbGVjdGVkID0gc3BpLT5jaGlwX3NlbGVjdDsNCj4gK30NCj4gKw0KPiArc3RhdGlj IHZvaWQgbnhwX2ZzcGlfcmVhZF9haGIoc3RydWN0IG54cF9mc3BpICpmLCBjb25zdCBzdHJ1Y3Qg c3BpX21lbV9vcCAqb3ApDQo+ICt7DQo+ICsJdTMyIGxlbiA9IG9wLT5kYXRhLm5ieXRlczsNCj4g Kw0KPiArCS8qIFJlYWQgb3V0IHRoZSBkYXRhIGRpcmVjdGx5IGZyb20gdGhlIEFIQiBidWZmZXIu ICovDQo+ICsJbWVtY3B5X2Zyb21pbyhvcC0+ZGF0YS5idWYuaW4sIChmLT5haGJfYWRkciArIG9w LT5hZGRyLnZhbCksIGxlbik7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyB2b2lkIG54cF9mc3BpX2Zp bGxfdHhmaWZvKHN0cnVjdCBueHBfZnNwaSAqZiwNCj4gKwkJCQkgY29uc3Qgc3RydWN0IHNwaV9t ZW1fb3AgKm9wKQ0KPiArew0KPiArCXZvaWQgX19pb21lbSAqYmFzZSA9IGYtPmlvYmFzZTsNCj4g KwlpbnQgaSwgaiwgcmV0Ow0KPiArCWludCBzaXplLCB0bXBfc2l6ZSwgd21fc2l6ZTsNCj4gKwl1 MzIgZGF0YSA9IDA7DQo+ICsJdTMyICp0eGJ1ZiA9ICh1MzIgKikgb3AtPmRhdGEuYnVmLm91dDsN Cj4gKw0KPiArCS8qIGNsZWFyIHRoZSBUWCBGSUZPLiAqLw0KPiArCWZzcGlfd3JpdGVsKGYsIEZT UElfSVBUWEZDUl9DTFIsIGJhc2UgKyBGU1BJX0lQVFhGQ1IpOw0KPiArDQo+ICsJLyogRGVmYXVs dCB2YWx1ZSBvZiB3YXRlciBtYXJrIGxldmVsIGlzIDggYnl0ZXMuICovDQo+ICsJd21fc2l6ZSA9 IDg7DQo+ICsJc2l6ZSA9IG9wLT5kYXRhLm5ieXRlcyAvIHdtX3NpemU7DQo+ICsJZm9yIChpID0g MDsgaSA8IHNpemU7IGkrKykgew0KPiArCQkvKiBXYWl0IGZvciBUWEZJRk8gZW1wdHkgKi8NCj4g KwkJcmV0ID0gZnNwaV9yZWFkbF9wb2xsX3RvdXQoZiwgZi0+aW9iYXNlICsgRlNQSV9JTlRSLA0K PiArCQkJCQkgICBGU1BJX0lOVFJfSVBUWFdFLCAwLA0KPiArCQkJCQkgICBQT0xMX1RPVVQsIHRy dWUpOw0KPiArCQlXQVJOX09OKHJldCk7DQo+ICsNCj4gKwkJaiA9IDA7DQo+ICsJCXRtcF9zaXpl ID0gd21fc2l6ZTsNCj4gKwkJd2hpbGUgKHRtcF9zaXplID4gMCkgew0KPiArCQkJZGF0YSA9IDA7 DQo+ICsJCQltZW1jcHkoJmRhdGEsIHR4YnVmLCA0KTsNCj4gKwkJCWZzcGlfd3JpdGVsKGYsIGRh dGEsIGJhc2UgKyBGU1BJX1RGRFIgKyBqICogNCk7DQo+ICsJCQl0bXBfc2l6ZSAtPSA0Ow0KPiAr CQkJaisrOw0KPiArCQkJdHhidWYgKz0gMTsNCj4gKwkJfQ0KPiArCQlmc3BpX3dyaXRlbChmLCBG U1BJX0lOVFJfSVBUWFdFLCBiYXNlICsgRlNQSV9JTlRSKTsNCj4gKwl9DQo+ICsNCj4gKwlzaXpl ID0gb3AtPmRhdGEubmJ5dGVzICUgd21fc2l6ZTsNCj4gKwlpZiAoc2l6ZSkgew0KPiArCQkvKiBX YWl0IGZvciBUWEZJRk8gZW1wdHkgKi8NCj4gKwkJcmV0ID0gZnNwaV9yZWFkbF9wb2xsX3RvdXQo ZiwgZi0+aW9iYXNlICsgRlNQSV9JTlRSLA0KPiArCQkJCQkgICBGU1BJX0lOVFJfSVBUWFdFLCAw LA0KPiArCQkJCQkgICBQT0xMX1RPVVQsIHRydWUpOw0KPiArCQlXQVJOX09OKHJldCk7DQo+ICsN Cj4gKwkJaiA9IDA7DQo+ICsJCXRtcF9zaXplID0gMDsNCj4gKwkJd2hpbGUgKHNpemUgPiAwKSB7 DQo+ICsJCQlkYXRhID0gMDsNCj4gKwkJCXRtcF9zaXplID0gKHNpemUgPCA0KSA/IHNpemUgOiA0 Ow0KPiArCQkJbWVtY3B5KCZkYXRhLCB0eGJ1ZiwgdG1wX3NpemUpOw0KPiArCQkJZnNwaV93cml0 ZWwoZiwgZGF0YSwgYmFzZSArIEZTUElfVEZEUiArIGogKiA0KTsNCj4gKwkJCXNpemUgLT0gdG1w X3NpemU7DQo+ICsJCQlqKys7DQo+ICsJCQl0eGJ1ZiArPSAxOw0KPiArCQl9DQo+ICsJCWZzcGlf d3JpdGVsKGYsIEZTUElfSU5UUl9JUFRYV0UsIGJhc2UgKyBGU1BJX0lOVFIpOw0KPiArCX0NCg0K QWxsIHRoZXNlIG5lc3RlZCBsb29wcyB0byBmaWxsIHRoZSBUWCBidWZmZXIgYW5kIGFsc28gdGhl IG9uZXMgYmVsb3cgdG8gDQpyZWFkIHRoZSBSWCBidWZmZXIgbG9vayBtdWNoIG1vcmUgY29tcGxp Y2F0ZWQgdGhhbiB0aGV5IHNob3VsZCByZWFsbHkgDQpiZS4gQ2FuIHlvdSB0cnkgdG8gbWFrZSB0 aGlzIG1vcmUgcmVhZGFibGU/DQoNCk1heWJlIHNvbWV0aGluZyBsaWtlIHRoaXMgd291bGQgd29y azoNCg0KZm9yIChpID0gMDsgaSA8IEFMSUdOX0RPV04ob3AtPmRhdGEubmJ5dGVzLCA4KTsgaSAr PSA4KSB7DQoJLyogV2FpdCBmb3IgVFhGSUZPIGVtcHR5ICovDQoJcmV0ID0gZnNwaV9yZWFkbF9w b2xsX3RvdXQoZiwgZi0+aW9iYXNlICsgRlNQSV9JTlRSLA0KCQkJCSAgIEZTUElfSU5UUl9JUFRY V0UsIDAsDQoJCQkJICAgUE9MTF9UT1VULCB0cnVlKTsNCg0KCWZzcGlfd3JpdGVsKGYsIG9wLT5k YXRhLmJ1Zi5vdXQgKyBpLCBiYXNlICsgRlNQSV9URkRSKTsNCglmc3BpX3dyaXRlbChmLCBvcC0+ ZGF0YS5idWYub3V0ICsgaSArIDQsIGJhc2UgKyBGU1BJX1RGRFIgKyA0KTsNCglmc3BpX3dyaXRl bChmLCBGU1BJX0lOVFJfSVBUWFdFLCBiYXNlICsgRlNQSV9JTlRSKTsNCn0NCg0KaWYgKGkgPCBv cC0+ZGF0YS5uYnl0ZXMpIHsNCgl1MzIgZGF0YSA9IDA7DQoJaW50IGo7DQoJLyogV2FpdCBmb3Ig VFhGSUZPIGVtcHR5ICovDQoJcmV0ID0gZnNwaV9yZWFkbF9wb2xsX3RvdXQoZiwgZi0+aW9iYXNl ICsgRlNQSV9JTlRSLA0KCQkJCSAgIEZTUElfSU5UUl9JUFRYV0UsIDAsDQoJCQkJICAgUE9MTF9U T1VULCB0cnVlKTsNCg0KCWZvciAoaiA9IDA7IGogPCBBTElHTihvcC0+ZGF0YS5uYnl0ZXMgLSBp LCA0KTsgaiArPSA0KSB7DQoJCW1lbWNweSgmZGF0YSwgb3AtPmRhdGEuYnVmLm91dCArIGkgKyBq LCA0KTsNCgkJZnNwaV93cml0ZWwoZiwgZGF0YSwgYmFzZSArIEZTUElfVEZEUiArIGopOw0KCX0N Cg0KCWZzcGlfd3JpdGVsKGYsIEZTUElfSU5UUl9JUFRYV0UsIGJhc2UgKyBGU1BJX0lOVFIpOw0K fQ0KDQo+ICt9DQo+ICsNCj4gK3N0YXRpYyB2b2lkIG54cF9mc3BpX3JlYWRfcnhmaWZvKHN0cnVj dCBueHBfZnNwaSAqZiwNCj4gKwkJCSAgY29uc3Qgc3RydWN0IHNwaV9tZW1fb3AgKm9wKQ0KPiAr ew0KPiArCXZvaWQgX19pb21lbSAqYmFzZSA9IGYtPmlvYmFzZTsNCj4gKwlpbnQgaSwgajsNCj4g KwlpbnQgc2l6ZSwgdG1wX3NpemUsIHdtX3NpemUsIHJldDsNCj4gKwl1MzIgdG1wID0gMDsNCj4g Kwl1OCAqYnVmID0gb3AtPmRhdGEuYnVmLmluOw0KPiArCXUzMiBsZW4gPSBvcC0+ZGF0YS5uYnl0 ZXM7DQo+ICsNCj4gKwkvKiBEZWZhdWx0IHZhbHVlIG9mIHdhdGVyIG1hcmsgbGV2ZWwgaXMgOCBi eXRlcy4gKi8NCj4gKwl3bV9zaXplID0gODsNCj4gKw0KPiArCXdoaWxlIChsZW4gPiAwKSB7DQo+ ICsJCXNpemUgPSBsZW4gLyB3bV9zaXplOw0KPiArDQo+ICsJCWZvciAoaSA9IDA7IGkgPCBzaXpl OyBpKyspIHsNCj4gKwkJCS8qIFdhaXQgZm9yIFJYRklGTyBhdmFpbGFibGUgKi8NCj4gKwkJCXJl dCA9IGZzcGlfcmVhZGxfcG9sbF90b3V0KGYsIGYtPmlvYmFzZSArIEZTUElfSU5UUiwNCj4gKwkJ CQkJCSAgIEZTUElfSU5UUl9JUFJYV0EsIDAsDQo+ICsJCQkJCQkgICBQT0xMX1RPVVQsIHRydWUp Ow0KPiArCQkJV0FSTl9PTihyZXQpOw0KPiArDQo+ICsJCQlqID0gMDsNCj4gKwkJCXRtcF9zaXpl ID0gd21fc2l6ZTsNCj4gKwkJCXdoaWxlICh0bXBfc2l6ZSA+IDApIHsNCj4gKwkJCQl0bXAgPSAw Ow0KPiArCQkJCXRtcCA9IGZzcGlfcmVhZGwoZiwgYmFzZSArIEZTUElfUkZEUiArIGogKiA0KTsN Cj4gKwkJCQltZW1jcHkoYnVmLCAmdG1wLCA0KTsNCj4gKwkJCQl0bXBfc2l6ZSAtPSA0Ow0KPiAr CQkJCWorKzsNCj4gKwkJCQlidWYgKz0gNDsNCj4gKwkJCX0NCj4gKwkJCS8qIG1vdmUgdGhlIEZJ Rk8gcG9pbnRlciAqLw0KPiArCQkJZnNwaV93cml0ZWwoZiwgRlNQSV9JTlRSX0lQUlhXQSwgYmFz ZSArIEZTUElfSU5UUik7DQo+ICsJCQlsZW4gLT0gd21fc2l6ZTsNCj4gKwkJfQ0KPiArDQo+ICsJ CXNpemUgPSBsZW4gJSB3bV9zaXplOw0KPiArDQo+ICsJCWogPSAwOw0KPiArCQlpZiAoc2l6ZSkg ew0KPiArCQkJLyogV2FpdCBmb3IgUlhGSUZPIGF2YWlsYWJsZSAqLw0KPiArCQkJcmV0ID0gZnNw aV9yZWFkbF9wb2xsX3RvdXQoZiwgZi0+aW9iYXNlICsgRlNQSV9JTlRSLA0KPiArCQkJCQkJICAg RlNQSV9JTlRSX0lQUlhXQSwgMCwNCj4gKwkJCQkJCSAgIFBPTExfVE9VVCwgdHJ1ZSk7DQo+ICsJ CQlXQVJOX09OKHJldCk7DQo+ICsNCj4gKwkJCXdoaWxlIChsZW4gPiAwKSB7DQo+ICsJCQkJdG1w ID0gMDsNCj4gKwkJCQlzaXplID0gKGxlbiA8IDQpID8gbGVuIDogNDsNCj4gKwkJCQl0bXAgPSBm c3BpX3JlYWRsKGYsIGJhc2UgKyBGU1BJX1JGRFIgKyBqICogNCk7DQo+ICsJCQkJbWVtY3B5KGJ1 ZiwgJnRtcCwgc2l6ZSk7DQo+ICsJCQkJbGVuIC09IHNpemU7DQo+ICsJCQkJaisrOw0KPiArCQkJ CWJ1ZiArPSBzaXplOw0KPiArCQkJfQ0KPiArCQl9DQo+ICsNCj4gKwkJLyogaW52YWxpZCB0aGUg UlhGSUZPICovDQo+ICsJCWZzcGlfd3JpdGVsKGYsIEZTUElfSVBSWEZDUl9DTFIsIGJhc2UgKyBG U1BJX0lQUlhGQ1IpOw0KPiArCQkvKiBtb3ZlIHRoZSBGSUZPIHBvaW50ZXIgKi8NCj4gKwkJZnNw aV93cml0ZWwoZiwgRlNQSV9JTlRSX0lQUlhXQSwgYmFzZSArIEZTUElfSU5UUik7DQo+ICsJfQ0K DQpTYW1lIGhlcmUuIEkgdGhpbmsgdGhpcyBpcyBvdmVybHkgY29tcGxpY2F0ZWQuDQoNCj4gK30N Cj4gKw0KPiArc3RhdGljIGludCBueHBfZnNwaV9kb19vcChzdHJ1Y3QgbnhwX2ZzcGkgKmYsIGNv bnN0IHN0cnVjdCBzcGlfbWVtX29wICpvcCkNCj4gK3sNCj4gKwl2b2lkIF9faW9tZW0gKmJhc2Ug PSBmLT5pb2Jhc2U7DQo+ICsJaW50IHNlcW51bSA9IDA7DQo+ICsJaW50IGVyciA9IDA7DQo+ICsJ dTMyIHJlZzsNCj4gKw0KPiArCXJlZyA9IGZzcGlfcmVhZGwoZiwgYmFzZSArIEZTUElfSVBSWEZD Uik7DQo+ICsJLyogaW52YWxpZCBSWEZJRk8gZmlyc3QgKi8NCj4gKwlyZWcgJj0gfkZTUElfSVBS WEZDUl9ETUFfRU47DQo+ICsJcmVnID0gcmVnIHwgRlNQSV9JUFJYRkNSX0NMUjsNCj4gKwlmc3Bp X3dyaXRlbChmLCByZWcsIGJhc2UgKyBGU1BJX0lQUlhGQ1IpOw0KPiArDQo+ICsJaW5pdF9jb21w bGV0aW9uKCZmLT5jKTsNCj4gKw0KPiArCWZzcGlfd3JpdGVsKGYsIG9wLT5hZGRyLnZhbCwgYmFz ZSArIEZTUElfSVBDUjApOw0KPiArCS8qDQo+ICsJICogQWx3YXlzIHN0YXJ0IHRoZSBzZXF1ZW5j ZSBhdCB0aGUgc2FtZSBpbmRleCBzaW5jZSB3ZSB1cGRhdGUNCj4gKwkgKiB0aGUgTFVUIGF0IGVh Y2ggZXhlY19vcCgpIGNhbGwuIEFuZCBhbHNvIHNwZWNpZnkgdGhlIERBVEENCj4gKwkgKiBsZW5n dGgsIHNpbmNlIGl0J3MgaGFzIG5vdCBiZWVuIHNwZWNpZmllZCBpbiB0aGUgTFVULg0KPiArCSAq Lw0KPiArCWZzcGlfd3JpdGVsKGYsIG9wLT5kYXRhLm5ieXRlcyB8DQo+ICsJCSAoU0VRSURfTFVU IDw8IEZTUElfSVBDUjFfU0VRSURfU0hJRlQpIHwNCj4gKwkJIChzZXFudW0gPDwgRlNQSV9JUENS MV9TRVFOVU1fU0hJRlQpLA0KPiArCQkgYmFzZSArIEZTUElfSVBDUjEpOw0KPiArDQo+ICsJLyog VHJpZ2dlciB0aGUgTFVUIG5vdy4gKi8NCj4gKwlmc3BpX3dyaXRlbChmLCBGU1BJX0lQQ01EX1RS RywgYmFzZSArIEZTUElfSVBDTUQpOw0KPiArDQo+ICsJLyogV2FpdCBmb3IgdGhlIGludGVycnVw dC4gKi8NCj4gKwlpZiAoIXdhaXRfZm9yX2NvbXBsZXRpb25fdGltZW91dCgmZi0+YywgbXNlY3Nf dG9famlmZmllcygxMDAwKSkpDQo+ICsJCWVyciA9IC1FVElNRURPVVQ7DQo+ICsNCj4gKwkvKiBJ bnZva2UgSVAgZGF0YSByZWFkLCBpZiByZXF1ZXN0IGlzIG9mIGRhdGEgcmVhZC4gKi8NCj4gKwlp ZiAoIWVyciAmJiBvcC0+ZGF0YS5uYnl0ZXMgJiYgb3AtPmRhdGEuZGlyID09IFNQSV9NRU1fREFU QV9JTikNCj4gKwkJbnhwX2ZzcGlfcmVhZF9yeGZpZm8oZiwgb3ApOw0KPiArDQo+ICsJcmV0dXJu IGVycjsNCj4gK30NCj4gKw0KPiArc3RhdGljIGludCBueHBfZnNwaV9leGVjX29wKHN0cnVjdCBz cGlfbWVtICptZW0sIGNvbnN0IHN0cnVjdCBzcGlfbWVtX29wICpvcCkNCj4gK3sNCj4gKwlzdHJ1 Y3QgbnhwX2ZzcGkgKmYgPSBzcGlfY29udHJvbGxlcl9nZXRfZGV2ZGF0YShtZW0tPnNwaS0+bWFz dGVyKTsNCj4gKwlpbnQgZXJyID0gMDsNCj4gKw0KPiArCW11dGV4X2xvY2soJmYtPmxvY2spOw0K PiArDQo+ICsJLyogV2FpdCBmb3IgY29udHJvbGxlciBiZWluZyByZWFkeS4gKi8NCj4gKwllcnIg PSBmc3BpX3JlYWRsX3BvbGxfdG91dChmLCBmLT5pb2Jhc2UgKyBGU1BJX1NUUzAsDQo+ICsJCQkJ ICAgRlNQSV9TVFMwX0FSQl9JRExFLCAxLCBQT0xMX1RPVVQsIHRydWUpOw0KPiArCVdBUk5fT04o ZXJyKTsNCj4gKw0KPiArCW54cF9mc3BpX3NlbGVjdF9tZW0oZiwgbWVtLT5zcGkpOw0KPiArDQo+ ICsJbnhwX2ZzcGlfcHJlcGFyZV9sdXQoZiwgb3ApOw0KPiArCS8qDQo+ICsJICogSWYgd2UgaGF2 ZSBsYXJnZSBjaHVua3Mgb2YgZGF0YSwgd2UgcmVhZCB0aGVtIHRocm91Z2ggdGhlIEFIQiBidXMN Cj4gKwkgKiBieSBhY2Nlc3NpbmcgdGhlIG1hcHBlZCBtZW1vcnkuIEluIGFsbCBvdGhlciBjYXNl cyB3ZSB1c2UNCj4gKwkgKiBJUCBjb21tYW5kcyB0byBhY2Nlc3MgdGhlIGZsYXNoLg0KPiArCSAq Lw0KPiArCWlmIChvcC0+ZGF0YS5uYnl0ZXMgPiAoZi0+ZGV2dHlwZV9kYXRhLT5yeGZpZm8gLSA0 KSAmJg0KPiArCSAgICBvcC0+ZGF0YS5kaXIgPT0gU1BJX01FTV9EQVRBX0lOKSB7DQo+ICsJCW54 cF9mc3BpX3JlYWRfYWhiKGYsIG9wKTsNCj4gKwl9IGVsc2Ugew0KPiArCQlpZiAob3AtPmRhdGEu bmJ5dGVzICYmIG9wLT5kYXRhLmRpciA9PSBTUElfTUVNX0RBVEFfT1VUKQ0KPiArCQkJbnhwX2Zz cGlfZmlsbF90eGZpZm8oZiwgb3ApOw0KPiArDQo+ICsJCWVyciA9IG54cF9mc3BpX2RvX29wKGYs IG9wKTsNCj4gKw0KPiArCQkvKiBJbnZhbGlkYXRlIHRoZSBkYXRhIGluIHRoZSBBSEIgYnVmZmVy LiAqLw0KPiArCQlpZiAob3AtPmRhdGEubmJ5dGVzICYmIG9wLT5kYXRhLmRpciA9PSBTUElfTUVN X0RBVEFfT1VUKQ0KPiArCQkJbnhwX2ZzcGlfaW52YWxpZChmKTsNCg0KRS5nLiBpbiBjYXNlIG9m IGFuIGVyYXNlIG9wZXJhdGlvbiBvciBhIE5BTkQgbG9hZCBwYWdlIG9wZXJhdGlvbiwgdGhlIA0K aW52YWxpZGF0aW9uIGlzIG5vdCB0cmlnZ2VyZWQsIGJ1dCBmbGFzaC9idWZmZXIgY29udGVudHMg aGF2ZSBjaGFuZ2VkLiANClNvIEknbSBub3Qgc3VyZSBpZiB0aGlzIGlzIGVub3VnaC4uLg0KDQo+ ICsJfQ0KPiArDQo+ICsJbXV0ZXhfdW5sb2NrKCZmLT5sb2NrKTsNCj4gKw0KPiArCXJldHVybiBl cnI7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpbnQgbnhwX2ZzcGlfYWRqdXN0X29wX3NpemUoc3Ry dWN0IHNwaV9tZW0gKm1lbSwgc3RydWN0IHNwaV9tZW1fb3AgKm9wKQ0KPiArew0KPiArCXN0cnVj dCBueHBfZnNwaSAqZiA9IHNwaV9jb250cm9sbGVyX2dldF9kZXZkYXRhKG1lbS0+c3BpLT5tYXN0 ZXIpOw0KPiArDQo+ICsJaWYgKG9wLT5kYXRhLmRpciA9PSBTUElfTUVNX0RBVEFfT1VUKSB7DQo+ ICsJCWlmIChvcC0+ZGF0YS5uYnl0ZXMgPiBmLT5kZXZ0eXBlX2RhdGEtPnR4ZmlmbykNCj4gKwkJ CW9wLT5kYXRhLm5ieXRlcyA9IGYtPmRldnR5cGVfZGF0YS0+dHhmaWZvOw0KPiArCX0gZWxzZSB7 DQo+ICsJCWlmIChvcC0+ZGF0YS5uYnl0ZXMgPiBmLT5kZXZ0eXBlX2RhdGEtPmFoYl9idWZfc2l6 ZSkNCj4gKwkJCW9wLT5kYXRhLm5ieXRlcyA9IGYtPmRldnR5cGVfZGF0YS0+YWhiX2J1Zl9zaXpl Ow0KPiArCQllbHNlIGlmIChvcC0+ZGF0YS5uYnl0ZXMgPiAoZi0+ZGV2dHlwZV9kYXRhLT5yeGZp Zm8gLSA0KSkNCj4gKwkJCW9wLT5kYXRhLm5ieXRlcyA9IEFMSUdOX0RPV04ob3AtPmRhdGEubmJ5 dGVzLCA4KTsNCg0KWW91IGFyZSB1c2luZyB0aGUgc2FtZSBhbGlnbm1lbnRzIGFzIGluIHRoZSBR U1BJIGRyaXZlci4gU28gQUhCIHJlYWRzIA0Kd2lsbCBoYXBwZW4gaW4gcG9ydGlvbnMgb2YgYWhi X2J1Zl9zaXplLCBidXQgeW91IGRvbnQnIHN0aWNrIHRvIHRoaXMgDQp3aGVuIHlvdSBtYXAgdGhl IG1lbW9yeS4gU2VlIGFib3ZlLg0KDQpSZWdhcmRzLA0KRnJpZWRlcg0KDQo+ICsJfQ0KPiArDQo+ ICsJcmV0dXJuIDA7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpbnQgbnhwX2ZzcGlfZGVmYXVsdF9z ZXR1cChzdHJ1Y3QgbnhwX2ZzcGkgKmYpDQo+ICt7DQo+ICsJdm9pZCBfX2lvbWVtICpiYXNlID0g Zi0+aW9iYXNlOw0KPiArCWludCByZXQsIGk7DQo+ICsJdTMyIHJlZzsNCj4gKw0KPiArCS8qIGRp c2FibGUgYW5kIHVucHJlcGFyZSBjbG9jayB0byBhdm9pZCBnbGl0Y2ggcGFzcyB0byBjb250cm9s bGVyICovDQo+ICsJbnhwX2ZzcGlfY2xrX2Rpc2FibGVfdW5wcmVwKGYpOw0KPiArDQo+ICsJLyog dGhlIGRlZmF1bHQgZnJlcXVlbmN5LCB3ZSB3aWxsIGNoYW5nZSBpdCBsYXRlciBpZiBuZWNlc3Nh cnkuICovDQo+ICsJcmV0ID0gY2xrX3NldF9yYXRlKGYtPmNsaywgMjAwMDAwMDApOw0KPiArCWlm IChyZXQpDQo+ICsJCXJldHVybiByZXQ7DQo+ICsNCj4gKwlyZXQgPSBueHBfZnNwaV9jbGtfcHJl cF9lbmFibGUoZik7DQo+ICsJaWYgKHJldCkNCj4gKwkJcmV0dXJuIHJldDsNCj4gKw0KPiArCS8q IFJlc2V0IHRoZSBtb2R1bGUgKi8NCj4gKwkvKiB3MWMgcmVnaXN0ZXIsIHdhaXQgdW5pdCBjbGVh ciAqLw0KPiArCXJldCA9IGZzcGlfcmVhZGxfcG9sbF90b3V0KGYsIGYtPmlvYmFzZSArIEZTUElf TUNSMCwNCj4gKwkJCQkgICBGU1BJX01DUjBfU1dSU1QsIDAsIFBPTExfVE9VVCwgZmFsc2UpOw0K PiArCVdBUk5fT04ocmV0KTsNCj4gKw0KPiArCS8qIERpc2FibGUgdGhlIG1vZHVsZSAqLw0KPiAr CWZzcGlfd3JpdGVsKGYsIEZTUElfTUNSMF9NRElTLCBiYXNlICsgRlNQSV9NQ1IwKTsNCj4gKw0K PiArCS8qIFJlc2V0IHRoZSBETEwgcmVnaXN0ZXIgdG8gZGVmYXVsdCB2YWx1ZSAqLw0KPiArCWZz cGlfd3JpdGVsKGYsIEZTUElfRExMQUNSX09WUkRFTiwgYmFzZSArIEZTUElfRExMQUNSKTsNCj4g Kwlmc3BpX3dyaXRlbChmLCBGU1BJX0RMTEJDUl9PVlJERU4sIGJhc2UgKyBGU1BJX0RMTEJDUik7 DQo+ICsNCj4gKwkvKiBlbmFibGUgbW9kdWxlICovDQo+ICsJZnNwaV93cml0ZWwoZiwgRlNQSV9N Q1IwX0FIQl9USU1FT1VUKDB4RkYpIHwgRlNQSV9NQ1IwX0lQX1RJTUVPVVQoMHhGRiksDQo+ICsJ CSBiYXNlICsgRlNQSV9NQ1IwKTsNCj4gKw0KPiArCS8qDQo+ICsJICogRGlzYWJsZSBzYW1lIGRl dmljZSBlbmFibGUgYml0IGFuZCBjb25maWd1cmUgYWxsIHNsYXZlIGRldmljZXMNCj4gKwkgKiBp bmRlcGVuZGVudGx5Lg0KPiArCSAqLw0KPiArCXJlZyA9IGZzcGlfcmVhZGwoZiwgZi0+aW9iYXNl ICsgRlNQSV9NQ1IyKTsNCj4gKwlyZWcgPSByZWcgJiB+KEZTUElfTUNSMl9TQU1FREVWSUNFRU4p Ow0KPiArCWZzcGlfd3JpdGVsKGYsIHJlZywgYmFzZSArIEZTUElfTUNSMik7DQo+ICsNCj4gKwkv KiBBSEIgY29uZmlndXJhdGlvbiBmb3IgYWNjZXNzIGJ1ZmZlciAwfjcuICovDQo+ICsJZm9yIChp ID0gMDsgaSA8IDc7IGkrKykNCj4gKwkJZnNwaV93cml0ZWwoZiwgMCwgYmFzZSArIEZTUElfQUhC UlhfQlVGMENSMCArIDQgKiBpKTsNCj4gKw0KPiArCS8qDQo+ICsJICogU2V0IEFEQVRTWiB3aXRo IHRoZSBtYXhpbXVtIEFIQiBidWZmZXIgc2l6ZSB0byBpbXByb3ZlIHRoZSByZWFkDQo+ICsJICog cGVyZm9ybWFuY2UuDQo+ICsJICovDQo+ICsJZnNwaV93cml0ZWwoZiwgKGYtPmRldnR5cGVfZGF0 YS0+YWhiX2J1Zl9zaXplIC8gOCB8DQo+ICsJCSAgRlNQSV9BSEJSWEJVRjBDUjdfUFJFRiksIGJh c2UgKyBGU1BJX0FIQlJYX0JVRjdDUjApOw0KPiArDQo+ICsJLyogcHJlZmV0Y2ggYW5kIG5vIHN0 YXJ0IGFkZHJlc3MgYWxpZ25tZW50IGxpbWl0YXRpb24gKi8NCj4gKwlmc3BpX3dyaXRlbChmLCBG U1BJX0FIQkNSX1BSRUZfRU4gfCBGU1BJX0FIQkNSX1JEQUREUk9QVCwNCj4gKwkJIGJhc2UgKyBG U1BJX0FIQkNSKTsNCj4gKw0KPiArCS8qIEFIQiBSZWFkIC0gU2V0IGx1dCBzZXF1ZW5jZSBJRCBm b3IgYWxsIENTLiAqLw0KPiArCWZzcGlfd3JpdGVsKGYsIFNFUUlEX0xVVCwgYmFzZSArIEZTUElf RkxTSEExQ1IyKTsNCj4gKwlmc3BpX3dyaXRlbChmLCBTRVFJRF9MVVQsIGJhc2UgKyBGU1BJX0ZM U0hBMkNSMik7DQo+ICsJZnNwaV93cml0ZWwoZiwgU0VRSURfTFVULCBiYXNlICsgRlNQSV9GTFNI QjFDUjIpOw0KPiArCWZzcGlfd3JpdGVsKGYsIFNFUUlEX0xVVCwgYmFzZSArIEZTUElfRkxTSEIy Q1IyKTsNCj4gKw0KPiArCWYtPnNlbGVjdGVkID0gLTE7DQo+ICsNCj4gKwkvKiBlbmFibGUgdGhl IGludGVycnVwdCAqLw0KPiArCWZzcGlfd3JpdGVsKGYsIEZTUElfSU5URU5fSVBDTURET05FLCBi YXNlICsgRlNQSV9JTlRFTik7DQo+ICsNCj4gKwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiArc3Rh dGljIGNvbnN0IHN0cnVjdCBzcGlfY29udHJvbGxlcl9tZW1fb3BzIG54cF9mc3BpX21lbV9vcHMg PSB7DQo+ICsJLmFkanVzdF9vcF9zaXplID0gbnhwX2ZzcGlfYWRqdXN0X29wX3NpemUsDQo+ICsJ LnN1cHBvcnRzX29wID0gbnhwX2ZzcGlfc3VwcG9ydHNfb3AsDQo+ICsJLmV4ZWNfb3AgPSBueHBf ZnNwaV9leGVjX29wLA0KPiArfTsNCj4gKw0KPiArc3RhdGljIGludCBueHBfZnNwaV9wcm9iZShz dHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KPiArew0KPiArCXN0cnVjdCBzcGlfY29udHJv bGxlciAqY3RscjsNCj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2Ow0KPiArCXN0 cnVjdCBkZXZpY2Vfbm9kZSAqbnAgPSBkZXYtPm9mX25vZGU7DQo+ICsJc3RydWN0IHJlc291cmNl ICpyZXM7DQo+ICsJc3RydWN0IG54cF9mc3BpICpmOw0KPiArCWludCByZXQ7DQo+ICsNCj4gKwlj dGxyID0gc3BpX2FsbG9jX21hc3RlcigmcGRldi0+ZGV2LCBzaXplb2YoKmYpKTsNCj4gKwlpZiAo IWN0bHIpDQo+ICsJCXJldHVybiAtRU5PTUVNOw0KPiArDQo+ICsJY3Rsci0+bW9kZV9iaXRzID0g U1BJX1JYX0RVQUwgfCBTUElfUlhfUVVBRCB8DQo+ICsJCQkgIFNQSV9UWF9EVUFMIHwgU1BJX1RY X1FVQUQ7DQo+ICsNCj4gKwlmID0gc3BpX2NvbnRyb2xsZXJfZ2V0X2RldmRhdGEoY3Rscik7DQo+ ICsJZi0+ZGV2ID0gZGV2Ow0KPiArCWYtPmRldnR5cGVfZGF0YSA9IG9mX2RldmljZV9nZXRfbWF0 Y2hfZGF0YShkZXYpOw0KPiArCWlmICghZi0+ZGV2dHlwZV9kYXRhKSB7DQo+ICsJCXJldCA9IC1F Tk9ERVY7DQo+ICsJCWdvdG8gZXJyX3B1dF9jdHJsOw0KPiArCX0NCj4gKw0KPiArCXBsYXRmb3Jt X3NldF9kcnZkYXRhKHBkZXYsIGYpOw0KPiArDQo+ICsJLyogZmluZCB0aGUgcmVzb3VyY2VzIC0g Y29uZmlndXJhdGlvbiByZWdpc3RlciBhZGRyZXNzIHNwYWNlICovDQo+ICsJcmVzID0gcGxhdGZv cm1fZ2V0X3Jlc291cmNlX2J5bmFtZShwZGV2LCBJT1JFU09VUkNFX01FTSwgImZzcGlfYmFzZSIp Ow0KPiArCWYtPmlvYmFzZSA9IGRldm1faW9yZW1hcF9yZXNvdXJjZShkZXYsIHJlcyk7DQo+ICsJ aWYgKElTX0VSUihmLT5pb2Jhc2UpKSB7DQo+ICsJCXJldCA9IFBUUl9FUlIoZi0+aW9iYXNlKTsN Cj4gKwkJZ290byBlcnJfcHV0X2N0cmw7DQo+ICsJfQ0KPiArDQo+ICsJLyogZmluZCB0aGUgcmVz b3VyY2VzIC0gY29udHJvbGxlciBtZW1vcnkgbWFwcGVkIHNwYWNlICovDQo+ICsJcmVzID0gcGxh dGZvcm1fZ2V0X3Jlc291cmNlX2J5bmFtZShwZGV2LCBJT1JFU09VUkNFX01FTSwgImZzcGlfbW1h cCIpOw0KPiArCWYtPmFoYl9hZGRyID0gZGV2bV9pb3JlbWFwX3Jlc291cmNlKGRldiwgcmVzKTsN Cj4gKwlpZiAoSVNfRVJSKGYtPmFoYl9hZGRyKSkgew0KPiArCQlyZXQgPSBQVFJfRVJSKGYtPmFo Yl9hZGRyKTsNCj4gKwkJZ290byBlcnJfcHV0X2N0cmw7DQo+ICsJfQ0KPiArDQo+ICsJLyogYXNz aWduIG1lbW9yeSBtYXBwZWQgc3RhcnRpbmcgYWRkcmVzcyBhbmQgbWFwcGVkIHNpemUuICovDQo+ ICsJZi0+bWVtbWFwX3BoeSA9IHJlcy0+c3RhcnQ7DQo+ICsJZi0+bWVtbWFwX3BoeV9zaXplID0g cmVzb3VyY2Vfc2l6ZShyZXMpOw0KPiArDQo+ICsJLyogZmluZCB0aGUgY2xvY2tzICovDQo+ICsJ Zi0+Y2xrX2VuID0gZGV2bV9jbGtfZ2V0KGRldiwgImZzcGlfZW4iKTsNCj4gKwlpZiAoSVNfRVJS KGYtPmNsa19lbikpIHsNCj4gKwkJcmV0ID0gUFRSX0VSUihmLT5jbGtfZW4pOw0KPiArCQlnb3Rv IGVycl9wdXRfY3RybDsNCj4gKwl9DQo+ICsNCj4gKwlmLT5jbGsgPSBkZXZtX2Nsa19nZXQoZGV2 LCAiZnNwaSIpOw0KPiArCWlmIChJU19FUlIoZi0+Y2xrKSkgew0KPiArCQlyZXQgPSBQVFJfRVJS KGYtPmNsayk7DQo+ICsJCWdvdG8gZXJyX3B1dF9jdHJsOw0KPiArCX0NCj4gKw0KPiArCXJldCA9 IG54cF9mc3BpX2Nsa19wcmVwX2VuYWJsZShmKTsNCj4gKwlpZiAocmV0KSB7DQo+ICsJCWRldl9l cnIoZGV2LCAiY2FuIG5vdCBlbmFibGUgdGhlIGNsb2NrXG4iKTsNCj4gKwkJZ290byBlcnJfcHV0 X2N0cmw7DQo+ICsJfQ0KPiArDQo+ICsJLyogZmluZCB0aGUgaXJxICovDQo+ICsJcmV0ID0gcGxh dGZvcm1fZ2V0X2lycShwZGV2LCAwKTsNCj4gKwlpZiAocmV0IDwgMCkgew0KPiArCQlkZXZfZXJy KGRldiwgImZhaWxlZCB0byBnZXQgdGhlIGlycTogJWRcbiIsIHJldCk7DQo+ICsJCWdvdG8gZXJy X2Rpc2FibGVfY2xrOw0KPiArCX0NCj4gKw0KPiArCXJldCA9IGRldm1fcmVxdWVzdF9pcnEoZGV2 LCByZXQsDQo+ICsJCQlueHBfZnNwaV9pcnFfaGFuZGxlciwgMCwgcGRldi0+bmFtZSwgZik7DQo+ ICsJaWYgKHJldCkgew0KPiArCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byByZXF1ZXN0IGlycTog JWRcbiIsIHJldCk7DQo+ICsJCWdvdG8gZXJyX2Rpc2FibGVfY2xrOw0KPiArCX0NCj4gKw0KPiAr CW11dGV4X2luaXQoJmYtPmxvY2spOw0KPiArDQo+ICsJY3Rsci0+YnVzX251bSA9IC0xOw0KPiAr CWN0bHItPm51bV9jaGlwc2VsZWN0ID0gTlhQX0ZTUElfTUFYX0NISVBTRUxFQ1Q7DQo+ICsJY3Rs ci0+bWVtX29wcyA9ICZueHBfZnNwaV9tZW1fb3BzOw0KPiArDQo+ICsJbnhwX2ZzcGlfZGVmYXVs dF9zZXR1cChmKTsNCj4gKw0KPiArCWN0bHItPmRldi5vZl9ub2RlID0gbnA7DQo+ICsNCj4gKwly ZXQgPSBzcGlfcmVnaXN0ZXJfY29udHJvbGxlcihjdGxyKTsNCj4gKwlpZiAocmV0KQ0KPiArCQln b3RvIGVycl9kZXN0cm95X211dGV4Ow0KPiArDQo+ICsJcmV0dXJuIDA7DQo+ICsNCj4gK2Vycl9k ZXN0cm95X211dGV4Og0KPiArCW11dGV4X2Rlc3Ryb3koJmYtPmxvY2spOw0KPiArDQo+ICtlcnJf ZGlzYWJsZV9jbGs6DQo+ICsJbnhwX2ZzcGlfY2xrX2Rpc2FibGVfdW5wcmVwKGYpOw0KPiArDQo+ ICtlcnJfcHV0X2N0cmw6DQo+ICsJc3BpX2NvbnRyb2xsZXJfcHV0KGN0bHIpOw0KPiArDQo+ICsJ ZGV2X2VycihkZXYsICJOWFAgRlNQSSBwcm9iZSBmYWlsZWRcbiIpOw0KPiArCXJldHVybiByZXQ7 DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpbnQgbnhwX2ZzcGlfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9y bV9kZXZpY2UgKnBkZXYpDQo+ICt7DQo+ICsJc3RydWN0IG54cF9mc3BpICpmID0gcGxhdGZvcm1f Z2V0X2RydmRhdGEocGRldik7DQo+ICsNCj4gKwkvKiBkaXNhYmxlIHRoZSBoYXJkd2FyZSAqLw0K PiArCWZzcGlfd3JpdGVsKGYsIEZTUElfTUNSMF9NRElTLCBmLT5pb2Jhc2UgKyBGU1BJX01DUjAp Ow0KPiArDQo+ICsJbnhwX2ZzcGlfY2xrX2Rpc2FibGVfdW5wcmVwKGYpOw0KPiArDQo+ICsJbXV0 ZXhfZGVzdHJveSgmZi0+bG9jayk7DQo+ICsNCj4gKwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiAr c3RhdGljIGludCBueHBfZnNwaV9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldikNCj4gK3sNCj4g KwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiArc3RhdGljIGludCBueHBfZnNwaV9yZXN1bWUoc3Ry dWN0IGRldmljZSAqZGV2KQ0KPiArew0KPiArCXN0cnVjdCBueHBfZnNwaSAqZiA9IGRldl9nZXRf ZHJ2ZGF0YShkZXYpOw0KPiArDQo+ICsJbnhwX2ZzcGlfZGVmYXVsdF9zZXR1cChmKTsNCj4gKw0K PiArCXJldHVybiAwOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2Rldmlj ZV9pZCBueHBfZnNwaV9kdF9pZHNbXSA9IHsNCj4gKwl7IC5jb21wYXRpYmxlID0gIm54cCxseDIx NjBhLWZzcGkiLCAuZGF0YSA9ICh2b2lkICopJmx4MjE2MGFfZGF0YSwgfSwNCj4gKwl7IC8qIHNl bnRpbmVsICovIH0NCj4gK307DQo+ICtNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBueHBfZnNwaV9k dF9pZHMpOw0KPiArDQo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGRldl9wbV9vcHMgbnhwX2ZzcGlf cG1fb3BzID0gew0KPiArCS5zdXNwZW5kCT0gbnhwX2ZzcGlfc3VzcGVuZCwNCj4gKwkucmVzdW1l CQk9IG54cF9mc3BpX3Jlc3VtZSwNCj4gK307DQo+ICsNCj4gK3N0YXRpYyBzdHJ1Y3QgcGxhdGZv cm1fZHJpdmVyIG54cF9mc3BpX2RyaXZlciA9IHsNCj4gKwkuZHJpdmVyID0gew0KPiArCQkubmFt ZQk9ICJueHAtZnNwaSIsDQo+ICsJCS5vZl9tYXRjaF90YWJsZSA9IG54cF9mc3BpX2R0X2lkcywN Cj4gKwkJLnBtID0gICAmbnhwX2ZzcGlfcG1fb3BzLA0KPiArCX0sDQo+ICsJLnByb2JlICAgICAg ICAgID0gbnhwX2ZzcGlfcHJvYmUsDQo+ICsJLnJlbW92ZQkJPSBueHBfZnNwaV9yZW1vdmUsDQo+ ICt9Ow0KPiArbW9kdWxlX3BsYXRmb3JtX2RyaXZlcihueHBfZnNwaV9kcml2ZXIpOw0KPiArDQo+ ICtNT0RVTEVfREVTQ1JJUFRJT04oIk5YUCBGU1BJIENvbnRyb2xsZXIgRHJpdmVyIik7DQo+ICtN T0RVTEVfQVVUSE9SKCJOWFAgU2VtaWNvbmR1Y3RvciIpOw0KPiArTU9EVUxFX0xJQ0VOU0UoIkdQ TCB2MiIpOw0KPiA= From mboxrd@z Thu Jan 1 00:00:00 1970 From: Schrempf Frieder Subject: Re: [PATCH v5 1/5] spi: spi-mem: Add driver for NXP FlexSPI controller Date: Thu, 6 Dec 2018 09:22:52 +0000 Message-ID: References: <1542366701-16065-1-git-send-email-yogeshnarayan.gaur@nxp.com> <1542366701-16065-2-git-send-email-yogeshnarayan.gaur@nxp.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1542366701-16065-2-git-send-email-yogeshnarayan.gaur@nxp.com> Content-Language: en-US Content-ID: <70157C6BFF32D04889CA366D5BC29377@snt-world.com> Sender: linux-kernel-owner@vger.kernel.org To: Yogesh Narayan Gaur , "linux-mtd@lists.infradead.org" , "boris.brezillon@bootlin.com" , "marek.vasut@gmail.com" , "broonie@kernel.org" , "linux-spi@vger.kernel.org" , "devicetree@vger.kernel.org" Cc: "robh@kernel.org" , "mark.rutland@arm.com" , "shawnguo@kernel.org" , "linux-arm-kernel@lists.infradead.org" , "computersforpeace@gmail.com" , "linux-kernel@vger.kernel.org" List-Id: devicetree@vger.kernel.org SGkgWW9nZXNoLA0KDQpJJ3ZlIGhhZCBhIGNsb3NlciBsb29rIGF0IHlvdXIgdjUuIFNlZSBteSBj b21tZW50cyBiZWxvdy4NCg0KT24gMTYuMTEuMTggMTI6MTMsIFlvZ2VzaCBOYXJheWFuIEdhdXIg d3JvdGU6DQo+IC0gQWRkIGRyaXZlciBmb3IgTlhQIEZsZXhTUEkgaG9zdCBjb250cm9sbGVyDQo+ IA0KPiAoMCkgV2hhdCBpcyB0aGUgRmxleFNQSSBjb250cm9sbGVyPw0KPiAgIEZsZXhTUEkgaXMg YSBmbGV4c2libGUgU1BJIGhvc3QgY29udHJvbGxlciB3aGljaCBzdXBwb3J0cyB0d28gU1BJDQo+ ICAgY2hhbm5lbHMgYW5kIHVwIHRvIDQgZXh0ZXJuYWwgZGV2aWNlcy4gRWFjaCBjaGFubmVsIHN1 cHBvcnRzDQo+ICAgU2luZ2xlL0R1YWwvUXVhZC9PY3RhbCBtb2RlIGRhdGEgdHJhbnNmZXIgKDEv Mi80LzggYmlkaXJlY3Rpb25hbA0KPiAgIGRhdGEgbGluZXMpIGkuZS4gRmxleFNQSSBhY3RzIGFz IGFuIGludGVyZmFjZSB0byBleHRlcm5hbCBkZXZpY2VzLA0KPiAgIG1heGltdW0gNCwgZWFjaCB3 aXRoIHVwIHRvIDggYmlkaXJlY3Rpb25hbCBkYXRhIGxpbmVzLg0KPiANCj4gICBJdCB1c2VzIG5l dyBTUEkgbWVtb3J5IGludGVyZmFjZSBvZiB0aGUgU1BJIGZyYW1ld29yayB0byBpc3N1ZQ0KPiAg IGZsYXNoIG1lbW9yeSBvcGVyYXRpb25zIHRvIHVwIHRvIGZvdXIgY29ubmVjdGVkIGZsYXNoDQo+ ICAgZGV2aWNlcyAoMiBidXNlcyB3aXRoIDIgQ1MgZWFjaCkuDQo+IA0KPiAoMSkgVGVzdGVkIHRo aXMgZHJpdmVyIHdpdGggdGhlIG10ZF9kZWJ1ZyBhbmQgSkZGUzIgZmlsZXN5c3RlbSB1dGlsaXR5 DQo+ICAgb24gTlhQIExYMjE2MEFSREIgYW5kIExYMjE2MEFRRFMgdGFyZ2V0cy4NCj4gICBMWDIx NjBBUkRCIGlzIGhhdmluZyB0d28gTk9SIHNsYXZlIGRldmljZSBjb25uZWN0ZWQgb24gc2luZ2xl IGJ1cyBBDQo+ICAgaS5lLiBBMCBhbmQgQTEgKENTMCBhbmQgQ1MxKS4NCj4gICBMWDIxNjBBUURT IGlzIGhhdmluZyB0d28gTk9SIHNsYXZlIGRldmljZSBjb25uZWN0ZWQgb24gc2VwYXJhdGUgYnVz ZXMNCj4gICBvbmUgZmxhc2ggb24gQTAgYW5kIHNlY29uZCBvbiBCMSBpLmUuIChDUzAgYW5kIENT MykuDQo+ICAgVmVyaWZpZWQgdGhpcyBkcml2ZXIgb24gZm9sbG93aW5nIFNQSSBOT1IgZmxhc2hl czoNCj4gICAgICBNaWNyb24sIG10MzV4dTUxMmFiLCBbUmVhZCAtIDEgYml0IG1vZGVdDQo+ICAg ICAgQ3lwcmVzcywgczI1Zmw1MTJzLCBbUmVhZCAtIDEvMi80IGJpdCBtb2RlXQ0KPiANCj4gU2ln bmVkLW9mZi1ieTogWW9nZXNoIEdhdXIgPHlvZ2VzaG5hcmF5YW4uZ2F1ckBueHAuY29tPg0KPiAt LS0NCj4gQ2hhbmdlcyBmb3IgdjU6DQo+IC0gUmViYXNlIG9uIHRvcCBvZiB2NC4yMC1yYzINCj4g LSBNb2RpZmllZCBmc3BpX3JlYWRsX3BvbGxfdG91dCgpIGFzIHBlciByZXZpZXcgY29tbWVudHMN Cj4gLSBBcnJhbmdlIGhlYWRlciBmaWxlIGluIGFscGhhYmV0aWNhbCBvcmRlcg0KPiAtIFJlbW92 ZWQgdXNhZ2Ugb2YgcmVhZCgpL3dyaXRlKCkgZnVuY3Rpb24gY2FsbGJhY2sgcG9pbnRlcg0KPiAt IEFkZCBzdXBwb3J0IGZvciAxIGFuZCAyIGJ5dGUgYWRkcmVzcyBsZW5ndGgNCj4gLSBDaGFuZ2Ug RnJpZWRlciBlLW1haWwgdG8gbmV3IGUtbWFpbCBhZGRyZXNzDQo+IENoYW5nZXMgZm9yIHY0Og0K PiAtIEluY29ycG9yYXRlIEJvcmlzIHJldmlldyBjb21tZW50cw0KPiAgICAqIFVzZSByZWFkbF9w b2xsX3RpbWVvdXQoKSBpbnN0ZWFkIG9mIGJ1c3kgbG9vcGluZy4NCj4gICAgKiBSZS1kZWZpbmUg cmVnaXN0ZXIgbWFza2luZyBhcyBwZXIgY29tbWVudC4NCj4gICAgKiBEcm9wIGZzcGlfZGV2dHlw ZSBlbnVtLg0KPiBDaGFuZ2VzIGZvciB2MzoNCj4gLSBBZGRlZCBlbmRpYW5uZXNzIGZsYWcgaW4g cGxhdGZvcm0gc3BlY2lmaWMgc3RydWN0dXJlIGluc3RlYWQgb2YgRFRTLg0KPiAtIE1vZGlmaWVk IG54cF9mc3BpX3JlYWRfYWhiKCksIHJlbW92ZWQgcmVtYXBwaW5nIGNvZGUuDQo+IC0gQWRkZWQg Qm9yaXMgYW5kIEZyaWVkZXIgYXMgQXV0aG9yIGFuZCBwcm92aWRlZCByZWZlcmVuY2Ugb2Ygc3Bp LWZzbC1xc3BpLmMNCj4gQ2hhbmdlcyBmb3IgdjI6DQo+IC0gSW5jb3Jwb3JhdGVkIEJvcmlzIHJl dmlldyBjb21tZW50cy4NCj4gLSBSZW1vdmUgZGVwZW5kZW5jeSBvZiBkcml2ZXIgb3ZlciBjb25u ZWN0ZWQgZmxhc2ggZGV2aWNlIHNpemUuDQo+IC0gTW9kaWZpZWQgdGhlIGxvZ2ljIHRvIHNlbGVj dCByZXF1ZXN0ZWQgQ1MuDQo+IC0gUmVtb3ZlIFNQSS1PY3RhbCBNYWNyb3MuDQo+IA0KPiAgIGRy aXZlcnMvc3BpL0tjb25maWcgICAgICAgIHwgICAxMCArDQo+ICAgZHJpdmVycy9zcGkvTWFrZWZp bGUgICAgICAgfCAgICAxICsNCj4gICBkcml2ZXJzL3NwaS9zcGktbnhwLWZzcGkuYyB8IDExNDUg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysNCj4gICAzIGZpbGVz IGNoYW5nZWQsIDExNTYgaW5zZXJ0aW9ucygrKQ0KPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL3NwaS9zcGktbnhwLWZzcGkuYw0KPiANCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL0tj b25maWcgYi9kcml2ZXJzL3NwaS9LY29uZmlnDQo+IGluZGV4IDdkM2E1YzkuLjM2NjMwYTEgMTAw NjQ0DQo+IC0tLSBhL2RyaXZlcnMvc3BpL0tjb25maWcNCj4gKysrIGIvZHJpdmVycy9zcGkvS2Nv bmZpZw0KPiBAQCAtMjU5LDYgKzI1OSwxNiBAQCBjb25maWcgU1BJX0ZTTF9MUFNQSQ0KPiAgIAlo ZWxwDQo+ICAgCSAgVGhpcyBlbmFibGVzIEZyZWVzY2FsZSBpLk1YIExQU1BJIGNvbnRyb2xsZXJz IGluIG1hc3RlciBtb2RlLg0KPiAgIA0KPiArY29uZmlnIFNQSV9OWFBfRkxFWFNQSQ0KPiArCXRy aXN0YXRlICJOWFAgRmxleCBTUEkgY29udHJvbGxlciINCj4gKwlkZXBlbmRzIG9uIEFSQ0hfTEFZ RVJTQ0FQRSB8fCBIQVNfSU9NRU0NCj4gKwloZWxwDQo+ICsJICBUaGlzIGVuYWJsZXMgc3VwcG9y dCBmb3IgdGhlIEZsZXggU1BJIGNvbnRyb2xsZXIgaW4gbWFzdGVyIG1vZGUuDQo+ICsJICBVcCB0 byBmb3VyIHNsYXZlIGRldmljZXMgY2FuIGJlIGNvbm5lY3RlZCBvbiB0d28gYnVzZXMgd2l0aCB0 d28NCj4gKwkgIGNoaXBzZWxlY3RzIGVhY2guDQo+ICsJICBUaGlzIGNvbnRyb2xsZXIgZG9lcyBu b3Qgc3VwcG9ydCBnZW5lcmljIFNQSSBtZXNzYWdlcyBhbmQgb25seQ0KPiArCSAgc3VwcG9ydHMg dGhlIGhpZ2gtbGV2ZWwgU1BJIG1lbW9yeSBpbnRlcmZhY2UuDQo+ICsNCj4gICBjb25maWcgU1BJ X0dQSU8NCj4gICAJdHJpc3RhdGUgIkdQSU8tYmFzZWQgYml0YmFuZ2luZyBTUEkgTWFzdGVyIg0K PiAgIAlkZXBlbmRzIG9uIEdQSU9MSUIgfHwgQ09NUElMRV9URVNUDQo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL3NwaS9NYWtlZmlsZSBiL2RyaXZlcnMvc3BpL01ha2VmaWxlDQo+IGluZGV4IDM1NzUy MDUuLjU1ZmVjNWMgMTAwNjQ0DQo+IC0tLSBhL2RyaXZlcnMvc3BpL01ha2VmaWxlDQo+ICsrKyBi L2RyaXZlcnMvc3BpL01ha2VmaWxlDQo+IEBAIC02MCw2ICs2MCw3IEBAIG9iai0kKENPTkZJR19T UElfTVBDNTJ4eCkJCSs9IHNwaS1tcGM1Mnh4Lm8NCj4gICBvYmotJChDT05GSUdfU1BJX01UNjVY WCkgICAgICAgICAgICAgICAgKz0gc3BpLW10NjV4eC5vDQo+ICAgb2JqLSQoQ09ORklHX1NQSV9N WFMpCQkJKz0gc3BpLW14cy5vDQo+ICAgb2JqLSQoQ09ORklHX1NQSV9OVUM5MDApCQkrPSBzcGkt bnVjOTAwLm8NCj4gK29iai0kKENPTkZJR19TUElfTlhQX0ZMRVhTUEkpCQkrPSBzcGktbnhwLWZz cGkubw0KPiAgIG9iai0kKENPTkZJR19TUElfT0NfVElOWSkJCSs9IHNwaS1vYy10aW55Lm8NCj4g ICBzcGktb2N0ZW9uLW9ianMJCQkJOj0gc3BpLWNhdml1bS5vIHNwaS1jYXZpdW0tb2N0ZW9uLm8N Cj4gICBvYmotJChDT05GSUdfU1BJX09DVEVPTikJCSs9IHNwaS1vY3Rlb24ubw0KPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9zcGkvc3BpLW54cC1mc3BpLmMgYi9kcml2ZXJzL3NwaS9zcGktbnhwLWZz cGkuYw0KPiBuZXcgZmlsZSBtb2RlIDEwMDY0NA0KPiBpbmRleCAwMDAwMDAwLi5hMzUwMTNiDQo+ IC0tLSAvZGV2L251bGwNCj4gKysrIGIvZHJpdmVycy9zcGkvc3BpLW54cC1mc3BpLmMNCj4gQEAg LTAsMCArMSwxMTQ1IEBADQo+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsN Cj4gKw0KPiArLyoNCj4gKyAqIE5YUCBGbGV4U1BJKEZTUEkpIGNvbnRyb2xsZXIgZHJpdmVyLg0K PiArICoNCj4gKyAqIENvcHlyaWdodCAyMDE4IE5YUC4NCj4gKyAqDQo+ICsgKiBGbGV4U1BJIGlz IGEgZmxleHNpYmxlIFNQSSBob3N0IGNvbnRyb2xsZXIgd2hpY2ggc3VwcG9ydHMgdHdvIFNQSQ0K PiArICogY2hhbm5lbHMgYW5kIHVwIHRvIDQgZXh0ZXJuYWwgZGV2aWNlcy4gRWFjaCBjaGFubmVs IHN1cHBvcnRzDQo+ICsgKiBTaW5nbGUvRHVhbC9RdWFkL09jdGFsIG1vZGUgZGF0YSB0cmFuc2Zl ciAoMS8yLzQvOCBiaWRpcmVjdGlvbmFsDQo+ICsgKiBkYXRhIGxpbmVzKS4NCj4gKyAqDQo+ICsg KiBGbGV4U1BJIGNvbnRyb2xsZXIgaXMgZHJpdmVuIGJ5IHRoZSBMVVQoTG9vay11cCBUYWJsZSkg cmVnaXN0ZXJzDQo+ICsgKiBMVVQgcmVnaXN0ZXJzIGFyZSBhIGxvb2stdXAtdGFibGUgZm9yIHNl cXVlbmNlcyBvZiBpbnN0cnVjdGlvbnMuDQo+ICsgKiBBIHZhbGlkIHNlcXVlbmNlIGNvbnNpc3Rz IG9mIGZvdXIgTFVUIHJlZ2lzdGVycy4NCj4gKyAqIE1heGltdW0gMzIgTFVUIHNlcXVlbmNlcyBj YW4gYmUgcHJvZ3JhbW1lZCBzaW11bHRhbmVvdXNseS4NCj4gKyAqDQo+ICsgKiBMVVRzIGFyZSBi ZWluZyBjcmVhdGVkIGF0IHJ1bi10aW1lIGJhc2VkIG9uIHRoZSBjb21tYW5kcyBwYXNzZWQNCj4g KyAqIGZyb20gdGhlIHNwaS1tZW0gZnJhbWV3b3JrLCB0aHVzIHVzaW5nIHNpbmdsZSBMVVQgaW5k ZXguDQo+ICsgKg0KPiArICogU29mdHdhcmUgdHJpZ2dlcmVkIEZsYXNoIHJlYWQvd3JpdGUgYWNj ZXNzIGJ5IElQIEJ1cy4NCj4gKyAqDQo+ICsgKiBNZW1vcnkgbWFwcGVkIHJlYWQgYWNjZXNzIGJ5 IEFIQiBCdXMuDQo+ICsgKg0KPiArICogQmFzZWQgb24gU1BJIE1FTSBpbnRlcmZhY2UgYW5kIHNw aS1mc2wtcXNwaS5jIGRyaXZlci4NCj4gKyAqDQo+ICsgKiBBdXRob3I6DQo+ICsgKiAgICAgWW9n ZXNoIEdhdXIgPHlvZ2VzaG5hcmF5YW4uZ2F1ckBueHAuY29tPg0KPiArICogICAgIEJvcmlzIEJy ZXppbGxpb24gPGJvcmlzLmJyZXppbGxvbkBib290bGluLmNvbT4NCj4gKyAqICAgICBGcmllZGVy IFNjaHJlbXBmIDxmcmllZGVyLnNjaHJlbXBmQGtvbnRyb24uZGU+DQo+ICsgKi8NCj4gKw0KPiAr I2luY2x1ZGUgPGxpbnV4L2JpdG9wcy5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L2Nsay5oPg0KPiAr I2luY2x1ZGUgPGxpbnV4L2NvbXBsZXRpb24uaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9kZWxheS5o Pg0KPiArI2luY2x1ZGUgPGxpbnV4L2Vyci5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+ DQo+ICsjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+DQo+ICsjaW5jbHVkZSA8bGludXgvaW8u aD4NCj4gKyNpbmNsdWRlIDxsaW51eC9pb3BvbGwuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9qaWZm aWVzLmg+DQo+ICsjaW5jbHVkZSA8bGludXgva2VybmVsLmg+DQo+ICsjaW5jbHVkZSA8bGludXgv bW9kdWxlLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4NCj4gKyNpbmNsdWRlIDxsaW51 eC9vZi5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L29mX2RldmljZS5oPg0KPiArI2luY2x1ZGUgPGxp bnV4L3BsYXRmb3JtX2RldmljZS5oPg0KPiArI2luY2x1ZGUgPGxpbnV4L3BtX3Fvcy5oPg0KPiAr I2luY2x1ZGUgPGxpbnV4L3NpemVzLmg+DQo+ICsNCj4gKyNpbmNsdWRlIDxsaW51eC9zcGkvc3Bp Lmg+DQo+ICsjaW5jbHVkZSA8bGludXgvc3BpL3NwaS1tZW0uaD4NCj4gKw0KPiArLyoNCj4gKyAq IFRoZSBkcml2ZXIgb25seSB1c2VzIG9uZSBzaW5nbGUgTFVUIGVudHJ5LCB0aGF0IGlzIHVwZGF0 ZWQgb24NCj4gKyAqIGVhY2ggY2FsbCBvZiBleGVjX29wKCkuIEluZGV4IDAgaXMgcHJlc2V0IGF0 IGJvb3Qgd2l0aCBhIGJhc2ljDQo+ICsgKiByZWFkIG9wZXJhdGlvbiwgc28gbGV0J3MgdXNlIHRo ZSBsYXN0IGVudHJ5ICgzMSkuDQo+ICsgKi8NCj4gKyNkZWZpbmUJU0VRSURfTFVUCQkJMzENCj4g Kw0KPiArLyogUmVnaXN0ZXJzIHVzZWQgYnkgdGhlIGRyaXZlciAqLw0KPiArI2RlZmluZSBGU1BJ X01DUjAJCQkweDAwDQo+ICsjZGVmaW5lIEZTUElfTUNSMF9BSEJfVElNRU9VVCh4KQkoKHgpIDw8 IDI0KQ0KPiArI2RlZmluZSBGU1BJX01DUjBfSVBfVElNRU9VVCh4KQkJKCh4KSA8PCAxNikNCj4g KyNkZWZpbmUgRlNQSV9NQ1IwX0xFQVJOX0VOCQlCSVQoMTUpDQo+ICsjZGVmaW5lIEZTUElfTUNS MF9TQ1JGUlVOX0VOCQlCSVQoMTQpDQo+ICsjZGVmaW5lIEZTUElfTUNSMF9PQ1RDT01CX0VOCQlC SVQoMTMpDQo+ICsjZGVmaW5lIEZTUElfTUNSMF9ET1pFX0VOCQlCSVQoMTIpDQo+ICsjZGVmaW5l IEZTUElfTUNSMF9IU0VOCQkJQklUKDExKQ0KPiArI2RlZmluZSBGU1BJX01DUjBfU0VSQ0xLRElW CQlCSVQoOCkNCj4gKyNkZWZpbmUgRlNQSV9NQ1IwX0FUREZfRU4JCUJJVCg3KQ0KPiArI2RlZmlu ZSBGU1BJX01DUjBfQVJERl9FTgkJQklUKDYpDQo+ICsjZGVmaW5lIEZTUElfTUNSMF9SWENMS1NS Qyh4KQkJKCh4KSA8PCA0KQ0KPiArI2RlZmluZSBGU1BJX01DUjBfRU5EX0NGRyh4KQkJKCh4KSA8 PCAyKQ0KPiArI2RlZmluZSBGU1BJX01DUjBfTURJUwkJCUJJVCgxKQ0KPiArI2RlZmluZSBGU1BJ X01DUjBfU1dSU1QJCQlCSVQoMCkNCj4gKw0KPiArI2RlZmluZSBGU1BJX01DUjEJCQkweDA0DQo+ ICsjZGVmaW5lIEZTUElfTUNSMV9TRVFfVElNRU9VVCh4KQkoKHgpIDw8IDE2KQ0KPiArI2RlZmlu ZSBGU1BJX01DUjFfQUhCX1RJTUVPVVQoeCkJKHgpDQo+ICsNCj4gKyNkZWZpbmUgRlNQSV9NQ1Iy CQkJMHgwOA0KPiArI2RlZmluZSBGU1BJX01DUjJfSURMRV9XQUlUKHgpCQkoKHgpIDw8IDI0KQ0K PiArI2RlZmluZSBGU1BJX01DUjJfU0FNRURFVklDRUVOCQlCSVQoMTUpDQo+ICsjZGVmaW5lIEZT UElfTUNSMl9DTFJMUlBIUwkJQklUKDE0KQ0KPiArI2RlZmluZSBGU1BJX01DUjJfQUJSREFUU1oJ CUJJVCg4KQ0KPiArI2RlZmluZSBGU1BJX01DUjJfQUJSTEVBUk4JCUJJVCg3KQ0KPiArI2RlZmlu ZSBGU1BJX01DUjJfQUJSX1JFQUQJCUJJVCg2KQ0KPiArI2RlZmluZSBGU1BJX01DUjJfQUJSV1JJ VEUJCUJJVCg1KQ0KPiArI2RlZmluZSBGU1BJX01DUjJfQUJSRFVNTVkJCUJJVCg0KQ0KPiArI2Rl ZmluZSBGU1BJX01DUjJfQUJSX01PREUJCUJJVCgzKQ0KPiArI2RlZmluZSBGU1BJX01DUjJfQUJS Q0FERFIJCUJJVCgyKQ0KPiArI2RlZmluZSBGU1BJX01DUjJfQUJSUkFERFIJCUJJVCgxKQ0KPiAr I2RlZmluZSBGU1BJX01DUjJfQUJSX0NNRAkJQklUKDApDQo+ICsNCj4gKyNkZWZpbmUgRlNQSV9B SEJDUgkJCTB4MGMNCj4gKyNkZWZpbmUgRlNQSV9BSEJDUl9SREFERFJPUFQJCUJJVCg2KQ0KPiAr I2RlZmluZSBGU1BJX0FIQkNSX1BSRUZfRU4JCUJJVCg1KQ0KPiArI2RlZmluZSBGU1BJX0FIQkNS X0JVRkZfRU4JCUJJVCg0KQ0KPiArI2RlZmluZSBGU1BJX0FIQkNSX0NBQ0hfRU4JCUJJVCgzKQ0K PiArI2RlZmluZSBGU1BJX0FIQkNSX0NMUlRYQlVGCQlCSVQoMikNCj4gKyNkZWZpbmUgRlNQSV9B SEJDUl9DTFJSWEJVRgkJQklUKDEpDQo+ICsjZGVmaW5lIEZTUElfQUhCQ1JfUEFSX0VOCQlCSVQo MCkNCj4gKw0KPiArI2RlZmluZSBGU1BJX0lOVEVOCQkJMHgxMA0KPiArI2RlZmluZSBGU1BJX0lO VEVOX1NDTEtTQldSCQlCSVQoOSkNCj4gKyNkZWZpbmUgRlNQSV9JTlRFTl9TQ0xLU0JSRAkJQklU KDgpDQo+ICsjZGVmaW5lIEZTUElfSU5URU5fREFUQUxSTkZMCQlCSVQoNykNCj4gKyNkZWZpbmUg RlNQSV9JTlRFTl9JUFRYV0UJCUJJVCg2KQ0KPiArI2RlZmluZSBGU1BJX0lOVEVOX0lQUlhXQQkJ QklUKDUpDQo+ICsjZGVmaW5lIEZTUElfSU5URU5fQUhCQ01ERVJSCQlCSVQoNCkNCj4gKyNkZWZp bmUgRlNQSV9JTlRFTl9JUENNREVSUgkJQklUKDMpDQo+ICsjZGVmaW5lIEZTUElfSU5URU5fQUhC Q01ER0UJCUJJVCgyKQ0KPiArI2RlZmluZSBGU1BJX0lOVEVOX0lQQ01ER0UJCUJJVCgxKQ0KPiAr I2RlZmluZSBGU1BJX0lOVEVOX0lQQ01ERE9ORQkJQklUKDApDQo+ICsNCj4gKyNkZWZpbmUgRlNQ SV9JTlRSCQkJMHgxNA0KPiArI2RlZmluZSBGU1BJX0lOVFJfU0NMS1NCV1IJCUJJVCg5KQ0KPiAr I2RlZmluZSBGU1BJX0lOVFJfU0NMS1NCUkQJCUJJVCg4KQ0KPiArI2RlZmluZSBGU1BJX0lOVFJf REFUQUxSTkZMCQlCSVQoNykNCj4gKyNkZWZpbmUgRlNQSV9JTlRSX0lQVFhXRQkJQklUKDYpDQo+ ICsjZGVmaW5lIEZTUElfSU5UUl9JUFJYV0EJCUJJVCg1KQ0KPiArI2RlZmluZSBGU1BJX0lOVFJf QUhCQ01ERVJSCQlCSVQoNCkNCj4gKyNkZWZpbmUgRlNQSV9JTlRSX0lQQ01ERVJSCQlCSVQoMykN Cj4gKyNkZWZpbmUgRlNQSV9JTlRSX0FIQkNNREdFCQlCSVQoMikNCj4gKyNkZWZpbmUgRlNQSV9J TlRSX0lQQ01ER0UJCUJJVCgxKQ0KPiArI2RlZmluZSBGU1BJX0lOVFJfSVBDTURET05FCQlCSVQo MCkNCj4gKw0KPiArI2RlZmluZSBGU1BJX0xVVEtFWQkJCTB4MTgNCj4gKyNkZWZpbmUgRlNQSV9M VVRLRVlfVkFMVUUJCTB4NUFGMDVBRjANCj4gKw0KPiArI2RlZmluZSBGU1BJX0xDS0NSCQkJMHgx Qw0KPiArDQo+ICsjZGVmaW5lIEZTUElfTENLRVJfTE9DSwkJCTB4MQ0KPiArI2RlZmluZSBGU1BJ X0xDS0VSX1VOTE9DSwkJMHgyDQo+ICsNCj4gKyNkZWZpbmUgRlNQSV9CVUZYQ1JfSU5WQUxJRF9N U1RSSUQJMHhFDQo+ICsjZGVmaW5lIEZTUElfQUhCUlhfQlVGMENSMAkJMHgyMA0KPiArI2RlZmlu ZSBGU1BJX0FIQlJYX0JVRjFDUjAJCTB4MjQNCj4gKyNkZWZpbmUgRlNQSV9BSEJSWF9CVUYyQ1Iw CQkweDI4DQo+ICsjZGVmaW5lIEZTUElfQUhCUlhfQlVGM0NSMAkJMHgyQw0KPiArI2RlZmluZSBG U1BJX0FIQlJYX0JVRjRDUjAJCTB4MzANCj4gKyNkZWZpbmUgRlNQSV9BSEJSWF9CVUY1Q1IwCQkw eDM0DQo+ICsjZGVmaW5lIEZTUElfQUhCUlhfQlVGNkNSMAkJMHgzOA0KPiArI2RlZmluZSBGU1BJ X0FIQlJYX0JVRjdDUjAJCTB4M0MNCj4gKyNkZWZpbmUgRlNQSV9BSEJSWEJVRjBDUjdfUFJFRgkJ QklUKDMxKQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfQUhCUlhfQlVGMENSMQkJMHg0MA0KPiArI2Rl ZmluZSBGU1BJX0FIQlJYX0JVRjFDUjEJCTB4NDQNCj4gKyNkZWZpbmUgRlNQSV9BSEJSWF9CVUYy Q1IxCQkweDQ4DQo+ICsjZGVmaW5lIEZTUElfQUhCUlhfQlVGM0NSMQkJMHg0Qw0KPiArI2RlZmlu ZSBGU1BJX0FIQlJYX0JVRjRDUjEJCTB4NTANCj4gKyNkZWZpbmUgRlNQSV9BSEJSWF9CVUY1Q1Ix CQkweDU0DQo+ICsjZGVmaW5lIEZTUElfQUhCUlhfQlVGNkNSMQkJMHg1OA0KPiArI2RlZmluZSBG U1BJX0FIQlJYX0JVRjdDUjEJCTB4NUMNCj4gKw0KPiArI2RlZmluZSBGU1BJX0ZMU0hBMUNSMAkJ CTB4NjANCj4gKyNkZWZpbmUgRlNQSV9GTFNIQTJDUjAJCQkweDY0DQo+ICsjZGVmaW5lIEZTUElf RkxTSEIxQ1IwCQkJMHg2OA0KPiArI2RlZmluZSBGU1BJX0ZMU0hCMkNSMAkJCTB4NkMNCj4gKyNk ZWZpbmUgRlNQSV9GTFNIWENSMF9TWl9LQgkJMTANCj4gKyNkZWZpbmUgRlNQSV9GTFNIWENSMF9T Wih4KQkJKCh4KSA+PiBGU1BJX0ZMU0hYQ1IwX1NaX0tCKQ0KPiArDQo+ICsjZGVmaW5lIEZTUElf RkxTSEExQ1IxCQkJMHg3MA0KPiArI2RlZmluZSBGU1BJX0ZMU0hBMkNSMQkJCTB4NzQNCj4gKyNk ZWZpbmUgRlNQSV9GTFNIQjFDUjEJCQkweDc4DQo+ICsjZGVmaW5lIEZTUElfRkxTSEIyQ1IxCQkJ MHg3Qw0KPiArI2RlZmluZSBGU1BJX0ZMU0hYQ1IxX0NTSU5UUih4KQkJKCh4KSA8PCAxNikNCj4g KyNkZWZpbmUgRlNQSV9GTFNIWENSMV9DQVMoeCkJCSgoeCkgPDwgMTEpDQo+ICsjZGVmaW5lIEZT UElfRkxTSFhDUjFfV0EJCUJJVCgxMCkNCj4gKyNkZWZpbmUgRlNQSV9GTFNIWENSMV9UQ1NIKHgp CQkoKHgpIDw8IDUpDQo+ICsjZGVmaW5lIEZTUElfRkxTSFhDUjFfVENTUyh4KQkJKHgpDQo+ICsN Cj4gKyNkZWZpbmUgRlNQSV9GTFNIQTFDUjIJCQkweDgwDQo+ICsjZGVmaW5lIEZTUElfRkxTSEEy Q1IyCQkJMHg4NA0KPiArI2RlZmluZSBGU1BJX0ZMU0hCMUNSMgkJCTB4ODgNCj4gKyNkZWZpbmUg RlNQSV9GTFNIQjJDUjIJCQkweDhDDQo+ICsjZGVmaW5lIEZTUElfRkxTSFhDUjJfQ0xSSU5TUAkJ QklUKDI0KQ0KPiArI2RlZmluZSBGU1BJX0ZMU0hYQ1IyX0FXUldBSVQJCUJJVCgxNikNCj4gKyNk ZWZpbmUgRlNQSV9GTFNIWENSMl9BV1JTRVFOX1NISUZUCTEzDQo+ICsjZGVmaW5lIEZTUElfRkxT SFhDUjJfQVdSU0VRSV9TSElGVAk4DQo+ICsjZGVmaW5lIEZTUElfRkxTSFhDUjJfQVJEU0VRTl9T SElGVAk1DQo+ICsjZGVmaW5lIEZTUElfRkxTSFhDUjJfQVJEU0VRSV9TSElGVAkwDQo+ICsNCj4g KyNkZWZpbmUgRlNQSV9JUENSMAkJCTB4QTANCj4gKw0KPiArI2RlZmluZSBGU1BJX0lQQ1IxCQkJ MHhBNA0KPiArI2RlZmluZSBGU1BJX0lQQ1IxX0lQQVJFTgkJQklUKDMxKQ0KPiArI2RlZmluZSBG U1BJX0lQQ1IxX1NFUU5VTV9TSElGVAkJMjQNCj4gKyNkZWZpbmUgRlNQSV9JUENSMV9TRVFJRF9T SElGVAkJMTYNCj4gKyNkZWZpbmUgRlNQSV9JUENSMV9JREFUU1ooeCkJCSh4KQ0KPiArDQo+ICsj ZGVmaW5lIEZTUElfSVBDTUQJCQkweEIwDQo+ICsjZGVmaW5lIEZTUElfSVBDTURfVFJHCQkJQklU KDApDQo+ICsNCj4gKyNkZWZpbmUgRlNQSV9ETFBSCQkJMHhCNA0KPiArDQo+ICsjZGVmaW5lIEZT UElfSVBSWEZDUgkJCTB4QjgNCj4gKyNkZWZpbmUgRlNQSV9JUFJYRkNSX0NMUgkJQklUKDApDQo+ ICsjZGVmaW5lIEZTUElfSVBSWEZDUl9ETUFfRU4JCUJJVCgxKQ0KPiArI2RlZmluZSBGU1BJX0lQ UlhGQ1JfV01SSyh4KQkJKCh4KSA8PCAyKQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfSVBUWEZDUgkJ CTB4QkMNCj4gKyNkZWZpbmUgRlNQSV9JUFRYRkNSX0NMUgkJQklUKDApDQo+ICsjZGVmaW5lIEZT UElfSVBUWEZDUl9ETUFfRU4JCUJJVCgxKQ0KPiArI2RlZmluZSBGU1BJX0lQVFhGQ1JfV01SSyh4 KQkJKCh4KSA8PCAyKQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfRExMQUNSCQkJMHhDMA0KPiArI2Rl ZmluZSBGU1BJX0RMTEFDUl9PVlJERU4JCUJJVCg4KQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfRExM QkNSCQkJMHhDNA0KPiArI2RlZmluZSBGU1BJX0RMTEJDUl9PVlJERU4JCUJJVCg4KQ0KPiArDQo+ ICsjZGVmaW5lIEZTUElfU1RTMAkJCTB4RTANCj4gKyNkZWZpbmUgRlNQSV9TVFMwX0RMUEhCKHgp CQkoKHgpIDw8IDgpDQo+ICsjZGVmaW5lIEZTUElfU1RTMF9ETFBIQSh4KQkJKCh4KSA8PCA0KQ0K PiArI2RlZmluZSBGU1BJX1NUUzBfQ01EX1NSQyh4KQkJKCh4KSA8PCAyKQ0KPiArI2RlZmluZSBG U1BJX1NUUzBfQVJCX0lETEUJCUJJVCgxKQ0KPiArI2RlZmluZSBGU1BJX1NUUzBfU0VRX0lETEUJ CUJJVCgwKQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfU1RTMQkJCTB4RTQNCj4gKyNkZWZpbmUgRlNQ SV9TVFMxX0lQX0VSUkNEKHgpCQkoKHgpIDw8IDI0KQ0KPiArI2RlZmluZSBGU1BJX1NUUzFfSVBf RVJSSUQoeCkJCSgoeCkgPDwgMTYpDQo+ICsjZGVmaW5lIEZTUElfU1RTMV9BSEJfRVJSQ0QoeCkJ CSgoeCkgPDwgOCkNCj4gKyNkZWZpbmUgRlNQSV9TVFMxX0FIQl9FUlJJRCh4KQkJKHgpDQo+ICsN Cj4gKyNkZWZpbmUgRlNQSV9BSEJTUE5TVAkJCTB4RUMNCj4gKyNkZWZpbmUgRlNQSV9BSEJTUE5T VF9EQVRMRlQoeCkJCSgoeCkgPDwgMTYpDQo+ICsjZGVmaW5lIEZTUElfQUhCU1BOU1RfQlVGSUQo eCkJCSgoeCkgPDwgMSkNCj4gKyNkZWZpbmUgRlNQSV9BSEJTUE5TVF9BQ1RJVkUJCUJJVCgwKQ0K PiArDQo+ICsjZGVmaW5lIEZTUElfSVBSWEZTVFMJCQkweEYwDQo+ICsjZGVmaW5lIEZTUElfSVBS WEZTVFNfUkRDTlRSKHgpCQkoKHgpIDw8IDE2KQ0KPiArI2RlZmluZSBGU1BJX0lQUlhGU1RTX0ZJ TEwoeCkJCSh4KQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfSVBUWEZTVFMJCQkweEY0DQo+ICsjZGVm aW5lIEZTUElfSVBUWEZTVFNfV1JDTlRSKHgpCQkoKHgpIDw8IDE2KQ0KPiArI2RlZmluZSBGU1BJ X0lQVFhGU1RTX0ZJTEwoeCkJCSh4KQ0KPiArDQo+ICsjZGVmaW5lIEZTUElfUkZEUgkJCTB4MTAw DQo+ICsjZGVmaW5lIEZTUElfVEZEUgkJCTB4MTgwDQo+ICsNCj4gKyNkZWZpbmUgRlNQSV9MVVRf QkFTRQkJCTB4MjAwDQo+ICsjZGVmaW5lIEZTUElfTFVUX09GRlNFVAkJCShTRVFJRF9MVVQgKiA0 ICogNCkNCj4gKyNkZWZpbmUgRlNQSV9MVVRfUkVHKGlkeCkgXA0KPiArCShGU1BJX0xVVF9CQVNF ICsgRlNQSV9MVVRfT0ZGU0VUICsgKGlkeCkgKiA0KQ0KPiArDQo+ICsvKiByZWdpc3RlciBtYXAg ZW5kICovDQo+ICsNCj4gKy8qIEluc3RydWN0aW9uIHNldCBmb3IgdGhlIExVVCByZWdpc3Rlci4g Ki8NCj4gKyNkZWZpbmUgTFVUX1NUT1AJCQkweDAwDQo+ICsjZGVmaW5lIExVVF9DTUQJCQkJMHgw MQ0KPiArI2RlZmluZSBMVVRfQUREUgkJCTB4MDINCj4gKyNkZWZpbmUgTFVUX0NBRERSX1NEUgkJ CTB4MDMNCj4gKyNkZWZpbmUgTFVUX01PREUJCQkweDA0DQo+ICsjZGVmaW5lIExVVF9NT0RFMgkJ CTB4MDUNCj4gKyNkZWZpbmUgTFVUX01PREU0CQkJMHgwNg0KPiArI2RlZmluZSBMVVRfTU9ERTgJ CQkweDA3DQo+ICsjZGVmaW5lIExVVF9OWFBfV1JJVEUJCQkweDA4DQo+ICsjZGVmaW5lIExVVF9O WFBfUkVBRAkJCTB4MDkNCj4gKyNkZWZpbmUgTFVUX0xFQVJOX1NEUgkJCTB4MEENCj4gKyNkZWZp bmUgTFVUX0RBVFNaX1NEUgkJCTB4MEINCj4gKyNkZWZpbmUgTFVUX0RVTU1ZCQkJMHgwQw0KPiAr I2RlZmluZSBMVVRfRFVNTVlfUldEU19TRFIJCTB4MEQNCj4gKyNkZWZpbmUgTFVUX0pNUF9PTl9D UwkJCTB4MUYNCj4gKyNkZWZpbmUgTFVUX0NNRF9ERFIJCQkweDIxDQo+ICsjZGVmaW5lIExVVF9B RERSX0REUgkJCTB4MjINCj4gKyNkZWZpbmUgTFVUX0NBRERSX0REUgkJCTB4MjMNCj4gKyNkZWZp bmUgTFVUX01PREVfRERSCQkJMHgyNA0KPiArI2RlZmluZSBMVVRfTU9ERTJfRERSCQkJMHgyNQ0K PiArI2RlZmluZSBMVVRfTU9ERTRfRERSCQkJMHgyNg0KPiArI2RlZmluZSBMVVRfTU9ERThfRERS CQkJMHgyNw0KPiArI2RlZmluZSBMVVRfV1JJVEVfRERSCQkJMHgyOA0KPiArI2RlZmluZSBMVVRf UkVBRF9ERFIJCQkweDI5DQo+ICsjZGVmaW5lIExVVF9MRUFSTl9ERFIJCQkweDJBDQo+ICsjZGVm aW5lIExVVF9EQVRTWl9ERFIJCQkweDJCDQo+ICsjZGVmaW5lIExVVF9EVU1NWV9ERFIJCQkweDJD DQo+ICsjZGVmaW5lIExVVF9EVU1NWV9SV0RTX0REUgkJMHgyRA0KPiArDQo+ICsvKg0KPiArICog Q2FsY3VsYXRlIG51bWJlciBvZiByZXF1aXJlZCBQQUQgYml0cyBmb3IgTFVUIHJlZ2lzdGVyLg0K PiArICoNCj4gKyAqIFRoZSBwYWQgc3RhbmRzIGZvciB0aGUgbnVtYmVyIG9mIElPIGxpbmVzIFsw OjddLg0KPiArICogRm9yIGV4YW1wbGUsIHRoZSBvY3RhbCByZWFkIG5lZWRzIGVpZ2h0IElPIGxp bmVzLA0KPiArICogc28geW91IHNob3VsZCB1c2UgTFVUX1BBRCg4KS4gVGhpcyBtYWNybw0KPiAr ICogcmV0dXJucyAzIGkuZS4gdXNlIGVpZ2h0ICgyXjMpIElQIGxpbmVzIGZvciByZWFkLg0KPiAr ICovDQo+ICsjZGVmaW5lIExVVF9QQUQoeCkgKGZscyh4KSAtIDEpDQo+ICsNCj4gKy8qDQo+ICsg KiBNYWNybyBmb3IgY29uc3RydWN0aW5nIHRoZSBMVVQgZW50cmllcyB3aXRoIHRoZSBmb2xsb3dp bmcNCj4gKyAqIHJlZ2lzdGVyIGxheW91dDoNCj4gKyAqDQo+ICsgKiAgLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tDQo+ICsgKiAgfCBJTlNUUjEgfCBQ QUQxIHwgT1BSTkQxIHwgSU5TVFIwIHwgUEFEMCB8IE9QUk5EMCB8DQo+ICsgKiAgLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tDQo+ICsgKi8NCj4gKyNk ZWZpbmUgUEFEX1NISUZUCQk4DQo+ICsjZGVmaW5lIElOU1RSX1NISUZUCQkxMA0KPiArI2RlZmlu ZSBPUFJORF9TSElGVAkJMTYNCj4gKw0KPiArLyogTWFjcm9zIGZvciBjb25zdHJ1Y3RpbmcgdGhl IExVVCByZWdpc3Rlci4gKi8NCj4gKyNkZWZpbmUgTFVUX0RFRihpZHgsIGlucywgcGFkLCBvcHIp CQkJICBcDQo+ICsJKCgoKGlucykgPDwgSU5TVFJfU0hJRlQpIHwgKChwYWQpIDw8IFBBRF9TSElG VCkgfCBcDQo+ICsJKG9wcikpIDw8ICgoKGlkeCkgJSAyKSAqIE9QUk5EX1NISUZUKSkNCj4gKw0K PiArLyogT3BlcmFuZHMgZm9yIHRoZSBMVVQgcmVnaXN0ZXIuICovDQo+ICsjZGVmaW5lIEFERFI4 QklUCQkweDA4DQo+ICsjZGVmaW5lIEFERFIxNkJJVAkJMHgxMA0KPiArI2RlZmluZSBBRERSMjRC SVQJCTB4MTgNCj4gKyNkZWZpbmUgQUREUjMyQklUCQkweDIwDQoNCllvdSBjYW4gZHJvcCB0aGVz ZSBBRERSWEJJVCBkZWZpbml0aW9ucywgc2VlIGJlbG93Li4uDQoNCj4gKw0KPiArI2RlZmluZSBQ T0xMX1RPVVQJCTUwMDANCj4gKyNkZWZpbmUgTlhQX0ZTUElfTUFYX0NISVBTRUxFQ1QJCTQNCj4g Kw0KPiArc3RydWN0IG54cF9mc3BpX2RldnR5cGVfZGF0YSB7DQo+ICsJdW5zaWduZWQgaW50IHJ4 ZmlmbzsNCj4gKwl1bnNpZ25lZCBpbnQgdHhmaWZvOw0KPiArCXVuc2lnbmVkIGludCBhaGJfYnVm X3NpemU7DQo+ICsJdW5zaWduZWQgaW50IHF1aXJrczsNCj4gKwlib29sIGxpdHRsZV9lbmRpYW47 DQo+ICt9Ow0KPiArDQo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG54cF9mc3BpX2RldnR5cGVfZGF0 YSBseDIxNjBhX2RhdGEgPSB7DQo+ICsJLnJ4ZmlmbyA9IFNaXzUxMiwgICAgICAgLyogKDY0ICAq IDY0IGJpdHMpICAqLw0KPiArCS50eGZpZm8gPSBTWl8xSywgICAgICAgIC8qICgxMjggKiA2NCBi aXRzKSAgKi8NCj4gKwkuYWhiX2J1Zl9zaXplID0gU1pfMkssICAvKiAoMjU2ICogNjQgYml0cykg ICovDQo+ICsJLnF1aXJrcyA9IDAsDQo+ICsJLmxpdHRsZV9lbmRpYW4gPSB0cnVlLCAgLyogbGl0 dGxlLWVuZGlhbiAgICAqLw0KPiArfTsNCj4gKw0KPiArc3RydWN0IG54cF9mc3BpIHsNCj4gKwl2 b2lkIF9faW9tZW0gKmlvYmFzZTsNCj4gKwl2b2lkIF9faW9tZW0gKmFoYl9hZGRyOw0KPiArCXUz MiBtZW1tYXBfcGh5Ow0KPiArCXUzMiBtZW1tYXBfcGh5X3NpemU7DQo+ICsJc3RydWN0IGNsayAq Y2xrLCAqY2xrX2VuOw0KPiArCXN0cnVjdCBkZXZpY2UgKmRldjsNCj4gKwlzdHJ1Y3QgY29tcGxl dGlvbiBjOw0KPiArCWNvbnN0IHN0cnVjdCBueHBfZnNwaV9kZXZ0eXBlX2RhdGEgKmRldnR5cGVf ZGF0YTsNCj4gKwlzdHJ1Y3QgbXV0ZXggbG9jazsNCj4gKwlzdHJ1Y3QgcG1fcW9zX3JlcXVlc3Qg cG1fcW9zX3JlcTsNCj4gKwlpbnQgc2VsZWN0ZWQ7DQo+ICt9Ow0KPiArDQo+ICsvKg0KPiArICog Ui9XIGZ1bmN0aW9ucyBmb3IgYmlnLSBvciBsaXR0bGUtZW5kaWFuIHJlZ2lzdGVyczoNCj4gKyAq IFRoZSBGU1BJIGNvbnRyb2xsZXIncyBlbmRpYW5uZXNzIGlzIGluZGVwZW5kZW50IG9mDQo+ICsg KiB0aGUgQ1BVIGNvcmUncyBlbmRpYW5uZXNzLiBTbyBmYXIsIGFsdGhvdWdoIHRoZSBDUFUNCj4g KyAqIGNvcmUgaXMgbGl0dGxlLWVuZGlhbiB0aGUgRlNQSSBjb250cm9sbGVyIGNhbiB1c2UNCj4g KyAqIGJpZy1lbmRpYW4gb3IgbGl0dGxlLWVuZGlhbi4NCj4gKyAqLw0KPiArc3RhdGljIHZvaWQg ZnNwaV93cml0ZWwoc3RydWN0IG54cF9mc3BpICpmLCB1MzIgdmFsLCB2b2lkIF9faW9tZW0gKmFk ZHIpDQo+ICt7DQo+ICsJaWYgKGYtPmRldnR5cGVfZGF0YS0+bGl0dGxlX2VuZGlhbikNCj4gKwkJ aW93cml0ZTMyKHZhbCwgYWRkcik7DQo+ICsJZWxzZQ0KPiArCQlpb3dyaXRlMzJiZSh2YWwsIGFk ZHIpOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgdTMyIGZzcGlfcmVhZGwoc3RydWN0IG54cF9mc3Bp ICpmLCB2b2lkIF9faW9tZW0gKmFkZHIpDQo+ICt7DQo+ICsJaWYgKGYtPmRldnR5cGVfZGF0YS0+ bGl0dGxlX2VuZGlhbikNCj4gKwkJcmV0dXJuIGlvcmVhZDMyKGFkZHIpOw0KPiArCWVsc2UNCj4g KwkJcmV0dXJuIGlvcmVhZDMyYmUoYWRkcik7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpcnFyZXR1 cm5fdCBueHBfZnNwaV9pcnFfaGFuZGxlcihpbnQgaXJxLCB2b2lkICpkZXZfaWQpDQo+ICt7DQo+ ICsJc3RydWN0IG54cF9mc3BpICpmID0gZGV2X2lkOw0KPiArCXUzMiByZWc7DQo+ICsNCj4gKwkv KiBjbGVhciBpbnRlcnJ1cHQgKi8NCj4gKwlyZWcgPSBmc3BpX3JlYWRsKGYsIGYtPmlvYmFzZSAr IEZTUElfSU5UUik7DQo+ICsJZnNwaV93cml0ZWwoZiwgRlNQSV9JTlRSX0lQQ01ERE9ORSwgZi0+ aW9iYXNlICsgRlNQSV9JTlRSKTsNCj4gKw0KPiArCWlmIChyZWcgJiBGU1BJX0lOVFJfSVBDTURE T05FKQ0KPiArCQljb21wbGV0ZSgmZi0+Yyk7DQo+ICsNCj4gKwlyZXR1cm4gSVJRX0hBTkRMRUQ7 DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpbnQgbnhwX2ZzcGlfY2hlY2tfYnVzd2lkdGgoc3RydWN0 IG54cF9mc3BpICpmLCB1OCB3aWR0aCkNCj4gK3sNCj4gKwlzd2l0Y2ggKHdpZHRoKSB7DQo+ICsJ Y2FzZSAxOg0KPiArCWNhc2UgMjoNCj4gKwljYXNlIDQ6DQo+ICsJY2FzZSA4Og0KPiArCQlyZXR1 cm4gMDsNCj4gKwl9DQo+ICsNCj4gKwlyZXR1cm4gLUVOT1RTVVBQOw0KPiArfQ0KPiArDQo+ICtz dGF0aWMgYm9vbCBueHBfZnNwaV9zdXBwb3J0c19vcChzdHJ1Y3Qgc3BpX21lbSAqbWVtLA0KPiAr CQkJCSBjb25zdCBzdHJ1Y3Qgc3BpX21lbV9vcCAqb3ApDQo+ICt7DQo+ICsJc3RydWN0IG54cF9m c3BpICpmID0gc3BpX2NvbnRyb2xsZXJfZ2V0X2RldmRhdGEobWVtLT5zcGktPm1hc3Rlcik7DQo+ ICsJaW50IHJldDsNCj4gKw0KPiArCXJldCA9IG54cF9mc3BpX2NoZWNrX2J1c3dpZHRoKGYsIG9w LT5jbWQuYnVzd2lkdGgpOw0KPiArDQo+ICsJaWYgKG9wLT5hZGRyLm5ieXRlcykNCj4gKwkJcmV0 IHw9IG54cF9mc3BpX2NoZWNrX2J1c3dpZHRoKGYsIG9wLT5hZGRyLmJ1c3dpZHRoKTsNCj4gKw0K PiArCWlmIChvcC0+ZHVtbXkubmJ5dGVzKQ0KPiArCQlyZXQgfD0gbnhwX2ZzcGlfY2hlY2tfYnVz d2lkdGgoZiwgb3AtPmR1bW15LmJ1c3dpZHRoKTsNCj4gKw0KPiArCWlmIChvcC0+ZGF0YS5uYnl0 ZXMpDQo+ICsJCXJldCB8PSBueHBfZnNwaV9jaGVja19idXN3aWR0aChmLCBvcC0+ZGF0YS5idXN3 aWR0aCk7DQo+ICsNCj4gKwlpZiAocmV0KQ0KPiArCQlyZXR1cm4gZmFsc2U7DQo+ICsNCj4gKwkv Kg0KPiArCSAqIFRoZSBudW1iZXIgb2YgaW5zdHJ1Y3Rpb25zIG5lZWRlZCBmb3IgdGhlIG9wLCBu ZWVkcw0KPiArCSAqIHRvIGZpdCBpbnRvIGEgc2luZ2xlIExVVCBlbnRyeS4NCj4gKwkgKi8NCj4g KwlpZiAob3AtPmFkZHIubmJ5dGVzICsNCj4gKwkgICAob3AtPmR1bW15Lm5ieXRlcyA/IDE6MCkg Kw0KPiArCSAgIChvcC0+ZGF0YS5uYnl0ZXMgPyAxOjApID4gNikNCj4gKwkJcmV0dXJuIGZhbHNl Ow0KPiArDQo+ICsJLyogTWF4IDY0IGR1bW15IGNsb2NrIGN5Y2xlcyBzdXBwb3J0ZWQgKi8NCj4g KwlpZiAob3AtPmR1bW15LmJ1c3dpZHRoICYmDQo+ICsJICAgIChvcC0+ZHVtbXkubmJ5dGVzICog OCAvIG9wLT5kdW1teS5idXN3aWR0aCA+IDY0KSkNCj4gKwkJcmV0dXJuIGZhbHNlOw0KPiArDQo+ ICsJLyogTWF4IGRhdGEgbGVuZ3RoLCBjaGVjayBjb250cm9sbGVyIGxpbWl0cyBhbmQgYWxpZ25t ZW50ICovDQo+ICsJaWYgKG9wLT5kYXRhLmRpciA9PSBTUElfTUVNX0RBVEFfSU4gJiYNCj4gKwkg ICAgKG9wLT5kYXRhLm5ieXRlcyA+IGYtPmRldnR5cGVfZGF0YS0+YWhiX2J1Zl9zaXplIHx8DQo+ ICsJICAgICAob3AtPmRhdGEubmJ5dGVzID4gZi0+ZGV2dHlwZV9kYXRhLT5yeGZpZm8gLSA0ICYm DQo+ICsJICAgICAgIUlTX0FMSUdORUQob3AtPmRhdGEubmJ5dGVzLCA4KSkpKQ0KPiArCQlyZXR1 cm4gZmFsc2U7DQo+ICsNCj4gKwlpZiAob3AtPmRhdGEuZGlyID09IFNQSV9NRU1fREFUQV9PVVQg JiYNCj4gKwkgICAgb3AtPmRhdGEubmJ5dGVzID4gZi0+ZGV2dHlwZV9kYXRhLT50eGZpZm8pDQo+ ICsJCXJldHVybiBmYWxzZTsNCj4gKw0KPiArCXJldHVybiB0cnVlOw0KPiArfQ0KPiArDQo+ICsv KiBJbnN0ZWFkIG9mIGJ1c3kgbG9vcGluZyBpbnZva2UgcmVhZGxfcG9sbF90aW1lb3V0IGZ1bmN0 aW9uYWxpdHkuICovDQo+ICtzdGF0aWMgaW50IGZzcGlfcmVhZGxfcG9sbF90b3V0KHN0cnVjdCBu eHBfZnNwaSAqZiwgdm9pZCBfX2lvbWVtICpiYXNlLA0KPiArCQkJCXUzMiBtYXNrLCB1MzIgZGVs YXlfdXMsDQo+ICsJCQkJdTMyIHRpbWVvdXRfdXMsIGJvb2wgY29uZGl0aW9uKQ0KPiArew0KPiAr CXUzMiByZWc7DQo+ICsNCj4gKwlpZiAoIWYtPmRldnR5cGVfZGF0YS0+bGl0dGxlX2VuZGlhbikN Cj4gKwkJbWFzayA9ICh1MzIpY3B1X3RvX2JlMzIobWFzayk7DQo+ICsNCj4gKwlpZiAoY29uZGl0 aW9uKQ0KPiArCQlyZXR1cm4gcmVhZGxfcG9sbF90aW1lb3V0KGJhc2UsIHJlZywgKHJlZyAmIG1h c2spLA0KPiArCQkJCQkgIGRlbGF5X3VzLCB0aW1lb3V0X3VzKTsNCj4gKwllbHNlDQo+ICsJCXJl dHVybiByZWFkbF9wb2xsX3RpbWVvdXQoYmFzZSwgcmVnLCAhKHJlZyAmIG1hc2spLA0KPiArCQkJ CQkgIGRlbGF5X3VzLCB0aW1lb3V0X3VzKTsNCg0KSSB3b3VsZCByYXRoZXIgdXNlIGEgbG9jYWwg dmFyaWFibGUgdG8gc3RvcmUgdGhlIGNvbmRpdGlvbjoNCg0KYm9vbCBjID0gY29uZGl0aW9uID8g KHJlZyAmIG1hc2spOiEocmVnICYgbWFzayk7DQoNCnJldHVybiByZWFkbF9wb2xsX3RpbWVvdXQo YmFzZSwgcmVnLCBjLCBkZWxheV91cywgdGltZW91dF91cyk7DQoNCj4gK30NCj4gKw0KPiArLyoN Cj4gKyAqIElmIHRoZSBzbGF2ZSBkZXZpY2UgY29udGVudCBiZWluZyBjaGFuZ2VkIGJ5IFdyaXRl L0VyYXNlLCBuZWVkIHRvDQo+ICsgKiBpbnZhbGlkYXRlIHRoZSBBSEIgYnVmZmVyLiBUaGlzIGNh biBiZSBhY2hpZXZlZCBieSBkb2luZyB0aGUgcmVzZXQNCj4gKyAqIG9mIGNvbnRyb2xsZXIgYWZ0 ZXIgc2V0dGluZyBNQ1IwW1NXUkVTRVRdIGJpdC4NCj4gKyAqLw0KPiArc3RhdGljIGlubGluZSB2 b2lkIG54cF9mc3BpX2ludmFsaWQoc3RydWN0IG54cF9mc3BpICpmKQ0KPiArew0KPiArCXUzMiBy ZWc7DQo+ICsJaW50IHJldDsNCj4gKw0KPiArCXJlZyA9IGZzcGlfcmVhZGwoZiwgZi0+aW9iYXNl ICsgRlNQSV9NQ1IwKTsNCj4gKwlmc3BpX3dyaXRlbChmLCByZWcgfCBGU1BJX01DUjBfU1dSU1Qs IGYtPmlvYmFzZSArIEZTUElfTUNSMCk7DQo+ICsNCj4gKwkvKiB3MWMgcmVnaXN0ZXIsIHdhaXQg dW5pdCBjbGVhciAqLw0KPiArCXJldCA9IGZzcGlfcmVhZGxfcG9sbF90b3V0KGYsIGYtPmlvYmFz ZSArIEZTUElfTUNSMCwNCj4gKwkJCQkgICBGU1BJX01DUjBfU1dSU1QsIDAsIFBPTExfVE9VVCwg ZmFsc2UpOw0KPiArCVdBUk5fT04ocmV0KTsNCj4gK30NCj4gKw0KPiArc3RhdGljIHZvaWQgbnhw X2ZzcGlfcHJlcGFyZV9sdXQoc3RydWN0IG54cF9mc3BpICpmLA0KPiArCQkJCSBjb25zdCBzdHJ1 Y3Qgc3BpX21lbV9vcCAqb3ApDQo+ICt7DQo+ICsJdm9pZCBfX2lvbWVtICpiYXNlID0gZi0+aW9i YXNlOw0KPiArCXUzMiBsdXR2YWxbNF0gPSB7fTsNCj4gKwlpbnQgbHV0aWR4ID0gMSwgaTsNCj4g Kw0KPiArCS8qIGNtZCAqLw0KPiArCWx1dHZhbFswXSB8PSBMVVRfREVGKDAsIExVVF9DTUQsIExV VF9QQUQob3AtPmNtZC5idXN3aWR0aCksDQo+ICsJCQkgICAgIG9wLT5jbWQub3Bjb2RlKTsNCj4g Kw0KPiArCS8qIGFkZHIgYnVzIHdpZHRoICovDQo+ICsJaWYgKG9wLT5hZGRyLm5ieXRlcykgew0K PiArCQl1MzIgYWRkcmxlbiA9IDA7DQo+ICsNCj4gKwkJc3dpdGNoIChvcC0+YWRkci5uYnl0ZXMp IHsNCj4gKwkJY2FzZSAxOg0KPiArCQkJYWRkcmxlbiA9IEFERFI4QklUOw0KPiArCQkJYnJlYWs7 DQo+ICsJCWNhc2UgMjoNCj4gKwkJCWFkZHJsZW4gPSBBRERSMTZCSVQ7DQo+ICsJCQlicmVhazsN Cj4gKwkJY2FzZSAzOg0KPiArCQkJYWRkcmxlbiA9IEFERFIyNEJJVDsNCj4gKwkJCWJyZWFrOw0K PiArCQljYXNlIDQ6DQo+ICsJCQlhZGRybGVuID0gQUREUjMyQklUOw0KPiArCQkJYnJlYWs7DQo+ ICsJCWRlZmF1bHQ6DQo+ICsJCQlkZXZfZXJyKGYtPmRldiwgIkluLWNvcnJlY3QgYWRkcmVzcyBs ZW5ndGhcbiIpOw0KPiArCQkJcmV0dXJuOw0KPiArCQl9DQoNCllvdSBkb24ndCBuZWVkIHRvIHZh bGlkYXRlIG9wLT5hZGRyLm5ieXRlcyBoZXJlLCB0aGlzIGlzIGFscmVhZHkgZG9uZSBpbiANCm54 cF9mc3BpX3N1cHBvcnRzX29wKCkuDQoNCj4gKw0KPiArCQlsdXR2YWxbbHV0aWR4IC8gMl0gfD0g TFVUX0RFRihsdXRpZHgsIExVVF9BRERSLA0KPiArCQkJCQkgICAgICBMVVRfUEFEKG9wLT5hZGRy LmJ1c3dpZHRoKSwNCj4gKwkJCQkJICAgICAgYWRkcmxlbik7DQoNCllvdSBjYW4gYWxzbyBqdXN0 IHJlbW92ZSB0aGUgd2hvbGUgc3dpdGNoIHN0YXRlbWVudCBhYm92ZSBhbmQgdXNlIHRoaXM6DQoN Cmx1dHZhbFtsdXRpZHggLyAyXSB8PSBMVVRfREVGKGx1dGlkeCwgTFVUX0FERFIsDQoJCQkgICAg ICBMVVRfUEFEKG9wLT5hZGRyLmJ1c3dpZHRoKSwNCgkJCSAgICAgIG9wLT5hZGRyLm5ieXRlcyAq IDgpOw0KDQo+ICsJCWx1dGlkeCsrOw0KPiArCX0NCj4gKw0KPiArCS8qIGR1bW15IGJ5dGVzLCBp ZiBuZWVkZWQgKi8NCj4gKwlpZiAob3AtPmR1bW15Lm5ieXRlcykgew0KPiArCQlsdXR2YWxbbHV0 aWR4IC8gMl0gfD0gTFVUX0RFRihsdXRpZHgsIExVVF9EVU1NWSwNCj4gKwkJLyoNCj4gKwkJICog RHVlIHRvIEZsZXhTUEkgY29udHJvbGxlciBsaW1pdGF0aW9uIG51bWJlciBvZiBQQUQgZm9yIGR1 bW15DQo+ICsJCSAqIGJ1c3dpZHRoIG5lZWRzIHRvIGJlIHByb2dyYW1tZWQgYXMgZXF1YWwgdG8g ZGF0YSBidXN3aWR0aC4NCj4gKwkJICovDQo+ICsJCQkJCSAgICAgIExVVF9QQUQob3AtPmRhdGEu YnVzd2lkdGgpLA0KPiArCQkJCQkgICAgICBvcC0+ZHVtbXkubmJ5dGVzICogOCAvDQo+ICsJCQkJ CSAgICAgIG9wLT5kdW1teS5idXN3aWR0aCk7DQo+ICsJCWx1dGlkeCsrOw0KPiArCX0NCj4gKw0K PiArCS8qIHJlYWQvd3JpdGUgZGF0YSBieXRlcyAqLw0KPiArCWlmIChvcC0+ZGF0YS5uYnl0ZXMp IHsNCj4gKwkJbHV0dmFsW2x1dGlkeCAvIDJdIHw9IExVVF9ERUYobHV0aWR4LA0KPiArCQkJCQkg ICAgICBvcC0+ZGF0YS5kaXIgPT0gU1BJX01FTV9EQVRBX0lOID8NCj4gKwkJCQkJICAgICAgTFVU X05YUF9SRUFEIDogTFVUX05YUF9XUklURSwNCj4gKwkJCQkJICAgICAgTFVUX1BBRChvcC0+ZGF0 YS5idXN3aWR0aCksDQo+ICsJCQkJCSAgICAgIDApOw0KPiArCQlsdXRpZHgrKzsNCj4gKwl9DQo+ ICsNCj4gKwkvKiBzdG9wIGNvbmRpdGlvbi4gKi8NCj4gKwlsdXR2YWxbbHV0aWR4IC8gMl0gfD0g TFVUX0RFRihsdXRpZHgsIExVVF9TVE9QLCAwLCAwKTsNCj4gKw0KPiArCS8qIHVubG9jayBMVVQg Ki8NCj4gKwlmc3BpX3dyaXRlbChmLCBGU1BJX0xVVEtFWV9WQUxVRSwgZi0+aW9iYXNlICsgRlNQ SV9MVVRLRVkpOw0KPiArCWZzcGlfd3JpdGVsKGYsIEZTUElfTENLRVJfVU5MT0NLLCBmLT5pb2Jh c2UgKyBGU1BJX0xDS0NSKTsNCj4gKw0KPiArCS8qIGZpbGwgTFVUICovDQo+ICsJZm9yIChpID0g MDsgaSA8IEFSUkFZX1NJWkUobHV0dmFsKTsgaSsrKQ0KPiArCQlmc3BpX3dyaXRlbChmLCBsdXR2 YWxbaV0sIGJhc2UgKyBGU1BJX0xVVF9SRUcoaSkpOw0KPiArDQo+ICsJZGV2X2RiZyhmLT5kZXYs ICJDTURbJXhdIGx1dHZhbFswOiV4IFx0IDE6JXggXHQgMjoleCBcdCAzOiV4XVxuIiwNCj4gKwkJ b3AtPmNtZC5vcGNvZGUsIGx1dHZhbFswXSwgbHV0dmFsWzFdLCBsdXR2YWxbMl0sIGx1dHZhbFsz XSk7DQo+ICsNCj4gKwkvKiBsb2NrIExVVCAqLw0KPiArCWZzcGlfd3JpdGVsKGYsIEZTUElfTFVU S0VZX1ZBTFVFLCBmLT5pb2Jhc2UgKyBGU1BJX0xVVEtFWSk7DQo+ICsJZnNwaV93cml0ZWwoZiwg RlNQSV9MQ0tFUl9MT0NLLCBmLT5pb2Jhc2UgKyBGU1BJX0xDS0NSKTsNCj4gK30NCj4gKw0KPiAr c3RhdGljIGludCBueHBfZnNwaV9jbGtfcHJlcF9lbmFibGUoc3RydWN0IG54cF9mc3BpICpmKQ0K PiArew0KPiArCWludCByZXQ7DQo+ICsNCj4gKwlyZXQgPSBjbGtfcHJlcGFyZV9lbmFibGUoZi0+ Y2xrX2VuKTsNCj4gKwlpZiAocmV0KQ0KPiArCQlyZXR1cm4gcmV0Ow0KPiArDQo+ICsJcmV0ID0g Y2xrX3ByZXBhcmVfZW5hYmxlKGYtPmNsayk7DQo+ICsJaWYgKHJldCkgew0KPiArCQljbGtfZGlz YWJsZV91bnByZXBhcmUoZi0+Y2xrX2VuKTsNCj4gKwkJcmV0dXJuIHJldDsNCj4gKwl9DQo+ICsN Cj4gKwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiArc3RhdGljIHZvaWQgbnhwX2ZzcGlfY2xrX2Rp c2FibGVfdW5wcmVwKHN0cnVjdCBueHBfZnNwaSAqZikNCj4gK3sNCj4gKwljbGtfZGlzYWJsZV91 bnByZXBhcmUoZi0+Y2xrKTsNCj4gKwljbGtfZGlzYWJsZV91bnByZXBhcmUoZi0+Y2xrX2VuKTsN Cj4gK30NCj4gKw0KPiArLyoNCj4gKyAqIEluIEZsZXhTUEkgY29udHJvbGxlciwgZmxhc2ggYWNj ZXNzIGlzIGJhc2VkIG9uIHZhbHVlIG9mIEZTUElfRkxTSFhYQ1IwDQo+ICsgKiByZWdpc3RlciBh bmQgc3RhcnQgYmFzZSBhZGRyZXNzIG9mIHRoZSBzbGF2ZSBkZXZpY2UuDQo+ICsgKg0KPiArICoJ CQkJCQkJICAgIChIaWdoZXIgYWRkcmVzcykNCj4gKyAqCQkJCS0tLS0tLS0tICAgIDwtLSBGTFNI QjJDUjANCj4gKyAqCQkJCXwgIEIyICB8DQo+ICsgKgkJCQl8ICAgICAgfA0KPiArICoJQjIgc3Rh cnQgYWRkcmVzcyAtLT4JLS0tLS0tLS0gICAgPC0tIEZMU0hCMUNSMA0KPiArICoJCQkJfCAgQjEg IHwNCj4gKyAqCQkJCXwgICAgICB8DQo+ICsgKglCMSBzdGFydCBhZGRyZXNzIC0tPgktLS0tLS0t LSAgICA8LS0gRkxTSEEyQ1IwDQo+ICsgKgkJCQl8ICBBMiAgfA0KPiArICoJCQkJfCAgICAgIHwN Cj4gKyAqCUEyIHN0YXJ0IGFkZHJlc3MgLS0+CS0tLS0tLS0tICAgIDwtLSBGTFNIQTFDUjANCj4g KyAqCQkJCXwgIEExICB8DQo+ICsgKgkJCQl8ICAgICAgfA0KPiArICoJQTEgc3RhcnQgYWRkcmVz cyAtLT4JLS0tLS0tLS0JCSAgICAoTG93ZXIgYWRkcmVzcykNCj4gKyAqDQo+ICsgKg0KPiArICog U3RhcnQgYmFzZSBhZGRyZXNzIGRlZmluZXMgdGhlIHN0YXJ0aW5nIGFkZHJlc3MgcmFuZ2UgZm9y IGdpdmVuIENTIGFuZA0KPiArICogRlNQSV9GTFNIWFhDUjAgZGVmaW5lcyB0aGUgc2l6ZSBvZiB0 aGUgc2xhdmUgZGV2aWNlIGNvbm5lY3RlZCBhdCBnaXZlbiBDUy4NCj4gKyAqDQo+ICsgKiBCdXQs IGRpZmZlcmVudCB0YXJnZXRzIGFyZSBoYXZpbmcgZGlmZmVyZW50IGNvbWJpbmF0aW9ucyBvZiBu dW1iZXIgb2YgQ1MsDQo+ICsgKiBzb21lIHRhcmdldHMgb25seSBoYXZlIHNpbmdsZSBDUyBvciB0 d28gQ1MgY292ZXJpbmcgY29udHJvbGxlcidzIGZ1bGwNCj4gKyAqIG1lbW9yeSBtYXBwZWQgc3Bh Y2UgYXJlYS4NCj4gKyAqIFRodXMsIGltcGxlbWVudGF0aW9uIGlzIGJlaW5nIGRvbmUgYXMgaW5k ZXBlbmRlbnQgb2YgdGhlIHNpemUgYW5kIG51bWJlcg0KPiArICogb2YgdGhlIGNvbm5lY3RlZCBz bGF2ZSBkZXZpY2UuDQo+ICsgKiBBc3NpZ24gY29udHJvbGxlciBtZW1vcnkgbWFwcGVkIHNwYWNl IHNpemUgYXMgdGhlIHNpemUgdG8gdGhlIGNvbm5lY3RlZA0KPiArICogc2xhdmUgZGV2aWNlLg0K PiArICogTWFyayBGTFNIeHhDUjAgYXMgemVybyBpbml0aWFsbHkgYW5kIHRoZW4gYXNzaWduIHZh bHVlIG9ubHkgdG8gdGhlIHNlbGVjdGVkDQo+ICsgKiBjaGlwLXNlbGVjdCBGbGFzaCBjb25maWd1 cmF0aW9uIHJlZ2lzdGVyLg0KPiArICoNCj4gKyAqIEZvciBlLmcuIHRvIGFjY2VzcyBDUzIgKEIx KSwgRkxTSEIxQ1IwIHJlZ2lzdGVyIHdvdWxkIGJlIGVxdWFsIHRvIHRoZQ0KPiArICogbWVtb3J5 IG1hcHBlZCBzaXplIG9mIHRoZSBjb250cm9sbGVyLg0KPiArICogVmFsdWUgZm9yIHJlc3Qgb2Yg dGhlIENTIEZMU0h4eENSMCByZWdpc3RlciB3b3VsZCBiZSB6ZXJvLg0KPiArICoNCj4gKyAqLw0K PiArc3RhdGljIHZvaWQgbnhwX2ZzcGlfc2VsZWN0X21lbShzdHJ1Y3QgbnhwX2ZzcGkgKmYsIHN0 cnVjdCBzcGlfZGV2aWNlICpzcGkpDQo+ICt7DQo+ICsJdW5zaWduZWQgbG9uZyByYXRlID0gc3Bp LT5tYXhfc3BlZWRfaHo7DQo+ICsJaW50IHJldDsNCj4gKwl1aW50NjRfdCBzaXplX2tiOw0KPiAr DQo+ICsJLyoNCj4gKwkgKiBSZXR1cm4sIGlmIHByZXZpb3VzbHkgc2VsZWN0ZWQgc2xhdmUgZGV2 aWNlIGlzIHNhbWUgYXMgY3VycmVudA0KPiArCSAqIHJlcXVlc3RlZCBzbGF2ZSBkZXZpY2UuDQo+ ICsJICovDQo+ICsJaWYgKGYtPnNlbGVjdGVkID09IHNwaS0+Y2hpcF9zZWxlY3QpDQo+ICsJCXJl dHVybjsNCj4gKw0KPiArCS8qIFJlc2V0IEZMU0h4eENSMCByZWdpc3RlcnMgKi8NCj4gKwlmc3Bp X3dyaXRlbChmLCAwLCBmLT5pb2Jhc2UgKyBGU1BJX0ZMU0hBMUNSMCk7DQo+ICsJZnNwaV93cml0 ZWwoZiwgMCwgZi0+aW9iYXNlICsgRlNQSV9GTFNIQTJDUjApOw0KPiArCWZzcGlfd3JpdGVsKGYs IDAsIGYtPmlvYmFzZSArIEZTUElfRkxTSEIxQ1IwKTsNCj4gKwlmc3BpX3dyaXRlbChmLCAwLCBm LT5pb2Jhc2UgKyBGU1BJX0ZMU0hCMkNSMCk7DQo+ICsNCj4gKwkvKiBBc3NpZ24gY29udHJvbGxl ciBtZW1vcnkgbWFwcGVkIHNwYWNlIGFzIHNpemUsIEtCeXRlcywgb2YgZmxhc2guICovDQo+ICsJ c2l6ZV9rYiA9IEZTUElfRkxTSFhDUjBfU1ooZi0+bWVtbWFwX3BoeV9zaXplKTsNCg0KWW91IGFy ZSBzdGlsbCB1c2luZyBtZW1vcnkgb2YgYXJiaXRyYXJ5IHNpemUgKG1lbW1hcF9waHlfc2l6ZSkg Zm9yIA0KbWFwcGluZyB0aGUgZmxhc2guIFdoeSBub3QgdXNlIHRoZSBzYW1lIGFwcHJvYWNoIGFz IGluIHRoZSBRU1BJIGRyaXZlciANCmFuZCBqdXN0IG1hcCBhaGJfYnVmX3NpemUgdW50aWwgd2Ug aW1wbGVtZW50IHRoZSBkaXJtYXAgQVBJPw0KWW91IGFyZSBhbHJlYWR5IGFsaWduaW5nIHRoZSBB SEIgcmVhZHMgZm9yIHRoaXMgaW4gDQpueHBfZnNwaV9hZGp1c3Rfb3Bfc2l6ZSgpLg0KDQo+ICsN Cj4gKwlzd2l0Y2ggKHNwaS0+Y2hpcF9zZWxlY3QpIHsNCj4gKwljYXNlIDA6DQo+ICsJCWZzcGlf d3JpdGVsKGYsIHNpemVfa2IsIGYtPmlvYmFzZSArIEZTUElfRkxTSEExQ1IwKTsNCj4gKwkJYnJl YWs7DQo+ICsJY2FzZSAxOg0KPiArCQlmc3BpX3dyaXRlbChmLCBzaXplX2tiLCBmLT5pb2Jhc2Ug KyBGU1BJX0ZMU0hBMkNSMCk7DQo+ICsJCWJyZWFrOw0KPiArCWNhc2UgMjoNCj4gKwkJZnNwaV93 cml0ZWwoZiwgc2l6ZV9rYiwgZi0+aW9iYXNlICsgRlNQSV9GTFNIQjFDUjApOw0KPiArCQlicmVh azsNCj4gKwljYXNlIDM6DQo+ICsJCWZzcGlfd3JpdGVsKGYsIHNpemVfa2IsIGYtPmlvYmFzZSAr IEZTUElfRkxTSEIyQ1IwKTsNCj4gKwkJYnJlYWs7DQo+ICsJZGVmYXVsdDoNCj4gKwkJZGV2X2Vy cihmLT5kZXYsICJJbi1jb3JyZWN0IENTIHByb3ZpZGVkXG4iKTsNCj4gKwkJcmV0dXJuOw0KDQpZ b3UgZG9uJ3QgbmVlZCB0byB2YWxpZGF0ZSBzcGktPmNoaXBfc2VsZWN0IGhlcmUuIFRoaXMgc2hv dWxkIG5ldmVyIGJlIA0KaW52YWxpZCBhbmQgaWYgaXQgaXMsIHNvbWV0aGluZyBpcyByZWFsbHkg d3JvbmcgYW5kIHlvdXIgY2hlY2sgd29uJ3QgaGVscC4NCg0KPiArCX0NCj4gKw0KPiArCWRldl9k YmcoZi0+ZGV2LCAiU2xhdmUgZGV2aWNlIFtDUzoleF0gc2VsZWN0ZWRcbiIsIHNwaS0+Y2hpcF9z ZWxlY3QpOw0KPiArDQo+ICsJbnhwX2ZzcGlfY2xrX2Rpc2FibGVfdW5wcmVwKGYpOw0KPiArDQo+ ICsJcmV0ID0gY2xrX3NldF9yYXRlKGYtPmNsaywgcmF0ZSk7DQo+ICsJaWYgKHJldCkNCj4gKwkJ cmV0dXJuOw0KPiArDQo+ICsJcmV0ID0gbnhwX2ZzcGlfY2xrX3ByZXBfZW5hYmxlKGYpOw0KPiAr CWlmIChyZXQpDQo+ICsJCXJldHVybjsNCg0KTWlzc2luZyBuZXdsaW5lIGxpbmUgaGVyZS4NCg0K PiArCWYtPnNlbGVjdGVkID0gc3BpLT5jaGlwX3NlbGVjdDsNCj4gK30NCj4gKw0KPiArc3RhdGlj IHZvaWQgbnhwX2ZzcGlfcmVhZF9haGIoc3RydWN0IG54cF9mc3BpICpmLCBjb25zdCBzdHJ1Y3Qg c3BpX21lbV9vcCAqb3ApDQo+ICt7DQo+ICsJdTMyIGxlbiA9IG9wLT5kYXRhLm5ieXRlczsNCj4g Kw0KPiArCS8qIFJlYWQgb3V0IHRoZSBkYXRhIGRpcmVjdGx5IGZyb20gdGhlIEFIQiBidWZmZXIu ICovDQo+ICsJbWVtY3B5X2Zyb21pbyhvcC0+ZGF0YS5idWYuaW4sIChmLT5haGJfYWRkciArIG9w LT5hZGRyLnZhbCksIGxlbik7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyB2b2lkIG54cF9mc3BpX2Zp bGxfdHhmaWZvKHN0cnVjdCBueHBfZnNwaSAqZiwNCj4gKwkJCQkgY29uc3Qgc3RydWN0IHNwaV9t ZW1fb3AgKm9wKQ0KPiArew0KPiArCXZvaWQgX19pb21lbSAqYmFzZSA9IGYtPmlvYmFzZTsNCj4g KwlpbnQgaSwgaiwgcmV0Ow0KPiArCWludCBzaXplLCB0bXBfc2l6ZSwgd21fc2l6ZTsNCj4gKwl1 MzIgZGF0YSA9IDA7DQo+ICsJdTMyICp0eGJ1ZiA9ICh1MzIgKikgb3AtPmRhdGEuYnVmLm91dDsN Cj4gKw0KPiArCS8qIGNsZWFyIHRoZSBUWCBGSUZPLiAqLw0KPiArCWZzcGlfd3JpdGVsKGYsIEZT UElfSVBUWEZDUl9DTFIsIGJhc2UgKyBGU1BJX0lQVFhGQ1IpOw0KPiArDQo+ICsJLyogRGVmYXVs dCB2YWx1ZSBvZiB3YXRlciBtYXJrIGxldmVsIGlzIDggYnl0ZXMuICovDQo+ICsJd21fc2l6ZSA9 IDg7DQo+ICsJc2l6ZSA9IG9wLT5kYXRhLm5ieXRlcyAvIHdtX3NpemU7DQo+ICsJZm9yIChpID0g MDsgaSA8IHNpemU7IGkrKykgew0KPiArCQkvKiBXYWl0IGZvciBUWEZJRk8gZW1wdHkgKi8NCj4g KwkJcmV0ID0gZnNwaV9yZWFkbF9wb2xsX3RvdXQoZiwgZi0+aW9iYXNlICsgRlNQSV9JTlRSLA0K PiArCQkJCQkgICBGU1BJX0lOVFJfSVBUWFdFLCAwLA0KPiArCQkJCQkgICBQT0xMX1RPVVQsIHRy dWUpOw0KPiArCQlXQVJOX09OKHJldCk7DQo+ICsNCj4gKwkJaiA9IDA7DQo+ICsJCXRtcF9zaXpl ID0gd21fc2l6ZTsNCj4gKwkJd2hpbGUgKHRtcF9zaXplID4gMCkgew0KPiArCQkJZGF0YSA9IDA7 DQo+ICsJCQltZW1jcHkoJmRhdGEsIHR4YnVmLCA0KTsNCj4gKwkJCWZzcGlfd3JpdGVsKGYsIGRh dGEsIGJhc2UgKyBGU1BJX1RGRFIgKyBqICogNCk7DQo+ICsJCQl0bXBfc2l6ZSAtPSA0Ow0KPiAr CQkJaisrOw0KPiArCQkJdHhidWYgKz0gMTsNCj4gKwkJfQ0KPiArCQlmc3BpX3dyaXRlbChmLCBG U1BJX0lOVFJfSVBUWFdFLCBiYXNlICsgRlNQSV9JTlRSKTsNCj4gKwl9DQo+ICsNCj4gKwlzaXpl ID0gb3AtPmRhdGEubmJ5dGVzICUgd21fc2l6ZTsNCj4gKwlpZiAoc2l6ZSkgew0KPiArCQkvKiBX YWl0IGZvciBUWEZJRk8gZW1wdHkgKi8NCj4gKwkJcmV0ID0gZnNwaV9yZWFkbF9wb2xsX3RvdXQo ZiwgZi0+aW9iYXNlICsgRlNQSV9JTlRSLA0KPiArCQkJCQkgICBGU1BJX0lOVFJfSVBUWFdFLCAw LA0KPiArCQkJCQkgICBQT0xMX1RPVVQsIHRydWUpOw0KPiArCQlXQVJOX09OKHJldCk7DQo+ICsN Cj4gKwkJaiA9IDA7DQo+ICsJCXRtcF9zaXplID0gMDsNCj4gKwkJd2hpbGUgKHNpemUgPiAwKSB7 DQo+ICsJCQlkYXRhID0gMDsNCj4gKwkJCXRtcF9zaXplID0gKHNpemUgPCA0KSA/IHNpemUgOiA0 Ow0KPiArCQkJbWVtY3B5KCZkYXRhLCB0eGJ1ZiwgdG1wX3NpemUpOw0KPiArCQkJZnNwaV93cml0 ZWwoZiwgZGF0YSwgYmFzZSArIEZTUElfVEZEUiArIGogKiA0KTsNCj4gKwkJCXNpemUgLT0gdG1w X3NpemU7DQo+ICsJCQlqKys7DQo+ICsJCQl0eGJ1ZiArPSAxOw0KPiArCQl9DQo+ICsJCWZzcGlf d3JpdGVsKGYsIEZTUElfSU5UUl9JUFRYV0UsIGJhc2UgKyBGU1BJX0lOVFIpOw0KPiArCX0NCg0K QWxsIHRoZXNlIG5lc3RlZCBsb29wcyB0byBmaWxsIHRoZSBUWCBidWZmZXIgYW5kIGFsc28gdGhl IG9uZXMgYmVsb3cgdG8gDQpyZWFkIHRoZSBSWCBidWZmZXIgbG9vayBtdWNoIG1vcmUgY29tcGxp Y2F0ZWQgdGhhbiB0aGV5IHNob3VsZCByZWFsbHkgDQpiZS4gQ2FuIHlvdSB0cnkgdG8gbWFrZSB0 aGlzIG1vcmUgcmVhZGFibGU/DQoNCk1heWJlIHNvbWV0aGluZyBsaWtlIHRoaXMgd291bGQgd29y azoNCg0KZm9yIChpID0gMDsgaSA8IEFMSUdOX0RPV04ob3AtPmRhdGEubmJ5dGVzLCA4KTsgaSAr PSA4KSB7DQoJLyogV2FpdCBmb3IgVFhGSUZPIGVtcHR5ICovDQoJcmV0ID0gZnNwaV9yZWFkbF9w b2xsX3RvdXQoZiwgZi0+aW9iYXNlICsgRlNQSV9JTlRSLA0KCQkJCSAgIEZTUElfSU5UUl9JUFRY V0UsIDAsDQoJCQkJICAgUE9MTF9UT1VULCB0cnVlKTsNCg0KCWZzcGlfd3JpdGVsKGYsIG9wLT5k YXRhLmJ1Zi5vdXQgKyBpLCBiYXNlICsgRlNQSV9URkRSKTsNCglmc3BpX3dyaXRlbChmLCBvcC0+ ZGF0YS5idWYub3V0ICsgaSArIDQsIGJhc2UgKyBGU1BJX1RGRFIgKyA0KTsNCglmc3BpX3dyaXRl bChmLCBGU1BJX0lOVFJfSVBUWFdFLCBiYXNlICsgRlNQSV9JTlRSKTsNCn0NCg0KaWYgKGkgPCBv cC0+ZGF0YS5uYnl0ZXMpIHsNCgl1MzIgZGF0YSA9IDA7DQoJaW50IGo7DQoJLyogV2FpdCBmb3Ig VFhGSUZPIGVtcHR5ICovDQoJcmV0ID0gZnNwaV9yZWFkbF9wb2xsX3RvdXQoZiwgZi0+aW9iYXNl ICsgRlNQSV9JTlRSLA0KCQkJCSAgIEZTUElfSU5UUl9JUFRYV0UsIDAsDQoJCQkJICAgUE9MTF9U T1VULCB0cnVlKTsNCg0KCWZvciAoaiA9IDA7IGogPCBBTElHTihvcC0+ZGF0YS5uYnl0ZXMgLSBp LCA0KTsgaiArPSA0KSB7DQoJCW1lbWNweSgmZGF0YSwgb3AtPmRhdGEuYnVmLm91dCArIGkgKyBq LCA0KTsNCgkJZnNwaV93cml0ZWwoZiwgZGF0YSwgYmFzZSArIEZTUElfVEZEUiArIGopOw0KCX0N Cg0KCWZzcGlfd3JpdGVsKGYsIEZTUElfSU5UUl9JUFRYV0UsIGJhc2UgKyBGU1BJX0lOVFIpOw0K fQ0KDQo+ICt9DQo+ICsNCj4gK3N0YXRpYyB2b2lkIG54cF9mc3BpX3JlYWRfcnhmaWZvKHN0cnVj dCBueHBfZnNwaSAqZiwNCj4gKwkJCSAgY29uc3Qgc3RydWN0IHNwaV9tZW1fb3AgKm9wKQ0KPiAr ew0KPiArCXZvaWQgX19pb21lbSAqYmFzZSA9IGYtPmlvYmFzZTsNCj4gKwlpbnQgaSwgajsNCj4g KwlpbnQgc2l6ZSwgdG1wX3NpemUsIHdtX3NpemUsIHJldDsNCj4gKwl1MzIgdG1wID0gMDsNCj4g Kwl1OCAqYnVmID0gb3AtPmRhdGEuYnVmLmluOw0KPiArCXUzMiBsZW4gPSBvcC0+ZGF0YS5uYnl0 ZXM7DQo+ICsNCj4gKwkvKiBEZWZhdWx0IHZhbHVlIG9mIHdhdGVyIG1hcmsgbGV2ZWwgaXMgOCBi eXRlcy4gKi8NCj4gKwl3bV9zaXplID0gODsNCj4gKw0KPiArCXdoaWxlIChsZW4gPiAwKSB7DQo+ ICsJCXNpemUgPSBsZW4gLyB3bV9zaXplOw0KPiArDQo+ICsJCWZvciAoaSA9IDA7IGkgPCBzaXpl OyBpKyspIHsNCj4gKwkJCS8qIFdhaXQgZm9yIFJYRklGTyBhdmFpbGFibGUgKi8NCj4gKwkJCXJl dCA9IGZzcGlfcmVhZGxfcG9sbF90b3V0KGYsIGYtPmlvYmFzZSArIEZTUElfSU5UUiwNCj4gKwkJ CQkJCSAgIEZTUElfSU5UUl9JUFJYV0EsIDAsDQo+ICsJCQkJCQkgICBQT0xMX1RPVVQsIHRydWUp Ow0KPiArCQkJV0FSTl9PTihyZXQpOw0KPiArDQo+ICsJCQlqID0gMDsNCj4gKwkJCXRtcF9zaXpl ID0gd21fc2l6ZTsNCj4gKwkJCXdoaWxlICh0bXBfc2l6ZSA+IDApIHsNCj4gKwkJCQl0bXAgPSAw Ow0KPiArCQkJCXRtcCA9IGZzcGlfcmVhZGwoZiwgYmFzZSArIEZTUElfUkZEUiArIGogKiA0KTsN Cj4gKwkJCQltZW1jcHkoYnVmLCAmdG1wLCA0KTsNCj4gKwkJCQl0bXBfc2l6ZSAtPSA0Ow0KPiAr CQkJCWorKzsNCj4gKwkJCQlidWYgKz0gNDsNCj4gKwkJCX0NCj4gKwkJCS8qIG1vdmUgdGhlIEZJ Rk8gcG9pbnRlciAqLw0KPiArCQkJZnNwaV93cml0ZWwoZiwgRlNQSV9JTlRSX0lQUlhXQSwgYmFz ZSArIEZTUElfSU5UUik7DQo+ICsJCQlsZW4gLT0gd21fc2l6ZTsNCj4gKwkJfQ0KPiArDQo+ICsJ CXNpemUgPSBsZW4gJSB3bV9zaXplOw0KPiArDQo+ICsJCWogPSAwOw0KPiArCQlpZiAoc2l6ZSkg ew0KPiArCQkJLyogV2FpdCBmb3IgUlhGSUZPIGF2YWlsYWJsZSAqLw0KPiArCQkJcmV0ID0gZnNw aV9yZWFkbF9wb2xsX3RvdXQoZiwgZi0+aW9iYXNlICsgRlNQSV9JTlRSLA0KPiArCQkJCQkJICAg RlNQSV9JTlRSX0lQUlhXQSwgMCwNCj4gKwkJCQkJCSAgIFBPTExfVE9VVCwgdHJ1ZSk7DQo+ICsJ CQlXQVJOX09OKHJldCk7DQo+ICsNCj4gKwkJCXdoaWxlIChsZW4gPiAwKSB7DQo+ICsJCQkJdG1w ID0gMDsNCj4gKwkJCQlzaXplID0gKGxlbiA8IDQpID8gbGVuIDogNDsNCj4gKwkJCQl0bXAgPSBm c3BpX3JlYWRsKGYsIGJhc2UgKyBGU1BJX1JGRFIgKyBqICogNCk7DQo+ICsJCQkJbWVtY3B5KGJ1 ZiwgJnRtcCwgc2l6ZSk7DQo+ICsJCQkJbGVuIC09IHNpemU7DQo+ICsJCQkJaisrOw0KPiArCQkJ CWJ1ZiArPSBzaXplOw0KPiArCQkJfQ0KPiArCQl9DQo+ICsNCj4gKwkJLyogaW52YWxpZCB0aGUg UlhGSUZPICovDQo+ICsJCWZzcGlfd3JpdGVsKGYsIEZTUElfSVBSWEZDUl9DTFIsIGJhc2UgKyBG U1BJX0lQUlhGQ1IpOw0KPiArCQkvKiBtb3ZlIHRoZSBGSUZPIHBvaW50ZXIgKi8NCj4gKwkJZnNw aV93cml0ZWwoZiwgRlNQSV9JTlRSX0lQUlhXQSwgYmFzZSArIEZTUElfSU5UUik7DQo+ICsJfQ0K DQpTYW1lIGhlcmUuIEkgdGhpbmsgdGhpcyBpcyBvdmVybHkgY29tcGxpY2F0ZWQuDQoNCj4gK30N Cj4gKw0KPiArc3RhdGljIGludCBueHBfZnNwaV9kb19vcChzdHJ1Y3QgbnhwX2ZzcGkgKmYsIGNv bnN0IHN0cnVjdCBzcGlfbWVtX29wICpvcCkNCj4gK3sNCj4gKwl2b2lkIF9faW9tZW0gKmJhc2Ug PSBmLT5pb2Jhc2U7DQo+ICsJaW50IHNlcW51bSA9IDA7DQo+ICsJaW50IGVyciA9IDA7DQo+ICsJ dTMyIHJlZzsNCj4gKw0KPiArCXJlZyA9IGZzcGlfcmVhZGwoZiwgYmFzZSArIEZTUElfSVBSWEZD Uik7DQo+ICsJLyogaW52YWxpZCBSWEZJRk8gZmlyc3QgKi8NCj4gKwlyZWcgJj0gfkZTUElfSVBS WEZDUl9ETUFfRU47DQo+ICsJcmVnID0gcmVnIHwgRlNQSV9JUFJYRkNSX0NMUjsNCj4gKwlmc3Bp X3dyaXRlbChmLCByZWcsIGJhc2UgKyBGU1BJX0lQUlhGQ1IpOw0KPiArDQo+ICsJaW5pdF9jb21w bGV0aW9uKCZmLT5jKTsNCj4gKw0KPiArCWZzcGlfd3JpdGVsKGYsIG9wLT5hZGRyLnZhbCwgYmFz ZSArIEZTUElfSVBDUjApOw0KPiArCS8qDQo+ICsJICogQWx3YXlzIHN0YXJ0IHRoZSBzZXF1ZW5j ZSBhdCB0aGUgc2FtZSBpbmRleCBzaW5jZSB3ZSB1cGRhdGUNCj4gKwkgKiB0aGUgTFVUIGF0IGVh Y2ggZXhlY19vcCgpIGNhbGwuIEFuZCBhbHNvIHNwZWNpZnkgdGhlIERBVEENCj4gKwkgKiBsZW5n dGgsIHNpbmNlIGl0J3MgaGFzIG5vdCBiZWVuIHNwZWNpZmllZCBpbiB0aGUgTFVULg0KPiArCSAq Lw0KPiArCWZzcGlfd3JpdGVsKGYsIG9wLT5kYXRhLm5ieXRlcyB8DQo+ICsJCSAoU0VRSURfTFVU IDw8IEZTUElfSVBDUjFfU0VRSURfU0hJRlQpIHwNCj4gKwkJIChzZXFudW0gPDwgRlNQSV9JUENS MV9TRVFOVU1fU0hJRlQpLA0KPiArCQkgYmFzZSArIEZTUElfSVBDUjEpOw0KPiArDQo+ICsJLyog VHJpZ2dlciB0aGUgTFVUIG5vdy4gKi8NCj4gKwlmc3BpX3dyaXRlbChmLCBGU1BJX0lQQ01EX1RS RywgYmFzZSArIEZTUElfSVBDTUQpOw0KPiArDQo+ICsJLyogV2FpdCBmb3IgdGhlIGludGVycnVw dC4gKi8NCj4gKwlpZiAoIXdhaXRfZm9yX2NvbXBsZXRpb25fdGltZW91dCgmZi0+YywgbXNlY3Nf dG9famlmZmllcygxMDAwKSkpDQo+ICsJCWVyciA9IC1FVElNRURPVVQ7DQo+ICsNCj4gKwkvKiBJ bnZva2UgSVAgZGF0YSByZWFkLCBpZiByZXF1ZXN0IGlzIG9mIGRhdGEgcmVhZC4gKi8NCj4gKwlp ZiAoIWVyciAmJiBvcC0+ZGF0YS5uYnl0ZXMgJiYgb3AtPmRhdGEuZGlyID09IFNQSV9NRU1fREFU QV9JTikNCj4gKwkJbnhwX2ZzcGlfcmVhZF9yeGZpZm8oZiwgb3ApOw0KPiArDQo+ICsJcmV0dXJu IGVycjsNCj4gK30NCj4gKw0KPiArc3RhdGljIGludCBueHBfZnNwaV9leGVjX29wKHN0cnVjdCBz cGlfbWVtICptZW0sIGNvbnN0IHN0cnVjdCBzcGlfbWVtX29wICpvcCkNCj4gK3sNCj4gKwlzdHJ1 Y3QgbnhwX2ZzcGkgKmYgPSBzcGlfY29udHJvbGxlcl9nZXRfZGV2ZGF0YShtZW0tPnNwaS0+bWFz dGVyKTsNCj4gKwlpbnQgZXJyID0gMDsNCj4gKw0KPiArCW11dGV4X2xvY2soJmYtPmxvY2spOw0K PiArDQo+ICsJLyogV2FpdCBmb3IgY29udHJvbGxlciBiZWluZyByZWFkeS4gKi8NCj4gKwllcnIg PSBmc3BpX3JlYWRsX3BvbGxfdG91dChmLCBmLT5pb2Jhc2UgKyBGU1BJX1NUUzAsDQo+ICsJCQkJ ICAgRlNQSV9TVFMwX0FSQl9JRExFLCAxLCBQT0xMX1RPVVQsIHRydWUpOw0KPiArCVdBUk5fT04o ZXJyKTsNCj4gKw0KPiArCW54cF9mc3BpX3NlbGVjdF9tZW0oZiwgbWVtLT5zcGkpOw0KPiArDQo+ ICsJbnhwX2ZzcGlfcHJlcGFyZV9sdXQoZiwgb3ApOw0KPiArCS8qDQo+ICsJICogSWYgd2UgaGF2 ZSBsYXJnZSBjaHVua3Mgb2YgZGF0YSwgd2UgcmVhZCB0aGVtIHRocm91Z2ggdGhlIEFIQiBidXMN Cj4gKwkgKiBieSBhY2Nlc3NpbmcgdGhlIG1hcHBlZCBtZW1vcnkuIEluIGFsbCBvdGhlciBjYXNl cyB3ZSB1c2UNCj4gKwkgKiBJUCBjb21tYW5kcyB0byBhY2Nlc3MgdGhlIGZsYXNoLg0KPiArCSAq Lw0KPiArCWlmIChvcC0+ZGF0YS5uYnl0ZXMgPiAoZi0+ZGV2dHlwZV9kYXRhLT5yeGZpZm8gLSA0 KSAmJg0KPiArCSAgICBvcC0+ZGF0YS5kaXIgPT0gU1BJX01FTV9EQVRBX0lOKSB7DQo+ICsJCW54 cF9mc3BpX3JlYWRfYWhiKGYsIG9wKTsNCj4gKwl9IGVsc2Ugew0KPiArCQlpZiAob3AtPmRhdGEu bmJ5dGVzICYmIG9wLT5kYXRhLmRpciA9PSBTUElfTUVNX0RBVEFfT1VUKQ0KPiArCQkJbnhwX2Zz cGlfZmlsbF90eGZpZm8oZiwgb3ApOw0KPiArDQo+ICsJCWVyciA9IG54cF9mc3BpX2RvX29wKGYs IG9wKTsNCj4gKw0KPiArCQkvKiBJbnZhbGlkYXRlIHRoZSBkYXRhIGluIHRoZSBBSEIgYnVmZmVy LiAqLw0KPiArCQlpZiAob3AtPmRhdGEubmJ5dGVzICYmIG9wLT5kYXRhLmRpciA9PSBTUElfTUVN X0RBVEFfT1VUKQ0KPiArCQkJbnhwX2ZzcGlfaW52YWxpZChmKTsNCg0KRS5nLiBpbiBjYXNlIG9m IGFuIGVyYXNlIG9wZXJhdGlvbiBvciBhIE5BTkQgbG9hZCBwYWdlIG9wZXJhdGlvbiwgdGhlIA0K aW52YWxpZGF0aW9uIGlzIG5vdCB0cmlnZ2VyZWQsIGJ1dCBmbGFzaC9idWZmZXIgY29udGVudHMg aGF2ZSBjaGFuZ2VkLiANClNvIEknbSBub3Qgc3VyZSBpZiB0aGlzIGlzIGVub3VnaC4uLg0KDQo+ ICsJfQ0KPiArDQo+ICsJbXV0ZXhfdW5sb2NrKCZmLT5sb2NrKTsNCj4gKw0KPiArCXJldHVybiBl cnI7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpbnQgbnhwX2ZzcGlfYWRqdXN0X29wX3NpemUoc3Ry dWN0IHNwaV9tZW0gKm1lbSwgc3RydWN0IHNwaV9tZW1fb3AgKm9wKQ0KPiArew0KPiArCXN0cnVj dCBueHBfZnNwaSAqZiA9IHNwaV9jb250cm9sbGVyX2dldF9kZXZkYXRhKG1lbS0+c3BpLT5tYXN0 ZXIpOw0KPiArDQo+ICsJaWYgKG9wLT5kYXRhLmRpciA9PSBTUElfTUVNX0RBVEFfT1VUKSB7DQo+ ICsJCWlmIChvcC0+ZGF0YS5uYnl0ZXMgPiBmLT5kZXZ0eXBlX2RhdGEtPnR4ZmlmbykNCj4gKwkJ CW9wLT5kYXRhLm5ieXRlcyA9IGYtPmRldnR5cGVfZGF0YS0+dHhmaWZvOw0KPiArCX0gZWxzZSB7 DQo+ICsJCWlmIChvcC0+ZGF0YS5uYnl0ZXMgPiBmLT5kZXZ0eXBlX2RhdGEtPmFoYl9idWZfc2l6 ZSkNCj4gKwkJCW9wLT5kYXRhLm5ieXRlcyA9IGYtPmRldnR5cGVfZGF0YS0+YWhiX2J1Zl9zaXpl Ow0KPiArCQllbHNlIGlmIChvcC0+ZGF0YS5uYnl0ZXMgPiAoZi0+ZGV2dHlwZV9kYXRhLT5yeGZp Zm8gLSA0KSkNCj4gKwkJCW9wLT5kYXRhLm5ieXRlcyA9IEFMSUdOX0RPV04ob3AtPmRhdGEubmJ5 dGVzLCA4KTsNCg0KWW91IGFyZSB1c2luZyB0aGUgc2FtZSBhbGlnbm1lbnRzIGFzIGluIHRoZSBR U1BJIGRyaXZlci4gU28gQUhCIHJlYWRzIA0Kd2lsbCBoYXBwZW4gaW4gcG9ydGlvbnMgb2YgYWhi X2J1Zl9zaXplLCBidXQgeW91IGRvbnQnIHN0aWNrIHRvIHRoaXMgDQp3aGVuIHlvdSBtYXAgdGhl IG1lbW9yeS4gU2VlIGFib3ZlLg0KDQpSZWdhcmRzLA0KRnJpZWRlcg0KDQo+ICsJfQ0KPiArDQo+ ICsJcmV0dXJuIDA7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpbnQgbnhwX2ZzcGlfZGVmYXVsdF9z ZXR1cChzdHJ1Y3QgbnhwX2ZzcGkgKmYpDQo+ICt7DQo+ICsJdm9pZCBfX2lvbWVtICpiYXNlID0g Zi0+aW9iYXNlOw0KPiArCWludCByZXQsIGk7DQo+ICsJdTMyIHJlZzsNCj4gKw0KPiArCS8qIGRp c2FibGUgYW5kIHVucHJlcGFyZSBjbG9jayB0byBhdm9pZCBnbGl0Y2ggcGFzcyB0byBjb250cm9s bGVyICovDQo+ICsJbnhwX2ZzcGlfY2xrX2Rpc2FibGVfdW5wcmVwKGYpOw0KPiArDQo+ICsJLyog dGhlIGRlZmF1bHQgZnJlcXVlbmN5LCB3ZSB3aWxsIGNoYW5nZSBpdCBsYXRlciBpZiBuZWNlc3Nh cnkuICovDQo+ICsJcmV0ID0gY2xrX3NldF9yYXRlKGYtPmNsaywgMjAwMDAwMDApOw0KPiArCWlm IChyZXQpDQo+ICsJCXJldHVybiByZXQ7DQo+ICsNCj4gKwlyZXQgPSBueHBfZnNwaV9jbGtfcHJl cF9lbmFibGUoZik7DQo+ICsJaWYgKHJldCkNCj4gKwkJcmV0dXJuIHJldDsNCj4gKw0KPiArCS8q IFJlc2V0IHRoZSBtb2R1bGUgKi8NCj4gKwkvKiB3MWMgcmVnaXN0ZXIsIHdhaXQgdW5pdCBjbGVh ciAqLw0KPiArCXJldCA9IGZzcGlfcmVhZGxfcG9sbF90b3V0KGYsIGYtPmlvYmFzZSArIEZTUElf TUNSMCwNCj4gKwkJCQkgICBGU1BJX01DUjBfU1dSU1QsIDAsIFBPTExfVE9VVCwgZmFsc2UpOw0K PiArCVdBUk5fT04ocmV0KTsNCj4gKw0KPiArCS8qIERpc2FibGUgdGhlIG1vZHVsZSAqLw0KPiAr CWZzcGlfd3JpdGVsKGYsIEZTUElfTUNSMF9NRElTLCBiYXNlICsgRlNQSV9NQ1IwKTsNCj4gKw0K PiArCS8qIFJlc2V0IHRoZSBETEwgcmVnaXN0ZXIgdG8gZGVmYXVsdCB2YWx1ZSAqLw0KPiArCWZz cGlfd3JpdGVsKGYsIEZTUElfRExMQUNSX09WUkRFTiwgYmFzZSArIEZTUElfRExMQUNSKTsNCj4g Kwlmc3BpX3dyaXRlbChmLCBGU1BJX0RMTEJDUl9PVlJERU4sIGJhc2UgKyBGU1BJX0RMTEJDUik7 DQo+ICsNCj4gKwkvKiBlbmFibGUgbW9kdWxlICovDQo+ICsJZnNwaV93cml0ZWwoZiwgRlNQSV9N Q1IwX0FIQl9USU1FT1VUKDB4RkYpIHwgRlNQSV9NQ1IwX0lQX1RJTUVPVVQoMHhGRiksDQo+ICsJ CSBiYXNlICsgRlNQSV9NQ1IwKTsNCj4gKw0KPiArCS8qDQo+ICsJICogRGlzYWJsZSBzYW1lIGRl dmljZSBlbmFibGUgYml0IGFuZCBjb25maWd1cmUgYWxsIHNsYXZlIGRldmljZXMNCj4gKwkgKiBp bmRlcGVuZGVudGx5Lg0KPiArCSAqLw0KPiArCXJlZyA9IGZzcGlfcmVhZGwoZiwgZi0+aW9iYXNl ICsgRlNQSV9NQ1IyKTsNCj4gKwlyZWcgPSByZWcgJiB+KEZTUElfTUNSMl9TQU1FREVWSUNFRU4p Ow0KPiArCWZzcGlfd3JpdGVsKGYsIHJlZywgYmFzZSArIEZTUElfTUNSMik7DQo+ICsNCj4gKwkv KiBBSEIgY29uZmlndXJhdGlvbiBmb3IgYWNjZXNzIGJ1ZmZlciAwfjcuICovDQo+ICsJZm9yIChp ID0gMDsgaSA8IDc7IGkrKykNCj4gKwkJZnNwaV93cml0ZWwoZiwgMCwgYmFzZSArIEZTUElfQUhC UlhfQlVGMENSMCArIDQgKiBpKTsNCj4gKw0KPiArCS8qDQo+ICsJICogU2V0IEFEQVRTWiB3aXRo IHRoZSBtYXhpbXVtIEFIQiBidWZmZXIgc2l6ZSB0byBpbXByb3ZlIHRoZSByZWFkDQo+ICsJICog cGVyZm9ybWFuY2UuDQo+ICsJICovDQo+ICsJZnNwaV93cml0ZWwoZiwgKGYtPmRldnR5cGVfZGF0 YS0+YWhiX2J1Zl9zaXplIC8gOCB8DQo+ICsJCSAgRlNQSV9BSEJSWEJVRjBDUjdfUFJFRiksIGJh c2UgKyBGU1BJX0FIQlJYX0JVRjdDUjApOw0KPiArDQo+ICsJLyogcHJlZmV0Y2ggYW5kIG5vIHN0 YXJ0IGFkZHJlc3MgYWxpZ25tZW50IGxpbWl0YXRpb24gKi8NCj4gKwlmc3BpX3dyaXRlbChmLCBG U1BJX0FIQkNSX1BSRUZfRU4gfCBGU1BJX0FIQkNSX1JEQUREUk9QVCwNCj4gKwkJIGJhc2UgKyBG U1BJX0FIQkNSKTsNCj4gKw0KPiArCS8qIEFIQiBSZWFkIC0gU2V0IGx1dCBzZXF1ZW5jZSBJRCBm b3IgYWxsIENTLiAqLw0KPiArCWZzcGlfd3JpdGVsKGYsIFNFUUlEX0xVVCwgYmFzZSArIEZTUElf RkxTSEExQ1IyKTsNCj4gKwlmc3BpX3dyaXRlbChmLCBTRVFJRF9MVVQsIGJhc2UgKyBGU1BJX0ZM U0hBMkNSMik7DQo+ICsJZnNwaV93cml0ZWwoZiwgU0VRSURfTFVULCBiYXNlICsgRlNQSV9GTFNI QjFDUjIpOw0KPiArCWZzcGlfd3JpdGVsKGYsIFNFUUlEX0xVVCwgYmFzZSArIEZTUElfRkxTSEIy Q1IyKTsNCj4gKw0KPiArCWYtPnNlbGVjdGVkID0gLTE7DQo+ICsNCj4gKwkvKiBlbmFibGUgdGhl IGludGVycnVwdCAqLw0KPiArCWZzcGlfd3JpdGVsKGYsIEZTUElfSU5URU5fSVBDTURET05FLCBi YXNlICsgRlNQSV9JTlRFTik7DQo+ICsNCj4gKwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiArc3Rh dGljIGNvbnN0IHN0cnVjdCBzcGlfY29udHJvbGxlcl9tZW1fb3BzIG54cF9mc3BpX21lbV9vcHMg PSB7DQo+ICsJLmFkanVzdF9vcF9zaXplID0gbnhwX2ZzcGlfYWRqdXN0X29wX3NpemUsDQo+ICsJ LnN1cHBvcnRzX29wID0gbnhwX2ZzcGlfc3VwcG9ydHNfb3AsDQo+ICsJLmV4ZWNfb3AgPSBueHBf ZnNwaV9leGVjX29wLA0KPiArfTsNCj4gKw0KPiArc3RhdGljIGludCBueHBfZnNwaV9wcm9iZShz dHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KPiArew0KPiArCXN0cnVjdCBzcGlfY29udHJv bGxlciAqY3RscjsNCj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2Ow0KPiArCXN0 cnVjdCBkZXZpY2Vfbm9kZSAqbnAgPSBkZXYtPm9mX25vZGU7DQo+ICsJc3RydWN0IHJlc291cmNl ICpyZXM7DQo+ICsJc3RydWN0IG54cF9mc3BpICpmOw0KPiArCWludCByZXQ7DQo+ICsNCj4gKwlj dGxyID0gc3BpX2FsbG9jX21hc3RlcigmcGRldi0+ZGV2LCBzaXplb2YoKmYpKTsNCj4gKwlpZiAo IWN0bHIpDQo+ICsJCXJldHVybiAtRU5PTUVNOw0KPiArDQo+ICsJY3Rsci0+bW9kZV9iaXRzID0g U1BJX1JYX0RVQUwgfCBTUElfUlhfUVVBRCB8DQo+ICsJCQkgIFNQSV9UWF9EVUFMIHwgU1BJX1RY X1FVQUQ7DQo+ICsNCj4gKwlmID0gc3BpX2NvbnRyb2xsZXJfZ2V0X2RldmRhdGEoY3Rscik7DQo+ ICsJZi0+ZGV2ID0gZGV2Ow0KPiArCWYtPmRldnR5cGVfZGF0YSA9IG9mX2RldmljZV9nZXRfbWF0 Y2hfZGF0YShkZXYpOw0KPiArCWlmICghZi0+ZGV2dHlwZV9kYXRhKSB7DQo+ICsJCXJldCA9IC1F Tk9ERVY7DQo+ICsJCWdvdG8gZXJyX3B1dF9jdHJsOw0KPiArCX0NCj4gKw0KPiArCXBsYXRmb3Jt X3NldF9kcnZkYXRhKHBkZXYsIGYpOw0KPiArDQo+ICsJLyogZmluZCB0aGUgcmVzb3VyY2VzIC0g Y29uZmlndXJhdGlvbiByZWdpc3RlciBhZGRyZXNzIHNwYWNlICovDQo+ICsJcmVzID0gcGxhdGZv cm1fZ2V0X3Jlc291cmNlX2J5bmFtZShwZGV2LCBJT1JFU09VUkNFX01FTSwgImZzcGlfYmFzZSIp Ow0KPiArCWYtPmlvYmFzZSA9IGRldm1faW9yZW1hcF9yZXNvdXJjZShkZXYsIHJlcyk7DQo+ICsJ aWYgKElTX0VSUihmLT5pb2Jhc2UpKSB7DQo+ICsJCXJldCA9IFBUUl9FUlIoZi0+aW9iYXNlKTsN Cj4gKwkJZ290byBlcnJfcHV0X2N0cmw7DQo+ICsJfQ0KPiArDQo+ICsJLyogZmluZCB0aGUgcmVz b3VyY2VzIC0gY29udHJvbGxlciBtZW1vcnkgbWFwcGVkIHNwYWNlICovDQo+ICsJcmVzID0gcGxh dGZvcm1fZ2V0X3Jlc291cmNlX2J5bmFtZShwZGV2LCBJT1JFU09VUkNFX01FTSwgImZzcGlfbW1h cCIpOw0KPiArCWYtPmFoYl9hZGRyID0gZGV2bV9pb3JlbWFwX3Jlc291cmNlKGRldiwgcmVzKTsN Cj4gKwlpZiAoSVNfRVJSKGYtPmFoYl9hZGRyKSkgew0KPiArCQlyZXQgPSBQVFJfRVJSKGYtPmFo Yl9hZGRyKTsNCj4gKwkJZ290byBlcnJfcHV0X2N0cmw7DQo+ICsJfQ0KPiArDQo+ICsJLyogYXNz aWduIG1lbW9yeSBtYXBwZWQgc3RhcnRpbmcgYWRkcmVzcyBhbmQgbWFwcGVkIHNpemUuICovDQo+ ICsJZi0+bWVtbWFwX3BoeSA9IHJlcy0+c3RhcnQ7DQo+ICsJZi0+bWVtbWFwX3BoeV9zaXplID0g cmVzb3VyY2Vfc2l6ZShyZXMpOw0KPiArDQo+ICsJLyogZmluZCB0aGUgY2xvY2tzICovDQo+ICsJ Zi0+Y2xrX2VuID0gZGV2bV9jbGtfZ2V0KGRldiwgImZzcGlfZW4iKTsNCj4gKwlpZiAoSVNfRVJS KGYtPmNsa19lbikpIHsNCj4gKwkJcmV0ID0gUFRSX0VSUihmLT5jbGtfZW4pOw0KPiArCQlnb3Rv IGVycl9wdXRfY3RybDsNCj4gKwl9DQo+ICsNCj4gKwlmLT5jbGsgPSBkZXZtX2Nsa19nZXQoZGV2 LCAiZnNwaSIpOw0KPiArCWlmIChJU19FUlIoZi0+Y2xrKSkgew0KPiArCQlyZXQgPSBQVFJfRVJS KGYtPmNsayk7DQo+ICsJCWdvdG8gZXJyX3B1dF9jdHJsOw0KPiArCX0NCj4gKw0KPiArCXJldCA9 IG54cF9mc3BpX2Nsa19wcmVwX2VuYWJsZShmKTsNCj4gKwlpZiAocmV0KSB7DQo+ICsJCWRldl9l cnIoZGV2LCAiY2FuIG5vdCBlbmFibGUgdGhlIGNsb2NrXG4iKTsNCj4gKwkJZ290byBlcnJfcHV0 X2N0cmw7DQo+ICsJfQ0KPiArDQo+ICsJLyogZmluZCB0aGUgaXJxICovDQo+ICsJcmV0ID0gcGxh dGZvcm1fZ2V0X2lycShwZGV2LCAwKTsNCj4gKwlpZiAocmV0IDwgMCkgew0KPiArCQlkZXZfZXJy KGRldiwgImZhaWxlZCB0byBnZXQgdGhlIGlycTogJWRcbiIsIHJldCk7DQo+ICsJCWdvdG8gZXJy X2Rpc2FibGVfY2xrOw0KPiArCX0NCj4gKw0KPiArCXJldCA9IGRldm1fcmVxdWVzdF9pcnEoZGV2 LCByZXQsDQo+ICsJCQlueHBfZnNwaV9pcnFfaGFuZGxlciwgMCwgcGRldi0+bmFtZSwgZik7DQo+ ICsJaWYgKHJldCkgew0KPiArCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byByZXF1ZXN0IGlycTog JWRcbiIsIHJldCk7DQo+ICsJCWdvdG8gZXJyX2Rpc2FibGVfY2xrOw0KPiArCX0NCj4gKw0KPiAr CW11dGV4X2luaXQoJmYtPmxvY2spOw0KPiArDQo+ICsJY3Rsci0+YnVzX251bSA9IC0xOw0KPiAr CWN0bHItPm51bV9jaGlwc2VsZWN0ID0gTlhQX0ZTUElfTUFYX0NISVBTRUxFQ1Q7DQo+ICsJY3Rs ci0+bWVtX29wcyA9ICZueHBfZnNwaV9tZW1fb3BzOw0KPiArDQo+ICsJbnhwX2ZzcGlfZGVmYXVs dF9zZXR1cChmKTsNCj4gKw0KPiArCWN0bHItPmRldi5vZl9ub2RlID0gbnA7DQo+ICsNCj4gKwly ZXQgPSBzcGlfcmVnaXN0ZXJfY29udHJvbGxlcihjdGxyKTsNCj4gKwlpZiAocmV0KQ0KPiArCQln b3RvIGVycl9kZXN0cm95X211dGV4Ow0KPiArDQo+ICsJcmV0dXJuIDA7DQo+ICsNCj4gK2Vycl9k ZXN0cm95X211dGV4Og0KPiArCW11dGV4X2Rlc3Ryb3koJmYtPmxvY2spOw0KPiArDQo+ICtlcnJf ZGlzYWJsZV9jbGs6DQo+ICsJbnhwX2ZzcGlfY2xrX2Rpc2FibGVfdW5wcmVwKGYpOw0KPiArDQo+ ICtlcnJfcHV0X2N0cmw6DQo+ICsJc3BpX2NvbnRyb2xsZXJfcHV0KGN0bHIpOw0KPiArDQo+ICsJ ZGV2X2VycihkZXYsICJOWFAgRlNQSSBwcm9iZSBmYWlsZWRcbiIpOw0KPiArCXJldHVybiByZXQ7 DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpbnQgbnhwX2ZzcGlfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9y bV9kZXZpY2UgKnBkZXYpDQo+ICt7DQo+ICsJc3RydWN0IG54cF9mc3BpICpmID0gcGxhdGZvcm1f Z2V0X2RydmRhdGEocGRldik7DQo+ICsNCj4gKwkvKiBkaXNhYmxlIHRoZSBoYXJkd2FyZSAqLw0K PiArCWZzcGlfd3JpdGVsKGYsIEZTUElfTUNSMF9NRElTLCBmLT5pb2Jhc2UgKyBGU1BJX01DUjAp Ow0KPiArDQo+ICsJbnhwX2ZzcGlfY2xrX2Rpc2FibGVfdW5wcmVwKGYpOw0KPiArDQo+ICsJbXV0 ZXhfZGVzdHJveSgmZi0+bG9jayk7DQo+ICsNCj4gKwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiAr c3RhdGljIGludCBueHBfZnNwaV9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldikNCj4gK3sNCj4g KwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiArc3RhdGljIGludCBueHBfZnNwaV9yZXN1bWUoc3Ry dWN0IGRldmljZSAqZGV2KQ0KPiArew0KPiArCXN0cnVjdCBueHBfZnNwaSAqZiA9IGRldl9nZXRf ZHJ2ZGF0YShkZXYpOw0KPiArDQo+ICsJbnhwX2ZzcGlfZGVmYXVsdF9zZXR1cChmKTsNCj4gKw0K PiArCXJldHVybiAwOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2Rldmlj ZV9pZCBueHBfZnNwaV9kdF9pZHNbXSA9IHsNCj4gKwl7IC5jb21wYXRpYmxlID0gIm54cCxseDIx NjBhLWZzcGkiLCAuZGF0YSA9ICh2b2lkICopJmx4MjE2MGFfZGF0YSwgfSwNCj4gKwl7IC8qIHNl bnRpbmVsICovIH0NCj4gK307DQo+ICtNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBueHBfZnNwaV9k dF9pZHMpOw0KPiArDQo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGRldl9wbV9vcHMgbnhwX2ZzcGlf cG1fb3BzID0gew0KPiArCS5zdXNwZW5kCT0gbnhwX2ZzcGlfc3VzcGVuZCwNCj4gKwkucmVzdW1l CQk9IG54cF9mc3BpX3Jlc3VtZSwNCj4gK307DQo+ICsNCj4gK3N0YXRpYyBzdHJ1Y3QgcGxhdGZv cm1fZHJpdmVyIG54cF9mc3BpX2RyaXZlciA9IHsNCj4gKwkuZHJpdmVyID0gew0KPiArCQkubmFt ZQk9ICJueHAtZnNwaSIsDQo+ICsJCS5vZl9tYXRjaF90YWJsZSA9IG54cF9mc3BpX2R0X2lkcywN Cj4gKwkJLnBtID0gICAmbnhwX2ZzcGlfcG1fb3BzLA0KPiArCX0sDQo+ICsJLnByb2JlICAgICAg ICAgID0gbnhwX2ZzcGlfcHJvYmUsDQo+ICsJLnJlbW92ZQkJPSBueHBfZnNwaV9yZW1vdmUsDQo+ ICt9Ow0KPiArbW9kdWxlX3BsYXRmb3JtX2RyaXZlcihueHBfZnNwaV9kcml2ZXIpOw0KPiArDQo+ ICtNT0RVTEVfREVTQ1JJUFRJT04oIk5YUCBGU1BJIENvbnRyb2xsZXIgRHJpdmVyIik7DQo+ICtN T0RVTEVfQVVUSE9SKCJOWFAgU2VtaWNvbmR1Y3RvciIpOw0KPiArTU9EVUxFX0xJQ0VOU0UoIkdQ TCB2MiIpOw0KPiA= 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.7 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 10140C04EB9 for ; Thu, 6 Dec 2018 09:23:17 +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 C6B0C20850 for ; Thu, 6 Dec 2018 09:23:16 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="hH0HGf3P" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C6B0C20850 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=kontron.de Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=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:Content-ID:In-Reply-To: References:Message-ID:Date:Subject:To:From:Reply-To:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=Ey71nniLWrR6qPFg4rqa5E0rDnHHGTuq3KY9y8I/Kjo=; b=hH0HGf3PK7t/FO atkyh602nvdBCWKfI81tg5pxSM4iMhEvPYyhHTcBuxXhVCCRekupkuAlI7MzOQj7B8xTjglKDKGRk F9eJCYlnYeXr6D+Ebdwa/PZDdoaCASwijmo21o5h+h8Le1f0XmUFUz7lFAvIl0JTT1POVnW8hon/+ fdySIF8IHcaRMfZZAJdLv9oAjGyMFJ45QWsT8PNTbpZNECtXl1rrBa8JffSVm4V/WuMK3wGml5rUT gqzFzikcNleGOAq5mQ+Qz0jdENiLyhdugpFGXPAKyykAQMWvtu9CauG2BMKW9qLYVcpseiDTbyxEt bWHm5u+AIjycwdic6bog==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gUpsJ-0006Nw-4z; Thu, 06 Dec 2018 09:23:15 +0000 Received: from skedge04.snt-world.com ([91.208.41.69]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1gUpsD-0006N5-5D; Thu, 06 Dec 2018 09:23:13 +0000 Received: from sntmail10s.snt-is.com (unknown [10.203.32.183]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by skedge04.snt-world.com (Postfix) with ESMTPS id 0945C67A7D5; Thu, 6 Dec 2018 10:22:53 +0100 (CET) Received: from sntmail12r.snt-is.com (10.203.32.182) by sntmail10s.snt-is.com (10.203.32.183) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.1466.3; Thu, 6 Dec 2018 10:22:52 +0100 Received: from sntmail12r.snt-is.com ([fe80::e551:8750:7bba:3305]) by sntmail12r.snt-is.com ([fe80::e551:8750:7bba:3305%5]) with mapi id 15.01.1466.003; Thu, 6 Dec 2018 10:22:52 +0100 From: Schrempf Frieder To: Yogesh Narayan Gaur , "linux-mtd@lists.infradead.org" , "boris.brezillon@bootlin.com" , "marek.vasut@gmail.com" , "broonie@kernel.org" , "linux-spi@vger.kernel.org" , "devicetree@vger.kernel.org" Subject: Re: [PATCH v5 1/5] spi: spi-mem: Add driver for NXP FlexSPI controller Thread-Topic: [PATCH v5 1/5] spi: spi-mem: Add driver for NXP FlexSPI controller Thread-Index: AQHUfZ16K+V2Xzw84ki+MmwTwSKgB6VxfoaA Date: Thu, 6 Dec 2018 09:22:52 +0000 Message-ID: References: <1542366701-16065-1-git-send-email-yogeshnarayan.gaur@nxp.com> <1542366701-16065-2-git-send-email-yogeshnarayan.gaur@nxp.com> In-Reply-To: <1542366701-16065-2-git-send-email-yogeshnarayan.gaur@nxp.com> Accept-Language: de-DE, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [172.25.9.43] x-c2processedorg: 51b406b7-48a2-4d03-b652-521f56ac89f3 Content-ID: <70157C6BFF32D04889CA366D5BC29377@snt-world.com> MIME-Version: 1.0 X-SnT-MailScanner-Information: Please contact the ISP for more information X-SnT-MailScanner-ID: 0945C67A7D5.A6035 X-SnT-MailScanner: Found to be clean X-SnT-MailScanner-SpamCheck: X-SnT-MailScanner-From: frieder.schrempf@kontron.de X-SnT-MailScanner-To: boris.brezillon@bootlin.com, broonie@kernel.org, computersforpeace@gmail.com, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-mtd@lists.infradead.org, linux-spi@vger.kernel.org, marek.vasut@gmail.com, mark.rutland@arm.com, robh@kernel.org, shawnguo@kernel.org, yogeshnarayan.gaur@nxp.com X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181206_012309_717116_A7ABFD06 X-CRM114-Status: GOOD ( 27.62 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: "mark.rutland@arm.com" , "robh@kernel.org" , "linux-kernel@vger.kernel.org" , "computersforpeace@gmail.com" , "shawnguo@kernel.org" , "linux-arm-kernel@lists.infradead.org" Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org Hi Yogesh, I've had a closer look at your v5. See my comments below. On 16.11.18 12:13, Yogesh Narayan Gaur wrote: > - Add driver for NXP FlexSPI host controller > > (0) What is the FlexSPI controller? > FlexSPI is a flexsible SPI host controller which supports two SPI > channels and up to 4 external devices. Each channel supports > Single/Dual/Quad/Octal mode data transfer (1/2/4/8 bidirectional > data lines) i.e. FlexSPI acts as an interface to external devices, > maximum 4, each with up to 8 bidirectional data lines. > > It uses new SPI memory interface of the SPI framework to issue > flash memory operations to up to four connected flash > devices (2 buses with 2 CS each). > > (1) Tested this driver with the mtd_debug and JFFS2 filesystem utility > on NXP LX2160ARDB and LX2160AQDS targets. > LX2160ARDB is having two NOR slave device connected on single bus A > i.e. A0 and A1 (CS0 and CS1). > LX2160AQDS is having two NOR slave device connected on separate buses > one flash on A0 and second on B1 i.e. (CS0 and CS3). > Verified this driver on following SPI NOR flashes: > Micron, mt35xu512ab, [Read - 1 bit mode] > Cypress, s25fl512s, [Read - 1/2/4 bit mode] > > Signed-off-by: Yogesh Gaur > --- > Changes for v5: > - Rebase on top of v4.20-rc2 > - Modified fspi_readl_poll_tout() as per review comments > - Arrange header file in alphabetical order > - Removed usage of read()/write() function callback pointer > - Add support for 1 and 2 byte address length > - Change Frieder e-mail to new e-mail address > Changes for v4: > - Incorporate Boris review comments > * Use readl_poll_timeout() instead of busy looping. > * Re-define register masking as per comment. > * Drop fspi_devtype enum. > Changes for v3: > - Added endianness flag in platform specific structure instead of DTS. > - Modified nxp_fspi_read_ahb(), removed remapping code. > - Added Boris and Frieder as Author and provided reference of spi-fsl-qspi.c > Changes for v2: > - Incorporated Boris review comments. > - Remove dependency of driver over connected flash device size. > - Modified the logic to select requested CS. > - Remove SPI-Octal Macros. > > drivers/spi/Kconfig | 10 + > drivers/spi/Makefile | 1 + > drivers/spi/spi-nxp-fspi.c | 1145 ++++++++++++++++++++++++++++++++++++++++++++ > 3 files changed, 1156 insertions(+) > create mode 100644 drivers/spi/spi-nxp-fspi.c > > diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig > index 7d3a5c9..36630a1 100644 > --- a/drivers/spi/Kconfig > +++ b/drivers/spi/Kconfig > @@ -259,6 +259,16 @@ config SPI_FSL_LPSPI > help > This enables Freescale i.MX LPSPI controllers in master mode. > > +config SPI_NXP_FLEXSPI > + tristate "NXP Flex SPI controller" > + depends on ARCH_LAYERSCAPE || HAS_IOMEM > + help > + This enables support for the Flex SPI controller in master mode. > + Up to four slave devices can be connected on two buses with two > + chipselects each. > + This controller does not support generic SPI messages and only > + supports the high-level SPI memory interface. > + > config SPI_GPIO > tristate "GPIO-based bitbanging SPI Master" > depends on GPIOLIB || COMPILE_TEST > diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile > index 3575205..55fec5c 100644 > --- a/drivers/spi/Makefile > +++ b/drivers/spi/Makefile > @@ -60,6 +60,7 @@ obj-$(CONFIG_SPI_MPC52xx) += spi-mpc52xx.o > obj-$(CONFIG_SPI_MT65XX) += spi-mt65xx.o > obj-$(CONFIG_SPI_MXS) += spi-mxs.o > obj-$(CONFIG_SPI_NUC900) += spi-nuc900.o > +obj-$(CONFIG_SPI_NXP_FLEXSPI) += spi-nxp-fspi.o > obj-$(CONFIG_SPI_OC_TINY) += spi-oc-tiny.o > spi-octeon-objs := spi-cavium.o spi-cavium-octeon.o > obj-$(CONFIG_SPI_OCTEON) += spi-octeon.o > diff --git a/drivers/spi/spi-nxp-fspi.c b/drivers/spi/spi-nxp-fspi.c > new file mode 100644 > index 0000000..a35013b > --- /dev/null > +++ b/drivers/spi/spi-nxp-fspi.c > @@ -0,0 +1,1145 @@ > +// SPDX-License-Identifier: GPL-2.0+ > + > +/* > + * NXP FlexSPI(FSPI) controller driver. > + * > + * Copyright 2018 NXP. > + * > + * FlexSPI is a flexsible SPI host controller which supports two SPI > + * channels and up to 4 external devices. Each channel supports > + * Single/Dual/Quad/Octal mode data transfer (1/2/4/8 bidirectional > + * data lines). > + * > + * FlexSPI controller is driven by the LUT(Look-up Table) registers > + * LUT registers are a look-up-table for sequences of instructions. > + * A valid sequence consists of four LUT registers. > + * Maximum 32 LUT sequences can be programmed simultaneously. > + * > + * LUTs are being created at run-time based on the commands passed > + * from the spi-mem framework, thus using single LUT index. > + * > + * Software triggered Flash read/write access by IP Bus. > + * > + * Memory mapped read access by AHB Bus. > + * > + * Based on SPI MEM interface and spi-fsl-qspi.c driver. > + * > + * Author: > + * Yogesh Gaur > + * Boris Brezillion > + * Frieder Schrempf > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > + > +/* > + * The driver only uses one single LUT entry, that is updated on > + * each call of exec_op(). Index 0 is preset at boot with a basic > + * read operation, so let's use the last entry (31). > + */ > +#define SEQID_LUT 31 > + > +/* Registers used by the driver */ > +#define FSPI_MCR0 0x00 > +#define FSPI_MCR0_AHB_TIMEOUT(x) ((x) << 24) > +#define FSPI_MCR0_IP_TIMEOUT(x) ((x) << 16) > +#define FSPI_MCR0_LEARN_EN BIT(15) > +#define FSPI_MCR0_SCRFRUN_EN BIT(14) > +#define FSPI_MCR0_OCTCOMB_EN BIT(13) > +#define FSPI_MCR0_DOZE_EN BIT(12) > +#define FSPI_MCR0_HSEN BIT(11) > +#define FSPI_MCR0_SERCLKDIV BIT(8) > +#define FSPI_MCR0_ATDF_EN BIT(7) > +#define FSPI_MCR0_ARDF_EN BIT(6) > +#define FSPI_MCR0_RXCLKSRC(x) ((x) << 4) > +#define FSPI_MCR0_END_CFG(x) ((x) << 2) > +#define FSPI_MCR0_MDIS BIT(1) > +#define FSPI_MCR0_SWRST BIT(0) > + > +#define FSPI_MCR1 0x04 > +#define FSPI_MCR1_SEQ_TIMEOUT(x) ((x) << 16) > +#define FSPI_MCR1_AHB_TIMEOUT(x) (x) > + > +#define FSPI_MCR2 0x08 > +#define FSPI_MCR2_IDLE_WAIT(x) ((x) << 24) > +#define FSPI_MCR2_SAMEDEVICEEN BIT(15) > +#define FSPI_MCR2_CLRLRPHS BIT(14) > +#define FSPI_MCR2_ABRDATSZ BIT(8) > +#define FSPI_MCR2_ABRLEARN BIT(7) > +#define FSPI_MCR2_ABR_READ BIT(6) > +#define FSPI_MCR2_ABRWRITE BIT(5) > +#define FSPI_MCR2_ABRDUMMY BIT(4) > +#define FSPI_MCR2_ABR_MODE BIT(3) > +#define FSPI_MCR2_ABRCADDR BIT(2) > +#define FSPI_MCR2_ABRRADDR BIT(1) > +#define FSPI_MCR2_ABR_CMD BIT(0) > + > +#define FSPI_AHBCR 0x0c > +#define FSPI_AHBCR_RDADDROPT BIT(6) > +#define FSPI_AHBCR_PREF_EN BIT(5) > +#define FSPI_AHBCR_BUFF_EN BIT(4) > +#define FSPI_AHBCR_CACH_EN BIT(3) > +#define FSPI_AHBCR_CLRTXBUF BIT(2) > +#define FSPI_AHBCR_CLRRXBUF BIT(1) > +#define FSPI_AHBCR_PAR_EN BIT(0) > + > +#define FSPI_INTEN 0x10 > +#define FSPI_INTEN_SCLKSBWR BIT(9) > +#define FSPI_INTEN_SCLKSBRD BIT(8) > +#define FSPI_INTEN_DATALRNFL BIT(7) > +#define FSPI_INTEN_IPTXWE BIT(6) > +#define FSPI_INTEN_IPRXWA BIT(5) > +#define FSPI_INTEN_AHBCMDERR BIT(4) > +#define FSPI_INTEN_IPCMDERR BIT(3) > +#define FSPI_INTEN_AHBCMDGE BIT(2) > +#define FSPI_INTEN_IPCMDGE BIT(1) > +#define FSPI_INTEN_IPCMDDONE BIT(0) > + > +#define FSPI_INTR 0x14 > +#define FSPI_INTR_SCLKSBWR BIT(9) > +#define FSPI_INTR_SCLKSBRD BIT(8) > +#define FSPI_INTR_DATALRNFL BIT(7) > +#define FSPI_INTR_IPTXWE BIT(6) > +#define FSPI_INTR_IPRXWA BIT(5) > +#define FSPI_INTR_AHBCMDERR BIT(4) > +#define FSPI_INTR_IPCMDERR BIT(3) > +#define FSPI_INTR_AHBCMDGE BIT(2) > +#define FSPI_INTR_IPCMDGE BIT(1) > +#define FSPI_INTR_IPCMDDONE BIT(0) > + > +#define FSPI_LUTKEY 0x18 > +#define FSPI_LUTKEY_VALUE 0x5AF05AF0 > + > +#define FSPI_LCKCR 0x1C > + > +#define FSPI_LCKER_LOCK 0x1 > +#define FSPI_LCKER_UNLOCK 0x2 > + > +#define FSPI_BUFXCR_INVALID_MSTRID 0xE > +#define FSPI_AHBRX_BUF0CR0 0x20 > +#define FSPI_AHBRX_BUF1CR0 0x24 > +#define FSPI_AHBRX_BUF2CR0 0x28 > +#define FSPI_AHBRX_BUF3CR0 0x2C > +#define FSPI_AHBRX_BUF4CR0 0x30 > +#define FSPI_AHBRX_BUF5CR0 0x34 > +#define FSPI_AHBRX_BUF6CR0 0x38 > +#define FSPI_AHBRX_BUF7CR0 0x3C > +#define FSPI_AHBRXBUF0CR7_PREF BIT(31) > + > +#define FSPI_AHBRX_BUF0CR1 0x40 > +#define FSPI_AHBRX_BUF1CR1 0x44 > +#define FSPI_AHBRX_BUF2CR1 0x48 > +#define FSPI_AHBRX_BUF3CR1 0x4C > +#define FSPI_AHBRX_BUF4CR1 0x50 > +#define FSPI_AHBRX_BUF5CR1 0x54 > +#define FSPI_AHBRX_BUF6CR1 0x58 > +#define FSPI_AHBRX_BUF7CR1 0x5C > + > +#define FSPI_FLSHA1CR0 0x60 > +#define FSPI_FLSHA2CR0 0x64 > +#define FSPI_FLSHB1CR0 0x68 > +#define FSPI_FLSHB2CR0 0x6C > +#define FSPI_FLSHXCR0_SZ_KB 10 > +#define FSPI_FLSHXCR0_SZ(x) ((x) >> FSPI_FLSHXCR0_SZ_KB) > + > +#define FSPI_FLSHA1CR1 0x70 > +#define FSPI_FLSHA2CR1 0x74 > +#define FSPI_FLSHB1CR1 0x78 > +#define FSPI_FLSHB2CR1 0x7C > +#define FSPI_FLSHXCR1_CSINTR(x) ((x) << 16) > +#define FSPI_FLSHXCR1_CAS(x) ((x) << 11) > +#define FSPI_FLSHXCR1_WA BIT(10) > +#define FSPI_FLSHXCR1_TCSH(x) ((x) << 5) > +#define FSPI_FLSHXCR1_TCSS(x) (x) > + > +#define FSPI_FLSHA1CR2 0x80 > +#define FSPI_FLSHA2CR2 0x84 > +#define FSPI_FLSHB1CR2 0x88 > +#define FSPI_FLSHB2CR2 0x8C > +#define FSPI_FLSHXCR2_CLRINSP BIT(24) > +#define FSPI_FLSHXCR2_AWRWAIT BIT(16) > +#define FSPI_FLSHXCR2_AWRSEQN_SHIFT 13 > +#define FSPI_FLSHXCR2_AWRSEQI_SHIFT 8 > +#define FSPI_FLSHXCR2_ARDSEQN_SHIFT 5 > +#define FSPI_FLSHXCR2_ARDSEQI_SHIFT 0 > + > +#define FSPI_IPCR0 0xA0 > + > +#define FSPI_IPCR1 0xA4 > +#define FSPI_IPCR1_IPAREN BIT(31) > +#define FSPI_IPCR1_SEQNUM_SHIFT 24 > +#define FSPI_IPCR1_SEQID_SHIFT 16 > +#define FSPI_IPCR1_IDATSZ(x) (x) > + > +#define FSPI_IPCMD 0xB0 > +#define FSPI_IPCMD_TRG BIT(0) > + > +#define FSPI_DLPR 0xB4 > + > +#define FSPI_IPRXFCR 0xB8 > +#define FSPI_IPRXFCR_CLR BIT(0) > +#define FSPI_IPRXFCR_DMA_EN BIT(1) > +#define FSPI_IPRXFCR_WMRK(x) ((x) << 2) > + > +#define FSPI_IPTXFCR 0xBC > +#define FSPI_IPTXFCR_CLR BIT(0) > +#define FSPI_IPTXFCR_DMA_EN BIT(1) > +#define FSPI_IPTXFCR_WMRK(x) ((x) << 2) > + > +#define FSPI_DLLACR 0xC0 > +#define FSPI_DLLACR_OVRDEN BIT(8) > + > +#define FSPI_DLLBCR 0xC4 > +#define FSPI_DLLBCR_OVRDEN BIT(8) > + > +#define FSPI_STS0 0xE0 > +#define FSPI_STS0_DLPHB(x) ((x) << 8) > +#define FSPI_STS0_DLPHA(x) ((x) << 4) > +#define FSPI_STS0_CMD_SRC(x) ((x) << 2) > +#define FSPI_STS0_ARB_IDLE BIT(1) > +#define FSPI_STS0_SEQ_IDLE BIT(0) > + > +#define FSPI_STS1 0xE4 > +#define FSPI_STS1_IP_ERRCD(x) ((x) << 24) > +#define FSPI_STS1_IP_ERRID(x) ((x) << 16) > +#define FSPI_STS1_AHB_ERRCD(x) ((x) << 8) > +#define FSPI_STS1_AHB_ERRID(x) (x) > + > +#define FSPI_AHBSPNST 0xEC > +#define FSPI_AHBSPNST_DATLFT(x) ((x) << 16) > +#define FSPI_AHBSPNST_BUFID(x) ((x) << 1) > +#define FSPI_AHBSPNST_ACTIVE BIT(0) > + > +#define FSPI_IPRXFSTS 0xF0 > +#define FSPI_IPRXFSTS_RDCNTR(x) ((x) << 16) > +#define FSPI_IPRXFSTS_FILL(x) (x) > + > +#define FSPI_IPTXFSTS 0xF4 > +#define FSPI_IPTXFSTS_WRCNTR(x) ((x) << 16) > +#define FSPI_IPTXFSTS_FILL(x) (x) > + > +#define FSPI_RFDR 0x100 > +#define FSPI_TFDR 0x180 > + > +#define FSPI_LUT_BASE 0x200 > +#define FSPI_LUT_OFFSET (SEQID_LUT * 4 * 4) > +#define FSPI_LUT_REG(idx) \ > + (FSPI_LUT_BASE + FSPI_LUT_OFFSET + (idx) * 4) > + > +/* register map end */ > + > +/* Instruction set for the LUT register. */ > +#define LUT_STOP 0x00 > +#define LUT_CMD 0x01 > +#define LUT_ADDR 0x02 > +#define LUT_CADDR_SDR 0x03 > +#define LUT_MODE 0x04 > +#define LUT_MODE2 0x05 > +#define LUT_MODE4 0x06 > +#define LUT_MODE8 0x07 > +#define LUT_NXP_WRITE 0x08 > +#define LUT_NXP_READ 0x09 > +#define LUT_LEARN_SDR 0x0A > +#define LUT_DATSZ_SDR 0x0B > +#define LUT_DUMMY 0x0C > +#define LUT_DUMMY_RWDS_SDR 0x0D > +#define LUT_JMP_ON_CS 0x1F > +#define LUT_CMD_DDR 0x21 > +#define LUT_ADDR_DDR 0x22 > +#define LUT_CADDR_DDR 0x23 > +#define LUT_MODE_DDR 0x24 > +#define LUT_MODE2_DDR 0x25 > +#define LUT_MODE4_DDR 0x26 > +#define LUT_MODE8_DDR 0x27 > +#define LUT_WRITE_DDR 0x28 > +#define LUT_READ_DDR 0x29 > +#define LUT_LEARN_DDR 0x2A > +#define LUT_DATSZ_DDR 0x2B > +#define LUT_DUMMY_DDR 0x2C > +#define LUT_DUMMY_RWDS_DDR 0x2D > + > +/* > + * Calculate number of required PAD bits for LUT register. > + * > + * The pad stands for the number of IO lines [0:7]. > + * For example, the octal read needs eight IO lines, > + * so you should use LUT_PAD(8). This macro > + * returns 3 i.e. use eight (2^3) IP lines for read. > + */ > +#define LUT_PAD(x) (fls(x) - 1) > + > +/* > + * Macro for constructing the LUT entries with the following > + * register layout: > + * > + * --------------------------------------------------- > + * | INSTR1 | PAD1 | OPRND1 | INSTR0 | PAD0 | OPRND0 | > + * --------------------------------------------------- > + */ > +#define PAD_SHIFT 8 > +#define INSTR_SHIFT 10 > +#define OPRND_SHIFT 16 > + > +/* Macros for constructing the LUT register. */ > +#define LUT_DEF(idx, ins, pad, opr) \ > + ((((ins) << INSTR_SHIFT) | ((pad) << PAD_SHIFT) | \ > + (opr)) << (((idx) % 2) * OPRND_SHIFT)) > + > +/* Operands for the LUT register. */ > +#define ADDR8BIT 0x08 > +#define ADDR16BIT 0x10 > +#define ADDR24BIT 0x18 > +#define ADDR32BIT 0x20 You can drop these ADDRXBIT definitions, see below... > + > +#define POLL_TOUT 5000 > +#define NXP_FSPI_MAX_CHIPSELECT 4 > + > +struct nxp_fspi_devtype_data { > + unsigned int rxfifo; > + unsigned int txfifo; > + unsigned int ahb_buf_size; > + unsigned int quirks; > + bool little_endian; > +}; > + > +static const struct nxp_fspi_devtype_data lx2160a_data = { > + .rxfifo = SZ_512, /* (64 * 64 bits) */ > + .txfifo = SZ_1K, /* (128 * 64 bits) */ > + .ahb_buf_size = SZ_2K, /* (256 * 64 bits) */ > + .quirks = 0, > + .little_endian = true, /* little-endian */ > +}; > + > +struct nxp_fspi { > + void __iomem *iobase; > + void __iomem *ahb_addr; > + u32 memmap_phy; > + u32 memmap_phy_size; > + struct clk *clk, *clk_en; > + struct device *dev; > + struct completion c; > + const struct nxp_fspi_devtype_data *devtype_data; > + struct mutex lock; > + struct pm_qos_request pm_qos_req; > + int selected; > +}; > + > +/* > + * R/W functions for big- or little-endian registers: > + * The FSPI controller's endianness is independent of > + * the CPU core's endianness. So far, although the CPU > + * core is little-endian the FSPI controller can use > + * big-endian or little-endian. > + */ > +static void fspi_writel(struct nxp_fspi *f, u32 val, void __iomem *addr) > +{ > + if (f->devtype_data->little_endian) > + iowrite32(val, addr); > + else > + iowrite32be(val, addr); > +} > + > +static u32 fspi_readl(struct nxp_fspi *f, void __iomem *addr) > +{ > + if (f->devtype_data->little_endian) > + return ioread32(addr); > + else > + return ioread32be(addr); > +} > + > +static irqreturn_t nxp_fspi_irq_handler(int irq, void *dev_id) > +{ > + struct nxp_fspi *f = dev_id; > + u32 reg; > + > + /* clear interrupt */ > + reg = fspi_readl(f, f->iobase + FSPI_INTR); > + fspi_writel(f, FSPI_INTR_IPCMDDONE, f->iobase + FSPI_INTR); > + > + if (reg & FSPI_INTR_IPCMDDONE) > + complete(&f->c); > + > + return IRQ_HANDLED; > +} > + > +static int nxp_fspi_check_buswidth(struct nxp_fspi *f, u8 width) > +{ > + switch (width) { > + case 1: > + case 2: > + case 4: > + case 8: > + return 0; > + } > + > + return -ENOTSUPP; > +} > + > +static bool nxp_fspi_supports_op(struct spi_mem *mem, > + const struct spi_mem_op *op) > +{ > + struct nxp_fspi *f = spi_controller_get_devdata(mem->spi->master); > + int ret; > + > + ret = nxp_fspi_check_buswidth(f, op->cmd.buswidth); > + > + if (op->addr.nbytes) > + ret |= nxp_fspi_check_buswidth(f, op->addr.buswidth); > + > + if (op->dummy.nbytes) > + ret |= nxp_fspi_check_buswidth(f, op->dummy.buswidth); > + > + if (op->data.nbytes) > + ret |= nxp_fspi_check_buswidth(f, op->data.buswidth); > + > + if (ret) > + return false; > + > + /* > + * The number of instructions needed for the op, needs > + * to fit into a single LUT entry. > + */ > + if (op->addr.nbytes + > + (op->dummy.nbytes ? 1:0) + > + (op->data.nbytes ? 1:0) > 6) > + return false; > + > + /* Max 64 dummy clock cycles supported */ > + if (op->dummy.buswidth && > + (op->dummy.nbytes * 8 / op->dummy.buswidth > 64)) > + return false; > + > + /* Max data length, check controller limits and alignment */ > + if (op->data.dir == SPI_MEM_DATA_IN && > + (op->data.nbytes > f->devtype_data->ahb_buf_size || > + (op->data.nbytes > f->devtype_data->rxfifo - 4 && > + !IS_ALIGNED(op->data.nbytes, 8)))) > + return false; > + > + if (op->data.dir == SPI_MEM_DATA_OUT && > + op->data.nbytes > f->devtype_data->txfifo) > + return false; > + > + return true; > +} > + > +/* Instead of busy looping invoke readl_poll_timeout functionality. */ > +static int fspi_readl_poll_tout(struct nxp_fspi *f, void __iomem *base, > + u32 mask, u32 delay_us, > + u32 timeout_us, bool condition) > +{ > + u32 reg; > + > + if (!f->devtype_data->little_endian) > + mask = (u32)cpu_to_be32(mask); > + > + if (condition) > + return readl_poll_timeout(base, reg, (reg & mask), > + delay_us, timeout_us); > + else > + return readl_poll_timeout(base, reg, !(reg & mask), > + delay_us, timeout_us); I would rather use a local variable to store the condition: bool c = condition ? (reg & mask):!(reg & mask); return readl_poll_timeout(base, reg, c, delay_us, timeout_us); > +} > + > +/* > + * If the slave device content being changed by Write/Erase, need to > + * invalidate the AHB buffer. This can be achieved by doing the reset > + * of controller after setting MCR0[SWRESET] bit. > + */ > +static inline void nxp_fspi_invalid(struct nxp_fspi *f) > +{ > + u32 reg; > + int ret; > + > + reg = fspi_readl(f, f->iobase + FSPI_MCR0); > + fspi_writel(f, reg | FSPI_MCR0_SWRST, f->iobase + FSPI_MCR0); > + > + /* w1c register, wait unit clear */ > + ret = fspi_readl_poll_tout(f, f->iobase + FSPI_MCR0, > + FSPI_MCR0_SWRST, 0, POLL_TOUT, false); > + WARN_ON(ret); > +} > + > +static void nxp_fspi_prepare_lut(struct nxp_fspi *f, > + const struct spi_mem_op *op) > +{ > + void __iomem *base = f->iobase; > + u32 lutval[4] = {}; > + int lutidx = 1, i; > + > + /* cmd */ > + lutval[0] |= LUT_DEF(0, LUT_CMD, LUT_PAD(op->cmd.buswidth), > + op->cmd.opcode); > + > + /* addr bus width */ > + if (op->addr.nbytes) { > + u32 addrlen = 0; > + > + switch (op->addr.nbytes) { > + case 1: > + addrlen = ADDR8BIT; > + break; > + case 2: > + addrlen = ADDR16BIT; > + break; > + case 3: > + addrlen = ADDR24BIT; > + break; > + case 4: > + addrlen = ADDR32BIT; > + break; > + default: > + dev_err(f->dev, "In-correct address length\n"); > + return; > + } You don't need to validate op->addr.nbytes here, this is already done in nxp_fspi_supports_op(). > + > + lutval[lutidx / 2] |= LUT_DEF(lutidx, LUT_ADDR, > + LUT_PAD(op->addr.buswidth), > + addrlen); You can also just remove the whole switch statement above and use this: lutval[lutidx / 2] |= LUT_DEF(lutidx, LUT_ADDR, LUT_PAD(op->addr.buswidth), op->addr.nbytes * 8); > + lutidx++; > + } > + > + /* dummy bytes, if needed */ > + if (op->dummy.nbytes) { > + lutval[lutidx / 2] |= LUT_DEF(lutidx, LUT_DUMMY, > + /* > + * Due to FlexSPI controller limitation number of PAD for dummy > + * buswidth needs to be programmed as equal to data buswidth. > + */ > + LUT_PAD(op->data.buswidth), > + op->dummy.nbytes * 8 / > + op->dummy.buswidth); > + lutidx++; > + } > + > + /* read/write data bytes */ > + if (op->data.nbytes) { > + lutval[lutidx / 2] |= LUT_DEF(lutidx, > + op->data.dir == SPI_MEM_DATA_IN ? > + LUT_NXP_READ : LUT_NXP_WRITE, > + LUT_PAD(op->data.buswidth), > + 0); > + lutidx++; > + } > + > + /* stop condition. */ > + lutval[lutidx / 2] |= LUT_DEF(lutidx, LUT_STOP, 0, 0); > + > + /* unlock LUT */ > + fspi_writel(f, FSPI_LUTKEY_VALUE, f->iobase + FSPI_LUTKEY); > + fspi_writel(f, FSPI_LCKER_UNLOCK, f->iobase + FSPI_LCKCR); > + > + /* fill LUT */ > + for (i = 0; i < ARRAY_SIZE(lutval); i++) > + fspi_writel(f, lutval[i], base + FSPI_LUT_REG(i)); > + > + dev_dbg(f->dev, "CMD[%x] lutval[0:%x \t 1:%x \t 2:%x \t 3:%x]\n", > + op->cmd.opcode, lutval[0], lutval[1], lutval[2], lutval[3]); > + > + /* lock LUT */ > + fspi_writel(f, FSPI_LUTKEY_VALUE, f->iobase + FSPI_LUTKEY); > + fspi_writel(f, FSPI_LCKER_LOCK, f->iobase + FSPI_LCKCR); > +} > + > +static int nxp_fspi_clk_prep_enable(struct nxp_fspi *f) > +{ > + int ret; > + > + ret = clk_prepare_enable(f->clk_en); > + if (ret) > + return ret; > + > + ret = clk_prepare_enable(f->clk); > + if (ret) { > + clk_disable_unprepare(f->clk_en); > + return ret; > + } > + > + return 0; > +} > + > +static void nxp_fspi_clk_disable_unprep(struct nxp_fspi *f) > +{ > + clk_disable_unprepare(f->clk); > + clk_disable_unprepare(f->clk_en); > +} > + > +/* > + * In FlexSPI controller, flash access is based on value of FSPI_FLSHXXCR0 > + * register and start base address of the slave device. > + * > + * (Higher address) > + * -------- <-- FLSHB2CR0 > + * | B2 | > + * | | > + * B2 start address --> -------- <-- FLSHB1CR0 > + * | B1 | > + * | | > + * B1 start address --> -------- <-- FLSHA2CR0 > + * | A2 | > + * | | > + * A2 start address --> -------- <-- FLSHA1CR0 > + * | A1 | > + * | | > + * A1 start address --> -------- (Lower address) > + * > + * > + * Start base address defines the starting address range for given CS and > + * FSPI_FLSHXXCR0 defines the size of the slave device connected at given CS. > + * > + * But, different targets are having different combinations of number of CS, > + * some targets only have single CS or two CS covering controller's full > + * memory mapped space area. > + * Thus, implementation is being done as independent of the size and number > + * of the connected slave device. > + * Assign controller memory mapped space size as the size to the connected > + * slave device. > + * Mark FLSHxxCR0 as zero initially and then assign value only to the selected > + * chip-select Flash configuration register. > + * > + * For e.g. to access CS2 (B1), FLSHB1CR0 register would be equal to the > + * memory mapped size of the controller. > + * Value for rest of the CS FLSHxxCR0 register would be zero. > + * > + */ > +static void nxp_fspi_select_mem(struct nxp_fspi *f, struct spi_device *spi) > +{ > + unsigned long rate = spi->max_speed_hz; > + int ret; > + uint64_t size_kb; > + > + /* > + * Return, if previously selected slave device is same as current > + * requested slave device. > + */ > + if (f->selected == spi->chip_select) > + return; > + > + /* Reset FLSHxxCR0 registers */ > + fspi_writel(f, 0, f->iobase + FSPI_FLSHA1CR0); > + fspi_writel(f, 0, f->iobase + FSPI_FLSHA2CR0); > + fspi_writel(f, 0, f->iobase + FSPI_FLSHB1CR0); > + fspi_writel(f, 0, f->iobase + FSPI_FLSHB2CR0); > + > + /* Assign controller memory mapped space as size, KBytes, of flash. */ > + size_kb = FSPI_FLSHXCR0_SZ(f->memmap_phy_size); You are still using memory of arbitrary size (memmap_phy_size) for mapping the flash. Why not use the same approach as in the QSPI driver and just map ahb_buf_size until we implement the dirmap API? You are already aligning the AHB reads for this in nxp_fspi_adjust_op_size(). > + > + switch (spi->chip_select) { > + case 0: > + fspi_writel(f, size_kb, f->iobase + FSPI_FLSHA1CR0); > + break; > + case 1: > + fspi_writel(f, size_kb, f->iobase + FSPI_FLSHA2CR0); > + break; > + case 2: > + fspi_writel(f, size_kb, f->iobase + FSPI_FLSHB1CR0); > + break; > + case 3: > + fspi_writel(f, size_kb, f->iobase + FSPI_FLSHB2CR0); > + break; > + default: > + dev_err(f->dev, "In-correct CS provided\n"); > + return; You don't need to validate spi->chip_select here. This should never be invalid and if it is, something is really wrong and your check won't help. > + } > + > + dev_dbg(f->dev, "Slave device [CS:%x] selected\n", spi->chip_select); > + > + nxp_fspi_clk_disable_unprep(f); > + > + ret = clk_set_rate(f->clk, rate); > + if (ret) > + return; > + > + ret = nxp_fspi_clk_prep_enable(f); > + if (ret) > + return; Missing newline line here. > + f->selected = spi->chip_select; > +} > + > +static void nxp_fspi_read_ahb(struct nxp_fspi *f, const struct spi_mem_op *op) > +{ > + u32 len = op->data.nbytes; > + > + /* Read out the data directly from the AHB buffer. */ > + memcpy_fromio(op->data.buf.in, (f->ahb_addr + op->addr.val), len); > +} > + > +static void nxp_fspi_fill_txfifo(struct nxp_fspi *f, > + const struct spi_mem_op *op) > +{ > + void __iomem *base = f->iobase; > + int i, j, ret; > + int size, tmp_size, wm_size; > + u32 data = 0; > + u32 *txbuf = (u32 *) op->data.buf.out; > + > + /* clear the TX FIFO. */ > + fspi_writel(f, FSPI_IPTXFCR_CLR, base + FSPI_IPTXFCR); > + > + /* Default value of water mark level is 8 bytes. */ > + wm_size = 8; > + size = op->data.nbytes / wm_size; > + for (i = 0; i < size; i++) { > + /* Wait for TXFIFO empty */ > + ret = fspi_readl_poll_tout(f, f->iobase + FSPI_INTR, > + FSPI_INTR_IPTXWE, 0, > + POLL_TOUT, true); > + WARN_ON(ret); > + > + j = 0; > + tmp_size = wm_size; > + while (tmp_size > 0) { > + data = 0; > + memcpy(&data, txbuf, 4); > + fspi_writel(f, data, base + FSPI_TFDR + j * 4); > + tmp_size -= 4; > + j++; > + txbuf += 1; > + } > + fspi_writel(f, FSPI_INTR_IPTXWE, base + FSPI_INTR); > + } > + > + size = op->data.nbytes % wm_size; > + if (size) { > + /* Wait for TXFIFO empty */ > + ret = fspi_readl_poll_tout(f, f->iobase + FSPI_INTR, > + FSPI_INTR_IPTXWE, 0, > + POLL_TOUT, true); > + WARN_ON(ret); > + > + j = 0; > + tmp_size = 0; > + while (size > 0) { > + data = 0; > + tmp_size = (size < 4) ? size : 4; > + memcpy(&data, txbuf, tmp_size); > + fspi_writel(f, data, base + FSPI_TFDR + j * 4); > + size -= tmp_size; > + j++; > + txbuf += 1; > + } > + fspi_writel(f, FSPI_INTR_IPTXWE, base + FSPI_INTR); > + } All these nested loops to fill the TX buffer and also the ones below to read the RX buffer look much more complicated than they should really be. Can you try to make this more readable? Maybe something like this would work: for (i = 0; i < ALIGN_DOWN(op->data.nbytes, 8); i += 8) { /* Wait for TXFIFO empty */ ret = fspi_readl_poll_tout(f, f->iobase + FSPI_INTR, FSPI_INTR_IPTXWE, 0, POLL_TOUT, true); fspi_writel(f, op->data.buf.out + i, base + FSPI_TFDR); fspi_writel(f, op->data.buf.out + i + 4, base + FSPI_TFDR + 4); fspi_writel(f, FSPI_INTR_IPTXWE, base + FSPI_INTR); } if (i < op->data.nbytes) { u32 data = 0; int j; /* Wait for TXFIFO empty */ ret = fspi_readl_poll_tout(f, f->iobase + FSPI_INTR, FSPI_INTR_IPTXWE, 0, POLL_TOUT, true); for (j = 0; j < ALIGN(op->data.nbytes - i, 4); j += 4) { memcpy(&data, op->data.buf.out + i + j, 4); fspi_writel(f, data, base + FSPI_TFDR + j); } fspi_writel(f, FSPI_INTR_IPTXWE, base + FSPI_INTR); } > +} > + > +static void nxp_fspi_read_rxfifo(struct nxp_fspi *f, > + const struct spi_mem_op *op) > +{ > + void __iomem *base = f->iobase; > + int i, j; > + int size, tmp_size, wm_size, ret; > + u32 tmp = 0; > + u8 *buf = op->data.buf.in; > + u32 len = op->data.nbytes; > + > + /* Default value of water mark level is 8 bytes. */ > + wm_size = 8; > + > + while (len > 0) { > + size = len / wm_size; > + > + for (i = 0; i < size; i++) { > + /* Wait for RXFIFO available */ > + ret = fspi_readl_poll_tout(f, f->iobase + FSPI_INTR, > + FSPI_INTR_IPRXWA, 0, > + POLL_TOUT, true); > + WARN_ON(ret); > + > + j = 0; > + tmp_size = wm_size; > + while (tmp_size > 0) { > + tmp = 0; > + tmp = fspi_readl(f, base + FSPI_RFDR + j * 4); > + memcpy(buf, &tmp, 4); > + tmp_size -= 4; > + j++; > + buf += 4; > + } > + /* move the FIFO pointer */ > + fspi_writel(f, FSPI_INTR_IPRXWA, base + FSPI_INTR); > + len -= wm_size; > + } > + > + size = len % wm_size; > + > + j = 0; > + if (size) { > + /* Wait for RXFIFO available */ > + ret = fspi_readl_poll_tout(f, f->iobase + FSPI_INTR, > + FSPI_INTR_IPRXWA, 0, > + POLL_TOUT, true); > + WARN_ON(ret); > + > + while (len > 0) { > + tmp = 0; > + size = (len < 4) ? len : 4; > + tmp = fspi_readl(f, base + FSPI_RFDR + j * 4); > + memcpy(buf, &tmp, size); > + len -= size; > + j++; > + buf += size; > + } > + } > + > + /* invalid the RXFIFO */ > + fspi_writel(f, FSPI_IPRXFCR_CLR, base + FSPI_IPRXFCR); > + /* move the FIFO pointer */ > + fspi_writel(f, FSPI_INTR_IPRXWA, base + FSPI_INTR); > + } Same here. I think this is overly complicated. > +} > + > +static int nxp_fspi_do_op(struct nxp_fspi *f, const struct spi_mem_op *op) > +{ > + void __iomem *base = f->iobase; > + int seqnum = 0; > + int err = 0; > + u32 reg; > + > + reg = fspi_readl(f, base + FSPI_IPRXFCR); > + /* invalid RXFIFO first */ > + reg &= ~FSPI_IPRXFCR_DMA_EN; > + reg = reg | FSPI_IPRXFCR_CLR; > + fspi_writel(f, reg, base + FSPI_IPRXFCR); > + > + init_completion(&f->c); > + > + fspi_writel(f, op->addr.val, base + FSPI_IPCR0); > + /* > + * Always start the sequence at the same index since we update > + * the LUT at each exec_op() call. And also specify the DATA > + * length, since it's has not been specified in the LUT. > + */ > + fspi_writel(f, op->data.nbytes | > + (SEQID_LUT << FSPI_IPCR1_SEQID_SHIFT) | > + (seqnum << FSPI_IPCR1_SEQNUM_SHIFT), > + base + FSPI_IPCR1); > + > + /* Trigger the LUT now. */ > + fspi_writel(f, FSPI_IPCMD_TRG, base + FSPI_IPCMD); > + > + /* Wait for the interrupt. */ > + if (!wait_for_completion_timeout(&f->c, msecs_to_jiffies(1000))) > + err = -ETIMEDOUT; > + > + /* Invoke IP data read, if request is of data read. */ > + if (!err && op->data.nbytes && op->data.dir == SPI_MEM_DATA_IN) > + nxp_fspi_read_rxfifo(f, op); > + > + return err; > +} > + > +static int nxp_fspi_exec_op(struct spi_mem *mem, const struct spi_mem_op *op) > +{ > + struct nxp_fspi *f = spi_controller_get_devdata(mem->spi->master); > + int err = 0; > + > + mutex_lock(&f->lock); > + > + /* Wait for controller being ready. */ > + err = fspi_readl_poll_tout(f, f->iobase + FSPI_STS0, > + FSPI_STS0_ARB_IDLE, 1, POLL_TOUT, true); > + WARN_ON(err); > + > + nxp_fspi_select_mem(f, mem->spi); > + > + nxp_fspi_prepare_lut(f, op); > + /* > + * If we have large chunks of data, we read them through the AHB bus > + * by accessing the mapped memory. In all other cases we use > + * IP commands to access the flash. > + */ > + if (op->data.nbytes > (f->devtype_data->rxfifo - 4) && > + op->data.dir == SPI_MEM_DATA_IN) { > + nxp_fspi_read_ahb(f, op); > + } else { > + if (op->data.nbytes && op->data.dir == SPI_MEM_DATA_OUT) > + nxp_fspi_fill_txfifo(f, op); > + > + err = nxp_fspi_do_op(f, op); > + > + /* Invalidate the data in the AHB buffer. */ > + if (op->data.nbytes && op->data.dir == SPI_MEM_DATA_OUT) > + nxp_fspi_invalid(f); E.g. in case of an erase operation or a NAND load page operation, the invalidation is not triggered, but flash/buffer contents have changed. So I'm not sure if this is enough... > + } > + > + mutex_unlock(&f->lock); > + > + return err; > +} > + > +static int nxp_fspi_adjust_op_size(struct spi_mem *mem, struct spi_mem_op *op) > +{ > + struct nxp_fspi *f = spi_controller_get_devdata(mem->spi->master); > + > + if (op->data.dir == SPI_MEM_DATA_OUT) { > + if (op->data.nbytes > f->devtype_data->txfifo) > + op->data.nbytes = f->devtype_data->txfifo; > + } else { > + if (op->data.nbytes > f->devtype_data->ahb_buf_size) > + op->data.nbytes = f->devtype_data->ahb_buf_size; > + else if (op->data.nbytes > (f->devtype_data->rxfifo - 4)) > + op->data.nbytes = ALIGN_DOWN(op->data.nbytes, 8); You are using the same alignments as in the QSPI driver. So AHB reads will happen in portions of ahb_buf_size, but you dont' stick to this when you map the memory. See above. Regards, Frieder > + } > + > + return 0; > +} > + > +static int nxp_fspi_default_setup(struct nxp_fspi *f) > +{ > + void __iomem *base = f->iobase; > + int ret, i; > + u32 reg; > + > + /* disable and unprepare clock to avoid glitch pass to controller */ > + nxp_fspi_clk_disable_unprep(f); > + > + /* the default frequency, we will change it later if necessary. */ > + ret = clk_set_rate(f->clk, 20000000); > + if (ret) > + return ret; > + > + ret = nxp_fspi_clk_prep_enable(f); > + if (ret) > + return ret; > + > + /* Reset the module */ > + /* w1c register, wait unit clear */ > + ret = fspi_readl_poll_tout(f, f->iobase + FSPI_MCR0, > + FSPI_MCR0_SWRST, 0, POLL_TOUT, false); > + WARN_ON(ret); > + > + /* Disable the module */ > + fspi_writel(f, FSPI_MCR0_MDIS, base + FSPI_MCR0); > + > + /* Reset the DLL register to default value */ > + fspi_writel(f, FSPI_DLLACR_OVRDEN, base + FSPI_DLLACR); > + fspi_writel(f, FSPI_DLLBCR_OVRDEN, base + FSPI_DLLBCR); > + > + /* enable module */ > + fspi_writel(f, FSPI_MCR0_AHB_TIMEOUT(0xFF) | FSPI_MCR0_IP_TIMEOUT(0xFF), > + base + FSPI_MCR0); > + > + /* > + * Disable same device enable bit and configure all slave devices > + * independently. > + */ > + reg = fspi_readl(f, f->iobase + FSPI_MCR2); > + reg = reg & ~(FSPI_MCR2_SAMEDEVICEEN); > + fspi_writel(f, reg, base + FSPI_MCR2); > + > + /* AHB configuration for access buffer 0~7. */ > + for (i = 0; i < 7; i++) > + fspi_writel(f, 0, base + FSPI_AHBRX_BUF0CR0 + 4 * i); > + > + /* > + * Set ADATSZ with the maximum AHB buffer size to improve the read > + * performance. > + */ > + fspi_writel(f, (f->devtype_data->ahb_buf_size / 8 | > + FSPI_AHBRXBUF0CR7_PREF), base + FSPI_AHBRX_BUF7CR0); > + > + /* prefetch and no start address alignment limitation */ > + fspi_writel(f, FSPI_AHBCR_PREF_EN | FSPI_AHBCR_RDADDROPT, > + base + FSPI_AHBCR); > + > + /* AHB Read - Set lut sequence ID for all CS. */ > + fspi_writel(f, SEQID_LUT, base + FSPI_FLSHA1CR2); > + fspi_writel(f, SEQID_LUT, base + FSPI_FLSHA2CR2); > + fspi_writel(f, SEQID_LUT, base + FSPI_FLSHB1CR2); > + fspi_writel(f, SEQID_LUT, base + FSPI_FLSHB2CR2); > + > + f->selected = -1; > + > + /* enable the interrupt */ > + fspi_writel(f, FSPI_INTEN_IPCMDDONE, base + FSPI_INTEN); > + > + return 0; > +} > + > +static const struct spi_controller_mem_ops nxp_fspi_mem_ops = { > + .adjust_op_size = nxp_fspi_adjust_op_size, > + .supports_op = nxp_fspi_supports_op, > + .exec_op = nxp_fspi_exec_op, > +}; > + > +static int nxp_fspi_probe(struct platform_device *pdev) > +{ > + struct spi_controller *ctlr; > + struct device *dev = &pdev->dev; > + struct device_node *np = dev->of_node; > + struct resource *res; > + struct nxp_fspi *f; > + int ret; > + > + ctlr = spi_alloc_master(&pdev->dev, sizeof(*f)); > + if (!ctlr) > + return -ENOMEM; > + > + ctlr->mode_bits = SPI_RX_DUAL | SPI_RX_QUAD | > + SPI_TX_DUAL | SPI_TX_QUAD; > + > + f = spi_controller_get_devdata(ctlr); > + f->dev = dev; > + f->devtype_data = of_device_get_match_data(dev); > + if (!f->devtype_data) { > + ret = -ENODEV; > + goto err_put_ctrl; > + } > + > + platform_set_drvdata(pdev, f); > + > + /* find the resources - configuration register address space */ > + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "fspi_base"); > + f->iobase = devm_ioremap_resource(dev, res); > + if (IS_ERR(f->iobase)) { > + ret = PTR_ERR(f->iobase); > + goto err_put_ctrl; > + } > + > + /* find the resources - controller memory mapped space */ > + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "fspi_mmap"); > + f->ahb_addr = devm_ioremap_resource(dev, res); > + if (IS_ERR(f->ahb_addr)) { > + ret = PTR_ERR(f->ahb_addr); > + goto err_put_ctrl; > + } > + > + /* assign memory mapped starting address and mapped size. */ > + f->memmap_phy = res->start; > + f->memmap_phy_size = resource_size(res); > + > + /* find the clocks */ > + f->clk_en = devm_clk_get(dev, "fspi_en"); > + if (IS_ERR(f->clk_en)) { > + ret = PTR_ERR(f->clk_en); > + goto err_put_ctrl; > + } > + > + f->clk = devm_clk_get(dev, "fspi"); > + if (IS_ERR(f->clk)) { > + ret = PTR_ERR(f->clk); > + goto err_put_ctrl; > + } > + > + ret = nxp_fspi_clk_prep_enable(f); > + if (ret) { > + dev_err(dev, "can not enable the clock\n"); > + goto err_put_ctrl; > + } > + > + /* find the irq */ > + ret = platform_get_irq(pdev, 0); > + if (ret < 0) { > + dev_err(dev, "failed to get the irq: %d\n", ret); > + goto err_disable_clk; > + } > + > + ret = devm_request_irq(dev, ret, > + nxp_fspi_irq_handler, 0, pdev->name, f); > + if (ret) { > + dev_err(dev, "failed to request irq: %d\n", ret); > + goto err_disable_clk; > + } > + > + mutex_init(&f->lock); > + > + ctlr->bus_num = -1; > + ctlr->num_chipselect = NXP_FSPI_MAX_CHIPSELECT; > + ctlr->mem_ops = &nxp_fspi_mem_ops; > + > + nxp_fspi_default_setup(f); > + > + ctlr->dev.of_node = np; > + > + ret = spi_register_controller(ctlr); > + if (ret) > + goto err_destroy_mutex; > + > + return 0; > + > +err_destroy_mutex: > + mutex_destroy(&f->lock); > + > +err_disable_clk: > + nxp_fspi_clk_disable_unprep(f); > + > +err_put_ctrl: > + spi_controller_put(ctlr); > + > + dev_err(dev, "NXP FSPI probe failed\n"); > + return ret; > +} > + > +static int nxp_fspi_remove(struct platform_device *pdev) > +{ > + struct nxp_fspi *f = platform_get_drvdata(pdev); > + > + /* disable the hardware */ > + fspi_writel(f, FSPI_MCR0_MDIS, f->iobase + FSPI_MCR0); > + > + nxp_fspi_clk_disable_unprep(f); > + > + mutex_destroy(&f->lock); > + > + return 0; > +} > + > +static int nxp_fspi_suspend(struct device *dev) > +{ > + return 0; > +} > + > +static int nxp_fspi_resume(struct device *dev) > +{ > + struct nxp_fspi *f = dev_get_drvdata(dev); > + > + nxp_fspi_default_setup(f); > + > + return 0; > +} > + > +static const struct of_device_id nxp_fspi_dt_ids[] = { > + { .compatible = "nxp,lx2160a-fspi", .data = (void *)&lx2160a_data, }, > + { /* sentinel */ } > +}; > +MODULE_DEVICE_TABLE(of, nxp_fspi_dt_ids); > + > +static const struct dev_pm_ops nxp_fspi_pm_ops = { > + .suspend = nxp_fspi_suspend, > + .resume = nxp_fspi_resume, > +}; > + > +static struct platform_driver nxp_fspi_driver = { > + .driver = { > + .name = "nxp-fspi", > + .of_match_table = nxp_fspi_dt_ids, > + .pm = &nxp_fspi_pm_ops, > + }, > + .probe = nxp_fspi_probe, > + .remove = nxp_fspi_remove, > +}; > +module_platform_driver(nxp_fspi_driver); > + > +MODULE_DESCRIPTION("NXP FSPI Controller Driver"); > +MODULE_AUTHOR("NXP Semiconductor"); > +MODULE_LICENSE("GPL v2"); > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel