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 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 smtp.lore.kernel.org (Postfix) with ESMTPS id ABC20EB64D7 for ; Fri, 16 Jun 2023 05:44:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=wo6lyfjTR+4CkEEwjUFG1nMwfFHDdHzv7ZkeUjdpsyA=; b=Rmaov8H1i5ZqC8 JP/nBl1qqj6zns6LNjDDqgFUFajPtUS1dKKRXkz4yxyzuCRDtNfiZmxPJlNjD6ss7TNDpERD/ygp6 e9CWcDth6OYA3Qw14nmHKYiscE4Eon0KhMz12ThKQ6AlKOCetKpT9/lFZAHsG2BI+7m2u6/rjza5/ heJfTbymAsAmxQvyP5vGgrMJVNOV7fP/S2LKEz4jjMN2AYtOsrgMcLK4HLHplyEP6nK8hvAqp7SEO Wnf14ofArrj/dh1ZsH4MxHPaHACHxTnVoc/VmUsl47ZOysBueSnEAC/fAs9xH0ZPaTrQXNyuZOETr aRZtjSE8WMyDab/XMM6w==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qA2F3-00Guu1-2a; Fri, 16 Jun 2023 05:43:25 +0000 Received: from inva020.nxp.com ([92.121.34.13]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1qA2En-00Gulp-0D for linux-arm-kernel@lists.infradead.org; Fri, 16 Jun 2023 05:43:18 +0000 Received: from inva020.nxp.com (localhost [127.0.0.1]) by inva020.eu-rdc02.nxp.com (Postfix) with ESMTP id A0B3A1A06A2; Fri, 16 Jun 2023 07:43:03 +0200 (CEST) Received: from aprdc01srsp001v.ap-rdc01.nxp.com (aprdc01srsp001v.ap-rdc01.nxp.com [165.114.16.16]) by inva020.eu-rdc02.nxp.com (Postfix) with ESMTP id AC4A61A068F; Fri, 16 Jun 2023 07:43:02 +0200 (CEST) Received: from localhost.localdomain (mega.ap.freescale.net [10.192.208.232]) by aprdc01srsp001v.ap-rdc01.nxp.com (Postfix) with ESMTP id 3BFDC180222B; Fri, 16 Jun 2023 13:43:01 +0800 (+08) From: Alison Wang To: gregkh@linuxfoundation.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: leoyang.li@nxp.com, xuelin.shi@nxp.com, xiaofeng.ren@nxp.com, feng.guo@nxp.com, Alison Wang Subject: [PATCH 1/8] ethosu: Add Arm Ethos-U driver Date: Fri, 16 Jun 2023 13:59:06 +0800 Message-Id: <20230616055913.2360-2-alison.wang@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20230616055913.2360-1-alison.wang@nxp.com> References: <20230616055913.2360-1-alison.wang@nxp.com> MIME-Version: 1.0 X-Virus-Scanned: ClamAV using ClamSMTP X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20230615_224309_656319_0B22467D X-CRM114-Status: GOOD ( 27.40 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org RXRob3MtVSBMaW51eCBkcml2ZXIgaXMgdG8gcHJvdmlkZSBhbiBleGFtcGxlIG9mIGhvdyBhIHJp Y2ggb3BlcmF0aW5nCnN5c3RlbSBsaWtlIExpbnV4IGNhbiBkaXNwYXRjaCBpbmZlcmVuY2VzIHRv IGFuIEFybSBDb3J0ZXgtTSBzdWJzeXN0ZW0sCmNvbnNpc3Rpbmcgb2YgYW4gQXJtIENvcnRleC1N IGFuZCBhbiBBcm0gRXRob3MtVSBOUFUuCgpMaW5rOiBodHRwczovL2dpdC5tbHBsYXRmb3JtLm9y Zy9tbC9ldGhvcy11L2V0aG9zLXUtbGludXgtZHJpdmVyLXN0YWNrLmdpdApUYWc6IDIyLjAyCgpT aWduZWQtb2ZmLWJ5OiBLcmlzdG9mZXIgSm9uc3NvbiA8a3Jpc3RvZmVyLmpvbnNzb25AYXJtLmNv bT4KU2lnbmVkLW9mZi1ieTogUGVyIEFzdHJhbmQgPHBlci5hc3RyYW5kQGFybS5jb20+ClNpZ25l ZC1vZmYtYnk6IEpvbm55IFN2w6RyZCA8am9ubnkuc3ZhZXJkQGFybS5jb20+ClNpZ25lZC1vZmYt Ynk6IExpb3IgRGVrZWwgPExpb3IuZGVrZWxAYXJtLmNvbT4KU2lnbmVkLW9mZi1ieTogSGVucmlr IEhvZ2xpbmQgPGhlbnJpay5ob2dsaW5kQGFybS5jb20+ClNpZ25lZC1vZmYtYnk6IERhdmlkZSBH cm9obWFubiA8ZGF2aWRlLmdyb2htYW5uQGFybS5jb20+ClNpZ25lZC1vZmYtYnk6IEFsaXNvbiBX YW5nIDxhbGlzb24ud2FuZ0BueHAuY29tPgotLS0KIGRyaXZlcnMvZmlybXdhcmUvS2NvbmZpZyAg ICAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL2Zpcm13YXJlL01ha2VmaWxlICAg ICAgICAgICAgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvS2NvbmZp ZyAgICAgICAgICAgICAgIHwgIDI0ICsKIGRyaXZlcnMvZmlybXdhcmUvZXRob3N1L01ha2VmaWxl ICAgICAgICAgICAgICB8ICAyOCArKwogZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvZXRob3N1X2J1 ZmZlci5jICAgICAgIHwgMzEyICsrKysrKysrKysrKwogZHJpdmVycy9maXJtd2FyZS9ldGhvc3Uv ZXRob3N1X2J1ZmZlci5oICAgICAgIHwgMTA2ICsrKysKIC4uLi9maXJtd2FyZS9ldGhvc3UvZXRo b3N1X2NvcmVfaW50ZXJmYWNlLmggICB8IDE4MyArKysrKysrCiBkcml2ZXJzL2Zpcm13YXJlL2V0 aG9zdS9ldGhvc3VfZGV2aWNlLmMgICAgICAgfCA0NzQgKysrKysrKysrKysrKysrKysrCiBkcml2 ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfZGV2aWNlLmggICAgICAgfCAgODggKysrKwogZHJp dmVycy9maXJtd2FyZS9ldGhvc3UvZXRob3N1X2RyaXZlci5jICAgICAgIHwgMTkxICsrKysrKysK IGRyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9pbmZlcmVuY2UuYyAgICB8IDQxNyArKysr KysrKysrKysrKysKIGRyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9pbmZlcmVuY2UuaCAg ICB8IDEyMCArKysrKwogZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvZXRob3N1X21haWxib3guYyAg ICAgIHwgMzc3ICsrKysrKysrKysrKysrCiBkcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhvc3Vf bWFpbGJveC5oICAgICAgfCAxNDAgKysrKysrCiBkcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhv c3VfbmV0d29yay5jICAgICAgfCAyMDEgKysrKysrKysKIGRyaXZlcnMvZmlybXdhcmUvZXRob3N1 L2V0aG9zdV9uZXR3b3JrLmggICAgICB8ICA4MSArKysKIGRyaXZlcnMvZmlybXdhcmUvZXRob3N1 L3VhcGkvZXRob3N1LmggICAgICAgICB8IDIwNyArKysrKysrKwogMTcgZmlsZXMgY2hhbmdlZCwg Mjk1MSBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9maXJtd2FyZS9l dGhvc3UvS2NvbmZpZwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZmlybXdhcmUvZXRob3N1 L01ha2VmaWxlCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvZXRo b3N1X2J1ZmZlci5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9maXJtd2FyZS9ldGhvc3Uv ZXRob3N1X2J1ZmZlci5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9maXJtd2FyZS9ldGhv c3UvZXRob3N1X2NvcmVfaW50ZXJmYWNlLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2Zp cm13YXJlL2V0aG9zdS9ldGhvc3VfZGV2aWNlLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJz L2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfZGV2aWNlLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfZHJpdmVyLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfaW5mZXJlbmNlLmMKIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfaW5mZXJlbmNlLmgKIGNyZWF0ZSBt b2RlIDEwMDY0NCBkcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfbWFpbGJveC5jCiBjcmVh dGUgbW9kZSAxMDA2NDQgZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvZXRob3N1X21haWxib3guaAog Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9uZXR3b3Jr LmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfbmV0 d29yay5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvdWFwaS9l dGhvc3UuaAoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZmlybXdhcmUvS2NvbmZpZyBiL2RyaXZlcnMv ZmlybXdhcmUvS2NvbmZpZwppbmRleCBiNTllMzA0MWZkNjIuLmJiYWQ2ZGM4MWU3YiAxMDA2NDQK LS0tIGEvZHJpdmVycy9maXJtd2FyZS9LY29uZmlnCisrKyBiL2RyaXZlcnMvZmlybXdhcmUvS2Nv bmZpZwpAQCAtMzA4LDYgKzMwOCw3IEBAIHNvdXJjZSAiZHJpdmVycy9maXJtd2FyZS9icm9hZGNv bS9LY29uZmlnIgogc291cmNlICJkcml2ZXJzL2Zpcm13YXJlL2NpcnJ1cy9LY29uZmlnIgogc291 cmNlICJkcml2ZXJzL2Zpcm13YXJlL2dvb2dsZS9LY29uZmlnIgogc291cmNlICJkcml2ZXJzL2Zp cm13YXJlL2VmaS9LY29uZmlnIgorc291cmNlICJkcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9LY29u ZmlnIgogc291cmNlICJkcml2ZXJzL2Zpcm13YXJlL2lteC9LY29uZmlnIgogc291cmNlICJkcml2 ZXJzL2Zpcm13YXJlL21lc29uL0tjb25maWciCiBzb3VyY2UgImRyaXZlcnMvZmlybXdhcmUvcHNj aS9LY29uZmlnIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9maXJtd2FyZS9NYWtlZmlsZSBiL2RyaXZl cnMvZmlybXdhcmUvTWFrZWZpbGUKaW5kZXggMjhmY2RkY2Q2ODhmLi42YzU5N2E3OGRhYTcgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZmlybXdhcmUvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9maXJtd2Fy ZS9NYWtlZmlsZQpAQCAtMzMsNiArMzMsNyBAQCBvYmoteQkJCQkrPSBjaXJydXMvCiBvYmoteQkJ CQkrPSBtZXNvbi8KIG9iai0kKENPTkZJR19HT09HTEVfRklSTVdBUkUpCSs9IGdvb2dsZS8KIG9i ai15CQkJCSs9IGVmaS8KK29iai0kKENPTkZJR19FVEhPU1UpCQkrPSBldGhvc3UvCiBvYmoteQkJ CQkrPSBpbXgvCiBvYmoteQkJCQkrPSBwc2NpLwogb2JqLXkJCQkJKz0gc21jY2MvCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9LY29uZmlnIGIvZHJpdmVycy9maXJtd2FyZS9l dGhvc3UvS2NvbmZpZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmNl ODM3ZjQ1ZjhlNQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZmlybXdhcmUvZXRob3N1L0tj b25maWcKQEAgLTAsMCArMSwyNCBAQAorIworIyAoQykgQ09QWVJJR0hUIDIwMjAgQVJNIExpbWl0 ZWQuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3 YXJlIGFuZCBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZQorIyBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlCisjIEZvdW5kYXRpb24sIGFuZCBhbnkgdXNlIGJ5IHlvdSBvZiB0aGlzIHByb2dy YW0gaXMgc3ViamVjdCB0byB0aGUgdGVybXMKKyMgb2Ygc3VjaCBHTlUgbGljZW5jZS4KKyMKKyMg VGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1 c2VmdWwsCisjIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBs aWVkIHdhcnJhbnR5IG9mCisjIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gU2VlIHRoZQorIyBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorIworIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRo ZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIyBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsg aWYgbm90LCB5b3UgY2FuIGFjY2VzcyBpdCBvbmxpbmUgYXQKKyMgaHR0cDovL3d3dy5nbnUub3Jn L2xpY2Vuc2VzL2dwbC0yLjAuaHRtbC4KKyMKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQ TC0yLjAtb25seQorIworCitjb25maWcgRVRIT1NVCisgICAgdHJpc3RhdGUgIkFybSBFdGhvcy1V IE5QVSBzdXBwb3J0IgorICAgIGhlbHAKKyAgICAgIEFybSBFdGhvcy1VIE5QVSBkcml2ZXIuCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9NYWtlZmlsZSBiL2RyaXZlcnMvZmly bXdhcmUvZXRob3N1L01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMC4uOTMzZWZlZTFiMjJmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9maXJtd2FyZS9l dGhvc3UvTWFrZWZpbGUKQEAgLTAsMCArMSwyOCBAQAorIworIyAoQykgQ09QWVJJR0hUIDIwMjAg QVJNIExpbWl0ZWQuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFRoaXMgcHJvZ3JhbSBpcyBm cmVlIHNvZnR3YXJlIGFuZCBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZQorIyBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkIGJ5 IHRoZSBGcmVlIFNvZnR3YXJlCisjIEZvdW5kYXRpb24sIGFuZCBhbnkgdXNlIGJ5IHlvdSBvZiB0 aGlzIHByb2dyYW0gaXMgc3ViamVjdCB0byB0aGUgdGVybXMKKyMgb2Ygc3VjaCBHTlUgbGljZW5j ZS4KKyMKKyMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQg d2lsbCBiZSB1c2VmdWwsCisjIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVu IHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisjIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZQorIyBHTlUgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorIworIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorIyBhbG9uZyB3aXRoIHRoaXMg cHJvZ3JhbTsgaWYgbm90LCB5b3UgY2FuIGFjY2VzcyBpdCBvbmxpbmUgYXQKKyMgaHR0cDovL3d3 dy5nbnUub3JnL2xpY2Vuc2VzL2dwbC0yLjAuaHRtbC4KKyMKKyMgU1BEWC1MaWNlbnNlLUlkZW50 aWZpZXI6IEdQTC0yLjAtb25seQorIworCitvYmotJChDT05GSUdfRVRIT1NVKSA9IGV0aG9zdS5v CisKK2V0aG9zdS1vYmpzIDo9IGV0aG9zdV9kcml2ZXIubyBcCisgICAgICAgICAgICAgICBldGhv c3VfYnVmZmVyLm8gXAorICAgICAgICAgICAgICAgZXRob3N1X2RldmljZS5vIFwKKyAgICAgICAg ICAgICAgIGV0aG9zdV9pbmZlcmVuY2UubyBcCisgICAgICAgICAgICAgICBldGhvc3VfbWFpbGJv eC5vIFwKKyAgICAgICAgICAgICAgIGV0aG9zdV9uZXR3b3JrLm8KZGlmZiAtLWdpdCBhL2RyaXZl cnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9idWZmZXIuYyBiL2RyaXZlcnMvZmlybXdhcmUvZXRo b3N1L2V0aG9zdV9idWZmZXIuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAuLjQzYTQzMzM1NWYzMAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZmlybXdhcmUvZXRo b3N1L2V0aG9zdV9idWZmZXIuYwpAQCAtMCwwICsxLDMxMiBAQAorLyoKKyAqIChDKSBDT1BZUklH SFQgMjAyMC0yMDIxIEFybSBMaW1pdGVkLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRo aXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlIGFuZCBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAy IGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgYW5kIGFu eSB1c2UgYnkgeW91IG9mIHRoaXMgcHJvZ3JhbSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcworICog b2Ygc3VjaCBHTlUgbGljZW5jZS4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQg aW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBX QVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFO VEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUKKyAq IEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91 IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExp Y2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHlvdSBjYW4gYWNjZXNz IGl0IG9ubGluZSBhdAorICogaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL2dwbC0yLjAuaHRt bC4KKyAqCisgKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CisgKi8KKwor LyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioKKyAqIEluY2x1ZGVzCisgKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8K KworI2luY2x1ZGUgImV0aG9zdV9idWZmZXIuaCIKKworI2luY2x1ZGUgImV0aG9zdV9kZXZpY2Uu aCIKKyNpbmNsdWRlICJ1YXBpL2V0aG9zdS5oIgorCisjaW5jbHVkZSA8bGludXgvYW5vbl9pbm9k ZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgorI2luY2x1ZGUgPGxpbnV4L29m X2FkZHJlc3MuaD4KKyNpbmNsdWRlIDxsaW51eC9maWxlLmg+CisjaW5jbHVkZSA8bGludXgvZnMu aD4KKyNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CisKKy8qKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisg KiBWYXJpYWJsZXMKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCitzdGF0aWMgaW50IGV0aG9zdV9i dWZmZXJfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLAorCQkJCSBzdHJ1Y3QgZmlsZSAqZmls ZSk7CisKK3N0YXRpYyBpbnQgZXRob3N1X2J1ZmZlcl9tbWFwKHN0cnVjdCBmaWxlICpmaWxlLAor CQkJICAgICAgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpOworCitzdGF0aWMgbG9uZyBldGhv c3VfYnVmZmVyX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLAorCQkJCXVuc2lnbmVkIGludCBjbWQs CisJCQkJdW5zaWduZWQgbG9uZyBhcmcpOworCitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3Bl cmF0aW9ucyBldGhvc3VfYnVmZmVyX2ZvcHMgPSB7CisJLnJlbGVhc2UgICAgICAgID0gJmV0aG9z dV9idWZmZXJfcmVsZWFzZSwKKwkubW1hcCAgICAgICAgICAgPSAmZXRob3N1X2J1ZmZlcl9tbWFw LAorCS51bmxvY2tlZF9pb2N0bCA9ICZldGhvc3VfYnVmZmVyX2lvY3RsLAorI2lmZGVmIENPTkZJ R19DT01QQVQKKwkuY29tcGF0X2lvY3RsICAgPSAmZXRob3N1X2J1ZmZlcl9pb2N0bCwKKyNlbmRp ZgorfTsKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIEZ1bmN0aW9ucworICoqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKiovCisKKy8qCisgKiBUaGUgJ2RtYS1yYW5nZXMnIGRldmljZSB0cmVlIHByb3BlcnR5 IGZvciBzaGFyZWQgZG1hIG1lbW9yeSBkb2VzIG5vdCBzZWVtCisgKiB0byBiZSBmdWxseSBzdXBw b3J0ZWQgZm9yIGNvaGVyZW50IG1lbW9yeS4gVGhlcmVmb3Igd2UgYXBwbHkgdGhlIERNQSByYW5n ZQorICogb2Zmc2V0IG91cnNlbHZlcy4KKyAqLworc3RhdGljIGRtYV9hZGRyX3QgZXRob3N1X2J1 ZmZlcl9kbWFfcmFuZ2VzKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQkJICAgZG1hX2FkZHJfdCBk bWFfYWRkciwKKwkJCQkJICAgc2l6ZV90IGRtYV9idWZfc2l6ZSkKK3sKKwlzdHJ1Y3QgZGV2aWNl X25vZGUgKm5vZGUgPSBkZXYtPm9mX25vZGU7CisJY29uc3QgX19iZTMyICpyYW5nZXM7CisJaW50 IGxlbjsKKwlpbnQgbmFkZHI7CisJaW50IG5zaXplOworCWludCBpbmM7CisJaW50IGk7CisKKwlp ZiAoIW5vZGUpCisJCXJldHVybiBkbWFfYWRkcjsKKworCS8qIEdldCB0aGUgI2FkZHJlc3MtY2Vs bHMgYW5kICNzaXplLWNlbGxzIHByb3BlcnRpZXMgKi8KKwluYWRkciA9IG9mX25fYWRkcl9jZWxs cyhub2RlKTsKKwluc2l6ZSA9IG9mX25fc2l6ZV9jZWxscyhub2RlKTsKKworCS8qIFJlYWQgdGhl ICdkbWEtcmFuZ2VzJyBwcm9wZXJ0eSAqLworCXJhbmdlcyA9IG9mX2dldF9wcm9wZXJ0eShub2Rl LCAiZG1hLXJhbmdlcyIsICZsZW4pOworCWlmICghcmFuZ2VzIHx8IGxlbiA8PSAwKQorCQlyZXR1 cm4gZG1hX2FkZHI7CisKKwlkZXZfZGJnKGRldiwgInJhbmdlcz0lcCwgbGVuPSVkLCBuYWRkcj0l ZCwgbnNpemU9JWRcbiIsCisJCXJhbmdlcywgbGVuLCBuYWRkciwgbnNpemUpOworCisJbGVuIC89 IHNpemVvZigqcmFuZ2VzKTsKKwlpbmMgPSBuYWRkciArIG5hZGRyICsgbnNpemU7CisKKwlmb3Ig KGkgPSAwOyAoaSArIGluYykgPD0gbGVuOyBpICs9IGluYykgeworCQlkbWFfYWRkcl90IGRhZGRy OworCQlkbWFfYWRkcl90IHBhZGRyOworCQlkbWFfYWRkcl90IHNpemU7CisKKwkJZGFkZHIgPSBv Zl9yZWFkX251bWJlcigmcmFuZ2VzW2ldLCBuYWRkcik7CisJCXBhZGRyID0gb2ZfcmVhZF9udW1i ZXIoJnJhbmdlc1tpICsgbmFkZHJdLCBuYWRkcik7CisJCXNpemUgPSBvZl9yZWFkX251bWJlcigm cmFuZ2VzW2kgKyBuYWRkciArIG5hZGRyXSwgbnNpemUpOworCisJCWRldl9kYmcoZGV2LCAiZGFk ZHI9MHglbGx4LCBwYWRkcj0weCVsbHgsIHNpemU9MHglbGx4XG4iLAorCQkJZGFkZHIsIHBhZGRy LCBzaXplKTsKKworCQlpZiAoZG1hX2FkZHIgPj0gcGFkZHIgJiYKKwkJICAgIChkbWFfYWRkciAr IGRtYV9idWZfc2l6ZSkgPCAocGFkZHIgKyBzaXplKSkKKwkJCXJldHVybiBkbWFfYWRkciArIGRh ZGRyIC0gcGFkZHI7CisJfQorCisJcmV0dXJuIGRtYV9hZGRyOworfQorCitzdGF0aWMgYm9vbCBl dGhvc3VfYnVmZmVyX3ZlcmlmeShzdHJ1Y3QgZmlsZSAqZmlsZSkKK3sKKwlyZXR1cm4gZmlsZS0+ Zl9vcCA9PSAmZXRob3N1X2J1ZmZlcl9mb3BzOworfQorCitzdGF0aWMgdm9pZCBldGhvc3VfYnVm ZmVyX2Rlc3Ryb3koc3RydWN0IGtyZWYgKmtyZWYpCit7CisJc3RydWN0IGV0aG9zdV9idWZmZXIg KmJ1ZiA9CisJCWNvbnRhaW5lcl9vZihrcmVmLCBzdHJ1Y3QgZXRob3N1X2J1ZmZlciwga3JlZik7 CisKKwlkZXZfaW5mbyhidWYtPmVkZXYtPmRldiwgIkJ1ZmZlciBkZXN0cm95LiBoYW5kbGU9MHgl cEtcbiIsIGJ1Zik7CisKKwlkbWFfZnJlZV9jb2hlcmVudChidWYtPmVkZXYtPmRldiwgYnVmLT5j YXBhY2l0eSwgYnVmLT5jcHVfYWRkciwKKwkJCSAgYnVmLT5kbWFfYWRkcl9vcmlnKTsKKwlkZXZt X2tmcmVlKGJ1Zi0+ZWRldi0+ZGV2LCBidWYpOworfQorCitzdGF0aWMgaW50IGV0aG9zdV9idWZm ZXJfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLAorCQkJCSBzdHJ1Y3QgZmlsZSAqZmlsZSkK K3sKKwlzdHJ1Y3QgZXRob3N1X2J1ZmZlciAqYnVmID0gZmlsZS0+cHJpdmF0ZV9kYXRhOworCisJ ZGV2X2luZm8oYnVmLT5lZGV2LT5kZXYsICJCdWZmZXIgcmVsZWFzZS4gaGFuZGxlPTB4JXBLXG4i LCBidWYpOworCisJZXRob3N1X2J1ZmZlcl9wdXQoYnVmKTsKKworCXJldHVybiAwOworfQorCitz dGF0aWMgaW50IGV0aG9zdV9idWZmZXJfbW1hcChzdHJ1Y3QgZmlsZSAqZmlsZSwKKwkJCSAgICAg IHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQoreworCXN0cnVjdCBldGhvc3VfYnVmZmVyICpi dWYgPSBmaWxlLT5wcml2YXRlX2RhdGE7CisJaW50IHJldDsKKworCWRldl9pbmZvKGJ1Zi0+ZWRl di0+ZGV2LCAiQnVmZmVyIG1tYXAuIGhhbmRsZT0weCVwS1xuIiwgYnVmKTsKKworCXJldCA9IGRt YV9tbWFwX2NvaGVyZW50KGJ1Zi0+ZWRldi0+ZGV2LCB2bWEsIGJ1Zi0+Y3B1X2FkZHIsCisJCQkJ YnVmLT5kbWFfYWRkcl9vcmlnLAorCQkJCWJ1Zi0+Y2FwYWNpdHkpOworCisJcmV0dXJuIHJldDsK K30KKworc3RhdGljIGxvbmcgZXRob3N1X2J1ZmZlcl9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlsZSwK KwkJCQl1bnNpZ25lZCBpbnQgY21kLAorCQkJCXVuc2lnbmVkIGxvbmcgYXJnKQoreworCXN0cnVj dCBldGhvc3VfYnVmZmVyICpidWYgPSBmaWxlLT5wcml2YXRlX2RhdGE7CisJdm9pZCBfX3VzZXIg KnVkYXRhID0gKHZvaWQgX191c2VyICopYXJnOworCWludCByZXQgPSAtRUlOVkFMOworCisJcmV0 ID0gbXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZidWYtPmVkZXYtPm11dGV4KTsKKwlpZiAocmV0 KQorCQlyZXR1cm4gcmV0OworCisJZGV2X2luZm8oYnVmLT5lZGV2LT5kZXYsICJJb2N0bC4gY21k PSV1LCBhcmc9JWx1XG4iLCBjbWQsIGFyZyk7CisKKwlzd2l0Y2ggKGNtZCkgeworCWNhc2UgRVRI T1NVX0lPQ1RMX0JVRkZFUl9TRVQ6IHsKKwkJc3RydWN0IGV0aG9zdV91YXBpX2J1ZmZlciB1YXBp OworCisJCWlmIChjb3B5X2Zyb21fdXNlcigmdWFwaSwgdWRhdGEsIHNpemVvZih1YXBpKSkpCisJ CQlicmVhazsKKworCQlkZXZfaW5mbyhidWYtPmVkZXYtPmRldiwKKwkJCSAiSW9jdGw6IEJ1ZmZl ciBzZXQuIHNpemU9JXUsIG9mZnNldD0ldVxuIiwKKwkJCSB1YXBpLnNpemUsIHVhcGkub2Zmc2V0 KTsKKworCQlyZXQgPSBldGhvc3VfYnVmZmVyX3Jlc2l6ZShidWYsIHVhcGkuc2l6ZSwgdWFwaS5v ZmZzZXQpOworCQlicmVhazsKKwl9CisJY2FzZSBFVEhPU1VfSU9DVExfQlVGRkVSX0dFVDogewor CQlzdHJ1Y3QgZXRob3N1X3VhcGlfYnVmZmVyIHVhcGk7CisKKwkJdWFwaS5zaXplID0gYnVmLT5z aXplOworCQl1YXBpLm9mZnNldCA9IGJ1Zi0+b2Zmc2V0OworCisJCWRldl9pbmZvKGJ1Zi0+ZWRl di0+ZGV2LAorCQkJICJJb2N0bDogQnVmZmVyIGdldC4gc2l6ZT0ldSwgb2Zmc2V0PSV1XG4iLAor CQkJIHVhcGkuc2l6ZSwgdWFwaS5vZmZzZXQpOworCisJCWlmIChjb3B5X3RvX3VzZXIodWRhdGEs ICZ1YXBpLCBzaXplb2YodWFwaSkpKQorCQkJYnJlYWs7CisKKwkJcmV0ID0gMDsKKwkJYnJlYWs7 CisJfQorCWRlZmF1bHQ6IHsKKwkJZGV2X2VycihidWYtPmVkZXYtPmRldiwgIkludmFsaWQgaW9j dGwuIGNtZD0ldSwgYXJnPSVsdSIsCisJCQljbWQsIGFyZyk7CisJCWJyZWFrOworCX0KKwl9CisK KwltdXRleF91bmxvY2soJmJ1Zi0+ZWRldi0+bXV0ZXgpOworCisJcmV0dXJuIHJldDsKK30KKwor aW50IGV0aG9zdV9idWZmZXJfY3JlYXRlKHN0cnVjdCBldGhvc3VfZGV2aWNlICplZGV2LAorCQkJ IHNpemVfdCBjYXBhY2l0eSkKK3sKKwlzdHJ1Y3QgZXRob3N1X2J1ZmZlciAqYnVmOworCWludCBy ZXQgPSAtRU5PTUVNOworCisJYnVmID0gZGV2bV9remFsbG9jKGVkZXYtPmRldiwgc2l6ZW9mKCpi dWYpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWJ1ZikKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlidWYt PmVkZXYgPSBlZGV2OworCWJ1Zi0+Y2FwYWNpdHkgPSBjYXBhY2l0eTsKKwlidWYtPm9mZnNldCA9 IDA7CisJYnVmLT5zaXplID0gMDsKKwlrcmVmX2luaXQoJmJ1Zi0+a3JlZik7CisKKwlidWYtPmNw dV9hZGRyID0gZG1hX2FsbG9jX2NvaGVyZW50KGJ1Zi0+ZWRldi0+ZGV2LCBjYXBhY2l0eSwKKwkJ CQkJICAgJmJ1Zi0+ZG1hX2FkZHJfb3JpZywgR0ZQX0tFUk5FTCk7CisJaWYgKCFidWYtPmNwdV9h ZGRyKQorCQlnb3RvIGZyZWVfYnVmOworCisJYnVmLT5kbWFfYWRkciA9IGV0aG9zdV9idWZmZXJf ZG1hX3JhbmdlcyhidWYtPmVkZXYtPmRldiwKKwkJCQkJCSBidWYtPmRtYV9hZGRyX29yaWcsCisJ CQkJCQkgYnVmLT5jYXBhY2l0eSk7CisKKwlyZXQgPSBhbm9uX2lub2RlX2dldGZkKCJldGhvc3Ut YnVmZmVyIiwgJmV0aG9zdV9idWZmZXJfZm9wcywgYnVmLAorCQkJICAgICAgIE9fUkRXUiB8IE9f Q0xPRVhFQyk7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZnJlZV9kbWE7CisKKwlidWYtPmZpbGUg PSBmZ2V0KHJldCk7CisJZnB1dChidWYtPmZpbGUpOworCisJZGV2X2luZm8oYnVmLT5lZGV2LT5k ZXYsCisJCSAiQnVmZmVyIGNyZWF0ZS4gaGFuZGxlPTB4JXBLLCBjYXBhY2l0eT0lenUsIGNwdV9h ZGRyPTB4JXBLLCBkbWFfYWRkcj0weCVsbHgsIGRtYV9hZGRyX29yaWc9MHglbGx4LCBwaHlzX2Fk ZHI9MHglbGx4XG4iLAorCQkgYnVmLCBjYXBhY2l0eSwgYnVmLT5jcHVfYWRkciwgYnVmLT5kbWFf YWRkciwKKwkJIGJ1Zi0+ZG1hX2FkZHJfb3JpZywgdmlydF90b19waHlzKGJ1Zi0+Y3B1X2FkZHIp KTsKKworCXJldHVybiByZXQ7CisKK2ZyZWVfZG1hOgorCWRtYV9mcmVlX2NvaGVyZW50KGJ1Zi0+ ZWRldi0+ZGV2LCBidWYtPmNhcGFjaXR5LCBidWYtPmNwdV9hZGRyLAorCQkJICBidWYtPmRtYV9h ZGRyX29yaWcpOworCitmcmVlX2J1ZjoKKwlkZXZtX2tmcmVlKGJ1Zi0+ZWRldi0+ZGV2LCBidWYp OworCisJcmV0dXJuIHJldDsKK30KKworc3RydWN0IGV0aG9zdV9idWZmZXIgKmV0aG9zdV9idWZm ZXJfZ2V0X2Zyb21fZmQoaW50IGZkKQoreworCXN0cnVjdCBldGhvc3VfYnVmZmVyICpidWY7CisJ c3RydWN0IGZpbGUgKmZpbGU7CisKKwlmaWxlID0gZmdldChmZCk7CisJaWYgKCFmaWxlKQorCQly ZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKKworCWlmICghZXRob3N1X2J1ZmZlcl92ZXJpZnkoZmls ZSkpIHsKKwkJZnB1dChmaWxlKTsKKworCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKKwl9CisK KwlidWYgPSBmaWxlLT5wcml2YXRlX2RhdGE7CisJZXRob3N1X2J1ZmZlcl9nZXQoYnVmKTsKKwlm cHV0KGZpbGUpOworCisJcmV0dXJuIGJ1ZjsKK30KKwordm9pZCBldGhvc3VfYnVmZmVyX2dldChz dHJ1Y3QgZXRob3N1X2J1ZmZlciAqYnVmKQoreworCWtyZWZfZ2V0KCZidWYtPmtyZWYpOworfQor Cit2b2lkIGV0aG9zdV9idWZmZXJfcHV0KHN0cnVjdCBldGhvc3VfYnVmZmVyICpidWYpCit7CisJ a3JlZl9wdXQoJmJ1Zi0+a3JlZiwgZXRob3N1X2J1ZmZlcl9kZXN0cm95KTsKK30KKworaW50IGV0 aG9zdV9idWZmZXJfcmVzaXplKHN0cnVjdCBldGhvc3VfYnVmZmVyICpidWYsCisJCQkgc2l6ZV90 IHNpemUsCisJCQkgc2l6ZV90IG9mZnNldCkKK3sKKwlpZiAoKHNpemUgKyBvZmZzZXQpID4gYnVm LT5jYXBhY2l0eSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlidWYtPnNpemUgPSBzaXplOworCWJ1 Zi0+b2Zmc2V0ID0gb2Zmc2V0OworCisJcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJz L2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfYnVmZmVyLmggYi9kcml2ZXJzL2Zpcm13YXJlL2V0aG9z dS9ldGhvc3VfYnVmZmVyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw Li4xNGYyNmMyYjBhOWQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2Zpcm13YXJlL2V0aG9z dS9ldGhvc3VfYnVmZmVyLmgKQEAgLTAsMCArMSwxMDYgQEAKKy8qCisgKiAoQykgQ09QWVJJR0hU IDIwMjAgQVJNIExpbWl0ZWQuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogVGhpcyBwcm9n cmFtIGlzIGZyZWUgc29mdHdhcmUgYW5kIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVy bXMgb2YgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVi bGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBhbmQgYW55IHVzZSBi eSB5b3Ugb2YgdGhpcyBwcm9ncmFtIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zCisgKiBvZiBzdWNo IEdOVSBsaWNlbmNlLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUg aG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZ OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElU WSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZQorICogR05VIEdl bmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQor ICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgeW91IGNhbiBhY2Nlc3MgaXQgb25s aW5lIGF0CisgKiBodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvZ3BsLTIuMC5odG1sLgorICoK KyAqIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkKKyAqLworCisjaWZuZGVm IEVUSE9TVV9CVUZGRVJfSAorI2RlZmluZSBFVEhPU1VfQlVGRkVSX0gKKworLyoqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioKKyAqIEluY2x1ZGVzCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworI2luY2x1ZGUg PGxpbnV4L2tyZWYuaD4KKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorCisvKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKgorICogVHlwZXMKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCitzdHJ1Y3QgZXRob3N1 X2RldmljZTsKK3N0cnVjdCBkZXZpY2U7CisKKy8qKgorICogc3RydWN0IGV0aG9zdV9idWZmZXIg LSBCdWZmZXIKKyAqIEBkZXY6CQlEZXZpY2UKKyAqIEBmaWxlOgkJRmlsZQorICogQGtyZWY6CQlS ZWZlcmVuY2UgY291bnRpbmcKKyAqIEBjYXBhY2l0eToJCU1heGltdW0gY2FwYWNpdHkgb2YgdGhl IGJ1ZmZlcgorICogQG9mZnNldDoJCU9mZnNldCB0byBmaXJzdCBieXRlIG9mIGJ1ZmZlcgorICog QHNpemU6CQlTaXplIG9mIHRoZSBkYXRhIGluIHRoZSBidWZmZXIKKyAqIEBjcHVfYWRkcjoJCUtl cm5lbCBtYXBwZWQgYWRkcmVzcworICogQGRtYV9hZGRyOgkJRE1BIGFkZHJlc3MKKyAqIEBkbWFf YWRkcl9vcmlnOglPcmlnaW5hbCBETUEgYWRkcmVzcyBiZWZvcmUgcmFuZ2UgbWFwcGluZworICoK KyAqICdvZmZzZXQgKyBzaXplJyBtdXN0IG5vdCBiZSBsYXJnZXIgdGhhbiAnY2FwYWNpdHknLgor ICovCitzdHJ1Y3QgZXRob3N1X2J1ZmZlciB7CisJc3RydWN0IGV0aG9zdV9kZXZpY2UgKmVkZXY7 CisJc3RydWN0IGZpbGUgICAgICAgICAgKmZpbGU7CisJc3RydWN0IGtyZWYgICAgICAgICAga3Jl ZjsKKwlzaXplX3QgICAgICAgICAgICAgICBjYXBhY2l0eTsKKwlzaXplX3QgICAgICAgICAgICAg ICBvZmZzZXQ7CisJc2l6ZV90ICAgICAgICAgICAgICAgc2l6ZTsKKwl2b2lkICAgICAgICAgICAg ICAgICAqY3B1X2FkZHI7CisJZG1hX2FkZHJfdCAgICAgICAgICAgZG1hX2FkZHI7CisJZG1hX2Fk ZHJfdCAgICAgICAgICAgZG1hX2FkZHJfb3JpZzsKK307CisKKy8qKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq CisgKiBGdW5jdGlvbnMKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisvKioKKyAqIGV0aG9zdV9i dWZmZXJfY3JlYXRlKCkgLSBDcmVhdGUgYnVmZmVyCisgKgorICogVGhpcyBmdW5jdGlvbiBtdXN0 IGJlIGNhbGxlZCBpbiB0aGUgY29udGV4dCBvZiBhIHVzZXIgc3BhY2UgcHJvY2Vzcy4KKyAqCisg KiBSZXR1cm46IGZkIG9uIHN1Y2Nlc3MsIGVsc2UgZXJyb3IgY29kZS4KKyAqLworaW50IGV0aG9z dV9idWZmZXJfY3JlYXRlKHN0cnVjdCBldGhvc3VfZGV2aWNlICplZGV2LAorCQkJIHNpemVfdCBj YXBhY2l0eSk7CisKKy8qKgorICogZXRob3N1X2J1ZmZlcl9nZXRfZnJvbV9mZCgpIC0gR2V0IGJ1 ZmZlciBoYW5kbGUgZnJvbSBmZAorICoKKyAqIFRoaXMgZnVuY3Rpb24gbXVzdCBiZSBjYWxsZWQg ZnJvbSBhIHVzZXIgc3BhY2UgY29udGV4dC4KKyAqCisgKiBSZXR1cm46IFBvaW50ZXIgb24gc3Vj Y2VzcywgZWxzZSBFUlJfUFRSLgorICovCitzdHJ1Y3QgZXRob3N1X2J1ZmZlciAqZXRob3N1X2J1 ZmZlcl9nZXRfZnJvbV9mZChpbnQgZmQpOworCisvKioKKyAqIGV0aG9zdV9idWZmZXJfZ2V0KCkg LSBQdXQgYnVmZmVyCisgKi8KK3ZvaWQgZXRob3N1X2J1ZmZlcl9nZXQoc3RydWN0IGV0aG9zdV9i dWZmZXIgKmJ1Zik7CisKKy8qKgorICogZXRob3N1X2J1ZmZlcl9wdXQoKSAtIFB1dCBidWZmZXIK KyAqLwordm9pZCBldGhvc3VfYnVmZmVyX3B1dChzdHJ1Y3QgZXRob3N1X2J1ZmZlciAqYnVmKTsK KworLyoqCisgKiBldGhvc3VfYnVmZmVyX3Jlc2l6ZSgpIC0gUmVzaXplIGFuZCB2YWxpZGF0ZSBi dWZmZXIKKyAqCisgKiBSZXR1cm46IDAgb24gc3VjY2VzcywgZWxzZSBlcnJvciBjb2RlLgorICov CitpbnQgZXRob3N1X2J1ZmZlcl9yZXNpemUoc3RydWN0IGV0aG9zdV9idWZmZXIgKmJ1ZiwKKwkJ CSBzaXplX3Qgc2l6ZSwKKwkJCSBzaXplX3Qgb2Zmc2V0KTsKKworI2VuZGlmIC8qIEVUSE9TVV9C VUZGRVJfSCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvZXRob3N1X2Nv cmVfaW50ZXJmYWNlLmggYi9kcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfY29yZV9pbnRl cmZhY2UuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmVmNjNjM2I1 NTM1MgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9j b3JlX2ludGVyZmFjZS5oCkBAIC0wLDAgKzEsMTgzIEBACisvKgorICogKEMpIENPUFlSSUdIVCAy MDIwIEFSTSBMaW1pdGVkLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3Jh bSBpcyBmcmVlIHNvZnR3YXJlIGFuZCBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1z IG9mIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxp c2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgYW5kIGFueSB1c2UgYnkg eW91IG9mIHRoaXMgcHJvZ3JhbSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcworICogb2Ygc3VjaCBH TlUgbGljZW5jZS4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhv cGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsg d2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkg b3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUKKyAqIEdOVSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBo YXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAq IGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHlvdSBjYW4gYWNjZXNzIGl0IG9ubGlu ZSBhdAorICogaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL2dwbC0yLjAuaHRtbC4KKyAqCisg KiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CisgKi8KKworI2lmbmRlZiBF VEhPU1VfQ09SRV9JTlRFUkZBQ0VfSAorI2RlZmluZSBFVEhPU1VfQ09SRV9JTlRFUkZBQ0VfSAor CisjaWZkZWYgX19LRVJORUxfXworI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisjZWxzZQorI2lu Y2x1ZGUgPHN0ZGludC5oPgorI2VuZGlmCisKKyNpZmRlZiBfX2NwbHVzcGx1cworbmFtZXNwYWNl IEV0aG9zVSB7CisjZW5kaWYKKworLyoqIE1heGltdW0gbnVtYmVyIG9mIElGTS9PRk0gYnVmZmVy cyBwZXIgaW5mZXJlbmNlICovCisjZGVmaW5lIEVUSE9TVV9DT1JFX0JVRkZFUl9NQVggMTYKKwor LyoqIE1heGltdW0gbnVtYmVyIG9mIFBNVSBjb3VudGVycyB0byBiZSByZXR1cm5lZCBmb3IgaW5m ZXJlbmNlICovCisjZGVmaW5lIEVUSE9TVV9DT1JFX1BNVV9NQVggOAorCisjZGVmaW5lIEVUSE9T VV9DT1JFX01TR19NQUdJQyAweDQxNDU3NjMxCisjZGVmaW5lIEVUSE9TVV9DT1JFX01TR19WRVJT SU9OX01BSk9SIDAKKyNkZWZpbmUgRVRIT1NVX0NPUkVfTVNHX1ZFUlNJT05fTUlOT1IgMgorI2Rl ZmluZSBFVEhPU1VfQ09SRV9NU0dfVkVSU0lPTl9QQVRDSCAwCisKKy8qKgorICogZW51bSBldGhv c3VfY29yZV9tc2dfdHlwZSAtIE1lc3NhZ2UgdHlwZXMKKyAqCisgKiBUeXBlcyBmb3IgdGhlIG1l c3NhZ2VzIHNlbnQgYmV0d2VlbiB0aGUgaG9zdCBhbmQgdGhlIGNvcmUgc3Vic3lzdGVtLgorICov CitlbnVtIGV0aG9zdV9jb3JlX21zZ190eXBlIHsKKwlFVEhPU1VfQ09SRV9NU0dfRVJSID0gMSwK KwlFVEhPU1VfQ09SRV9NU0dfUElORywKKwlFVEhPU1VfQ09SRV9NU0dfUE9ORywKKwlFVEhPU1Vf Q09SRV9NU0dfSU5GRVJFTkNFX1JFUSwKKwlFVEhPU1VfQ09SRV9NU0dfSU5GRVJFTkNFX1JTUCwK KwlFVEhPU1VfQ09SRV9NU0dfVkVSU0lPTl9SRVEsCisJRVRIT1NVX0NPUkVfTVNHX1ZFUlNJT05f UlNQLAorCUVUSE9TVV9DT1JFX01TR19DQVBBQklMSVRJRVNfUkVRLAorCUVUSE9TVV9DT1JFX01T R19DQVBBQklMSVRJRVNfUlNQLAorCUVUSE9TVV9DT1JFX01TR19NQVgKK307CisKKy8qKgorICog c3RydWN0IGV0aG9zdV9jb3JlX21zZyAtIE1lc3NhZ2UgaGVhZGVyCisgKi8KK3N0cnVjdCBldGhv c3VfY29yZV9tc2cgeworCXVpbnQzMl90IG1hZ2ljOworCXVpbnQzMl90IHR5cGU7CisJdWludDMy X3QgbGVuZ3RoOworfTsKKworLyoqCisgKiBzdHJ1Y3QgZXRob3N1X2NvcmVfcXVldWVfaGVhZGVy IC0gTWVzc2FnZSBxdWV1ZSBoZWFkZXIKKyAqLworc3RydWN0IGV0aG9zdV9jb3JlX3F1ZXVlX2hl YWRlciB7CisJdWludDMyX3Qgc2l6ZTsKKwl1aW50MzJfdCByZWFkOworCXVpbnQzMl90IHdyaXRl OworfTsKKworLyoqCisgKiBzdHJ1Y3QgZXRob3N1X2NvcmVfcXVldWUgLSBNZXNzYWdlIHF1ZXVl CisgKgorICogRHluYW1pY2FsbHkgc2l6ZWQgbWVzc2FnZSBxdWV1ZS4KKyAqLworc3RydWN0IGV0 aG9zdV9jb3JlX3F1ZXVlIHsKKwlzdHJ1Y3QgZXRob3N1X2NvcmVfcXVldWVfaGVhZGVyIGhlYWRl cjsKKwl1aW50OF90ICAgICAgICAgICAgICAgICAgICAgICAgIGRhdGFbXTsKK307CisKK2VudW0g ZXRob3N1X2NvcmVfc3RhdHVzIHsKKwlFVEhPU1VfQ09SRV9TVEFUVVNfT0ssCisJRVRIT1NVX0NP UkVfU1RBVFVTX0VSUk9SCit9OworCitzdHJ1Y3QgZXRob3N1X2NvcmVfYnVmZmVyIHsKKwl1aW50 MzJfdCBwdHI7CisJdWludDMyX3Qgc2l6ZTsKK307CisKK3N0cnVjdCBldGhvc3VfY29yZV9pbmZl cmVuY2VfcmVxIHsKKwl1aW50NjRfdCAgICAgICAgICAgICAgICAgIHVzZXJfYXJnOworCXVpbnQz Ml90ICAgICAgICAgICAgICAgICAgaWZtX2NvdW50OworCXN0cnVjdCBldGhvc3VfY29yZV9idWZm ZXIgaWZtW0VUSE9TVV9DT1JFX0JVRkZFUl9NQVhdOworCXVpbnQzMl90ICAgICAgICAgICAgICAg ICAgb2ZtX2NvdW50OworCXN0cnVjdCBldGhvc3VfY29yZV9idWZmZXIgb2ZtW0VUSE9TVV9DT1JF X0JVRkZFUl9NQVhdOworCXN0cnVjdCBldGhvc3VfY29yZV9idWZmZXIgbmV0d29yazsKKwl1aW50 OF90ICAgICAgICAgICAgICAgICAgIHBtdV9ldmVudF9jb25maWdbRVRIT1NVX0NPUkVfUE1VX01B WF07CisJdWludDMyX3QgICAgICAgICAgICAgICAgICBwbXVfY3ljbGVfY291bnRlcl9lbmFibGU7 Cit9OworCitzdHJ1Y3QgZXRob3N1X2NvcmVfaW5mZXJlbmNlX3JzcCB7CisJdWludDY0X3QgdXNl cl9hcmc7CisJdWludDMyX3Qgb2ZtX2NvdW50OworCXVpbnQzMl90IG9mbV9zaXplW0VUSE9TVV9D T1JFX0JVRkZFUl9NQVhdOworCXVpbnQzMl90IHN0YXR1czsKKwl1aW50OF90ICBwbXVfZXZlbnRf Y29uZmlnW0VUSE9TVV9DT1JFX1BNVV9NQVhdOworCXVpbnQzMl90IHBtdV9ldmVudF9jb3VudFtF VEhPU1VfQ09SRV9QTVVfTUFYXTsKKwl1aW50MzJfdCBwbXVfY3ljbGVfY291bnRlcl9lbmFibGU7 CisJdWludDY0X3QgcG11X2N5Y2xlX2NvdW50ZXJfY291bnQ7Cit9OworCisvKioKKyAqIHN0cnVj dCBldGhvc3VfY29yZV9tc2dfdmVyc29uIC0gTWVzc2FnZSBwcm90b2NvbCB2ZXJzaW9uCisgKi8K K3N0cnVjdCBldGhvc3VfY29yZV9tc2dfdmVyc2lvbiB7CisJdWludDhfdCBtYWpvcjsKKwl1aW50 OF90IG1pbm9yOworCXVpbnQ4X3QgcGF0Y2g7CisJdWludDhfdCBfcmVzZXJ2ZWQ7Cit9OworCisv KioKKyAqIHN0cnVjdCBldGhvc3VfY29yZV9jYXBhYmlsaXRpZXNfcmVxIC0gTWVzc2FnZSBjYXBh YmlsaXRpZXMgcmVxdWVzdAorICovCitzdHJ1Y3QgZXRob3N1X2NvcmVfY2FwYWJpbGl0aWVzX3Jl cSB7CisJdWludDY0X3QgdXNlcl9hcmc7Cit9OworCisvKioKKyAqIHN0cnVjdCBldGhvc3VfY29y ZV9jYXBhYmlsaXRpZXNfcnNwIC0gTWVzc2FnZSBjYXBhYmlsaXRpZXMgcmVzcG9uc2UKKyAqLwor c3RydWN0IGV0aG9zdV9jb3JlX21zZ19jYXBhYmlsaXRpZXNfcnNwIHsKKwl1aW50NjRfdCB1c2Vy X2FyZzsKKwl1aW50MzJfdCB2ZXJzaW9uX3N0YXR1czsKKwl1aW50MzJfdCB2ZXJzaW9uX21pbm9y OworCXVpbnQzMl90IHZlcnNpb25fbWFqb3I7CisJdWludDMyX3QgcHJvZHVjdF9tYWpvcjsKKwl1 aW50MzJfdCBhcmNoX3BhdGNoX3JldjsKKwl1aW50MzJfdCBhcmNoX21pbm9yX3JldjsKKwl1aW50 MzJfdCBhcmNoX21ham9yX3JldjsKKwl1aW50MzJfdCBkcml2ZXJfcGF0Y2hfcmV2OworCXVpbnQz Ml90IGRyaXZlcl9taW5vcl9yZXY7CisJdWludDMyX3QgZHJpdmVyX21ham9yX3JldjsKKwl1aW50 MzJfdCBtYWNzX3Blcl9jYzsKKwl1aW50MzJfdCBjbWRfc3RyZWFtX3ZlcnNpb247CisJdWludDMy X3QgY3VzdG9tX2RtYTsKK307CisKKy8qKgorICogZW51bSBldGhvc3VfY29yZV9tc2dfZXJyX3R5 cGUgLSBFcnJvciB0eXBlcworICovCitlbnVtIGV0aG9zdV9jb3JlX21zZ19lcnJfdHlwZSB7CisJ RVRIT1NVX0NPUkVfTVNHX0VSUl9HRU5FUklDID0gMCwKKwlFVEhPU1VfQ09SRV9NU0dfRVJSX1VO U1VQUE9SVEVEX1RZUEUsCisJRVRIT1NVX0NPUkVfTVNHX0VSUl9JTlZBTElEX1BBWUxPQUQsCisJ RVRIT1NVX0NPUkVfTVNHX0VSUl9JTlZBTElEX1NJWkUsCisJRVRIT1NVX0NPUkVfTVNHX0VSUl9J TlZBTElEX01BR0lDLAorCUVUSE9TVV9DT1JFX01TR19FUlJfTUFYCit9OworCisvKioKKyAqIHN0 cnVjdCBldGhvc3VfY29yZV9tc2dfZXJyIC0gRXJyb3IgbWVzc2FnZSBzdHJ1Y3QKKyAqLworc3Ry dWN0IGV0aG9zdV9jb3JlX21zZ19lcnIgeworCXVpbnQzMl90IHR5cGU7ICAgICAvKiBvcHRpb25h bCB1c2Ugb2YgZXh0cmEgZXJyb3IgY29kZSAqLworCWNoYXIgICAgIG1zZ1sxMjhdOworfTsKKyNp ZmRlZiBfX2NwbHVzcGx1cworfSAvKm5hbWVzcGFjZSBFdGhvc1UgKi8KKyNlbmRpZgorCisjZW5k aWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9kZXZpY2UuYyBi L2RyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9kZXZpY2UuYwpuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmU2ZjFlODAxMmIwNgotLS0gL2Rldi9udWxsCisrKyBi L2RyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9kZXZpY2UuYwpAQCAtMCwwICsxLDQ3NCBA QAorLyoKKyAqIChDKSBDT1BZUklHSFQgMjAyMCBBUk0gTGltaXRlZC4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZSBhbmQgaXMgcHJvdmlk ZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUKKyAqIEZv dW5kYXRpb24sIGFuZCBhbnkgdXNlIGJ5IHlvdSBvZiB0aGlzIHByb2dyYW0gaXMgc3ViamVjdCB0 byB0aGUgdGVybXMKKyAqIG9mIHN1Y2ggR05VIGxpY2VuY2UuCisgKgorICogVGhpcyBwcm9ncmFt IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBi dXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50 eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRh aWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90 LCB5b3UgY2FuIGFjY2VzcyBpdCBvbmxpbmUgYXQKKyAqIGh0dHA6Ly93d3cuZ251Lm9yZy9saWNl bnNlcy9ncGwtMi4wLmh0bWwuCisgKgorICogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0y LjAtb25seQorICovCisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBJbmNsdWRlcworICoqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKiovCisKKyNpbmNsdWRlICJldGhvc3VfZGV2aWNlLmgiCisKKyNpbmNsdWRl ICJldGhvc3VfYnVmZmVyLmgiCisjaW5jbHVkZSAiZXRob3N1X2NvcmVfaW50ZXJmYWNlLmgiCisj aW5jbHVkZSAiZXRob3N1X2luZmVyZW5jZS5oIgorI2luY2x1ZGUgImV0aG9zdV9uZXR3b3JrLmgi CisjaW5jbHVkZSAidWFwaS9ldGhvc3UuaCIKKworI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+Cisj aW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgor I2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CisjaW5j bHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9vZl9yZXNlcnZlZF9tZW0uaD4KKyNp bmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgorCisvKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKgorICogRGVmaW5lcworICoqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKyNk ZWZpbmUgRE1BX0FERFJfQklUUyAzMiAvKiBOdW1iZXIgb2YgYWRkcmVzcyBiaXRzICovCisKKyNk ZWZpbmUgQ0FQQUJJTElUSUVTX1JFU1BfVElNRU9VVF9NUyAyMDAwCisKKy8qKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqCisgKiBUeXBlcworICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKy8qKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqCisgKiBGdW5jdGlvbnMKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCitzdGF0aWMgdm9p ZCBldGhvc3VfY2FwYWJpbGl0aWVzX2Rlc3Ryb3koc3RydWN0IGtyZWYgKmtyZWYpCit7CisJc3Ry dWN0IGV0aG9zdV9jYXBhYmlsaXRpZXMgKmNhcCA9CisJCWNvbnRhaW5lcl9vZihrcmVmLCBzdHJ1 Y3QgZXRob3N1X2NhcGFiaWxpdGllcywgcmVmY291bnQpOworCisJbGlzdF9kZWwoJmNhcC0+bGlz dCk7CisKKwlkZXZtX2tmcmVlKGNhcC0+ZWRldi0+ZGV2LCBjYXApOworfQorCitzdGF0aWMgaW50 IGV0aG9zdV9jYXBhYmlsaXRpZXNfZmluZChzdHJ1Y3QgZXRob3N1X2NhcGFiaWxpdGllcyAqY2Fw LAorCQkJCSAgICBzdHJ1Y3QgbGlzdF9oZWFkICpjYXBhYmlsdGllc19saXN0KQoreworCXN0cnVj dCBldGhvc3VfY2FwYWJpbGl0aWVzICpjdXI7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGN1ciwg Y2FwYWJpbHRpZXNfbGlzdCwgbGlzdCkgeworCQlpZiAoY3VyID09IGNhcCkKKwkJCXJldHVybiAw OworCX0KKworCXJldHVybiAtRUlOVkFMOworfQorCitzdGF0aWMgaW50IGV0aG9zdV9jYXBhYmls aXR5X3JzcChzdHJ1Y3QgZXRob3N1X2RldmljZSAqZWRldiwKKwkJCQkgc3RydWN0IGV0aG9zdV9j b3JlX21zZ19jYXBhYmlsaXRpZXNfcnNwICptc2cpCit7CisJc3RydWN0IGV0aG9zdV9jYXBhYmls aXRpZXMgKmNhcDsKKwlzdHJ1Y3QgZXRob3N1X3VhcGlfZGV2aWNlX2NhcGFiaWxpdGllcyAqY2Fw YWJpbGl0aWVzOworCWludCByZXQ7CisKKwljYXAgPSAoc3RydWN0IGV0aG9zdV9jYXBhYmlsaXRp ZXMgKiltc2ctPnVzZXJfYXJnOworCXJldCA9IGV0aG9zdV9jYXBhYmlsaXRpZXNfZmluZChjYXAs ICZlZGV2LT5jYXBhYmlsaXRpZXNfbGlzdCk7CisJaWYgKDAgIT0gcmV0KSB7CisJCWRldl93YXJu KGVkZXYtPmRldiwKKwkJCSAiSGFuZGxlIG5vdCBmb3VuZCBpbiBjYXBhYmlsaXRpZXMgbGlzdC4g aGFuZGxlPTB4JXBcbiIsCisJCQkgY2FwKTsKKworCQkvKiBOT1RFOiBkbyBub3QgY2FsbCBjb21w bGV0ZSBvciBrcmVmX3B1dCBvbiBpbnZhbGlkIGRhdGEhICovCisJCXJldHVybiByZXQ7CisJfQor CisJY2FwYWJpbGl0aWVzID0gY2FwLT5jYXBhYmlsaXRpZXM7CisKKwljYXBhYmlsaXRpZXMtPmh3 X2lkLnZlcnNpb25fc3RhdHVzID0gbXNnLT52ZXJzaW9uX3N0YXR1czsKKwljYXBhYmlsaXRpZXMt Pmh3X2lkLnZlcnNpb25fbWlub3IgPSBtc2ctPnZlcnNpb25fbWlub3I7CisJY2FwYWJpbGl0aWVz LT5od19pZC52ZXJzaW9uX21ham9yID0gbXNnLT52ZXJzaW9uX21ham9yOworCWNhcGFiaWxpdGll cy0+aHdfaWQucHJvZHVjdF9tYWpvciA9IG1zZy0+cHJvZHVjdF9tYWpvcjsKKwljYXBhYmlsaXRp ZXMtPmh3X2lkLmFyY2hfcGF0Y2hfcmV2ID0gbXNnLT5hcmNoX3BhdGNoX3JldjsKKwljYXBhYmls aXRpZXMtPmh3X2lkLmFyY2hfbWlub3JfcmV2ID0gbXNnLT5hcmNoX21pbm9yX3JldjsKKwljYXBh YmlsaXRpZXMtPmh3X2lkLmFyY2hfbWFqb3JfcmV2ID0gbXNnLT5hcmNoX21ham9yX3JldjsKKwlj YXBhYmlsaXRpZXMtPmRyaXZlcl9wYXRjaF9yZXYgPSBtc2ctPmRyaXZlcl9wYXRjaF9yZXY7CisJ Y2FwYWJpbGl0aWVzLT5kcml2ZXJfbWlub3JfcmV2ID0gbXNnLT5kcml2ZXJfbWlub3JfcmV2Owor CWNhcGFiaWxpdGllcy0+ZHJpdmVyX21ham9yX3JldiA9IG1zZy0+ZHJpdmVyX21ham9yX3JldjsK KwljYXBhYmlsaXRpZXMtPmh3X2NmZy5tYWNzX3Blcl9jYyA9IG1zZy0+bWFjc19wZXJfY2M7CisJ Y2FwYWJpbGl0aWVzLT5od19jZmcuY21kX3N0cmVhbV92ZXJzaW9uID0gbXNnLT5jbWRfc3RyZWFt X3ZlcnNpb247CisJY2FwYWJpbGl0aWVzLT5od19jZmcuY3VzdG9tX2RtYSA9IG1zZy0+Y3VzdG9t X2RtYTsKKworCWNvbXBsZXRlKCZjYXAtPmRvbmUpOworCisJa3JlZl9wdXQoJmNhcC0+cmVmY291 bnQsIGV0aG9zdV9jYXBhYmlsaXRpZXNfZGVzdHJveSk7CisKKwlyZXR1cm4gMDsKK30KKworLyog SW5jb21pbmcgbWVzc2FnZXMgKi8KK3N0YXRpYyBpbnQgZXRob3N1X2hhbmRsZV9tc2coc3RydWN0 IGV0aG9zdV9kZXZpY2UgKmVkZXYpCit7CisJaW50IHJldDsKKwlzdHJ1Y3QgZXRob3N1X2NvcmVf bXNnIGhlYWRlcjsKKworCXVuaW9uIHsKKwkJc3RydWN0IGV0aG9zdV9jb3JlX21zZ19lcnIgICAg ICAgICAgICAgIGVycm9yOworCQlzdHJ1Y3QgZXRob3N1X2NvcmVfaW5mZXJlbmNlX3JzcCAgICAg ICAgaW5mOworCQlzdHJ1Y3QgZXRob3N1X2NvcmVfbXNnX3ZlcnNpb24gICAgICAgICAgdmVyc2lv bjsKKwkJc3RydWN0IGV0aG9zdV9jb3JlX21zZ19jYXBhYmlsaXRpZXNfcnNwIGNhcGFiaWxpdGll czsKKwl9IGRhdGE7CisKKwkvKiBSZWFkIG1lc3NhZ2UgKi8KKwlyZXQgPSBldGhvc3VfbWFpbGJv eF9yZWFkKCZlZGV2LT5tYWlsYm94LCAmaGVhZGVyLCAmZGF0YSwgc2l6ZW9mKGRhdGEpKTsKKwlp ZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJc3dpdGNoIChoZWFkZXIudHlwZSkgeworCWNhc2Ug RVRIT1NVX0NPUkVfTVNHX0VSUjoKKwkJaWYgKGhlYWRlci5sZW5ndGggIT0gc2l6ZW9mKGRhdGEu ZXJyb3IpKSB7CisJCQlkZXZfd2FybihlZGV2LT5kZXYsCisJCQkJICJNc2c6IEVycm9yIG1lc3Nh Z2Ugb2YgaW5jb3JyZWN0IHNpemUuIHNpemU9JXUsIGV4cGVjdGVkPSV6dVxuIiwgaGVhZGVyLmxl bmd0aCwKKwkJCQkgc2l6ZW9mKGRhdGEuZXJyb3IpKTsKKwkJCXJldCA9IC1FQkFETVNHOworCQkJ YnJlYWs7CisJCX0KKworCQlkYXRhLmVycm9yLm1zZ1tzaXplb2YoZGF0YS5lcnJvci5tc2cpIC0g MV0gPSAnXDAnOworCQlkZXZfd2FybihlZGV2LT5kZXYsICJNc2c6IEVycm9yLiB0eXBlPSV1LCBt c2c9XCIlc1wiXG4iLAorCQkJIGRhdGEuZXJyb3IudHlwZSwgZGF0YS5lcnJvci5tc2cpOworCQly ZXQgPSAtRUJBRE1TRzsKKwkJYnJlYWs7CisJY2FzZSBFVEhPU1VfQ09SRV9NU0dfUElORzoKKwkJ ZGV2X2luZm8oZWRldi0+ZGV2LCAiTXNnOiBQaW5nXG4iKTsKKwkJcmV0ID0gZXRob3N1X21haWxi b3hfcG9uZygmZWRldi0+bWFpbGJveCk7CisJCWJyZWFrOworCWNhc2UgRVRIT1NVX0NPUkVfTVNH X1BPTkc6CisJCWRldl9pbmZvKGVkZXYtPmRldiwgIk1zZzogUG9uZ1xuIik7CisJCWJyZWFrOwor CWNhc2UgRVRIT1NVX0NPUkVfTVNHX0lORkVSRU5DRV9SU1A6CisJCWlmIChoZWFkZXIubGVuZ3Ro ICE9IHNpemVvZihkYXRhLmluZikpIHsKKwkJCWRldl93YXJuKGVkZXYtPmRldiwKKwkJCQkgIk1z ZzogSW5mZXJlbmNlIHJlc3BvbnNlIG9mIGluY29ycmVjdCBzaXplLiBzaXplPSV1LCBleHBlY3Rl ZD0lenVcbiIsIGhlYWRlci5sZW5ndGgsCisJCQkJIHNpemVvZihkYXRhLmluZikpOworCQkJcmV0 ID0gLUVCQURNU0c7CisJCQlicmVhazsKKwkJfQorCisJCWRldl9pbmZvKGVkZXYtPmRldiwKKwkJ CSAiTXNnOiBJbmZlcmVuY2UgcmVzcG9uc2UuIHVzZXJfYXJnPTB4JWxseCwgb2ZtX2NvdW50PSV1 LCBzdGF0dXM9JXVcbiIsCisJCQkgZGF0YS5pbmYudXNlcl9hcmcsIGRhdGEuaW5mLm9mbV9jb3Vu dCwKKwkJCSBkYXRhLmluZi5zdGF0dXMpOworCQlldGhvc3VfaW5mZXJlbmNlX3JzcChlZGV2LCAm ZGF0YS5pbmYpOworCQlicmVhazsKKwljYXNlIEVUSE9TVV9DT1JFX01TR19WRVJTSU9OX1JTUDoK KwkJaWYgKGhlYWRlci5sZW5ndGggIT0gc2l6ZW9mKGRhdGEudmVyc2lvbikpIHsKKwkJCWRldl93 YXJuKGVkZXYtPmRldiwKKwkJCQkgIk1zZzogVmVyc2lvbiByZXNwb25zZSBvZiBpbmNvcnJlY3Qg c2l6ZS4gc2l6ZT0ldSwgZXhwZWN0ZWQ9JXp1XG4iLCBoZWFkZXIubGVuZ3RoLAorCQkJCSBzaXpl b2YoZGF0YS52ZXJzaW9uKSk7CisJCQlyZXQgPSAtRUJBRE1TRzsKKwkJCWJyZWFrOworCQl9CisK KwkJZGV2X2luZm8oZWRldi0+ZGV2LCAiTXNnOiBWZXJzaW9uIHJlc3BvbnNlIHYldS4ldS4ldVxu IiwKKwkJCSBkYXRhLnZlcnNpb24ubWFqb3IsIGRhdGEudmVyc2lvbi5taW5vciwKKwkJCSBkYXRh LnZlcnNpb24ucGF0Y2gpOworCisJCS8qIENoZWNrIG1ham9yIGFuZCBtaW5vciB2ZXJzaW9uIG1h dGNoLCBlbHNlIHJldHVybiBlcnJvciAqLworCQlpZiAoZGF0YS52ZXJzaW9uLm1ham9yICE9IEVU SE9TVV9DT1JFX01TR19WRVJTSU9OX01BSk9SIHx8CisJCSAgICBkYXRhLnZlcnNpb24ubWlub3Ig IT0gRVRIT1NVX0NPUkVfTVNHX1ZFUlNJT05fTUlOT1IpIHsKKwkJCWRldl93YXJuKGVkZXYtPmRl diwgIk1zZzogVmVyc2lvbiBtaXNtYXRjaCBkZXRlY3RlZCEgIik7CisJCQlkZXZfd2FybihlZGV2 LT5kZXYsICJMb2NhbCB2ZXJzaW9uOiB2JXUuJXUuJXVcbiIsCisJCQkJIEVUSE9TVV9DT1JFX01T R19WRVJTSU9OX01BSk9SLAorCQkJCSBFVEhPU1VfQ09SRV9NU0dfVkVSU0lPTl9NSU5PUiwKKwkJ CQkgRVRIT1NVX0NPUkVfTVNHX1ZFUlNJT05fUEFUQ0gpOworCQl9CisKKwkJYnJlYWs7CisJY2Fz ZSBFVEhPU1VfQ09SRV9NU0dfQ0FQQUJJTElUSUVTX1JTUDoKKwkJaWYgKGhlYWRlci5sZW5ndGgg IT0gc2l6ZW9mKGRhdGEuY2FwYWJpbGl0aWVzKSkgeworCQkJZGV2X3dhcm4oZWRldi0+ZGV2LAor CQkJCSAiTXNnOiBDYXBhYmlsaXRpZXMgcmVzcG9uc2Ugb2YgaW5jb3JyZWN0IHNpemUuIHNpemU9 JXUsIGV4cGVjdGVkPSV6dVxuIiwgaGVhZGVyLmxlbmd0aCwKKwkJCQkgc2l6ZW9mKGRhdGEuY2Fw YWJpbGl0aWVzKSk7CisJCQlyZXQgPSAtRUJBRE1TRzsKKwkJCWJyZWFrOworCQl9CisKKwkJZGV2 X2luZm8oZWRldi0+ZGV2LAorCQkJICJNc2c6IENhcGFiaWxpdGllcyByZXNwb25zZSB1YSVsbHgg dnMlaGh1IHYlaGh1LiVoaHUgcCVoaHUgYXYlaGh1LiVoaHUuJWhodSBkdiVoaHUuJWhodS4laGh1 IG1jYyVoaHUgY3N2JWhodSBjZCVoaHVcbiIsCisJCQkgZGF0YS5jYXBhYmlsaXRpZXMudXNlcl9h cmcsCisJCQkgZGF0YS5jYXBhYmlsaXRpZXMudmVyc2lvbl9zdGF0dXMsCisJCQkgZGF0YS5jYXBh YmlsaXRpZXMudmVyc2lvbl9tYWpvciwKKwkJCSBkYXRhLmNhcGFiaWxpdGllcy52ZXJzaW9uX21p bm9yLAorCQkJIGRhdGEuY2FwYWJpbGl0aWVzLnByb2R1Y3RfbWFqb3IsCisJCQkgZGF0YS5jYXBh YmlsaXRpZXMuYXJjaF9tYWpvcl9yZXYsCisJCQkgZGF0YS5jYXBhYmlsaXRpZXMuYXJjaF9taW5v cl9yZXYsCisJCQkgZGF0YS5jYXBhYmlsaXRpZXMuYXJjaF9wYXRjaF9yZXYsCisJCQkgZGF0YS5j YXBhYmlsaXRpZXMuZHJpdmVyX21ham9yX3JldiwKKwkJCSBkYXRhLmNhcGFiaWxpdGllcy5kcml2 ZXJfbWlub3JfcmV2LAorCQkJIGRhdGEuY2FwYWJpbGl0aWVzLmRyaXZlcl9wYXRjaF9yZXYsCisJ CQkgZGF0YS5jYXBhYmlsaXRpZXMubWFjc19wZXJfY2MsCisJCQkgZGF0YS5jYXBhYmlsaXRpZXMu Y21kX3N0cmVhbV92ZXJzaW9uLAorCQkJIGRhdGEuY2FwYWJpbGl0aWVzLmN1c3RvbV9kbWEpOwor CisJCXJldCA9IGV0aG9zdV9jYXBhYmlsaXR5X3JzcChlZGV2LCAmZGF0YS5jYXBhYmlsaXRpZXMp OworCQlicmVhazsKKwlkZWZhdWx0OgorCQkvKiBUaGlzIHNob3VsZCBub3QgaGFwcGVuIGR1ZSB0 byB2ZXJzaW9uIGNoZWNrcyAqLworCQlkZXZfd2FybihlZGV2LT5kZXYsICJNc2c6IFByb3RvY29s IGVycm9yXG4iKTsKKwkJcmV0ID0gLUVQUk9UTzsKKwkJYnJlYWs7CisJfQorCisJcmV0dXJuIHJl dDsKK30KKworc3RhdGljIGludCBldGhvc3Vfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLAorCQkg ICAgICAgc3RydWN0IGZpbGUgKmZpbGUpCit7CisJc3RydWN0IGV0aG9zdV9kZXZpY2UgKmVkZXYg PQorCQljb250YWluZXJfb2YoaW5vZGUtPmlfY2Rldiwgc3RydWN0IGV0aG9zdV9kZXZpY2UsIGNk ZXYpOworCisJZmlsZS0+cHJpdmF0ZV9kYXRhID0gZWRldjsKKworCWRldl9pbmZvKGVkZXYtPmRl diwgIk9wZW5pbmcgZGV2aWNlIG5vZGUuXG4iKTsKKworCXJldHVybiBub25zZWVrYWJsZV9vcGVu KGlub2RlLCBmaWxlKTsKK30KKworc3RhdGljIGludCBldGhvc3Vfc2VuZF9jYXBhYmlsaXRpZXNf cmVxdWVzdChzdHJ1Y3QgZXRob3N1X2RldmljZSAqZWRldiwKKwkJCQkJICAgIHZvaWQgX191c2Vy ICp1ZGF0YSkKK3sKKwlzdHJ1Y3QgZXRob3N1X3VhcGlfZGV2aWNlX2NhcGFiaWxpdGllcyB1YXBp OworCXN0cnVjdCBldGhvc3VfY2FwYWJpbGl0aWVzICpjYXA7CisJaW50IHJldDsKKwlpbnQgdGlt ZW91dDsKKworCWNhcCA9IGRldm1fa3phbGxvYyhlZGV2LT5kZXYsIHNpemVvZihzdHJ1Y3QgZXRo b3N1X2NhcGFiaWxpdGllcyksCisJCQkgICBHRlBfS0VSTkVMKTsKKwlpZiAoIWNhcCkKKwkJcmV0 dXJuIC1FTk9NRU07CisKKwljYXAtPmVkZXYgPSBlZGV2OworCWNhcC0+Y2FwYWJpbGl0aWVzID0g JnVhcGk7CisJa3JlZl9pbml0KCZjYXAtPnJlZmNvdW50KTsKKwlpbml0X2NvbXBsZXRpb24oJmNh cC0+ZG9uZSk7CisJbGlzdF9hZGQoJmNhcC0+bGlzdCwgJmVkZXYtPmNhcGFiaWxpdGllc19saXN0 KTsKKworCXJldCA9IGV0aG9zdV9tYWlsYm94X2NhcGFiaWxpdGllc19yZXF1ZXN0KCZlZGV2LT5t YWlsYm94LCBjYXApOworCWlmICgwICE9IHJldCkKKwkJZ290byBwdXRfa3JlZjsKKworCS8qCisJ ICogSW5jcmVhc2UgcmVmIGNvdW50ZXIgc2luY2Ugd2Ugc2VudCB0aGUgcG9pbnRlciBvdXQgdG8K KwkgKiByZXNwb25zZSBoYW5kbGVyIHRocmVhZC4gVGhhdCB0aHJlYWQgaXMgcmVzcG9uc2libGUg dG8KKwkgKiBkZWNyZWFzZSB0aGUgcmVmIGNvdW50ZXIgYmVmb3JlIGV4aXRpbmcuIFNvIHRoZSBt ZW1vcnkKKwkgKiBjYW4gYmUgZnJlZWQuCisJICoKKwkgKiBOT1RFOiBpZiBubyByZXNwb25zZSBp cyByZWNlaXZlZCBiYWNrLCB0aGUgbWVtb3J5IGlzIGxlYWtlZC4KKwkgKi8KKwlrcmVmX2dldCgm Y2FwLT5yZWZjb3VudCk7CisJLyogVW5sb2NrIHRoZSBtdXRleCBiZWZvcmUgZ29pbmcgdG8gYmxv Y2sgb24gdGhlIGNvbmRpdGlvbiAqLworCW11dGV4X3VubG9jaygmZWRldi0+bXV0ZXgpOworCS8q IHdhaXQgZm9yIHJlc3BvbnNlIHRvIGFycml2ZSBiYWNrICovCisJdGltZW91dCA9IHdhaXRfZm9y X2NvbXBsZXRpb25fdGltZW91dCgmY2FwLT5kb25lLAorCQkJCQkgICAgICBtc2Vjc190b19qaWZm aWVzKAorCQkJCQkJICAgICAgQ0FQQUJJTElUSUVTX1JFU1BfVElNRU9VVF9NUykpOworCS8qIHRh a2UgYmFjayB0aGUgbXV0ZXggYmVmb3JlIHJlc3VtaW5nIHRvIGRvIGFueXRoaW5nICovCisJcmV0 ID0gbXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZlZGV2LT5tdXRleCk7CisJaWYgKDAgIT0gcmV0 KQorCQlnb3RvIHB1dF9rcmVmOworCisJaWYgKDAgPT0gdGltZW91dCAvKiB0aW1lZCBvdXQqLykg eworCQlkZXZfd2FybihlZGV2LT5kZXYsCisJCQkgIk1zZzogQ2FwYWJpbGl0aWVzIHJlc3BvbnNl IGxvc3QgLSB0aW1lb3V0XG4iKTsKKwkJcmV0ID0gLUVJTzsKKwkJZ290byBwdXRfa3JlZjsKKwl9 CisKKwlyZXQgPSBjb3B5X3RvX3VzZXIodWRhdGEsICZ1YXBpLCBzaXplb2YodWFwaSkpID8gLUVG QVVMVCA6IDA7CisKK3B1dF9rcmVmOgorCWtyZWZfcHV0KCZjYXAtPnJlZmNvdW50LCBldGhvc3Vf Y2FwYWJpbGl0aWVzX2Rlc3Ryb3kpOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIGxvbmcg ZXRob3N1X2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLAorCQkJIHVuc2lnbmVkIGludCBjbWQsCisJ CQkgdW5zaWduZWQgbG9uZyBhcmcpCit7CisJc3RydWN0IGV0aG9zdV9kZXZpY2UgKmVkZXYgPSBm aWxlLT5wcml2YXRlX2RhdGE7CisJdm9pZCBfX3VzZXIgKnVkYXRhID0gKHZvaWQgX191c2VyICop YXJnOworCWludCByZXQgPSAtRUlOVkFMOworCisJcmV0ID0gbXV0ZXhfbG9ja19pbnRlcnJ1cHRp YmxlKCZlZGV2LT5tdXRleCk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCWRldl9pbmZv KGVkZXYtPmRldiwgIklvY3RsLiBjbWQ9JXUsIGFyZz0lbHVcbiIsIGNtZCwgYXJnKTsKKworCXN3 aXRjaCAoY21kKSB7CisJY2FzZSBFVEhPU1VfSU9DVExfVkVSU0lPTl9SRVE6CisJCWRldl9pbmZv KGVkZXYtPmRldiwgIklvY3RsOiBTZW5kIHZlcnNpb24gcmVxdWVzdFxuIik7CisJCXJldCA9IGV0 aG9zdV9tYWlsYm94X3ZlcnNpb25fcmVxdWVzdCgmZWRldi0+bWFpbGJveCk7CisJCWJyZWFrOwor CWNhc2UgRVRIT1NVX0lPQ1RMX0NBUEFCSUxJVElFU19SRVE6CisJCWRldl9pbmZvKGVkZXYtPmRl diwgIklvY3RsOiBTZW5kIGNhcGFiaWxpdGllcyByZXF1ZXN0XG4iKTsKKwkJcmV0ID0gZXRob3N1 X3NlbmRfY2FwYWJpbGl0aWVzX3JlcXVlc3QoZWRldiwgdWRhdGEpOworCQlicmVhazsKKwljYXNl IEVUSE9TVV9JT0NUTF9QSU5HOiB7CisJCWRldl9pbmZvKGVkZXYtPmRldiwgIklvY3RsOiBTZW5k IHBpbmdcbiIpOworCQlyZXQgPSBldGhvc3VfbWFpbGJveF9waW5nKCZlZGV2LT5tYWlsYm94KTsK KwkJYnJlYWs7CisJfQorCWNhc2UgRVRIT1NVX0lPQ1RMX0JVRkZFUl9DUkVBVEU6IHsKKwkJc3Ry dWN0IGV0aG9zdV91YXBpX2J1ZmZlcl9jcmVhdGUgdWFwaTsKKworCQlkZXZfaW5mbyhlZGV2LT5k ZXYsICJJb2N0bDogQnVmZmVyIGNyZWF0ZVxuIik7CisKKwkJaWYgKGNvcHlfZnJvbV91c2VyKCZ1 YXBpLCB1ZGF0YSwgc2l6ZW9mKHVhcGkpKSkKKwkJCWJyZWFrOworCisJCWRldl9pbmZvKGVkZXYt PmRldiwgIklvY3RsOiBCdWZmZXIuIGNhcGFjaXR5PSV1XG4iLAorCQkJIHVhcGkuY2FwYWNpdHkp OworCisJCXJldCA9IGV0aG9zdV9idWZmZXJfY3JlYXRlKGVkZXYsIHVhcGkuY2FwYWNpdHkpOwor CQlicmVhazsKKwl9CisJY2FzZSBFVEhPU1VfSU9DVExfTkVUV09SS19DUkVBVEU6IHsKKwkJc3Ry dWN0IGV0aG9zdV91YXBpX25ldHdvcmtfY3JlYXRlIHVhcGk7CisKKwkJaWYgKGNvcHlfZnJvbV91 c2VyKCZ1YXBpLCB1ZGF0YSwgc2l6ZW9mKHVhcGkpKSkKKwkJCWJyZWFrOworCisJCWRldl9pbmZv KGVkZXYtPmRldiwgIklvY3RsOiBOZXR3b3JrLiBmZD0ldVxuIiwgdWFwaS5mZCk7CisKKwkJcmV0 ID0gZXRob3N1X25ldHdvcmtfY3JlYXRlKGVkZXYsICZ1YXBpKTsKKwkJYnJlYWs7CisJfQorCWRl ZmF1bHQ6IHsKKwkJZGV2X2VycihlZGV2LT5kZXYsICJJbnZhbGlkIGlvY3RsLiBjbWQ9JXUsIGFy Zz0lbHUiLAorCQkJY21kLCBhcmcpOworCQlicmVhazsKKwl9CisJfQorCisJbXV0ZXhfdW5sb2Nr KCZlZGV2LT5tdXRleCk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCBldGhvc3Vf bWJveF9yeCh2b2lkICp1c2VyX2FyZykKK3sKKwlzdHJ1Y3QgZXRob3N1X2RldmljZSAqZWRldiA9 IHVzZXJfYXJnOworCWludCByZXQ7CisKKwltdXRleF9sb2NrKCZlZGV2LT5tdXRleCk7CisKKwlk byB7CisJCXJldCA9IGV0aG9zdV9oYW5kbGVfbXNnKGVkZXYpOworCQlpZiAocmV0ICYmIHJldCAh PSAtRU5PTVNHKQorCQkJLyogTmVlZCB0byBzdGFydCBvdmVyIGluIGNhc2Ugb2YgZXJyb3IsIGVt cHR5IHRoZSBxdWV1ZQorCQkJICogYnkgZmFzdC1mb3J3YXJkaW5nIHJlYWQgcG9zaXRpb24gdG8g d3JpdGUgcG9zaXRpb24uCisJCQkgKiAqLworCQkJZXRob3N1X21haWxib3hfcmVzZXQoJmVkZXYt Pm1haWxib3gpOworCX0gd2hpbGUgKHJldCA9PSAwKTsKKworCW11dGV4X3VubG9jaygmZWRldi0+ bXV0ZXgpOworfQorCitpbnQgZXRob3N1X2Rldl9pbml0KHN0cnVjdCBldGhvc3VfZGV2aWNlICpl ZGV2LAorCQkgICAgc3RydWN0IGRldmljZSAqZGV2LAorCQkgICAgc3RydWN0IGNsYXNzICpjbGFz cywKKwkJICAgIGRldl90IGRldnQsCisJCSAgICBzdHJ1Y3QgcmVzb3VyY2UgKmluX3F1ZXVlLAor CQkgICAgc3RydWN0IHJlc291cmNlICpvdXRfcXVldWUpCit7CisJc3RhdGljIGNvbnN0IHN0cnVj dCBmaWxlX29wZXJhdGlvbnMgZm9wcyA9IHsKKwkJLm93bmVyICAgICAgICAgID0gVEhJU19NT0RV TEUsCisJCS5vcGVuICAgICAgICAgICA9ICZldGhvc3Vfb3BlbiwKKwkJLnVubG9ja2VkX2lvY3Rs ID0gJmV0aG9zdV9pb2N0bCwKKyNpZmRlZiBDT05GSUdfQ09NUEFUCisJCS5jb21wYXRfaW9jdGwg ICA9ICZldGhvc3VfaW9jdGwsCisjZW5kaWYKKwl9OworCXN0cnVjdCBkZXZpY2UgKnN5c2RldjsK KwlpbnQgcmV0OworCisJZWRldi0+ZGV2ID0gZGV2OworCWVkZXYtPmNsYXNzID0gY2xhc3M7CisJ ZWRldi0+ZGV2dCA9IGRldnQ7CisJbXV0ZXhfaW5pdCgmZWRldi0+bXV0ZXgpOworCUlOSVRfTElT VF9IRUFEKCZlZGV2LT5jYXBhYmlsaXRpZXNfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJmVkZXYt PmluZmVyZW5jZV9saXN0KTsKKworCXJldCA9IG9mX3Jlc2VydmVkX21lbV9kZXZpY2VfaW5pdChl ZGV2LT5kZXYpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlkbWFfc2V0X21hc2tfYW5k X2NvaGVyZW50KGVkZXYtPmRldiwgRE1BX0JJVF9NQVNLKERNQV9BRERSX0JJVFMpKTsKKworCXJl dCA9IGV0aG9zdV9tYWlsYm94X2luaXQoJmVkZXYtPm1haWxib3gsIGRldiwgaW5fcXVldWUsIG91 dF9xdWV1ZSwKKwkJCQkgIGV0aG9zdV9tYm94X3J4LCBlZGV2KTsKKwlpZiAocmV0KQorCQlnb3Rv IHJlbGVhc2VfcmVzZXJ2ZWRfbWVtOworCisJY2Rldl9pbml0KCZlZGV2LT5jZGV2LCAmZm9wcyk7 CisJZWRldi0+Y2Rldi5vd25lciA9IFRISVNfTU9EVUxFOworCisJcmV0ID0gY2Rldl9hZGQoJmVk ZXYtPmNkZXYsIGVkZXYtPmRldnQsIDEpOworCWlmIChyZXQpIHsKKwkJZGV2X2VycihlZGV2LT5k ZXYsICJGYWlsZWQgdG8gYWRkIGNoYXJhY3RlciBkZXZpY2UuXG4iKTsKKwkJZ290byBkZWluaXRf bWFpbGJveDsKKwl9CisKKwlzeXNkZXYgPSBkZXZpY2VfY3JlYXRlKGVkZXYtPmNsYXNzLCBOVUxM LCBlZGV2LT5kZXZ0LCBlZGV2LAorCQkJICAgICAgICJldGhvc3UlZCIsIE1JTk9SKGVkZXYtPmRl dnQpKTsKKwlpZiAoSVNfRVJSKHN5c2RldikpIHsKKwkJZGV2X2VycihlZGV2LT5kZXYsICJGYWls ZWQgdG8gY3JlYXRlIGRldmljZS5cbiIpOworCQlyZXQgPSBQVFJfRVJSKHN5c2Rldik7CisJCWdv dG8gZGVsX2NkZXY7CisJfQorCisJZGV2X2luZm8oZWRldi0+ZGV2LAorCQkgIkNyZWF0ZWQgQXJt IEV0aG9zLVUgZGV2aWNlLiBuYW1lPSVzLCBtYWpvcj0lZCwgbWlub3I9JWRcbiIsCisJCSBkZXZf bmFtZShzeXNkZXYpLCBNQUpPUihlZGV2LT5kZXZ0KSwgTUlOT1IoZWRldi0+ZGV2dCkpOworCisJ cmV0dXJuIDA7CisKK2RlbF9jZGV2OgorCWNkZXZfZGVsKCZlZGV2LT5jZGV2KTsKKworZGVpbml0 X21haWxib3g6CisJZXRob3N1X21haWxib3hfZGVpbml0KCZlZGV2LT5tYWlsYm94KTsKKworcmVs ZWFzZV9yZXNlcnZlZF9tZW06CisJb2ZfcmVzZXJ2ZWRfbWVtX2RldmljZV9yZWxlYXNlKGVkZXYt PmRldik7CisKKwlyZXR1cm4gcmV0OworfQorCit2b2lkIGV0aG9zdV9kZXZfZGVpbml0KHN0cnVj dCBldGhvc3VfZGV2aWNlICplZGV2KQoreworCWV0aG9zdV9tYWlsYm94X2RlaW5pdCgmZWRldi0+ bWFpbGJveCk7CisJZGV2aWNlX2Rlc3Ryb3koZWRldi0+Y2xhc3MsIGVkZXYtPmNkZXYuZGV2KTsK KwljZGV2X2RlbCgmZWRldi0+Y2Rldik7CisJb2ZfcmVzZXJ2ZWRfbWVtX2RldmljZV9yZWxlYXNl KGVkZXYtPmRldik7CisKKwlkZXZfaW5mbyhlZGV2LT5kZXYsICIlc1xuIiwgX19GVU5DVElPTl9f KTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9kZXZpY2Uu aCBiL2RyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9kZXZpY2UuaApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjNhZmRkYTg0ODYyZAotLS0gL2Rldi9udWxsCisr KyBiL2RyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9kZXZpY2UuaApAQCAtMCwwICsxLDg4 IEBACisvKgorICogKEMpIENPUFlSSUdIVCAyMDIwIEFSTSBMaW1pdGVkLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlIGFuZCBpcyBwcm92 aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZQorICogR05VIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQorICog Rm91bmRhdGlvbiwgYW5kIGFueSB1c2UgYnkgeW91IG9mIHRoaXMgcHJvZ3JhbSBpcyBzdWJqZWN0 IHRvIHRoZSB0ZXJtcworICogb2Ygc3VjaCBHTlUgbGljZW5jZS4KKyAqCisgKiBUaGlzIHByb2dy YW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAq IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRl dGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05V IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBu b3QsIHlvdSBjYW4gYWNjZXNzIGl0IG9ubGluZSBhdAorICogaHR0cDovL3d3dy5nbnUub3JnL2xp Y2Vuc2VzL2dwbC0yLjAuaHRtbC4KKyAqCisgKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BM LTIuMC1vbmx5CisgKi8KKworI2lmbmRlZiBFVEhPU1VfREVWSUNFX0gKKyNkZWZpbmUgRVRIT1NV X0RFVklDRV9ICisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBJbmNsdWRlcworICoqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKiovCisKKyNpbmNsdWRlICJ1YXBpL2V0aG9zdS5oIgorI2luY2x1ZGUgImV0aG9z dV9tYWlsYm94LmgiCisKKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51 eC9jZGV2Lmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9tdXRleC5o PgorI2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgorI2luY2x1ZGUgPGxpbnV4L2NvbXBsZXRp b24uaD4KKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIFR5cGVzCisgKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKi8KKworLyoqCisgKiBzdHJ1Y3QgZXRob3N1X2RldmljZSAtIERldmljZSBzdHJ1Y3R1cmUK KyAqLworc3RydWN0IGV0aG9zdV9kZXZpY2UgeworCXN0cnVjdCBkZXZpY2UgICAgICAgICAqZGV2 OworCXN0cnVjdCBjZGV2ICAgICAgICAgICBjZGV2OworCXN0cnVjdCAgICAgICAgICAgICAgICBj bGFzcyAqY2xhc3M7CisJZGV2X3QgICAgICAgICAgICAgICAgIGRldnQ7CisJc3RydWN0IG11dGV4 ICAgICAgICAgIG11dGV4OworCXN0cnVjdCBldGhvc3VfbWFpbGJveCBtYWlsYm94OworCXN0cnVj dCBsaXN0X2hlYWQgICAgICBjYXBhYmlsaXRpZXNfbGlzdDsKKwlzdHJ1Y3QgbGlzdF9oZWFkICAg ICAgaW5mZXJlbmNlX2xpc3Q7Cit9OworCisvKioKKyAqIHN0cnVjdCBldGhvc3VfY2FwYWJpbGl0 aWVzIC0gQ2FwYWJpbGl0aWVzIGludGVybmFsIHN0cnVjdAorICovCitzdHJ1Y3QgZXRob3N1X2Nh cGFiaWxpdGllcyB7CisJc3RydWN0IGV0aG9zdV9kZXZpY2UgICAgICAgICAgICAgICAgICAgKmVk ZXY7CisJc3RydWN0IGNvbXBsZXRpb24gICAgICAgICAgICAgICAgICAgICAgZG9uZTsKKwlzdHJ1 Y3Qga3JlZiAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWZjb3VudDsKKwlzdHJ1Y3QgZXRo b3N1X3VhcGlfZGV2aWNlX2NhcGFiaWxpdGllcyAqY2FwYWJpbGl0aWVzOworCXN0cnVjdCBsaXN0 X2hlYWQgICAgICAgICAgICAgICAgICAgICAgIGxpc3Q7Cit9OworCisvKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKgorICogRnVuY3Rpb25zCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworLyoqCisgKiBldGhv c3VfZGV2X2luaXQoKSAtIEluaXRpYWxpemUgdGhlIGRldmljZQorICoKKyAqIFJldHVybjogMCBv biBzdWNjZXNzLCBlbHNlIGVycm9yIGNvZGUuCisgKi8KK2ludCBldGhvc3VfZGV2X2luaXQoc3Ry dWN0IGV0aG9zdV9kZXZpY2UgKmVkZXYsCisJCSAgICBzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCSAg ICBzdHJ1Y3QgY2xhc3MgKmNsYXNzLAorCQkgICAgZGV2X3QgZGV2dCwKKwkJICAgIHN0cnVjdCBy ZXNvdXJjZSAqaW5fcXVldWUsCisJCSAgICBzdHJ1Y3QgcmVzb3VyY2UgKm91dF9xdWV1ZSk7CisK Ky8qKgorICogZXRob3N1X2Rldl9kZWluaXQoKSAtIEluaXRpYWxpemUgdGhlIGRldmljZQorICov Cit2b2lkIGV0aG9zdV9kZXZfZGVpbml0KHN0cnVjdCBldGhvc3VfZGV2aWNlICplZGV2KTsKKwor I2VuZGlmIC8qIEVUSE9TVV9ERVZJQ0VfSCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9maXJtd2Fy ZS9ldGhvc3UvZXRob3N1X2RyaXZlci5jIGIvZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvZXRob3N1 X2RyaXZlci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uOWQwMjQz MWQzMTk0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvZXRob3N1 X2RyaXZlci5jCkBAIC0wLDAgKzEsMTkxIEBACisvKgorICogKEMpIENPUFlSSUdIVCAyMDIwIEFS TSBMaW1pdGVkLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBm cmVlIHNvZnR3YXJlIGFuZCBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZCBi eSB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgYW5kIGFueSB1c2UgYnkgeW91IG9m IHRoaXMgcHJvZ3JhbSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcworICogb2Ygc3VjaCBHTlUgbGlj ZW5jZS4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhh dCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91 dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJl Y2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25n IHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHlvdSBjYW4gYWNjZXNzIGl0IG9ubGluZSBhdAor ICogaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL2dwbC0yLjAuaHRtbC4KKyAqCisgKiBTUERY LUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CisgKi8KKworI2luY2x1ZGUgPGxpbnV4 L2JpdG1hcC5oPgorI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CisjaW5jbHVkZSA8bGludXgvbW9kdWxl Lmg+CisjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9vZi5oPgorI2luY2x1 ZGUgPGxpbnV4L29mX2FkZHJlc3MuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2Uu aD4KKworI2luY2x1ZGUgImV0aG9zdV9kZXZpY2UuaCIKKworLyoqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioK KyAqIERlZmluZXMKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisjZGVmaW5lIEVUSE9TVV9EUklW RVJfVkVSU0lPTiAiMS4wIgorI2RlZmluZSBFVEhPU1VfRFJJVkVSX05BTUUgICAgImV0aG9zdSIK KworI2RlZmluZSBNSU5PUl9CQVNFICAgICAgMCAvKiBNaW5vciB2ZXJzaW9uIHN0YXJ0cyBhdCAw ICovCisjZGVmaW5lIE1JTk9SX0NPVU5UICAgIDY0IC8qIEFsbG9jYXRlIG1pbm9yIHZlcnNpb25z ICovCisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBWYXJpYWJsZXMKKyAqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqLworCitzdGF0aWMgc3RydWN0IGNsYXNzICpldGhvc3VfY2xhc3M7CisKK3N0YXRpYyBk ZXZfdCBkZXZ0OworCitzdGF0aWMgREVDTEFSRV9CSVRNQVAobWlub3JzLCBNSU5PUl9DT1VOVCk7 CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqCisgKiBBcm0gRXRob3MtVQorICoqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKiovCisKK3N0YXRpYyBpbnQgZXRob3N1X3BkZXZfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikKK3sKKwlzdHJ1Y3QgZXRob3N1X2RldmljZSAqZWRldjsKKwlzdHJ1Y3QgcmVz b3VyY2UgKmluX3F1ZXVlX3JlczsKKwlzdHJ1Y3QgcmVzb3VyY2UgKm91dF9xdWV1ZV9yZXM7CisJ aW50IG1pbm9yOworCWludCByZXQ7CisKKwlkZXZfaW5mbygmcGRldi0+ZGV2LCAiUHJvYmVcbiIp OworCisJbWlub3IgPSBmaW5kX2ZpcnN0X3plcm9fYml0KG1pbm9ycywgTUlOT1JfQ09VTlQpOwor CWlmIChtaW5vciA+PSBNSU5PUl9DT1VOVCkgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJObyBt b3JlIG1pbm9yIG51bWJlcnMuXG4iKTsKKworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwkvKiBH ZXQgcGF0aCB0byBUQ00gbWVtb3J5ICovCisJaW5fcXVldWVfcmVzID0gcGxhdGZvcm1fZ2V0X3Jl c291cmNlX2J5bmFtZShwZGV2LCBJT1JFU09VUkNFX01FTSwKKwkJCQkJCSAgICAiaW5fcXVldWUi KTsKKwlpZiAoSVNfRVJSKGluX3F1ZXVlX3JlcykpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAi RmFpbGVkIHRvIGdldCBpbl9xdWV1ZSByZXNvdXJjZS5cbiIpOworCisJCXJldHVybiBQVFJfRVJS KGluX3F1ZXVlX3Jlcyk7CisJfQorCisJb3V0X3F1ZXVlX3JlcyA9IHBsYXRmb3JtX2dldF9yZXNv dXJjZV9ieW5hbWUocGRldiwgSU9SRVNPVVJDRV9NRU0sCisJCQkJCQkgICAgICJvdXRfcXVldWUi KTsKKwlpZiAoSVNfRVJSKG91dF9xdWV1ZV9yZXMpKSB7CisJCWRldl9lcnIoJnBkZXYtPmRldiwg IkZhaWxlZCB0byBnZXQgb3V0X3F1ZXVlIHJlc291cmNlLlxuIik7CisKKwkJcmV0dXJuIFBUUl9F UlIob3V0X3F1ZXVlX3Jlcyk7CisJfQorCisJLyogQWxsb2NhdGUgbWVtb3J5IGZvciBBcm0gRXRo b3MtVSBkZXZpY2UgKi8KKwllZGV2ID0gZGV2bV9remFsbG9jKCZwZGV2LT5kZXYsIHNpemVvZigq ZWRldiksIEdGUF9LRVJORUwpOworCWlmICghZWRldikKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlw bGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBlZGV2KTsKKworCS8qIEluaXRpYWxpemUgZGV2aWNl ICovCisJcmV0ID0gZXRob3N1X2Rldl9pbml0KGVkZXYsICZwZGV2LT5kZXYsIGV0aG9zdV9jbGFz cywKKwkJCSAgICAgIE1LREVWKE1BSk9SKGRldnQpLCBtaW5vciksIGluX3F1ZXVlX3JlcywKKwkJ CSAgICAgIG91dF9xdWV1ZV9yZXMpOworCWlmIChyZXQpCisJCWdvdG8gZnJlZV9kZXY7CisKKwlz ZXRfYml0KG1pbm9yLCBtaW5vcnMpOworCisJcmV0dXJuIDA7CisKK2ZyZWVfZGV2OgorCWRldm1f a2ZyZWUoJnBkZXYtPmRldiwgZWRldik7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50 IGV0aG9zdV9wZGV2X3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXN0 cnVjdCBldGhvc3VfZGV2aWNlICplZGV2ID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CisK KwljbGVhcl9iaXQoTUlOT1IoZWRldi0+ZGV2dCksIG1pbm9ycyk7CisJZXRob3N1X2Rldl9kZWlu aXQoZWRldik7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZp Y2VfaWQgZXRob3N1X3BkZXZfbWF0Y2hbXSA9IHsKKwl7IC5jb21wYXRpYmxlID0gImFybSxldGhv c3UiIH0sCisJeyAvKiBTZW50aW5lbCAqLyB9LAorfTsKKworTU9EVUxFX0RFVklDRV9UQUJMRShv ZiwgZXRob3N1X3BkZXZfbWF0Y2gpOworCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBl dGhvc3VfcGRldl9kcml2ZXIgPSB7CisJLnByb2JlICAgICAgICAgICAgICAgICAgPSAmZXRob3N1 X3BkZXZfcHJvYmUsCisJLnJlbW92ZSAgICAgICAgICAgICAgICAgPSAmZXRob3N1X3BkZXZfcmVt b3ZlLAorCS5kcml2ZXIgICAgICAgICAgICAgICAgID0geworCQkubmFtZSAgICAgICAgICAgPSBF VEhPU1VfRFJJVkVSX05BTUUsCisJCS5vd25lciAgICAgICAgICA9IFRISVNfTU9EVUxFLAorCQku b2ZfbWF0Y2hfdGFibGUgPSBvZl9tYXRjaF9wdHIoZXRob3N1X3BkZXZfbWF0Y2gpLAorCX0sCit9 OworCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKgorICogTW9kdWxlIGluaXQgYW5kIGV4aXQKKyAqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqLworCitzdGF0aWMgaW50IF9faW5pdCBldGhvc3VfaW5pdCh2b2lkKQor eworCWludCByZXQ7CisKKwlldGhvc3VfY2xhc3MgPSBjbGFzc19jcmVhdGUoVEhJU19NT0RVTEUs IEVUSE9TVV9EUklWRVJfTkFNRSk7CisJaWYgKElTX0VSUihldGhvc3VfY2xhc3MpKSB7CisJCXBy aW50aygiRmFpbGVkIHRvIGNyZWF0ZSBjbGFzcyAnJXMnLlxuIiwgRVRIT1NVX0RSSVZFUl9OQU1F KTsKKworCQlyZXR1cm4gUFRSX0VSUihldGhvc3VfY2xhc3MpOworCX0KKworCXJldCA9IGFsbG9j X2NocmRldl9yZWdpb24oJmRldnQsIE1JTk9SX0JBU0UsIE1JTk9SX0NPVU5ULAorCQkJCSAgRVRI T1NVX0RSSVZFUl9OQU1FKTsKKwlpZiAocmV0KSB7CisJCXByaW50aygiRmFpbGVkIHRvIGFsbG9j YXRlIGNocmRldiByZWdpb24uXG4iKTsKKwkJZ290byBkZXN0cm95X2NsYXNzOworCX0KKworCXJl dCA9IHBsYXRmb3JtX2RyaXZlcl9yZWdpc3RlcigmZXRob3N1X3BkZXZfZHJpdmVyKTsKKwlpZiAo cmV0KSB7CisJCXByaW50aygiRmFpbGVkIHRvIHJlZ2lzdGVyIEFybSBFdGhvcy1VIHBsYXRmb3Jt IGRyaXZlci5cbiIpOworCQlnb3RvIHJlZ2lvbl91bnJlZ2lzdGVyOworCX0KKworCXJldHVybiAw OworCityZWdpb25fdW5yZWdpc3RlcjoKKwl1bnJlZ2lzdGVyX2NocmRldl9yZWdpb24oZGV2dCwg TUlOT1JfQ09VTlQpOworCitkZXN0cm95X2NsYXNzOgorCWNsYXNzX2Rlc3Ryb3koZXRob3N1X2Ns YXNzKTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIF9fZXhpdCBldGhvc3VfZXhp dCh2b2lkKQoreworCXBsYXRmb3JtX2RyaXZlcl91bnJlZ2lzdGVyKCZldGhvc3VfcGRldl9kcml2 ZXIpOworCXVucmVnaXN0ZXJfY2hyZGV2X3JlZ2lvbihkZXZ0LCBNSU5PUl9DT1VOVCk7CisJY2xh c3NfZGVzdHJveShldGhvc3VfY2xhc3MpOworfQorCittb2R1bGVfaW5pdChldGhvc3VfaW5pdCkK K21vZHVsZV9leGl0KGV0aG9zdV9leGl0KQorTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOworTU9E VUxFX0FVVEhPUigiQXJtIEx0ZCIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJBcm0gRXRob3MtVSBO UFUgRHJpdmVyIik7CitNT0RVTEVfVkVSU0lPTihFVEhPU1VfRFJJVkVSX1ZFUlNJT04pOwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvZXRob3N1X2luZmVyZW5jZS5jIGIvZHJp dmVycy9maXJtd2FyZS9ldGhvc3UvZXRob3N1X2luZmVyZW5jZS5jCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNmZkZTkyYzE0OGEwCi0tLSAvZGV2L251bGwKKysrIGIv ZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvZXRob3N1X2luZmVyZW5jZS5jCkBAIC0wLDAgKzEsNDE3 IEBACisvKgorICogKEMpIENPUFlSSUdIVCAyMDIwIEFSTSBMaW1pdGVkLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlIGFuZCBpcyBwcm92 aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZQorICogR05VIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQorICog Rm91bmRhdGlvbiwgYW5kIGFueSB1c2UgYnkgeW91IG9mIHRoaXMgcHJvZ3JhbSBpcyBzdWJqZWN0 IHRvIHRoZSB0ZXJtcworICogb2Ygc3VjaCBHTlUgbGljZW5jZS4KKyAqCisgKiBUaGlzIHByb2dy YW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAq IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRl dGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05V IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBu b3QsIHlvdSBjYW4gYWNjZXNzIGl0IG9ubGluZSBhdAorICogaHR0cDovL3d3dy5nbnUub3JnL2xp Y2Vuc2VzL2dwbC0yLjAuaHRtbC4KKyAqCisgKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BM LTIuMC1vbmx5CisgKi8KKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIEluY2x1ZGVzCisgKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKi8KKworI2luY2x1ZGUgImV0aG9zdV9pbmZlcmVuY2UuaCIKKworI2lu Y2x1ZGUgImV0aG9zdV9idWZmZXIuaCIKKyNpbmNsdWRlICJldGhvc3VfY29yZV9pbnRlcmZhY2Uu aCIKKyNpbmNsdWRlICJldGhvc3VfZGV2aWNlLmgiCisjaW5jbHVkZSAiZXRob3N1X25ldHdvcmsu aCIKKyNpbmNsdWRlICJ1YXBpL2V0aG9zdS5oIgorCisjaW5jbHVkZSA8bGludXgvYW5vbl9pbm9k ZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9maWxlLmg+CisjaW5jbHVkZSA8bGludXgvZnMuaD4KKyNp bmNsdWRlIDxsaW51eC9wb2xsLmg+CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBWYXJpYWJs ZXMKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqLworCitzdGF0aWMgaW50IGV0aG9zdV9pbmZlcmVuY2Vf cmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLAorCQkJCSAgICBzdHJ1Y3QgZmlsZSAqZmlsZSk7 CisKK3N0YXRpYyB1bnNpZ25lZCBpbnQgZXRob3N1X2luZmVyZW5jZV9wb2xsKHN0cnVjdCBmaWxl ICpmaWxlLAorCQkJCQkgIHBvbGxfdGFibGUgKndhaXQpOworCitzdGF0aWMgbG9uZyBldGhvc3Vf aW5mZXJlbmNlX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLAorCQkJCSAgIHVuc2lnbmVkIGludCBj bWQsCisJCQkJICAgdW5zaWduZWQgbG9uZyBhcmcpOworCitzdGF0aWMgY29uc3Qgc3RydWN0IGZp bGVfb3BlcmF0aW9ucyBldGhvc3VfaW5mZXJlbmNlX2ZvcHMgPSB7CisJLnJlbGVhc2UgICAgICAg ID0gJmV0aG9zdV9pbmZlcmVuY2VfcmVsZWFzZSwKKwkucG9sbCAgICAgICAgICAgPSAmZXRob3N1 X2luZmVyZW5jZV9wb2xsLAorCS51bmxvY2tlZF9pb2N0bCA9ICZldGhvc3VfaW5mZXJlbmNlX2lv Y3RsLAorI2lmZGVmIENPTkZJR19DT01QQVQKKwkuY29tcGF0X2lvY3RsICAgPSAmZXRob3N1X2lu ZmVyZW5jZV9pb2N0bCwKKyNlbmRpZgorfTsKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIEZ1 bmN0aW9ucworICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKK3N0YXRpYyBjb25zdCBjaGFyICpzdGF0 dXNfdG9fc3RyaW5nKGNvbnN0IGVudW0gZXRob3N1X3VhcGlfc3RhdHVzIHN0YXR1cykKK3sKKwlz d2l0Y2ggKHN0YXR1cykgeworCWNhc2UgRVRIT1NVX1VBUElfU1RBVFVTX09LOiB7CisJCXJldHVy biAiT2siOworCX0KKwljYXNlIEVUSE9TVV9VQVBJX1NUQVRVU19FUlJPUjogeworCQlyZXR1cm4g IkVycm9yIjsKKwl9CisJZGVmYXVsdDogeworCQlyZXR1cm4gIlVua25vd24iOworCX0KKwl9Cit9 CisKK3N0YXRpYyBpbnQgZXRob3N1X2luZmVyZW5jZV9zZW5kKHN0cnVjdCBldGhvc3VfaW5mZXJl bmNlICppbmYpCit7CisJaW50IHJldDsKKworCWlmIChpbmYtPnBlbmRpbmcpCisJCXJldHVybiAt RUlOVkFMOworCisJaW5mLT5zdGF0dXMgPSBFVEhPU1VfVUFQSV9TVEFUVVNfRVJST1I7CisKKwly ZXQgPSBldGhvc3VfbWFpbGJveF9pbmZlcmVuY2UoJmluZi0+ZWRldi0+bWFpbGJveCwgaW5mLAor CQkJCSAgICAgICBpbmYtPmlmbV9jb3VudCwgaW5mLT5pZm0sCisJCQkJICAgICAgIGluZi0+b2Zt X2NvdW50LCBpbmYtPm9mbSwKKwkJCQkgICAgICAgaW5mLT5uZXQtPmJ1ZiwKKwkJCQkgICAgICAg aW5mLT5wbXVfZXZlbnRfY29uZmlnLAorCQkJCSAgICAgICBFVEhPU1VfUE1VX0VWRU5UX01BWCwK KwkJCQkgICAgICAgaW5mLT5wbXVfY3ljbGVfY291bnRlcl9lbmFibGUpOworCWlmIChyZXQpCisJ CXJldHVybiByZXQ7CisKKwlpbmYtPnBlbmRpbmcgPSB0cnVlOworCisJZXRob3N1X2luZmVyZW5j ZV9nZXQoaW5mKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGV0aG9zdV9pbmZlcmVu Y2VfZmluZChzdHJ1Y3QgZXRob3N1X2luZmVyZW5jZSAqaW5mLAorCQkJCSBzdHJ1Y3QgbGlzdF9o ZWFkICppbmZlcmVuY2VfbGlzdCkKK3sKKwlzdHJ1Y3QgZXRob3N1X2luZmVyZW5jZSAqY3VyOwor CisJbGlzdF9mb3JfZWFjaF9lbnRyeShjdXIsIGluZmVyZW5jZV9saXN0LCBsaXN0KSB7CisJCWlm IChjdXIgPT0gaW5mKQorCQkJcmV0dXJuIDA7CisJfQorCisJcmV0dXJuIC1FSU5WQUw7Cit9CisK K3N0YXRpYyBib29sIGV0aG9zdV9pbmZlcmVuY2VfdmVyaWZ5KHN0cnVjdCBmaWxlICpmaWxlKQor eworCXJldHVybiBmaWxlLT5mX29wID09ICZldGhvc3VfaW5mZXJlbmNlX2ZvcHM7Cit9CisKK3N0 YXRpYyB2b2lkIGV0aG9zdV9pbmZlcmVuY2Vfa3JlZl9kZXN0cm95KHN0cnVjdCBrcmVmICprcmVm KQoreworCXN0cnVjdCBldGhvc3VfaW5mZXJlbmNlICppbmYgPQorCQljb250YWluZXJfb2Yoa3Jl Ziwgc3RydWN0IGV0aG9zdV9pbmZlcmVuY2UsIGtyZWYpOworCisJZGV2X2luZm8oaW5mLT5lZGV2 LT5kZXYsCisJCSAiSW5mZXJlbmNlIGRlc3Ryb3kuIGhhbmRsZT0weCVwSywgc3RhdHVzPSVkXG4i LAorCQkgaW5mLCBpbmYtPnN0YXR1cyk7CisKKwlsaXN0X2RlbCgmaW5mLT5saXN0KTsKKworCXdo aWxlIChpbmYtPmlmbV9jb3VudC0tID4gMCkKKwkJZXRob3N1X2J1ZmZlcl9wdXQoaW5mLT5pZm1b aW5mLT5pZm1fY291bnRdKTsKKworCXdoaWxlIChpbmYtPm9mbV9jb3VudC0tID4gMCkKKwkJZXRo b3N1X2J1ZmZlcl9wdXQoaW5mLT5vZm1baW5mLT5vZm1fY291bnRdKTsKKworCWV0aG9zdV9uZXR3 b3JrX3B1dChpbmYtPm5ldCk7CisJZGV2bV9rZnJlZShpbmYtPmVkZXYtPmRldiwgaW5mKTsKK30K Kworc3RhdGljIGludCBldGhvc3VfaW5mZXJlbmNlX3JlbGVhc2Uoc3RydWN0IGlub2RlICppbm9k ZSwKKwkJCQkgICAgc3RydWN0IGZpbGUgKmZpbGUpCit7CisJc3RydWN0IGV0aG9zdV9pbmZlcmVu Y2UgKmluZiA9IGZpbGUtPnByaXZhdGVfZGF0YTsKKworCWRldl9pbmZvKGluZi0+ZWRldi0+ZGV2 LAorCQkgIkluZmVyZW5jZSByZWxlYXNlLiBoYW5kbGU9MHglcEssIHN0YXR1cz0lZFxuIiwKKwkJ IGluZiwgaW5mLT5zdGF0dXMpOworCisJZXRob3N1X2luZmVyZW5jZV9wdXQoaW5mKTsKKworCXJl dHVybiAwOworfQorCitzdGF0aWMgdW5zaWduZWQgaW50IGV0aG9zdV9pbmZlcmVuY2VfcG9sbChz dHJ1Y3QgZmlsZSAqZmlsZSwKKwkJCQkJICBwb2xsX3RhYmxlICp3YWl0KQoreworCXN0cnVjdCBl dGhvc3VfaW5mZXJlbmNlICppbmYgPSBmaWxlLT5wcml2YXRlX2RhdGE7CisJaW50IHJldCA9IDA7 CisKKwlwb2xsX3dhaXQoZmlsZSwgJmluZi0+d2FpdHEsIHdhaXQpOworCisJaWYgKCFpbmYtPnBl bmRpbmcpCisJCXJldCB8PSBQT0xMSU47CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgbG9u ZyBldGhvc3VfaW5mZXJlbmNlX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLAorCQkJCSAgIHVuc2ln bmVkIGludCBjbWQsCisJCQkJICAgdW5zaWduZWQgbG9uZyBhcmcpCit7CisJc3RydWN0IGV0aG9z dV9pbmZlcmVuY2UgKmluZiA9IGZpbGUtPnByaXZhdGVfZGF0YTsKKwl2b2lkIF9fdXNlciAqdWRh dGEgPSAodm9pZCBfX3VzZXIgKilhcmc7CisJaW50IHJldDsKKworCXJldCA9IG11dGV4X2xvY2tf aW50ZXJydXB0aWJsZSgmaW5mLT5lZGV2LT5tdXRleCk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJl dDsKKworCWRldl9pbmZvKGluZi0+ZWRldi0+ZGV2LCAiSW9jdGw6IGNtZD0ldSwgYXJnPSVsdVxu IiwgY21kLCBhcmcpOworCisJc3dpdGNoIChjbWQpIHsKKwljYXNlIEVUSE9TVV9JT0NUTF9JTkZF UkVOQ0VfU1RBVFVTOiB7CisJCXN0cnVjdCBldGhvc3VfdWFwaV9yZXN1bHRfc3RhdHVzIHVhcGk7 CisJCWludCBpOworCisJCXVhcGkuc3RhdHVzID0gaW5mLT5zdGF0dXM7CisKKwkJZm9yIChpID0g MDsgaSA8IEVUSE9TVV9QTVVfRVZFTlRfTUFYOyBpKyspIHsKKwkJCXVhcGkucG11X2NvbmZpZy5l dmVudHNbaV0gPQorCQkJCWluZi0+cG11X2V2ZW50X2NvbmZpZ1tpXTsKKwkJCXVhcGkucG11X2Nv dW50LmV2ZW50c1tpXSA9CisJCQkJaW5mLT5wbXVfZXZlbnRfY291bnRbaV07CisJCX0KKworCQl1 YXBpLnBtdV9jb25maWcuY3ljbGVfY291bnQgPSBpbmYtPnBtdV9jeWNsZV9jb3VudGVyX2VuYWJs ZTsKKwkJdWFwaS5wbXVfY291bnQuY3ljbGVfY291bnQgPSBpbmYtPnBtdV9jeWNsZV9jb3VudGVy X2NvdW50OworCisJCWRldl9pbmZvKGluZi0+ZWRldi0+ZGV2LAorCQkJICJJb2N0bDogSW5mZXJl bmNlIHN0YXR1cy4gc3RhdHVzPSVzICglZClcbiIsCisJCQkgc3RhdHVzX3RvX3N0cmluZyh1YXBp LnN0YXR1cyksIHVhcGkuc3RhdHVzKTsKKworCQlyZXQgPSBjb3B5X3RvX3VzZXIodWRhdGEsICZ1 YXBpLCBzaXplb2YodWFwaSkpID8gLUVGQVVMVCA6IDA7CisKKwkJYnJlYWs7CisJfQorCWRlZmF1 bHQ6IHsKKwkJZGV2X2VycihpbmYtPmVkZXYtPmRldiwgIkludmFsaWQgaW9jdGwuIGNtZD0ldSwg YXJnPSVsdSIsCisJCQljbWQsIGFyZyk7CisJCWJyZWFrOworCX0KKwl9CisKKwltdXRleF91bmxv Y2soJmluZi0+ZWRldi0+bXV0ZXgpOworCisJcmV0dXJuIHJldDsKK30KKworaW50IGV0aG9zdV9p bmZlcmVuY2VfY3JlYXRlKHN0cnVjdCBldGhvc3VfZGV2aWNlICplZGV2LAorCQkJICAgIHN0cnVj dCBldGhvc3VfbmV0d29yayAqbmV0LAorCQkJICAgIHN0cnVjdCBldGhvc3VfdWFwaV9pbmZlcmVu Y2VfY3JlYXRlICp1YXBpKQoreworCXN0cnVjdCBldGhvc3VfaW5mZXJlbmNlICppbmY7CisJdWlu dDMyX3QgaTsKKwlpbnQgZmQ7CisJaW50IHJldCA9IC1FTk9NRU07CisKKwlpbmYgPSBkZXZtX2t6 YWxsb2MoZWRldi0+ZGV2LCBzaXplb2YoKmluZiksIEdGUF9LRVJORUwpOworCWlmICghaW5mKQor CQlyZXR1cm4gLUVOT01FTTsKKworCWluZi0+ZWRldiA9IGVkZXY7CisJaW5mLT5uZXQgPSBuZXQ7 CisJaW5mLT5wZW5kaW5nID0gZmFsc2U7CisJaW5mLT5zdGF0dXMgPSBFVEhPU1VfVUFQSV9TVEFU VVNfRVJST1I7CisJa3JlZl9pbml0KCZpbmYtPmtyZWYpOworCWluaXRfd2FpdHF1ZXVlX2hlYWQo JmluZi0+d2FpdHEpOworCisJLyogR2V0IHBvaW50ZXIgdG8gSUZNIGJ1ZmZlcnMgKi8KKwlmb3Ig KGkgPSAwOyBpIDwgdWFwaS0+aWZtX2NvdW50OyBpKyspIHsKKwkJaW5mLT5pZm1baV0gPSBldGhv c3VfYnVmZmVyX2dldF9mcm9tX2ZkKHVhcGktPmlmbV9mZFtpXSk7CisJCWlmIChJU19FUlIoaW5m LT5pZm1baV0pKSB7CisJCQlyZXQgPSBQVFJfRVJSKGluZi0+aWZtW2ldKTsKKwkJCWdvdG8gcHV0 X2lmbTsKKwkJfQorCisJCWluZi0+aWZtX2NvdW50Kys7CisJfQorCisJLyogR2V0IHBvaW50ZXIg dG8gT0ZNIGJ1ZmZlciAqLworCWZvciAoaSA9IDA7IGkgPCB1YXBpLT5vZm1fY291bnQ7IGkrKykg eworCQlpbmYtPm9mbVtpXSA9IGV0aG9zdV9idWZmZXJfZ2V0X2Zyb21fZmQodWFwaS0+b2ZtX2Zk W2ldKTsKKwkJaWYgKElTX0VSUihpbmYtPm9mbVtpXSkpIHsKKwkJCXJldCA9IFBUUl9FUlIoaW5m LT5vZm1baV0pOworCQkJZ290byBwdXRfb2ZtOworCQl9CisKKwkJaW5mLT5vZm1fY291bnQrKzsK Kwl9CisKKwkvKiBDb25maWd1cmUgUE1VIGFuZCBjeWNsZSBjb3VudGVyICovCisJZGV2X2luZm8o aW5mLT5lZGV2LT5kZXYsCisJCSAiQ29uZmlndXJpbmcgZXZlbnRzIGZvciBQTVUuIGV2ZW50cz1b JXUsICV1LCAldSwgJXVdXG4iLAorCQkgdWFwaS0+cG11X2NvbmZpZy5ldmVudHNbMF0sIHVhcGkt PnBtdV9jb25maWcuZXZlbnRzWzFdLAorCQkgdWFwaS0+cG11X2NvbmZpZy5ldmVudHNbMl0sIHVh cGktPnBtdV9jb25maWcuZXZlbnRzWzNdKTsKKworCS8qIENvbmZpZ3VyZSBldmVudHMgYW5kIHJl c2V0IGNvdW50IGZvciBhbGwgZXZlbnRzICovCisJZm9yIChpID0gMDsgaSA8IEVUSE9TVV9QTVVf RVZFTlRfTUFYOyBpKyspIHsKKwkJaW5mLT5wbXVfZXZlbnRfY29uZmlnW2ldID0gdWFwaS0+cG11 X2NvbmZpZy5ldmVudHNbaV07CisJCWluZi0+cG11X2V2ZW50X2NvdW50W2ldID0gMDsKKwl9CisK KwlpZiAodWFwaS0+cG11X2NvbmZpZy5jeWNsZV9jb3VudCkKKwkJZGV2X2luZm8oaW5mLT5lZGV2 LT5kZXYsICJFbmFibGluZyBjeWNsZSBjb3VudGVyXG4iKTsKKworCS8qIENvbmZpZ3VyZSBjeWNs ZSBjb3VudGVyIGFuZCByZXNldCBhbnkgcHJldmlvdXMgY291bnQgKi8KKwlpbmYtPnBtdV9jeWNs ZV9jb3VudGVyX2VuYWJsZSA9IHVhcGktPnBtdV9jb25maWcuY3ljbGVfY291bnQ7CisJaW5mLT5w bXVfY3ljbGVfY291bnRlcl9jb3VudCA9IDA7CisKKwkvKiBJbmNyZW1lbnQgbmV0d29yayByZWZl cmVuY2UgY291bnQgKi8KKwlldGhvc3VfbmV0d29ya19nZXQobmV0KTsKKworCS8qIENyZWF0ZSBm aWxlIGRlc2NyaXB0b3IgKi8KKwlyZXQgPSBmZCA9IGFub25faW5vZGVfZ2V0ZmQoImV0aG9zdS1p bmZlcmVuY2UiLCAmZXRob3N1X2luZmVyZW5jZV9mb3BzLAorCQkJCSAgICBpbmYsIE9fUkRXUiB8 IE9fQ0xPRVhFQyk7CisJaWYgKHJldCA8IDApCisJCWdvdG8gcHV0X25ldDsKKworCS8qIFN0b3Jl IHBvaW50ZXIgdG8gZmlsZSBzdHJ1Y3R1cmUgKi8KKwlpbmYtPmZpbGUgPSBmZ2V0KHJldCk7CisJ ZnB1dChpbmYtPmZpbGUpOworCisJLyogQWRkIGluZmVyZW5jZSB0byBpbmZlcmVuY2UgbGlzdCAq LworCWxpc3RfYWRkKCZpbmYtPmxpc3QsICZlZGV2LT5pbmZlcmVuY2VfbGlzdCk7CisKKwkvKiBT ZW5kIGluZmVyZW5jZSByZXF1ZXN0IHRvIEFybSBFdGhvcy1VIHN1YnN5c3RlbSAqLworCSh2b2lk KWV0aG9zdV9pbmZlcmVuY2Vfc2VuZChpbmYpOworCisJZGV2X2luZm8oZWRldi0+ZGV2LCAiSW5m ZXJlbmNlIGNyZWF0ZS4gaGFuZGxlPTB4JXBLLCBmZD0lZCIsCisJCSBpbmYsIGZkKTsKKworCXJl dHVybiBmZDsKKworcHV0X25ldDoKKwlldGhvc3VfbmV0d29ya19wdXQoaW5mLT5uZXQpOworCitw dXRfb2ZtOgorCXdoaWxlIChpbmYtPm9mbV9jb3VudC0tID4gMCkKKwkJZXRob3N1X2J1ZmZlcl9w dXQoaW5mLT5vZm1baW5mLT5vZm1fY291bnRdKTsKKworcHV0X2lmbToKKwl3aGlsZSAoaW5mLT5p Zm1fY291bnQtLSA+IDApCisJCWV0aG9zdV9idWZmZXJfcHV0KGluZi0+aWZtW2luZi0+aWZtX2Nv dW50XSk7CisKKwlkZXZtX2tmcmVlKGVkZXYtPmRldiwgaW5mKTsKKworCXJldHVybiByZXQ7Cit9 CisKK3N0cnVjdCBldGhvc3VfaW5mZXJlbmNlICpldGhvc3VfaW5mZXJlbmNlX2dldF9mcm9tX2Zk KGludCBmZCkKK3sKKwlzdHJ1Y3QgZXRob3N1X2luZmVyZW5jZSAqaW5mOworCXN0cnVjdCBmaWxl ICpmaWxlOworCisJZmlsZSA9IGZnZXQoZmQpOworCWlmICghZmlsZSkKKwkJcmV0dXJuIEVSUl9Q VFIoLUVJTlZBTCk7CisKKwlpZiAoIWV0aG9zdV9pbmZlcmVuY2VfdmVyaWZ5KGZpbGUpKSB7CisJ CWZwdXQoZmlsZSk7CisKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CisJfQorCisJaW5mID0g ZmlsZS0+cHJpdmF0ZV9kYXRhOworCWV0aG9zdV9pbmZlcmVuY2VfZ2V0KGluZik7CisJZnB1dChm aWxlKTsKKworCXJldHVybiBpbmY7Cit9CisKK3ZvaWQgZXRob3N1X2luZmVyZW5jZV9nZXQoc3Ry dWN0IGV0aG9zdV9pbmZlcmVuY2UgKmluZikKK3sKKwlrcmVmX2dldCgmaW5mLT5rcmVmKTsKK30K Kwordm9pZCBldGhvc3VfaW5mZXJlbmNlX3B1dChzdHJ1Y3QgZXRob3N1X2luZmVyZW5jZSAqaW5m KQoreworCWtyZWZfcHV0KCZpbmYtPmtyZWYsICZldGhvc3VfaW5mZXJlbmNlX2tyZWZfZGVzdHJv eSk7Cit9CisKK3ZvaWQgZXRob3N1X2luZmVyZW5jZV9yc3Aoc3RydWN0IGV0aG9zdV9kZXZpY2Ug KmVkZXYsCisJCQkgIHN0cnVjdCBldGhvc3VfY29yZV9pbmZlcmVuY2VfcnNwICpyc3ApCit7CisJ c3RydWN0IGV0aG9zdV9pbmZlcmVuY2UgKmluZiA9CisJCShzdHJ1Y3QgZXRob3N1X2luZmVyZW5j ZSAqKXJzcC0+dXNlcl9hcmc7CisJaW50IHJldDsKKwlpbnQgaTsKKworCXJldCA9IGV0aG9zdV9p bmZlcmVuY2VfZmluZChpbmYsICZlZGV2LT5pbmZlcmVuY2VfbGlzdCk7CisJaWYgKHJldCkgewor CQlkZXZfd2FybihlZGV2LT5kZXYsCisJCQkgIkhhbmRsZSBub3QgZm91bmQgaW4gaW5mZXJlbmNl IGxpc3QuIGhhbmRsZT0weCVwXG4iLAorCQkJIHJzcCk7CisKKwkJcmV0dXJuOworCX0KKworCWlu Zi0+cGVuZGluZyA9IGZhbHNlOworCisJaWYgKHJzcC0+c3RhdHVzID09IEVUSE9TVV9DT1JFX1NU QVRVU19PSyAmJgorCSAgICBpbmYtPm9mbV9jb3VudCA8PSBFVEhPU1VfQ09SRV9CVUZGRVJfTUFY KSB7CisJCXVpbnQzMl90IGk7CisKKwkJaW5mLT5zdGF0dXMgPSBFVEhPU1VfVUFQSV9TVEFUVVNf T0s7CisKKwkJZm9yIChpID0gMDsgaSA8IGluZi0+b2ZtX2NvdW50OyBpKyspIHsKKwkJCXN0cnVj dCBldGhvc3VfYnVmZmVyICpvZm0gPSBpbmYtPm9mbVtpXTsKKworCQkJcmV0ID0gZXRob3N1X2J1 ZmZlcl9yZXNpemUoCisJCQkJb2ZtLCBvZm0tPnNpemUgKyByc3AtPm9mbV9zaXplW2ldLAorCQkJ CW9mbS0+b2Zmc2V0KTsKKwkJCWlmIChyZXQpCisJCQkJaW5mLT5zdGF0dXMgPSBFVEhPU1VfVUFQ SV9TVEFUVVNfRVJST1I7CisJCX0KKwl9IGVsc2UgeworCQlpbmYtPnN0YXR1cyA9IEVUSE9TVV9V QVBJX1NUQVRVU19FUlJPUjsKKwl9CisKKwlmb3IgKGkgPSAwOyBpIDwgRVRIT1NVX0NPUkVfUE1V X01BWDsgaSsrKSB7CisJCWluZi0+cG11X2V2ZW50X2NvbmZpZ1tpXSA9IHJzcC0+cG11X2V2ZW50 X2NvbmZpZ1tpXTsKKwkJaW5mLT5wbXVfZXZlbnRfY291bnRbaV0gPSByc3AtPnBtdV9ldmVudF9j b3VudFtpXTsKKwl9CisKKwlpbmYtPnBtdV9jeWNsZV9jb3VudGVyX2VuYWJsZSA9IHJzcC0+cG11 X2N5Y2xlX2NvdW50ZXJfZW5hYmxlOworCWluZi0+cG11X2N5Y2xlX2NvdW50ZXJfY291bnQgPSBy c3AtPnBtdV9jeWNsZV9jb3VudGVyX2NvdW50OworCisJZGV2X2luZm8oZWRldi0+ZGV2LAorCQkg IlBNVSBldmVudHMuIGNvbmZpZz1bJXUsICV1LCAldSwgJXVdLCBjb3VudD1bJXUsICV1LCAldSwg JXVdXG4iLAorCQkgaW5mLT5wbXVfZXZlbnRfY29uZmlnWzBdLCBpbmYtPnBtdV9ldmVudF9jb25m aWdbMV0sCisJCSBpbmYtPnBtdV9ldmVudF9jb25maWdbMl0sIGluZi0+cG11X2V2ZW50X2NvbmZp Z1szXSwKKwkJIGluZi0+cG11X2V2ZW50X2NvdW50WzBdLCBpbmYtPnBtdV9ldmVudF9jb3VudFsx XSwKKwkJIGluZi0+cG11X2V2ZW50X2NvdW50WzJdLCBpbmYtPnBtdV9ldmVudF9jb3VudFszXSk7 CisKKwlkZXZfaW5mbyhlZGV2LT5kZXYsCisJCSAiUE1VIGN5Y2xlIGNvdW50ZXIuIGVuYWJsZT0l dSwgY291bnQ9JWxsdVxuIiwKKwkJIGluZi0+cG11X2N5Y2xlX2NvdW50ZXJfZW5hYmxlLAorCQkg aW5mLT5wbXVfY3ljbGVfY291bnRlcl9jb3VudCk7CisJd2FrZV91cF9pbnRlcnJ1cHRpYmxlKCZp bmYtPndhaXRxKTsKKworCWV0aG9zdV9pbmZlcmVuY2VfcHV0KGluZik7Cit9CmRpZmYgLS1naXQg YS9kcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfaW5mZXJlbmNlLmggYi9kcml2ZXJzL2Zp cm13YXJlL2V0aG9zdS9ldGhvc3VfaW5mZXJlbmNlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwLi4wNzM3MGNhMDFmMjIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJz L2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfaW5mZXJlbmNlLmgKQEAgLTAsMCArMSwxMjAgQEAKKy8q CisgKiAoQykgQ09QWVJJR0hUIDIwMjAgQVJNIExpbWl0ZWQuIEFsbCByaWdodHMgcmVzZXJ2ZWQu CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmUgYW5kIGlzIHByb3ZpZGVkIHRv IHlvdSB1bmRlciB0aGUgdGVybXMgb2YgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0 aW9uLCBhbmQgYW55IHVzZSBieSB5b3Ugb2YgdGhpcyBwcm9ncmFtIGlzIHN1YmplY3QgdG8gdGhl IHRlcm1zCisgKiBvZiBzdWNoIEdOVSBsaWNlbmNlLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBk aXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJ VEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YK KyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4g U2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4K KyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgeW91 IGNhbiBhY2Nlc3MgaXQgb25saW5lIGF0CisgKiBodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMv Z3BsLTIuMC5odG1sLgorICoKKyAqIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9u bHkKKyAqLworCisjaWZuZGVmIEVUSE9TVV9JTkZFUkVOQ0VfSAorI2RlZmluZSBFVEhPU1VfSU5G RVJFTkNFX0gKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIEluY2x1ZGVzCisgKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKi8KKworI2luY2x1ZGUgInVhcGkvZXRob3N1LmgiCisKKyNpbmNsdWRlIDxsaW51 eC9rcmVmLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC93YWl0 Lmg+CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBUeXBlcworICoqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KiovCisKK3N0cnVjdCBldGhvc3VfYnVmZmVyOworc3RydWN0IGV0aG9zdV9jb3JlX2luZmVyZW5j ZV9yc3A7CitzdHJ1Y3QgZXRob3N1X2RldmljZTsKK3N0cnVjdCBldGhvc3VfbmV0d29yazsKK3N0 cnVjdCBldGhvc3VfdWFwaV9pbmZlcmVuY2VfY3JlYXRlOworc3RydWN0IGZpbGU7CisKKy8qKgor ICogc3RydWN0IGV0aG9zdV9pbmZlcmVuY2UgLSBJbmZlcmVuY2Ugc3RydWN0CisgKiBAZWRldjoJ CQlBcm0gRXRob3MtVSBkZXZpY2UKKyAqIEBmaWxlOgkJCUZpbGUgaGFuZGxlCisgKiBAa3JlZjoJ CQlSZWZlcmVuY2UgY291bnRlcgorICogQHdhaXRxOgkJCVdhaXQgcXVldWUKKyAqIEBpZm06CQkJ UG9pbnRlciB0byBJRk0gYnVmZmVyCisgKiBAb2ZtOgkJCVBvaW50ZXIgdG8gT0ZNIGJ1ZmZlcgor ICogQG5ldDoJCQlQb2ludGVyIHRvIG5ldHdvcmsKKyAqIEBwZW5kaW5nOgkJCVBlbmRpbmcgcmVz cG9uc2UgZnJvbSB0aGUgZmlybXdhcmUKKyAqIEBzdGF0dXM6CQkJSW5mZXJlbmNlIHN0YXR1cwor ICogQHBtdV9ldmVudF9jb25maWc6CQlQTVUgZXZlbnQgY29uZmlndXJhdGlvbgorICogQHBtdV9l dmVudF9jb3VudDoJCVBNVSBldmVudCBjb3VudCBhZnRlciBpbmZlcmVuY2UKKyAqIEBwbXVfY3lj bGVfY291bnRlcl9lbmFibGU6CVBNVSBjeWNsZSBjb3VudGVyIGNvbmZpZworICogQHBtdV9jeWNs ZV9jb3VudGVyX2NvdW50OglQTVUgY3ljbGUgY291bnRlciBjb3VudCBhZnRlciBpbmZlcmVuY2UK KyAqLworc3RydWN0IGV0aG9zdV9pbmZlcmVuY2UgeworCXN0cnVjdCBldGhvc3VfZGV2aWNlICAg ICplZGV2OworCXN0cnVjdCBmaWxlICAgICAgICAgICAgICpmaWxlOworCXN0cnVjdCBrcmVmICAg ICAgICAgICAgIGtyZWY7CisJd2FpdF9xdWV1ZV9oZWFkX3QgICAgICAgd2FpdHE7CisJdWludDMy X3QgICAgICAgICAgICAgICAgaWZtX2NvdW50OworCXN0cnVjdCBldGhvc3VfYnVmZmVyICAgICpp Zm1bRVRIT1NVX0ZEX01BWF07CisJdWludDMyX3QgICAgICAgICAgICAgICAgb2ZtX2NvdW50Owor CXN0cnVjdCBldGhvc3VfYnVmZmVyICAgICpvZm1bRVRIT1NVX0ZEX01BWF07CisJc3RydWN0IGV0 aG9zdV9uZXR3b3JrICAgKm5ldDsKKwlib29sICAgICAgICAgICAgICAgICAgICBwZW5kaW5nOwor CWVudW0gZXRob3N1X3VhcGlfc3RhdHVzIHN0YXR1czsKKwl1aW50OF90ICAgICAgICAgICAgICAg ICBwbXVfZXZlbnRfY29uZmlnW0VUSE9TVV9QTVVfRVZFTlRfTUFYXTsKKwl1aW50MzJfdCAgICAg ICAgICAgICAgICBwbXVfZXZlbnRfY291bnRbRVRIT1NVX1BNVV9FVkVOVF9NQVhdOworCXVpbnQz Ml90ICAgICAgICAgICAgICAgIHBtdV9jeWNsZV9jb3VudGVyX2VuYWJsZTsKKwl1aW50NjRfdCAg ICAgICAgICAgICAgICBwbXVfY3ljbGVfY291bnRlcl9jb3VudDsKKwlzdHJ1Y3QgbGlzdF9oZWFk ICAgICAgICBsaXN0OworfTsKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIEZ1bmN0aW9ucwor ICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKiovCisKKy8qKgorICogZXRob3N1X2luZmVyZW5jZV9jcmVhdGUo KSAtIENyZWF0ZSBpbmZlcmVuY2UKKyAqCisgKiBUaGlzIGZ1bmN0aW9uIG11c3QgYmUgY2FsbGVk IGluIHRoZSBjb250ZXh0IG9mIGEgdXNlciBzcGFjZSBwcm9jZXNzLgorICoKKyAqIFJldHVybjog ZmQgb24gc3VjY2VzcywgZWxzZSBlcnJvciBjb2RlLgorICovCitpbnQgZXRob3N1X2luZmVyZW5j ZV9jcmVhdGUoc3RydWN0IGV0aG9zdV9kZXZpY2UgKmVkZXYsCisJCQkgICAgc3RydWN0IGV0aG9z dV9uZXR3b3JrICpuZXQsCisJCQkgICAgc3RydWN0IGV0aG9zdV91YXBpX2luZmVyZW5jZV9jcmVh dGUgKnVhcGkpOworCisvKioKKyAqIGV0aG9zdV9pbmZlcmVuY2VfZ2V0X2Zyb21fZmQoKSAtIEdl dCBpbmZlcmVuY2UgaGFuZGxlIGZyb20gZmQKKyAqCisgKiBUaGlzIGZ1bmN0aW9uIG11c3QgYmUg Y2FsbGVkIGZyb20gYSB1c2VyIHNwYWNlIGNvbnRleHQuCisgKgorICogUmV0dXJuOiBQb2ludGVy IG9uIHN1Y2Nlc3MsIGVsc2UgRVJSX1BUUi4KKyAqLworc3RydWN0IGV0aG9zdV9pbmZlcmVuY2Ug KmV0aG9zdV9pbmZlcmVuY2VfZ2V0X2Zyb21fZmQoaW50IGZkKTsKKworLyoqCisgKiBldGhvc3Vf aW5mZXJlbmNlX2dldCgpIC0gR2V0IGluZmVyZW5jZQorICovCit2b2lkIGV0aG9zdV9pbmZlcmVu Y2VfZ2V0KHN0cnVjdCBldGhvc3VfaW5mZXJlbmNlICppbmYpOworCisvKioKKyAqIGV0aG9zdV9p bmZlcmVuY2VfcHV0KCkgLSBQdXQgaW5mZXJlbmNlCisgKi8KK3ZvaWQgZXRob3N1X2luZmVyZW5j ZV9wdXQoc3RydWN0IGV0aG9zdV9pbmZlcmVuY2UgKmluZik7CisKKy8qKgorICogZXRob3N1X2lu ZmVyZW5jZV9yc3AoKSAtIEhhbmRsZSBpbmZlcmVuY2UgcmVzcG9uc2UKKyAqLwordm9pZCBldGhv c3VfaW5mZXJlbmNlX3JzcChzdHJ1Y3QgZXRob3N1X2RldmljZSAqZWRldiwKKwkJCSAgc3RydWN0 IGV0aG9zdV9jb3JlX2luZmVyZW5jZV9yc3AgKnJzcCk7CisKKyNlbmRpZiAvKiBFVEhPU1VfSU5G RVJFTkNFX0ggKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9t YWlsYm94LmMgYi9kcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfbWFpbGJveC5jCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uN2YxNTlmM2IwYTYwCi0tLSAvZGV2 L251bGwKKysrIGIvZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvZXRob3N1X21haWxib3guYwpAQCAt MCwwICsxLDM3NyBAQAorLyoKKyAqIChDKSBDT1BZUklHSFQgMjAyMCBBUk0gTGltaXRlZC4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZSBh bmQgaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUKKyAqIEdOVSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29m dHdhcmUKKyAqIEZvdW5kYXRpb24sIGFuZCBhbnkgdXNlIGJ5IHlvdSBvZiB0aGlzIHByb2dyYW0g aXMgc3ViamVjdCB0byB0aGUgdGVybXMKKyAqIG9mIHN1Y2ggR05VIGxpY2VuY2UuCisgKgorICog VGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1 c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkg b2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJv Z3JhbTsgaWYgbm90LCB5b3UgY2FuIGFjY2VzcyBpdCBvbmxpbmUgYXQKKyAqIGh0dHA6Ly93d3cu Z251Lm9yZy9saWNlbnNlcy9ncGwtMi4wLmh0bWwuCisgKgorICogU1BEWC1MaWNlbnNlLUlkZW50 aWZpZXI6IEdQTC0yLjAtb25seQorICovCisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBJbmNs dWRlcworICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKyNpbmNsdWRlICJldGhvc3VfbWFpbGJveC5o IgorCisjaW5jbHVkZSAiZXRob3N1X2J1ZmZlci5oIgorI2luY2x1ZGUgImV0aG9zdV9jb3JlX2lu dGVyZmFjZS5oIgorI2luY2x1ZGUgImV0aG9zdV9kZXZpY2UuaCIKKworI2luY2x1ZGUgPGxpbnV4 L3Jlc291cmNlLmg+CisjaW5jbHVkZSA8bGludXgvdWlvLmg+CisKKy8qKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqCisgKiBGdW5jdGlvbnMKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCitzdGF0aWMgdm9pZCBl dGhvc3VfY29yZV9zZXRfc2l6ZShzdHJ1Y3QgZXRob3N1X2J1ZmZlciAqYnVmLAorCQkJCSBzdHJ1 Y3QgZXRob3N1X2NvcmVfYnVmZmVyICpjYnVmKQoreworCWNidWYtPnB0ciA9ICh1aW50MzJfdCli dWYtPmRtYV9hZGRyICsgYnVmLT5vZmZzZXQ7CisJY2J1Zi0+c2l6ZSA9ICh1aW50MzJfdClidWYt PnNpemU7Cit9CisKK3N0YXRpYyB2b2lkIGV0aG9zdV9jb3JlX3NldF9jYXBhY2l0eShzdHJ1Y3Qg ZXRob3N1X2J1ZmZlciAqYnVmLAorCQkJCSAgICAgc3RydWN0IGV0aG9zdV9jb3JlX2J1ZmZlciAq Y2J1ZikKK3sKKwljYnVmLT5wdHIgPSAodWludDMyX3QpYnVmLT5kbWFfYWRkciArIGJ1Zi0+b2Zm c2V0ICsgYnVmLT5zaXplOworCWNidWYtPnNpemUgPSAodWludDMyX3QpYnVmLT5jYXBhY2l0eSAt IGJ1Zi0+b2Zmc2V0IC0gYnVmLT5zaXplOworfQorCitzdGF0aWMgc2l6ZV90IGV0aG9zdV9xdWV1 ZV9hdmFpbGFibGUoc3RydWN0IGV0aG9zdV9jb3JlX3F1ZXVlICpxdWV1ZSkKK3sKKwlzaXplX3Qg c2l6ZSA9IHF1ZXVlLT5oZWFkZXIud3JpdGUgLSBxdWV1ZS0+aGVhZGVyLnJlYWQ7CisKKwlpZiAo cXVldWUtPmhlYWRlci5yZWFkID4gcXVldWUtPmhlYWRlci53cml0ZSkKKwkJc2l6ZSArPSBxdWV1 ZS0+aGVhZGVyLnNpemU7CisKKwlyZXR1cm4gc2l6ZTsKK30KKworc3RhdGljIHNpemVfdCBldGhv c3VfcXVldWVfY2FwYWNpdHkoc3RydWN0IGV0aG9zdV9jb3JlX3F1ZXVlICpxdWV1ZSkKK3sKKwly ZXR1cm4gcXVldWUtPmhlYWRlci5zaXplIC0gZXRob3N1X3F1ZXVlX2F2YWlsYWJsZShxdWV1ZSk7 Cit9CisKK3N0YXRpYyBpbnQgZXRob3N1X3F1ZXVlX3dyaXRlKHN0cnVjdCBldGhvc3VfbWFpbGJv eCAqbWJveCwKKwkJCSAgICAgIGNvbnN0IHN0cnVjdCBrdmVjICp2ZWMsCisJCQkgICAgICBzaXpl X3QgbGVuZ3RoKQoreworCXN0cnVjdCBldGhvc3VfY29yZV9xdWV1ZSAqcXVldWUgPSBtYm94LT5p bl9xdWV1ZTsKKwl1aW50OF90ICpkc3QgPSAmcXVldWUtPmRhdGFbMF07CisJdWludDMyX3Qgd3Bv cyA9IHF1ZXVlLT5oZWFkZXIud3JpdGU7CisJc2l6ZV90IHRvdGFsX3NpemU7CisJc2l6ZV90IGk7 CisJaW50IHJldDsKKworCWZvciAoaSA9IDAsIHRvdGFsX3NpemUgPSAwOyBpIDwgbGVuZ3RoOyBp KyspCisJCXRvdGFsX3NpemUgKz0gdmVjW2ldLmlvdl9sZW47CisKKwlpZiAodG90YWxfc2l6ZSA+ IGV0aG9zdV9xdWV1ZV9jYXBhY2l0eShxdWV1ZSkpCisJCXJldHVybiAtRUlOVkFMOworCisJZm9y IChpID0gMDsgaSA8IGxlbmd0aDsgaSsrKSB7CisJCWNvbnN0IHVpbnQ4X3QgKnNyYyA9IHZlY1tp XS5pb3ZfYmFzZTsKKwkJY29uc3QgdWludDhfdCAqZW5kID0gc3JjICsgdmVjW2ldLmlvdl9sZW47 CisKKwkJd2hpbGUgKHNyYyA8IGVuZCkgeworCQkJZHN0W3dwb3NdID0gKnNyYysrOworCQkJd3Bv cyA9ICh3cG9zICsgMSkgJSBxdWV1ZS0+aGVhZGVyLnNpemU7CisJCX0KKwl9CisKKwlxdWV1ZS0+ aGVhZGVyLndyaXRlID0gd3BvczsKKworCXJldCA9IG1ib3hfc2VuZF9tZXNzYWdlKG1ib3gtPnR4 LCBxdWV1ZSk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gMDsKK30K Kworc3RhdGljIGludCBldGhvc3VfcXVldWVfd3JpdGVfbXNnKHN0cnVjdCBldGhvc3VfbWFpbGJv eCAqbWJveCwKKwkJCQkgIHVpbnQzMl90IHR5cGUsCisJCQkJICB2b2lkICpkYXRhLAorCQkJCSAg c2l6ZV90IGxlbmd0aCkKK3sKKwlzdHJ1Y3QgZXRob3N1X2NvcmVfbXNnIG1zZyA9IHsKKwkJLm1h Z2ljID0gRVRIT1NVX0NPUkVfTVNHX01BR0lDLAorCQkudHlwZSAgPSB0eXBlLCAgICAgICAgICAg ICAgICAgLmxlbmd0aD0gbGVuZ3RoCisJfTsKKwljb25zdCBzdHJ1Y3Qga3ZlYyB2ZWNbMl0gPSB7 CisJCXsgJm1zZywgc2l6ZW9mKG1zZykgfSwKKwkJeyBkYXRhLCBsZW5ndGggICAgICB9CisJfTsK KworCXJldHVybiBldGhvc3VfcXVldWVfd3JpdGUobWJveCwgdmVjLCAyKTsKK30KKworc3RhdGlj IGludCBldGhvc3VfcXVldWVfcmVhZChzdHJ1Y3QgZXRob3N1X21haWxib3ggKm1ib3gsCisJCQkg ICAgIHZvaWQgKmRhdGEsCisJCQkgICAgIHNpemVfdCBsZW5ndGgpCit7CisJc3RydWN0IGV0aG9z dV9jb3JlX3F1ZXVlICpxdWV1ZSA9IG1ib3gtPm91dF9xdWV1ZTsKKwl1aW50OF90ICpzcmMgPSAm cXVldWUtPmRhdGFbMF07CisJdWludDhfdCAqZHN0ID0gKHVpbnQ4X3QgKilkYXRhOworCWNvbnN0 IHVpbnQ4X3QgKmVuZCA9IGRzdCArIGxlbmd0aDsKKwl1aW50MzJfdCBycG9zID0gcXVldWUtPmhl YWRlci5yZWFkOworCXNpemVfdCBxdWV1ZV9hdmFpbCA9IGV0aG9zdV9xdWV1ZV9hdmFpbGFibGUo cXVldWUpOworCisJaWYgKGxlbmd0aCA9PSAwKQorCQlyZXR1cm4gMDsKKwllbHNlIGlmIChxdWV1 ZV9hdmFpbCA9PSAwKQorCQlyZXR1cm4gLUVOT01TRzsKKwllbHNlIGlmIChsZW5ndGggPiBxdWV1 ZV9hdmFpbCkKKwkJcmV0dXJuIC1FQkFETVNHOworCisJd2hpbGUgKGRzdCA8IGVuZCkgeworCQkq ZHN0KysgPSBzcmNbcnBvc107CisJCXJwb3MgPSAocnBvcyArIDEpICUgcXVldWUtPmhlYWRlci5z aXplOworCX0KKworCXF1ZXVlLT5oZWFkZXIucmVhZCA9IHJwb3M7CisKKwlyZXR1cm4gMDsKK30K Kwordm9pZCBldGhvc3VfbWFpbGJveF9yZXNldChzdHJ1Y3QgZXRob3N1X21haWxib3ggKm1ib3gp Cit7CisJbWJveC0+b3V0X3F1ZXVlLT5oZWFkZXIucmVhZCA9IG1ib3gtPm91dF9xdWV1ZS0+aGVh ZGVyLndyaXRlOworfQorCitpbnQgZXRob3N1X21haWxib3hfcmVhZChzdHJ1Y3QgZXRob3N1X21h aWxib3ggKm1ib3gsCisJCQlzdHJ1Y3QgZXRob3N1X2NvcmVfbXNnICpoZWFkZXIsCisJCQl2b2lk ICpkYXRhLAorCQkJc2l6ZV90IGxlbmd0aCkKK3sKKwlpbnQgcmV0OworCisJLyogUmVhZCBtZXNz YWdlIGhlYWRlciBtYWdpYyAqLworCXJldCA9IGV0aG9zdV9xdWV1ZV9yZWFkKG1ib3gsIGhlYWRl ciwgc2l6ZW9mKCpoZWFkZXIpKTsKKwlpZiAocmV0KSB7CisJCWlmIChyZXQgIT0gLUVOT01TRykK KwkJCWRldl93YXJuKG1ib3gtPmRldiwKKwkJCQkgIk1zZzogRmFpbGVkIHRvIHJlYWQgbWVzc2Fn ZSBoZWFkZXJcbiIpOworCisJCXJldHVybiByZXQ7CisJfQorCisJaWYgKGhlYWRlci0+bWFnaWMg IT0gRVRIT1NVX0NPUkVfTVNHX01BR0lDKSB7CisJCWRldl93YXJuKG1ib3gtPmRldiwKKwkJCSAi TXNnOiBJbnZhbGlkIG1hZ2ljLiBHb3Q6ICUwOFggYnV0IGV4cGVjdGVkICUwOFhcbiIsCisJCQkg aGVhZGVyLT5tYWdpYywgRVRIT1NVX0NPUkVfTVNHX01BR0lDKTsKKworCQlyZXR1cm4gLUVJTlZB TDsKKwl9CisKKwlkZXZfaW5mbyhtYm94LT5kZXYsCisJCSAibWJveDogUmVhZCBtc2cgaGVhZGVy LiBtYWdpYz0lMDhYLCB0eXBlPSV1LCBsZW5ndGg9JXUiLAorCQkgaGVhZGVyLT5tYWdpYywgaGVh ZGVyLT50eXBlLCBoZWFkZXItPmxlbmd0aCk7CisKKwkvKiBDaGVjayB0aGF0IHBheWxvYWQgaXMg bm90IGxhcmdlciB0aGFuIGFsbG9jYXRlZCBidWZmZXIgKi8KKwlpZiAoaGVhZGVyLT5sZW5ndGgg PiBsZW5ndGgpIHsKKwkJZGV2X3dhcm4obWJveC0+ZGV2LAorCQkJICJNc2c6IEJ1ZmZlciBzaXpl ICglenUpIHRvbyBzbWFsbCBmb3IgbWVzc2FnZSAoJXUpXG4iLAorCQkJIHNpemVvZihkYXRhKSwg aGVhZGVyLT5sZW5ndGgpOworCisJCXJldHVybiAtRU5PTUVNOworCX0KKworCS8qIFJlYWQgcGF5 bG9hZCBkYXRhICovCisJcmV0ID0gZXRob3N1X3F1ZXVlX3JlYWQobWJveCwgZGF0YSwgaGVhZGVy LT5sZW5ndGgpOworCWlmIChyZXQpIHsKKwkJZGV2X3dhcm4obWJveC0+ZGV2LCAiTXNnOiBGYWls ZWQgdG8gcmVhZCBwYXlsb2FkIGRhdGFcbiIpOworCisJCXJldHVybiAtRUJBRE1TRzsKKwl9CisK KwlyZXR1cm4gMDsKK30KKworaW50IGV0aG9zdV9tYWlsYm94X3Bpbmcoc3RydWN0IGV0aG9zdV9t YWlsYm94ICptYm94KQoreworCXJldHVybiBldGhvc3VfcXVldWVfd3JpdGVfbXNnKG1ib3gsIEVU SE9TVV9DT1JFX01TR19QSU5HLCBOVUxMLCAwKTsKK30KKworaW50IGV0aG9zdV9tYWlsYm94X3Bv bmcoc3RydWN0IGV0aG9zdV9tYWlsYm94ICptYm94KQoreworCXJldHVybiBldGhvc3VfcXVldWVf d3JpdGVfbXNnKG1ib3gsIEVUSE9TVV9DT1JFX01TR19QT05HLCBOVUxMLCAwKTsKK30KKworaW50 IGV0aG9zdV9tYWlsYm94X3ZlcnNpb25fcmVxdWVzdChzdHJ1Y3QgZXRob3N1X21haWxib3ggKm1i b3gpCit7CisJcmV0dXJuIGV0aG9zdV9xdWV1ZV93cml0ZV9tc2cobWJveCwgRVRIT1NVX0NPUkVf TVNHX1ZFUlNJT05fUkVRLCBOVUxMLAorCQkJCSAgICAgIDApOworfQorCitpbnQgZXRob3N1X21h aWxib3hfY2FwYWJpbGl0aWVzX3JlcXVlc3Qoc3RydWN0IGV0aG9zdV9tYWlsYm94ICptYm94LAor CQkJCQl2b2lkICp1c2VyX2FyZykKK3sKKwlzdHJ1Y3QgZXRob3N1X2NvcmVfY2FwYWJpbGl0aWVz X3JlcSByZXEgPSB7CisJCS51c2VyX2FyZyA9IChwdHJkaWZmX3QpdXNlcl9hcmcKKwl9OworCisJ cmV0dXJuIGV0aG9zdV9xdWV1ZV93cml0ZV9tc2cobWJveCwgRVRIT1NVX0NPUkVfTVNHX0NBUEFC SUxJVElFU19SRVEsCisJCQkJICAgICAgJnJlcSwKKwkJCQkgICAgICBzaXplb2YocmVxKSk7Cit9 CisKK2ludCBldGhvc3VfbWFpbGJveF9pbmZlcmVuY2Uoc3RydWN0IGV0aG9zdV9tYWlsYm94ICpt Ym94LAorCQkJICAgICB2b2lkICp1c2VyX2FyZywKKwkJCSAgICAgdWludDMyX3QgaWZtX2NvdW50 LAorCQkJICAgICBzdHJ1Y3QgZXRob3N1X2J1ZmZlciAqKmlmbSwKKwkJCSAgICAgdWludDMyX3Qg b2ZtX2NvdW50LAorCQkJICAgICBzdHJ1Y3QgZXRob3N1X2J1ZmZlciAqKm9mbSwKKwkJCSAgICAg c3RydWN0IGV0aG9zdV9idWZmZXIgKm5ldHdvcmssCisJCQkgICAgIHVpbnQ4X3QgKnBtdV9ldmVu dF9jb25maWcsCisJCQkgICAgIHVpbnQ4X3QgcG11X2V2ZW50X2NvbmZpZ19jb3VudCwKKwkJCSAg ICAgdWludDhfdCBwbXVfY3ljbGVfY291bnRlcl9lbmFibGUpCit7CisJc3RydWN0IGV0aG9zdV9j b3JlX2luZmVyZW5jZV9yZXEgaW5mOworCXVpbnQzMl90IGk7CisKKwkvKiBWZXJpZnkgdGhhdCB0 aGUgdWFwaSBhbmQgY29yZSBoYXMgdGhlIHNhbWUgbnVtYmVyIG9mIHBtdXMgKi8KKwlpZiAocG11 X2V2ZW50X2NvbmZpZ19jb3VudCAhPSBFVEhPU1VfQ09SRV9QTVVfTUFYKSB7CisJCWRldl9lcnIo bWJveC0+ZGV2LCAiUE1VIGNvdW50IG1pc2NvbmZpZ3VyZWQuXG4iKTsKKworCQlyZXR1cm4gLUVJ TlZBTDsKKwl9CisKKwlpbmYudXNlcl9hcmcgPSAocHRyZGlmZl90KXVzZXJfYXJnOworCWluZi5p Zm1fY291bnQgPSBpZm1fY291bnQ7CisJaW5mLm9mbV9jb3VudCA9IG9mbV9jb3VudDsKKwlpbmYu cG11X2N5Y2xlX2NvdW50ZXJfZW5hYmxlID0gcG11X2N5Y2xlX2NvdW50ZXJfZW5hYmxlOworCisJ Zm9yIChpID0gMDsgaSA8IGlmbV9jb3VudDsgaSsrKQorCQlldGhvc3VfY29yZV9zZXRfc2l6ZShp Zm1baV0sICZpbmYuaWZtW2ldKTsKKworCWZvciAoaSA9IDA7IGkgPCBvZm1fY291bnQ7IGkrKykK KwkJZXRob3N1X2NvcmVfc2V0X2NhcGFjaXR5KG9mbVtpXSwgJmluZi5vZm1baV0pOworCisJZm9y IChpID0gMDsgaSA8IEVUSE9TVV9DT1JFX1BNVV9NQVg7IGkrKykKKwkJaW5mLnBtdV9ldmVudF9j b25maWdbaV0gPSBwbXVfZXZlbnRfY29uZmlnW2ldOworCisJZXRob3N1X2NvcmVfc2V0X3NpemUo bmV0d29yaywgJmluZi5uZXR3b3JrKTsKKworCXJldHVybiBldGhvc3VfcXVldWVfd3JpdGVfbXNn KG1ib3gsIEVUSE9TVV9DT1JFX01TR19JTkZFUkVOQ0VfUkVRLAorCQkJCSAgICAgICZpbmYsIHNp emVvZihpbmYpKTsKK30KKworc3RhdGljIHZvaWQgZXRob3N1X21haWxib3hfcnhfd29yayhzdHJ1 Y3Qgd29ya19zdHJ1Y3QgKndvcmspCit7CisJc3RydWN0IGV0aG9zdV9tYWlsYm94ICptYm94ID0g Y29udGFpbmVyX29mKHdvcmssIHR5cGVvZigqbWJveCksIHdvcmspOworCisJbWJveC0+Y2FsbGJh Y2sobWJveC0+dXNlcl9hcmcpOworfQorCitzdGF0aWMgdm9pZCBldGhvc3VfbWFpbGJveF9yeF9j YWxsYmFjayhzdHJ1Y3QgbWJveF9jbGllbnQgKmNsaWVudCwKKwkJCQkgICAgICAgdm9pZCAqbWVz c2FnZSkKK3sKKwlzdHJ1Y3QgZXRob3N1X21haWxib3ggKm1ib3ggPQorCQljb250YWluZXJfb2Yo Y2xpZW50LCB0eXBlb2YoKm1ib3gpLCBjbGllbnQpOworCisJZGV2X2luZm8obWJveC0+ZGV2LCAi bWJveDogUmVjZWl2ZWQgbWVzc2FnZS5cbiIpOworCisJcXVldWVfd29yayhtYm94LT53cSwgJm1i b3gtPndvcmspOworfQorCitzdGF0aWMgdm9pZCBldGhvc3VfbWFpbGJveF90eF9kb25lKHN0cnVj dCBtYm94X2NsaWVudCAqY2xpZW50LAorCQkJCSAgIHZvaWQgKm1lc3NhZ2UsCisJCQkJICAgaW50 IHIpCit7CisJaWYgKHIpCisJCWRldl93YXJuKGNsaWVudC0+ZGV2LCAibWJveDogRmFpbGVkIHNl bmRpbmcgbWVzc2FnZSAoJWQpXG4iLCByKTsKKwllbHNlCisJCWRldl9pbmZvKGNsaWVudC0+ZGV2 LCAibWJveDogTWVzc2FnZSBzZW50XG4iKTsKK30KKworaW50IGV0aG9zdV9tYWlsYm94X2luaXQo c3RydWN0IGV0aG9zdV9tYWlsYm94ICptYm94LAorCQkJc3RydWN0IGRldmljZSAqZGV2LAorCQkJ c3RydWN0IHJlc291cmNlICppbl9xdWV1ZSwKKwkJCXN0cnVjdCByZXNvdXJjZSAqb3V0X3F1ZXVl LAorCQkJZXRob3N1X21haWxib3hfY2IgY2FsbGJhY2ssCisJCQl2b2lkICp1c2VyX2FyZykKK3sK KwlpbnQgcmV0OworCisJbWJveC0+ZGV2ID0gZGV2OworCW1ib3gtPmNhbGxiYWNrID0gY2FsbGJh Y2s7CisJbWJveC0+dXNlcl9hcmcgPSB1c2VyX2FyZzsKKworCW1ib3gtPmNsaWVudC5kZXYgPSBk ZXY7CisJbWJveC0+Y2xpZW50LnJ4X2NhbGxiYWNrID0gZXRob3N1X21haWxib3hfcnhfY2FsbGJh Y2s7CisJbWJveC0+Y2xpZW50LnR4X3ByZXBhcmUgPSBOVUxMOyAvKiBwcmVwYXJhdGlvbiBvZiBk YXRhIGlzIGhhbmRsZWQKKwkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqIHRocm91 Z2ggdGhlCisJICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKiBxdWV1ZSBmdW5jdGlv bnMgKi8KKwltYm94LT5jbGllbnQudHhfZG9uZSA9IGV0aG9zdV9tYWlsYm94X3R4X2RvbmU7CisJ bWJveC0+Y2xpZW50LnR4X2Jsb2NrID0gdHJ1ZTsKKwltYm94LT5jbGllbnQua25vd3NfdHhkb25l ID0gZmFsc2U7CisJbWJveC0+Y2xpZW50LnR4X3RvdXQgPSA1MDA7CisKKwltYm94LT5pbl9xdWV1 ZSA9IGRldm1faW9yZW1hcF9yZXNvdXJjZShtYm94LT5kZXYsIGluX3F1ZXVlKTsKKwlpZiAoSVNf RVJSKG1ib3gtPmluX3F1ZXVlKSkKKwkJcmV0dXJuIFBUUl9FUlIobWJveC0+aW5fcXVldWUpOwor CisJbWJveC0+b3V0X3F1ZXVlID0gZGV2bV9pb3JlbWFwX3Jlc291cmNlKG1ib3gtPmRldiwgb3V0 X3F1ZXVlKTsKKwlpZiAoSVNfRVJSKG1ib3gtPm91dF9xdWV1ZSkpIHsKKwkJcmV0ID0gUFRSX0VS UihtYm94LT5vdXRfcXVldWUpOworCQlnb3RvIHVubWFwX2luX3F1ZXVlOworCX0KKworCW1ib3gt PndxID0gY3JlYXRlX3NpbmdsZXRocmVhZF93b3JrcXVldWUoImV0aG9zdV93b3JrcXVldWUiKTsK KwlpZiAoIW1ib3gtPndxKSB7CisJCWRldl9lcnIobWJveC0+ZGV2LCAiRmFpbGVkIHRvIGNyZWF0 ZSB3b3JrIHF1ZXVlXG4iKTsKKwkJcmV0ID0gLUVJTlZBTDsKKwkJZ290byB1bm1hcF9vdXRfcXVl dWU7CisJfQorCisJSU5JVF9XT1JLKCZtYm94LT53b3JrLCBldGhvc3VfbWFpbGJveF9yeF93b3Jr KTsKKworCW1ib3gtPnR4ID0gbWJveF9yZXF1ZXN0X2NoYW5uZWxfYnluYW1lKCZtYm94LT5jbGll bnQsICJ0eCIpOworCWlmIChJU19FUlIobWJveC0+dHgpKSB7CisJCWRldl93YXJuKG1ib3gtPmRl diwgIm1ib3g6IEZhaWxlZCB0byByZXF1ZXN0IHR4IGNoYW5uZWxcbiIpOworCQlyZXQgPSBQVFJf RVJSKG1ib3gtPnR4KTsKKwkJZ290byB3b3JrcXVldWVfZGVzdHJveTsKKwl9CisKKwltYm94LT5y eCA9IG1ib3hfcmVxdWVzdF9jaGFubmVsX2J5bmFtZSgmbWJveC0+Y2xpZW50LCAicngiKTsKKwlp ZiAoSVNfRVJSKG1ib3gtPnJ4KSkgeworCQlkZXZfaW5mbyhkZXYsICJtYm94OiBVc2luZyBzYW1l IGNoYW5uZWwgZm9yIFJYIGFuZCBUWFxuIik7CisJCW1ib3gtPnJ4ID0gbWJveC0+dHg7CisJfQor CisJcmV0dXJuIDA7CisKK3dvcmtxdWV1ZV9kZXN0cm95OgorCWRlc3Ryb3lfd29ya3F1ZXVlKG1i b3gtPndxKTsKKwordW5tYXBfb3V0X3F1ZXVlOgorCWRldm1faW91bm1hcChtYm94LT5kZXYsIG1i b3gtPm91dF9xdWV1ZSk7CisKK3VubWFwX2luX3F1ZXVlOgorCWRldm1faW91bm1hcChtYm94LT5k ZXYsIG1ib3gtPmluX3F1ZXVlKTsKKworCXJldHVybiByZXQ7Cit9CisKK3ZvaWQgZXRob3N1X21h aWxib3hfZGVpbml0KHN0cnVjdCBldGhvc3VfbWFpbGJveCAqbWJveCkKK3sKKwlpZiAobWJveC0+ cnggIT0gbWJveC0+dHgpCisJCW1ib3hfZnJlZV9jaGFubmVsKG1ib3gtPnJ4KTsKKworCW1ib3hf ZnJlZV9jaGFubmVsKG1ib3gtPnR4KTsKKwlkZXN0cm95X3dvcmtxdWV1ZShtYm94LT53cSk7CisJ ZGV2bV9pb3VubWFwKG1ib3gtPmRldiwgbWJveC0+b3V0X3F1ZXVlKTsKKwlkZXZtX2lvdW5tYXAo bWJveC0+ZGV2LCBtYm94LT5pbl9xdWV1ZSk7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Zpcm13 YXJlL2V0aG9zdS9ldGhvc3VfbWFpbGJveC5oIGIvZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvZXRo b3N1X21haWxib3guaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjVj ZDVlNjIxOThiOAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0 aG9zdV9tYWlsYm94LmgKQEAgLTAsMCArMSwxNDAgQEAKKy8qCisgKiAoQykgQ09QWVJJR0hUIDIw MjAgQVJNIExpbWl0ZWQuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogVGhpcyBwcm9ncmFt IGlzIGZyZWUgc29mdHdhcmUgYW5kIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMg b2YgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlz aGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBhbmQgYW55IHVzZSBieSB5 b3Ugb2YgdGhpcyBwcm9ncmFtIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zCisgKiBvZiBzdWNoIEdO VSBsaWNlbmNlLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3 aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZQorICogR05VIEdlbmVy YWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhh dmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICog YWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgeW91IGNhbiBhY2Nlc3MgaXQgb25saW5l IGF0CisgKiBodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvZ3BsLTIuMC5odG1sLgorICoKKyAq IFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkKKyAqLworCisjaWZuZGVmIEVU SE9TVV9NQUlMQk9YX0gKKyNkZWZpbmUgRVRIT1NVX01BSUxCT1hfSAorCisvKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKgorICogSW5jbHVkZXMKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworI2luY2x1ZGUgImV0 aG9zdV9jb3JlX2ludGVyZmFjZS5oIgorCisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNs dWRlIDxsaW51eC9tYWlsYm94X2NsaWVudC5oPgorI2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5o PgorCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKgorICogVHlwZXMKKyAqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq LworCitzdHJ1Y3QgZGV2aWNlOworc3RydWN0IGV0aG9zdV9idWZmZXI7CitzdHJ1Y3QgZXRob3N1 X2RldmljZTsKK3N0cnVjdCBldGhvc3VfY29yZV9tc2c7CitzdHJ1Y3QgZXRob3N1X2NvcmVfcXVl dWU7CitzdHJ1Y3QgcmVzb3VyY2U7CisKK3R5cGVkZWYgdm9pZCAoKmV0aG9zdV9tYWlsYm94X2Ni KSh2b2lkICp1c2VyX2FyZyk7CisKK3N0cnVjdCBldGhvc3VfbWFpbGJveCB7CisJc3RydWN0IGRl dmljZSAgICAgICAgICAgICpkZXY7CisJc3RydWN0IHdvcmtxdWV1ZV9zdHJ1Y3QgICp3cTsKKwlz dHJ1Y3Qgd29ya19zdHJ1Y3QgICAgICAgd29yazsKKwlzdHJ1Y3QgZXRob3N1X2NvcmVfcXVldWUg X19pb21lbSAqaW5fcXVldWU7CisJc3RydWN0IGV0aG9zdV9jb3JlX3F1ZXVlIF9faW9tZW0gKm91 dF9xdWV1ZTsKKwlzdHJ1Y3QgbWJveF9jbGllbnQgICAgICAgY2xpZW50OworCXN0cnVjdCBtYm94 X2NoYW4gICAgICAgICAqcng7CisJc3RydWN0IG1ib3hfY2hhbiAgICAgICAgICp0eDsKKwlldGhv c3VfbWFpbGJveF9jYiAgICAgICAgY2FsbGJhY2s7CisJdm9pZCAgICAgICAgICAgICAgICAgICAg ICp1c2VyX2FyZzsKK307CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBGdW5jdGlvbnMKKyAq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqLworCisvKioKKyAqIGV0aG9zdV9tYWlsYm94X2luaXQoKSAtIElu aXRpYWxpemUgbWFpbGJveAorICoKKyAqIFJldHVybjogMCBvbiBzdWNjZXNzLCBlbHNlIGVycm9y IGNvZGUuCisgKi8KK2ludCBldGhvc3VfbWFpbGJveF9pbml0KHN0cnVjdCBldGhvc3VfbWFpbGJv eCAqbWJveCwKKwkJCXN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCXN0cnVjdCByZXNvdXJjZSAqaW5f cXVldWUsCisJCQlzdHJ1Y3QgcmVzb3VyY2UgKm91dF9xdWV1ZSwKKwkJCWV0aG9zdV9tYWlsYm94 X2NiIGNhbGxiYWNrLAorCQkJdm9pZCAqdXNlcl9hcmcpOworCisvKioKKyAqIGV0aG9zdV9tYWls Ym94X2RlaW5pdCgpIC0gRGVpbml0aWFsaXplIG1haWxib3gKKyAqLwordm9pZCBldGhvc3VfbWFp bGJveF9kZWluaXQoc3RydWN0IGV0aG9zdV9tYWlsYm94ICptYm94KTsKKworLyoqCisgKiBldGhv c3VfbWFpbGJveF9yZWFkKCkgLSBSZWFkIG1lc3NhZ2UgZnJvbSBtYWlsYm94CisgKgorICogUmV0 dXJuOiAwIG1lc3NhZ2UgcmVhZCwgZWxzZSBlcnJvciBjb2RlLgorICovCitpbnQgZXRob3N1X21h aWxib3hfcmVhZChzdHJ1Y3QgZXRob3N1X21haWxib3ggKm1ib3gsCisJCQlzdHJ1Y3QgZXRob3N1 X2NvcmVfbXNnICpoZWFkZXIsCisJCQl2b2lkICpkYXRhLAorCQkJc2l6ZV90IGxlbmd0aCk7CisK Ky8qKgorICogZXRob3N1X21haWxib3hfcmVzZXQoKSAtIFJlc2V0IHRvIGVuZCBvZiBxdWV1ZQor ICovCit2b2lkIGV0aG9zdV9tYWlsYm94X3Jlc2V0KHN0cnVjdCBldGhvc3VfbWFpbGJveCAqbWJv eCk7CisKKy8qKgorICogZXRob3N1X21haWxib3hfcGluZygpIC0gU2VuZCBwaW5nIG1lc3NhZ2UK KyAqCisgKiBSZXR1cm46IDAgb24gc3VjY2VzcywgZWxzZSBlcnJvciBjb2RlLgorICovCitpbnQg ZXRob3N1X21haWxib3hfcGluZyhzdHJ1Y3QgZXRob3N1X21haWxib3ggKm1ib3gpOworCisvKioK KyAqIGV0aG9zdV9tYWlsYm94X3BvbmcoKSAtIFNlbmQgcG9uZyByZXNwb25zZQorICoKKyAqIFJl dHVybjogMCBvbiBzdWNjZXNzLCBlbHNlIGVycm9yIGNvZGUuCisgKi8KK2ludCBldGhvc3VfbWFp bGJveF9wb25nKHN0cnVjdCBldGhvc3VfbWFpbGJveCAqbWJveCk7CisKKy8qKgorICogZXRob3N1 X21haWxib3hfdmVyc2lvbl9yZXNwb25zZSAtIFNlbmQgdmVyc2lvbiByZXF1ZXN0CisgKgorICog UmV0dXJuOiAwIG9uIHN1Y2NlcywgZWxzZSBlcnJvciBjb2RlCisgKi8KK2ludCBldGhvc3VfbWFp bGJveF92ZXJzaW9uX3JlcXVlc3Qoc3RydWN0IGV0aG9zdV9tYWlsYm94ICptYm94KTsKKworLyoq CisgKiBldGhvc3VfbWFpbGJveF9jYXBhYmlsaXRpZXNfcmVxdWVzdCgpIC0gU2VuZCBjYXBhYmls aXRpZXMgcmVxdWVzdAorICoKKyAqIFJldHVybjogMCBvbiBzdWNjZXNzLCBlbHNlIGVycm9yIGNv ZGUuCisgKi8KK2ludCBldGhvc3VfbWFpbGJveF9jYXBhYmlsaXRpZXNfcmVxdWVzdChzdHJ1Y3Qg ZXRob3N1X21haWxib3ggKm1ib3gsCisJCQkJCXZvaWQgKnVzZXJfYXJnKTsKKworLyoqCisgKiBl dGhvc3VfbWFpbGJveF9pbmZlcmVuY2UoKSAtIFNlbmQgaW5mZXJlbmNlCisgKgorICogUmV0dXJu OiAwIG9uIHN1Y2Nlc3MsIGVsc2UgZXJyb3IgY29kZS4KKyAqLworaW50IGV0aG9zdV9tYWlsYm94 X2luZmVyZW5jZShzdHJ1Y3QgZXRob3N1X21haWxib3ggKm1ib3gsCisJCQkgICAgIHZvaWQgKnVz ZXJfYXJnLAorCQkJICAgICB1aW50MzJfdCBpZm1fY291bnQsCisJCQkgICAgIHN0cnVjdCBldGhv c3VfYnVmZmVyICoqaWZtLAorCQkJICAgICB1aW50MzJfdCBvZm1fY291bnQsCisJCQkgICAgIHN0 cnVjdCBldGhvc3VfYnVmZmVyICoqb2ZtLAorCQkJICAgICBzdHJ1Y3QgZXRob3N1X2J1ZmZlciAq bmV0d29yaywKKwkJCSAgICAgdWludDhfdCAqcG11X2V2ZW50X2NvbmZpZywKKwkJCSAgICAgdWlu dDhfdCBwbXVfZXZlbnRfY29uZmlnX2NvdW50LAorCQkJICAgICB1aW50OF90IHBtdV9jeWNsZV9j b3VudGVyX2VuYWJsZSk7CisKKyNlbmRpZiAvKiBFVEhPU1VfTUFJTEJPWF9IICovCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfbmV0d29yay5jIGIvZHJpdmVycy9m aXJtd2FyZS9ldGhvc3UvZXRob3N1X25ldHdvcmsuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAuLjRkNjhmMDUzN2UzOAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMv ZmlybXdhcmUvZXRob3N1L2V0aG9zdV9uZXR3b3JrLmMKQEAgLTAsMCArMSwyMDEgQEAKKy8qCisg KiAoQykgQ09QWVJJR0hUIDIwMjAgQVJNIExpbWl0ZWQuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmUgYW5kIGlzIHByb3ZpZGVkIHRvIHlv dSB1bmRlciB0aGUgdGVybXMgb2YgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2 ZXJzaW9uIDIgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9u LCBhbmQgYW55IHVzZSBieSB5b3Ugb2YgdGhpcyBwcm9ncmFtIGlzIHN1YmplY3QgdG8gdGhlIHRl cm1zCisgKiBvZiBzdWNoIEdOVSBsaWNlbmNlLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0 cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhP VVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAq IE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2Vl IHRoZQorICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAq CisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQ dWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgeW91IGNh biBhY2Nlc3MgaXQgb25saW5lIGF0CisgKiBodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvZ3Bs LTIuMC5odG1sLgorICoKKyAqIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkK KyAqLworCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogSW5jbHVkZXMKKyAqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqLworCisjaW5jbHVkZSAiZXRob3N1X25ldHdvcmsuaCIKKworI2luY2x1ZGUgImV0aG9z dV9idWZmZXIuaCIKKyNpbmNsdWRlICJldGhvc3VfZGV2aWNlLmgiCisjaW5jbHVkZSAiZXRob3N1 X2luZmVyZW5jZS5oIgorI2luY2x1ZGUgInVhcGkvZXRob3N1LmgiCisKKyNpbmNsdWRlIDxsaW51 eC9hbm9uX2lub2Rlcy5oPgorI2luY2x1ZGUgPGxpbnV4L2ZpbGUuaD4KKyNpbmNsdWRlIDxsaW51 eC9mcy5oPgorI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KKworLyoqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioKKyAqIFZhcmlhYmxlcworICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKK3N0YXRpYyBpbnQgZXRo b3N1X25ldHdvcmtfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLAorCQkJCSAgc3RydWN0IGZp bGUgKmZpbGUpOworCitzdGF0aWMgbG9uZyBldGhvc3VfbmV0d29ya19pb2N0bChzdHJ1Y3QgZmls ZSAqZmlsZSwKKwkJCQkgdW5zaWduZWQgaW50IGNtZCwKKwkJCQkgdW5zaWduZWQgbG9uZyBhcmcp OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBldGhvc3VfbmV0d29ya19m b3BzID0geworCS5yZWxlYXNlICAgICAgICA9ICZldGhvc3VfbmV0d29ya19yZWxlYXNlLAorCS51 bmxvY2tlZF9pb2N0bCA9ICZldGhvc3VfbmV0d29ya19pb2N0bCwKKyNpZmRlZiBDT05GSUdfQ09N UEFUCisJLmNvbXBhdF9pb2N0bCAgID0gJmV0aG9zdV9uZXR3b3JrX2lvY3RsLAorI2VuZGlmCit9 OworCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKgorICogRnVuY3Rpb25zCisgKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKi8KKworc3RhdGljIGJvb2wgZXRob3N1X25ldHdvcmtfdmVyaWZ5KHN0cnVjdCBmaWxlICpm aWxlKQoreworCXJldHVybiBmaWxlLT5mX29wID09ICZldGhvc3VfbmV0d29ya19mb3BzOworfQor CitzdGF0aWMgdm9pZCBldGhvc3VfbmV0d29ya19kZXN0cm95KHN0cnVjdCBrcmVmICprcmVmKQor eworCXN0cnVjdCBldGhvc3VfbmV0d29yayAqbmV0ID0KKwkJY29udGFpbmVyX29mKGtyZWYsIHN0 cnVjdCBldGhvc3VfbmV0d29yaywga3JlZik7CisKKwlkZXZfaW5mbyhuZXQtPmVkZXYtPmRldiwg Ik5ldHdvcmsgZGVzdHJveS4gaGFuZGxlPTB4JXBLXG4iLCBuZXQpOworCisJZXRob3N1X2J1ZmZl cl9wdXQobmV0LT5idWYpOworCWRldm1fa2ZyZWUobmV0LT5lZGV2LT5kZXYsIG5ldCk7Cit9CisK K3N0YXRpYyBpbnQgZXRob3N1X25ldHdvcmtfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLAor CQkJCSAgc3RydWN0IGZpbGUgKmZpbGUpCit7CisJc3RydWN0IGV0aG9zdV9uZXR3b3JrICpuZXQg PSBmaWxlLT5wcml2YXRlX2RhdGE7CisKKwlkZXZfaW5mbyhuZXQtPmVkZXYtPmRldiwgIk5ldHdv cmsgcmVsZWFzZS4gaGFuZGxlPTB4JXBLXG4iLCBuZXQpOworCisJZXRob3N1X25ldHdvcmtfcHV0 KG5ldCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGxvbmcgZXRob3N1X25ldHdvcmtfaW9j dGwoc3RydWN0IGZpbGUgKmZpbGUsCisJCQkJIHVuc2lnbmVkIGludCBjbWQsCisJCQkJIHVuc2ln bmVkIGxvbmcgYXJnKQoreworCXN0cnVjdCBldGhvc3VfbmV0d29yayAqbmV0ID0gZmlsZS0+cHJp dmF0ZV9kYXRhOworCXZvaWQgX191c2VyICp1ZGF0YSA9ICh2b2lkIF9fdXNlciAqKWFyZzsKKwlp bnQgcmV0ID0gLUVJTlZBTDsKKworCXJldCA9IG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmbmV0 LT5lZGV2LT5tdXRleCk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCWRldl9pbmZvKG5l dC0+ZWRldi0+ZGV2LCAiSW9jdGw6IGNtZD0ldSwgYXJnPSVsdVxuIiwgY21kLCBhcmcpOworCisJ c3dpdGNoIChjbWQpIHsKKwljYXNlIEVUSE9TVV9JT0NUTF9JTkZFUkVOQ0VfQ1JFQVRFOiB7CisJ CXN0cnVjdCBldGhvc3VfdWFwaV9pbmZlcmVuY2VfY3JlYXRlIHVhcGk7CisKKwkJaWYgKGNvcHlf ZnJvbV91c2VyKCZ1YXBpLCB1ZGF0YSwgc2l6ZW9mKHVhcGkpKSkKKwkJCWJyZWFrOworCisJCWRl dl9pbmZvKG5ldC0+ZWRldi0+ZGV2LAorCQkJICJJb2N0bDogSW5mZXJlbmNlLiBpZm1fZmQ9JXUs IG9mbV9mZD0ldVxuIiwKKwkJCSB1YXBpLmlmbV9mZFswXSwgdWFwaS5vZm1fZmRbMF0pOworCisJ CXJldCA9IGV0aG9zdV9pbmZlcmVuY2VfY3JlYXRlKG5ldC0+ZWRldiwgbmV0LCAmdWFwaSk7CisJ CWJyZWFrOworCX0KKwlkZWZhdWx0OiB7CisJCWRldl9lcnIobmV0LT5lZGV2LT5kZXYsICJJbnZh bGlkIGlvY3RsLiBjbWQ9JXUsIGFyZz0lbHUiLAorCQkJY21kLCBhcmcpOworCQlicmVhazsKKwl9 CisJfQorCisJbXV0ZXhfdW5sb2NrKCZuZXQtPmVkZXYtPm11dGV4KTsKKworCXJldHVybiByZXQ7 Cit9CisKK2ludCBldGhvc3VfbmV0d29ya19jcmVhdGUoc3RydWN0IGV0aG9zdV9kZXZpY2UgKmVk ZXYsCisJCQkgIHN0cnVjdCBldGhvc3VfdWFwaV9uZXR3b3JrX2NyZWF0ZSAqdWFwaSkKK3sKKwlz dHJ1Y3QgZXRob3N1X2J1ZmZlciAqYnVmOworCXN0cnVjdCBldGhvc3VfbmV0d29yayAqbmV0Owor CWludCByZXQgPSAtRU5PTUVNOworCisJYnVmID0gZXRob3N1X2J1ZmZlcl9nZXRfZnJvbV9mZCh1 YXBpLT5mZCk7CisJaWYgKElTX0VSUihidWYpKQorCQlyZXR1cm4gUFRSX0VSUihidWYpOworCisJ bmV0ID0gZGV2bV9remFsbG9jKGVkZXYtPmRldiwgc2l6ZW9mKCpuZXQpLCBHRlBfS0VSTkVMKTsK KwlpZiAoIW5ldCkgeworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIHB1dF9idWY7CisJfQorCisJ bmV0LT5lZGV2ID0gZWRldjsKKwluZXQtPmJ1ZiA9IGJ1ZjsKKwlrcmVmX2luaXQoJm5ldC0+a3Jl Zik7CisKKwlyZXQgPSBhbm9uX2lub2RlX2dldGZkKCJldGhvc3UtbmV0d29yayIsICZldGhvc3Vf bmV0d29ya19mb3BzLCBuZXQsCisJCQkgICAgICAgT19SRFdSIHwgT19DTE9FWEVDKTsKKwlpZiAo cmV0IDwgMCkKKwkJZ290byBmcmVlX25ldDsKKworCW5ldC0+ZmlsZSA9IGZnZXQocmV0KTsKKwlm cHV0KG5ldC0+ZmlsZSk7CisKKwlkZXZfaW5mbyhlZGV2LT5kZXYsICJOZXR3b3JrIGNyZWF0ZS4g aGFuZGxlPTB4JXBLIiwKKwkJIG5ldCk7CisKKwlyZXR1cm4gcmV0OworCitmcmVlX25ldDoKKwlk ZXZtX2tmcmVlKGVkZXYtPmRldiwgbmV0KTsKKworcHV0X2J1ZjoKKwlldGhvc3VfYnVmZmVyX3B1 dChidWYpOworCisJcmV0dXJuIHJldDsKK30KKworc3RydWN0IGV0aG9zdV9uZXR3b3JrICpldGhv c3VfbmV0d29ya19nZXRfZnJvbV9mZChpbnQgZmQpCit7CisJc3RydWN0IGV0aG9zdV9uZXR3b3Jr ICpuZXQ7CisJc3RydWN0IGZpbGUgKmZpbGU7CisKKwlmaWxlID0gZmdldChmZCk7CisJaWYgKCFm aWxlKQorCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKKworCWlmICghZXRob3N1X25ldHdvcmtf dmVyaWZ5KGZpbGUpKSB7CisJCWZwdXQoZmlsZSk7CisKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZB TCk7CisJfQorCisJbmV0ID0gZmlsZS0+cHJpdmF0ZV9kYXRhOworCWV0aG9zdV9uZXR3b3JrX2dl dChuZXQpOworCWZwdXQoZmlsZSk7CisKKwlyZXR1cm4gbmV0OworfQorCit2b2lkIGV0aG9zdV9u ZXR3b3JrX2dldChzdHJ1Y3QgZXRob3N1X25ldHdvcmsgKm5ldCkKK3sKKwlrcmVmX2dldCgmbmV0 LT5rcmVmKTsKK30KKwordm9pZCBldGhvc3VfbmV0d29ya19wdXQoc3RydWN0IGV0aG9zdV9uZXR3 b3JrICpuZXQpCit7CisJa3JlZl9wdXQoJm5ldC0+a3JlZiwgZXRob3N1X25ldHdvcmtfZGVzdHJv eSk7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS9ldGhvc3VfbmV0d29y ay5oIGIvZHJpdmVycy9maXJtd2FyZS9ldGhvc3UvZXRob3N1X25ldHdvcmsuaApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmJiNzBhZmNiMjU3MgotLS0gL2Rldi9udWxs CisrKyBiL2RyaXZlcnMvZmlybXdhcmUvZXRob3N1L2V0aG9zdV9uZXR3b3JrLmgKQEAgLTAsMCAr MSw4MSBAQAorLyoKKyAqIChDKSBDT1BZUklHSFQgMjAyMCBBUk0gTGltaXRlZC4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZSBhbmQgaXMg cHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUK KyAqIEZvdW5kYXRpb24sIGFuZCBhbnkgdXNlIGJ5IHlvdSBvZiB0aGlzIHByb2dyYW0gaXMgc3Vi amVjdCB0byB0aGUgdGVybXMKKyAqIG9mIHN1Y2ggR05VIGxpY2VuY2UuCisgKgorICogVGhpcyBw cm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWws CisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3 YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9y ZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhl IEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsg aWYgbm90LCB5b3UgY2FuIGFjY2VzcyBpdCBvbmxpbmUgYXQKKyAqIGh0dHA6Ly93d3cuZ251Lm9y Zy9saWNlbnNlcy9ncGwtMi4wLmh0bWwuCisgKgorICogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IEdQTC0yLjAtb25seQorICovCisKKyNpZm5kZWYgRVRIT1NVX05FVFdPUktfSAorI2RlZmluZSBF VEhPU1VfTkVUV09SS19ICisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBJbmNsdWRlcworICoq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKiovCisKKyNpbmNsdWRlIDxsaW51eC9rcmVmLmg+CisjaW5jbHVkZSA8 bGludXgvdHlwZXMuaD4KKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIFR5cGVzCisgKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKi8KKworc3RydWN0IGV0aG9zdV9idWZmZXI7CitzdHJ1Y3QgZXRob3N1X2Rl dmljZTsKK3N0cnVjdCBldGhvc3VfdWFwaV9uZXR3b3JrX2NyZWF0ZTsKK3N0cnVjdCBkZXZpY2U7 CitzdHJ1Y3QgZmlsZTsKKworc3RydWN0IGV0aG9zdV9uZXR3b3JrIHsKKwlzdHJ1Y3QgZXRob3N1 X2RldmljZSAqZWRldjsKKwlzdHJ1Y3QgZmlsZSAgICAgICAgICAqZmlsZTsKKwlzdHJ1Y3Qga3Jl ZiAgICAgICAgICBrcmVmOworCXN0cnVjdCBldGhvc3VfYnVmZmVyICpidWY7Cit9OworCisvKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKgorICogRnVuY3Rpb25zCisgKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKwor LyoqCisgKiBldGhvc3VfbmV0d29ya19jcmVhdGUoKSAtIENyZWF0ZSBuZXR3b3JrCisgKgorICog VGhpcyBmdW5jdGlvbiBtdXN0IGJlIGNhbGxlZCBpbiB0aGUgY29udGV4dCBvZiBhIHVzZXIgc3Bh Y2UgcHJvY2Vzcy4KKyAqCisgKiBSZXR1cm46IGZkIG9uIHN1Y2Nlc3MsIGVsc2UgZXJyb3IgY29k ZS4KKyAqLworaW50IGV0aG9zdV9uZXR3b3JrX2NyZWF0ZShzdHJ1Y3QgZXRob3N1X2RldmljZSAq ZWRldiwKKwkJCSAgc3RydWN0IGV0aG9zdV91YXBpX25ldHdvcmtfY3JlYXRlICp1YXBpKTsKKwor LyoqCisgKiBldGhvc3VfbmV0d29ya19nZXRfZnJvbV9mZCgpIC0gR2V0IG5ldHdvcmsgaGFuZGxl IGZyb20gZmQKKyAqCisgKiBUaGlzIGZ1bmN0aW9uIG11c3QgYmUgY2FsbGVkIGZyb20gYSB1c2Vy IHNwYWNlIGNvbnRleHQuCisgKgorICogUmV0dXJuOiBQb2ludGVyIG9uIHN1Y2Nlc3MsIGVsc2Ug RVJSX1BUUi4KKyAqLworc3RydWN0IGV0aG9zdV9uZXR3b3JrICpldGhvc3VfbmV0d29ya19nZXRf ZnJvbV9mZChpbnQgZmQpOworCisvKioKKyAqIGV0aG9zdV9uZXR3b3JrX2dldCgpIC0gR2V0IG5l dHdvcmsKKyAqLwordm9pZCBldGhvc3VfbmV0d29ya19nZXQoc3RydWN0IGV0aG9zdV9uZXR3b3Jr ICpuZXQpOworCisvKioKKyAqIGV0aG9zdV9uZXR3b3JrX3B1dCgpIC0gUHV0IG5ldHdvcmsKKyAq Lwordm9pZCBldGhvc3VfbmV0d29ya19wdXQoc3RydWN0IGV0aG9zdV9uZXR3b3JrICpuZXQpOwor CisjZW5kaWYgLyogRVRIT1NVX05FVFdPUktfSCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9maXJt d2FyZS9ldGhvc3UvdWFwaS9ldGhvc3UuaCBiL2RyaXZlcnMvZmlybXdhcmUvZXRob3N1L3VhcGkv ZXRob3N1LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi45MDMzMTZk ZmY3YjMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2Zpcm13YXJlL2V0aG9zdS91YXBpL2V0 aG9zdS5oCkBAIC0wLDAgKzEsMjA3IEBACisvKgorICogKEMpIENPUFlSSUdIVCAyMDIwIEFSTSBM aW1pdGVkLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVl IHNvZnR3YXJlIGFuZCBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZQor ICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZCBieSB0 aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlvbiwgYW5kIGFueSB1c2UgYnkgeW91IG9mIHRo aXMgcHJvZ3JhbSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcworICogb2Ygc3VjaCBHTlUgbGljZW5j ZS4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBl dmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUKKyAqIEdOVSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdp dGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHlvdSBjYW4gYWNjZXNzIGl0IG9ubGluZSBhdAorICog aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL2dwbC0yLjAuaHRtbC4KKyAqCisgKiBTUERYLUxp Y2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CisgKi8KKworI2lmbmRlZiBFVEhPU1VfSAor I2RlZmluZSBFVEhPU1VfSAorCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogSW5jbHVkZXMKKyAq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqLworCisjaW5jbHVkZSA8bGludXgvaW9jdGwuaD4KKyNpbmNsdWRl IDxsaW51eC90eXBlcy5oPgorCisjaWZkZWYgX19jcGx1c3BsdXMKK25hbWVzcGFjZSBFdGhvc1Ug eworI2VuZGlmCisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBEZWZpbmVzCisgKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKi8KKworI2RlZmluZSBFVEhPU1VfSU9DVExfQkFTRSAgICAgICAgICAgICAgIDB4 MDEKKyNkZWZpbmUgRVRIT1NVX0lPKG5yKSAgICAgICAgICAgICAgICAgICBfSU8oRVRIT1NVX0lP Q1RMX0JBU0UsIG5yKQorI2RlZmluZSBFVEhPU1VfSU9SKG5yLCB0eXBlKSAgICAgICAgICAgIF9J T1IoRVRIT1NVX0lPQ1RMX0JBU0UsIG5yLCB0eXBlKQorI2RlZmluZSBFVEhPU1VfSU9XKG5yLCB0 eXBlKSAgICAgICAgICAgIF9JT1coRVRIT1NVX0lPQ1RMX0JBU0UsIG5yLCB0eXBlKQorI2RlZmlu ZSBFVEhPU1VfSU9XUihuciwgdHlwZSkgICAgICAgICAgIF9JT1dSKEVUSE9TVV9JT0NUTF9CQVNF LCBuciwgdHlwZSkKKworI2RlZmluZSBFVEhPU1VfSU9DVExfUElORyAgICAgICAgICAgICAgIEVU SE9TVV9JTygweDAwKQorI2RlZmluZSBFVEhPU1VfSU9DVExfVkVSU0lPTl9SRVEgICAgICAgIEVU SE9TVV9JTygweDAxKQorI2RlZmluZSBFVEhPU1VfSU9DVExfQ0FQQUJJTElUSUVTX1JFUSAgIEVU SE9TVV9JTygweDAyKQorI2RlZmluZSBFVEhPU1VfSU9DVExfQlVGRkVSX0NSRUFURSAgICAgIEVU SE9TVV9JT1IoMHgxMCwgXAorCQkJCQkJICAgc3RydWN0IGV0aG9zdV91YXBpX2J1ZmZlcl9jcmVh dGUpCisjZGVmaW5lIEVUSE9TVV9JT0NUTF9CVUZGRVJfU0VUICAgICAgICAgRVRIT1NVX0lPUigw eDExLCBcCisJCQkJCQkgICBzdHJ1Y3QgZXRob3N1X3VhcGlfYnVmZmVyKQorI2RlZmluZSBFVEhP U1VfSU9DVExfQlVGRkVSX0dFVCAgICAgICAgIEVUSE9TVV9JT1coMHgxMiwgXAorCQkJCQkJICAg c3RydWN0IGV0aG9zdV91YXBpX2J1ZmZlcikKKyNkZWZpbmUgRVRIT1NVX0lPQ1RMX05FVFdPUktf Q1JFQVRFICAgICBFVEhPU1VfSU9SKDB4MjAsIFwKKwkJCQkJCSAgIHN0cnVjdCBldGhvc3VfdWFw aV9uZXR3b3JrX2NyZWF0ZSkKKyNkZWZpbmUgRVRIT1NVX0lPQ1RMX0lORkVSRU5DRV9DUkVBVEUg ICBFVEhPU1VfSU9SKDB4MzAsIFwKKwkJCQkJCSAgIHN0cnVjdCBldGhvc3VfdWFwaV9pbmZlcmVu Y2VfY3JlYXRlKQorI2RlZmluZSBFVEhPU1VfSU9DVExfSU5GRVJFTkNFX1NUQVRVUyAgIEVUSE9T VV9JT1IoMHgzMSwgXAorCQkJCQkJICAgc3RydWN0IGV0aG9zdV91YXBpX3Jlc3VsdF9zdGF0dXMp CisKKy8qIE1heGltdW0gbnVtYmVyIG9mIElGTS9PRk0gZmlsZSBkZXNjcmlwdG9ycyBwZXIgbmV0 d29yayAqLworI2RlZmluZSBFVEhPU1VfRkRfTUFYICAgICAgICAgICAgICAgICAgIDE2CisKKy8q IE1heGltdW0gbnVtYmVyIG9mIFBNVXMgYXZhaWxhYmxlICovCisjZGVmaW5lIEVUSE9TVV9QTVVf RVZFTlRfTUFYICAgICAgICAgICAgIDgKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIFR5cGVz CisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKi8KKworLyoqCisgKiBlbnVtIGV0aG9zdV91YXBpX3N0YXR1 cyAtIFN0YXR1cworICovCitlbnVtIGV0aG9zdV91YXBpX3N0YXR1cyB7CisJRVRIT1NVX1VBUElf U1RBVFVTX09LLAorCUVUSE9TVV9VQVBJX1NUQVRVU19FUlJPUgorfTsKKworLyoqCisgKiBzdHJ1 Y3QgZXRob3N1X3VhcGlfYnVmZmVyX2NyZWF0ZSAtIENyZWF0ZSBidWZmZXIgcmVxdWVzdAorICog QGNhcGFjaXR5OglNYXhpbXVtIGNhcGFjaXR5IG9mIHRoZSBidWZmZXIKKyAqLworc3RydWN0IGV0 aG9zdV91YXBpX2J1ZmZlcl9jcmVhdGUgeworCV9fdTMyIGNhcGFjaXR5OworfTsKKworLyoqCisg KiBzdHJ1Y3QgZXRob3N1X3VhcGlfYnVmZmVyIC0gQnVmZmVyIGRlc2NyaXB0b3IKKyAqIEBvZmZz ZXQ6CU9mZnNldCB0byB3aGVyZSB0aGUgZGF0YSBzdGFydHMKKyAqIEBzaXplOglTaXplIG9mIHRo ZSBkYXRhCisgKgorICogJ29mZnNldCArIHNpemUnIG11c3Qgbm90IGV4Y2VlZCB0aGUgY2FwYWNp dHkgb2YgdGhlIGJ1ZmZlci4KKyAqLworc3RydWN0IGV0aG9zdV91YXBpX2J1ZmZlciB7CisJX191 MzIgb2Zmc2V0OworCV9fdTMyIHNpemU7Cit9OworCisvKioKKyAqIHN0cnVjdCBldGhvc3VfdWFw aV9uZXR3b3JrX2NyZWF0ZSAtIENyZWF0ZSBuZXR3b3JrIHJlcXVlc3QKKyAqIEBmZDoJCUJ1ZmZl ciBmaWxlIGRlc2NyaXB0b3IKKyAqLworc3RydWN0IGV0aG9zdV91YXBpX25ldHdvcmtfY3JlYXRl IHsKKwlfX3UzMiBmZDsKK307CisKKy8qKgorICogc3RydWN0IGV0aG9zdV91YXBpX3BtdV9jb25m aWcgLSBDb25maWd1cmUgcGVyZm9ybWFuY2UgY291bnRlcnMKKyAqIEBldmVudHM6ICAgICAgICAg ICAgIEFycmF5IG9mIGNvdW50ZXJzIHRvIGNvbmZpZ3VyZSwgc2V0IHRvIG5vbi16ZXJvIGZvcgor ICogICAgICAgICAgICAgICAgICAgICAgZWFjaCBjb3VudGVyIHRvIGVuYWJsZSBjb3JyZXNwb25k aW5nIGV2ZW50LgorICogQGN5Y2xlX2NvdW50OiAgICAgICAgU2V0IHRvIGVuYWJsZSB0aGUgY3lj bGUgY291bnRlci4KKyAqLworc3RydWN0IGV0aG9zdV91YXBpX3BtdV9jb25maWcgeworCV9fdTMy IGV2ZW50c1tFVEhPU1VfUE1VX0VWRU5UX01BWF07CisJX191MzIgY3ljbGVfY291bnQ7Cit9Owor CisvKioKKyAqIHN0cnVjdCBldGhvc3VfdWFwaV9wbXVfY291bnRzIC0gU3RhdHVzIG9mIHBlcmZv cm1hbmNlIGNvdW50ZXJzCisgKiBAZXZlbnRzOiAgICAgICAgICAgICBDb3VudCBmb3IgcmVzcGVj dGl2ZSBjb25maWd1cmVkIGV2ZW50cy4KKyAqIEBjeWNsZV9jb3VudDogICAgICAgIENvdW50IGZv ciBjeWNsZSBjb3VudGVyLgorICovCitzdHJ1Y3QgZXRob3N1X3VhcGlfcG11X2NvdW50cyB7CisJ X191MzIgZXZlbnRzW0VUSE9TVV9QTVVfRVZFTlRfTUFYXTsKKwlfX3U2NCBjeWNsZV9jb3VudDsK K307CisKKy8qKgorICogc3RydWN0IGV0aG9zdV91YXBpX2RldmljZV9od19pZCAtIERldmljZSBo YXJkd2FyZSBpZGVudGlmaWNhdGlvbgorICogQHZlcnNpb25fc3RhdHVzOiAgICAgICAgICAgIFZl cnNpb24gc3RhdHVzCisgKiBAdmVyc2lvbl9taW5vcjogICAgICAgICAgICAgVmVyc2lvbiBtaW5v cgorICogQHZlcnNpb25fbWFqb3I6ICAgICAgICAgICAgIFZlcnNpb24gbWFqb3IKKyAqIEBwcm9k dWN0X21ham9yOiAgICAgICAgICAgICBQcm9kdWN0IG1ham9yCisgKiBAYXJjaF9wYXRjaF9yZXY6 ICAgICAgICAgICAgQXJjaGl0ZWN0dXJlIHZlcnNpb24gcGF0Y2gKKyAqIEBhcmNoX21pbm9yX3Jl djogICAgICAgICAgICBBcmNoaXRlY3R1cmUgdmVyc2lvbiBtaW5vcgorICogQGFyY2hfbWFqb3Jf cmV2OiAgICAgICAgICAgIEFyY2hpdGVjdHVyZSB2ZXJzaW9uIG1ham9yCisgKi8KK3N0cnVjdCBl dGhvc3VfdWFwaV9kZXZpY2VfaHdfaWQgeworCV9fdTMyIHZlcnNpb25fc3RhdHVzOworCV9fdTMy IHZlcnNpb25fbWlub3I7CisJX191MzIgdmVyc2lvbl9tYWpvcjsKKwlfX3UzMiBwcm9kdWN0X21h am9yOworCV9fdTMyIGFyY2hfcGF0Y2hfcmV2OworCV9fdTMyIGFyY2hfbWlub3JfcmV2OworCV9f dTMyIGFyY2hfbWFqb3JfcmV2OworfTsKKworLyoqCisgKiBzdHJ1Y3QgZXRob3N1X3VhcGlfZGV2 aWNlX2h3X2NmZyAtIERldmljZSBoYXJkd2FyZSBjb25maWd1cmF0aW9uCisgKiBAbWFjc19wZXJf Y2M6ICAgICAgICAgICAgICAgTUFDcyBwZXIgY2xvY2sgY3ljbGUKKyAqIEBjbWRfc3RyZWFtX3Zl cnNpb246ICAgICAgICBOUFUgY29tbWFuZCBzdHJlYW0gdmVyc2lvbgorICogQGN1c3RvbV9kbWE6 ICAgICAgICAgICAgICAgIEN1c3RvbSBETUEgZW5hYmxlZAorICovCitzdHJ1Y3QgZXRob3N1X3Vh cGlfZGV2aWNlX2h3X2NmZyB7CisJX191MzIgbWFjc19wZXJfY2M7CisJX191MzIgY21kX3N0cmVh bV92ZXJzaW9uOworCV9fdTMyIGN1c3RvbV9kbWE7Cit9OworCisvKioKKyAqIHN0cnVjdCBldGhv c3VfdWFwaV9jYXBhYmlsaXRpZXMgLSBEZXZpY2UgY2FwYWJpbGl0aWVzCisgKiBAaHdfaWQ6ICAg ICAgICAgICAgICAgICAgICAgSGFyZHdhcmUgaWRlbnRpZmljYXRpb24KKyAqIEBod19jZmc6ICAg ICAgICAgICAgICAgICAgICBIYXJkd2FyZSBjb25maWd1cmF0aW9uCisgKiBAZHJpdmVyX3BhdGNo X3JldjogICAgICAgICAgRHJpdmVyIHZlcnNpb24gcGF0Y2gKKyAqIEBkcml2ZXJfbWlub3JfcmV2 OiAgICAgICAgICBEcml2ZXIgdmVyc2lvbiBtaW5vcgorICogQGRyaXZlcl9tYWpvcl9yZXY6ICAg ICAgICAgIERyaXZlciB2ZXJzaW9uIG1ham9yCisgKi8KK3N0cnVjdCBldGhvc3VfdWFwaV9kZXZp Y2VfY2FwYWJpbGl0aWVzIHsKKwlzdHJ1Y3QgZXRob3N1X3VhcGlfZGV2aWNlX2h3X2lkICBod19p ZDsKKwlzdHJ1Y3QgZXRob3N1X3VhcGlfZGV2aWNlX2h3X2NmZyBod19jZmc7CisJX191MzIgICAg ICAgICAgICAgICAgICAgICAgICAgICAgZHJpdmVyX3BhdGNoX3JldjsKKwlfX3UzMiAgICAgICAg ICAgICAgICAgICAgICAgICAgICBkcml2ZXJfbWlub3JfcmV2OworCV9fdTMyICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGRyaXZlcl9tYWpvcl9yZXY7Cit9OworCisvKioKKyAqIHN0cnVjdCBl dGhvc3VfdWFwaV9pbmZlcmVuY2VfY3JlYXRlIC0gQ3JlYXRlIG5ldHdvcmsgcmVxdWVzdAorICog QGlmbV9jb3VudDoJCU51bWJlciBvZiBJRk0gZmlsZSBkZXNjcmlwdG9ycworICogQGlmbV9mZDoJ CUlGTSBidWZmZXIgZmlsZSBkZXNjcmlwdG9ycworICogQG9mbV9jb3VudDoJCU51bWJlciBvZiBP Rk0gZmlsZSBkZXNjcmlwdG9ycworICogQG9mbV9mZDoJCU9GTSBidWZmZXIgZmlsZSBkZXNjcmlw dG9ycworICovCitzdHJ1Y3QgZXRob3N1X3VhcGlfaW5mZXJlbmNlX2NyZWF0ZSB7CisJX191MzIg ICAgICAgICAgICAgICAgICAgICAgICAgaWZtX2NvdW50OworCV9fdTMyICAgICAgICAgICAgICAg ICAgICAgICAgIGlmbV9mZFtFVEhPU1VfRkRfTUFYXTsKKwlfX3UzMiAgICAgICAgICAgICAgICAg ICAgICAgICBvZm1fY291bnQ7CisJX191MzIgICAgICAgICAgICAgICAgICAgICAgICAgb2ZtX2Zk W0VUSE9TVV9GRF9NQVhdOworCXN0cnVjdCBldGhvc3VfdWFwaV9wbXVfY29uZmlnIHBtdV9jb25m aWc7Cit9OworCisvKioKKyAqIHN0cnVjdCBldGhvc3VfdWFwaV9yZXN1bHRfc3RhdHVzIC0gU3Rh dHVzIG9mIGluZmVyZW5jZQorICogQHN0YXR1cwlTdGF0dXMgb2YgcnVuIGluZmVyZW5jZS4KKyAq IEBwbXVfY29uZmlnCUNvbmZpZ3VyZWQgcGVyZm9ybWFuY2UgY291bnRlcnMuCisgKiBAcG11X2Nv dW50CVBlcmZvbWFuY2UgY291bnRlcnMgdmFsdWVzLCB3aGVuIHN0YXR1cyBpcworICogICAgICAg ICAgICAgIEVUSE9TVV9VQVBJX1NUQVRVU19PSy4KKyAqLworc3RydWN0IGV0aG9zdV91YXBpX3Jl c3VsdF9zdGF0dXMgeworCWVudW0gZXRob3N1X3VhcGlfc3RhdHVzICAgICAgIHN0YXR1czsKKwlz dHJ1Y3QgZXRob3N1X3VhcGlfcG11X2NvbmZpZyBwbXVfY29uZmlnOworCXN0cnVjdCBldGhvc3Vf dWFwaV9wbXVfY291bnRzIHBtdV9jb3VudDsKK307CisKKyNpZmRlZiBfX2NwbHVzcGx1cworfSAv KiBuYW1lc3BhY2UgRXRob3NVICovCisjZW5kaWYKKyNlbmRpZgotLSAKMi4xNy4xCgoKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5l bCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6 Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo= 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 Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8FF53EB64D7 for ; Fri, 16 Jun 2023 05:53:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241773AbjFPFxh (ORCPT ); Fri, 16 Jun 2023 01:53:37 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:41532 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241336AbjFPFxM (ORCPT ); Fri, 16 Jun 2023 01:53:12 -0400 Received: from inva020.nxp.com (inva020.nxp.com [92.121.34.13]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D60472D63 for ; Thu, 15 Jun 2023 22:53:06 -0700 (PDT) Received: from inva020.nxp.com (localhost [127.0.0.1]) by inva020.eu-rdc02.nxp.com (Postfix) with ESMTP id A0B3A1A06A2; Fri, 16 Jun 2023 07:43:03 +0200 (CEST) Received: from aprdc01srsp001v.ap-rdc01.nxp.com (aprdc01srsp001v.ap-rdc01.nxp.com [165.114.16.16]) by inva020.eu-rdc02.nxp.com (Postfix) with ESMTP id AC4A61A068F; Fri, 16 Jun 2023 07:43:02 +0200 (CEST) Received: from localhost.localdomain (mega.ap.freescale.net [10.192.208.232]) by aprdc01srsp001v.ap-rdc01.nxp.com (Postfix) with ESMTP id 3BFDC180222B; Fri, 16 Jun 2023 13:43:01 +0800 (+08) From: Alison Wang To: gregkh@linuxfoundation.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: leoyang.li@nxp.com, xuelin.shi@nxp.com, xiaofeng.ren@nxp.com, feng.guo@nxp.com, Alison Wang Subject: [PATCH 1/8] ethosu: Add Arm Ethos-U driver Date: Fri, 16 Jun 2023 13:59:06 +0800 Message-Id: <20230616055913.2360-2-alison.wang@nxp.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20230616055913.2360-1-alison.wang@nxp.com> References: <20230616055913.2360-1-alison.wang@nxp.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Virus-Scanned: ClamAV using ClamSMTP Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Ethos-U Linux driver is to provide an example of how a rich operating system like Linux can dispatch inferences to an Arm Cortex-M subsystem, consisting of an Arm Cortex-M and an Arm Ethos-U NPU. Link: https://git.mlplatform.org/ml/ethos-u/ethos-u-linux-driver-stack.git Tag: 22.02 Signed-off-by: Kristofer Jonsson Signed-off-by: Per Astrand Signed-off-by: Jonny Svärd Signed-off-by: Lior Dekel Signed-off-by: Henrik Hoglind Signed-off-by: Davide Grohmann Signed-off-by: Alison Wang --- drivers/firmware/Kconfig | 1 + drivers/firmware/Makefile | 1 + drivers/firmware/ethosu/Kconfig | 24 + drivers/firmware/ethosu/Makefile | 28 ++ drivers/firmware/ethosu/ethosu_buffer.c | 312 ++++++++++++ drivers/firmware/ethosu/ethosu_buffer.h | 106 ++++ .../firmware/ethosu/ethosu_core_interface.h | 183 +++++++ drivers/firmware/ethosu/ethosu_device.c | 474 ++++++++++++++++++ drivers/firmware/ethosu/ethosu_device.h | 88 ++++ drivers/firmware/ethosu/ethosu_driver.c | 191 +++++++ drivers/firmware/ethosu/ethosu_inference.c | 417 +++++++++++++++ drivers/firmware/ethosu/ethosu_inference.h | 120 +++++ drivers/firmware/ethosu/ethosu_mailbox.c | 377 ++++++++++++++ drivers/firmware/ethosu/ethosu_mailbox.h | 140 ++++++ drivers/firmware/ethosu/ethosu_network.c | 201 ++++++++ drivers/firmware/ethosu/ethosu_network.h | 81 +++ drivers/firmware/ethosu/uapi/ethosu.h | 207 ++++++++ 17 files changed, 2951 insertions(+) create mode 100644 drivers/firmware/ethosu/Kconfig create mode 100644 drivers/firmware/ethosu/Makefile create mode 100644 drivers/firmware/ethosu/ethosu_buffer.c create mode 100644 drivers/firmware/ethosu/ethosu_buffer.h create mode 100644 drivers/firmware/ethosu/ethosu_core_interface.h create mode 100644 drivers/firmware/ethosu/ethosu_device.c create mode 100644 drivers/firmware/ethosu/ethosu_device.h create mode 100644 drivers/firmware/ethosu/ethosu_driver.c create mode 100644 drivers/firmware/ethosu/ethosu_inference.c create mode 100644 drivers/firmware/ethosu/ethosu_inference.h create mode 100644 drivers/firmware/ethosu/ethosu_mailbox.c create mode 100644 drivers/firmware/ethosu/ethosu_mailbox.h create mode 100644 drivers/firmware/ethosu/ethosu_network.c create mode 100644 drivers/firmware/ethosu/ethosu_network.h create mode 100644 drivers/firmware/ethosu/uapi/ethosu.h diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig index b59e3041fd62..bbad6dc81e7b 100644 --- a/drivers/firmware/Kconfig +++ b/drivers/firmware/Kconfig @@ -308,6 +308,7 @@ source "drivers/firmware/broadcom/Kconfig" source "drivers/firmware/cirrus/Kconfig" source "drivers/firmware/google/Kconfig" source "drivers/firmware/efi/Kconfig" +source "drivers/firmware/ethosu/Kconfig" source "drivers/firmware/imx/Kconfig" source "drivers/firmware/meson/Kconfig" source "drivers/firmware/psci/Kconfig" diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile index 28fcddcd688f..6c597a78daa7 100644 --- a/drivers/firmware/Makefile +++ b/drivers/firmware/Makefile @@ -33,6 +33,7 @@ obj-y += cirrus/ obj-y += meson/ obj-$(CONFIG_GOOGLE_FIRMWARE) += google/ obj-y += efi/ +obj-$(CONFIG_ETHOSU) += ethosu/ obj-y += imx/ obj-y += psci/ obj-y += smccc/ diff --git a/drivers/firmware/ethosu/Kconfig b/drivers/firmware/ethosu/Kconfig new file mode 100644 index 000000000000..ce837f45f8e5 --- /dev/null +++ b/drivers/firmware/ethosu/Kconfig @@ -0,0 +1,24 @@ +# +# (C) COPYRIGHT 2020 ARM Limited. All rights reserved. +# +# This program is free software and is provided to you under the terms of the +# GNU General Public License version 2 as published by the Free Software +# Foundation, and any use by you of this program is subject to the terms +# of such GNU licence. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, you can access it online at +# http://www.gnu.org/licenses/gpl-2.0.html. +# +# SPDX-License-Identifier: GPL-2.0-only +# + +config ETHOSU + tristate "Arm Ethos-U NPU support" + help + Arm Ethos-U NPU driver. diff --git a/drivers/firmware/ethosu/Makefile b/drivers/firmware/ethosu/Makefile new file mode 100644 index 000000000000..933efee1b22f --- /dev/null +++ b/drivers/firmware/ethosu/Makefile @@ -0,0 +1,28 @@ +# +# (C) COPYRIGHT 2020 ARM Limited. All rights reserved. +# +# This program is free software and is provided to you under the terms of the +# GNU General Public License version 2 as published by the Free Software +# Foundation, and any use by you of this program is subject to the terms +# of such GNU licence. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, you can access it online at +# http://www.gnu.org/licenses/gpl-2.0.html. +# +# SPDX-License-Identifier: GPL-2.0-only +# + +obj-$(CONFIG_ETHOSU) = ethosu.o + +ethosu-objs := ethosu_driver.o \ + ethosu_buffer.o \ + ethosu_device.o \ + ethosu_inference.o \ + ethosu_mailbox.o \ + ethosu_network.o diff --git a/drivers/firmware/ethosu/ethosu_buffer.c b/drivers/firmware/ethosu/ethosu_buffer.c new file mode 100644 index 000000000000..43a433355f30 --- /dev/null +++ b/drivers/firmware/ethosu/ethosu_buffer.c @@ -0,0 +1,312 @@ +/* + * (C) COPYRIGHT 2020-2021 Arm Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +/**************************************************************************** + * Includes + ****************************************************************************/ + +#include "ethosu_buffer.h" + +#include "ethosu_device.h" +#include "uapi/ethosu.h" + +#include +#include +#include +#include +#include +#include + +/**************************************************************************** + * Variables + ****************************************************************************/ + +static int ethosu_buffer_release(struct inode *inode, + struct file *file); + +static int ethosu_buffer_mmap(struct file *file, + struct vm_area_struct *vma); + +static long ethosu_buffer_ioctl(struct file *file, + unsigned int cmd, + unsigned long arg); + +static const struct file_operations ethosu_buffer_fops = { + .release = ðosu_buffer_release, + .mmap = ðosu_buffer_mmap, + .unlocked_ioctl = ðosu_buffer_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = ðosu_buffer_ioctl, +#endif +}; + +/**************************************************************************** + * Functions + ****************************************************************************/ + +/* + * The 'dma-ranges' device tree property for shared dma memory does not seem + * to be fully supported for coherent memory. Therefor we apply the DMA range + * offset ourselves. + */ +static dma_addr_t ethosu_buffer_dma_ranges(struct device *dev, + dma_addr_t dma_addr, + size_t dma_buf_size) +{ + struct device_node *node = dev->of_node; + const __be32 *ranges; + int len; + int naddr; + int nsize; + int inc; + int i; + + if (!node) + return dma_addr; + + /* Get the #address-cells and #size-cells properties */ + naddr = of_n_addr_cells(node); + nsize = of_n_size_cells(node); + + /* Read the 'dma-ranges' property */ + ranges = of_get_property(node, "dma-ranges", &len); + if (!ranges || len <= 0) + return dma_addr; + + dev_dbg(dev, "ranges=%p, len=%d, naddr=%d, nsize=%d\n", + ranges, len, naddr, nsize); + + len /= sizeof(*ranges); + inc = naddr + naddr + nsize; + + for (i = 0; (i + inc) <= len; i += inc) { + dma_addr_t daddr; + dma_addr_t paddr; + dma_addr_t size; + + daddr = of_read_number(&ranges[i], naddr); + paddr = of_read_number(&ranges[i + naddr], naddr); + size = of_read_number(&ranges[i + naddr + naddr], nsize); + + dev_dbg(dev, "daddr=0x%llx, paddr=0x%llx, size=0x%llx\n", + daddr, paddr, size); + + if (dma_addr >= paddr && + (dma_addr + dma_buf_size) < (paddr + size)) + return dma_addr + daddr - paddr; + } + + return dma_addr; +} + +static bool ethosu_buffer_verify(struct file *file) +{ + return file->f_op == ðosu_buffer_fops; +} + +static void ethosu_buffer_destroy(struct kref *kref) +{ + struct ethosu_buffer *buf = + container_of(kref, struct ethosu_buffer, kref); + + dev_info(buf->edev->dev, "Buffer destroy. handle=0x%pK\n", buf); + + dma_free_coherent(buf->edev->dev, buf->capacity, buf->cpu_addr, + buf->dma_addr_orig); + devm_kfree(buf->edev->dev, buf); +} + +static int ethosu_buffer_release(struct inode *inode, + struct file *file) +{ + struct ethosu_buffer *buf = file->private_data; + + dev_info(buf->edev->dev, "Buffer release. handle=0x%pK\n", buf); + + ethosu_buffer_put(buf); + + return 0; +} + +static int ethosu_buffer_mmap(struct file *file, + struct vm_area_struct *vma) +{ + struct ethosu_buffer *buf = file->private_data; + int ret; + + dev_info(buf->edev->dev, "Buffer mmap. handle=0x%pK\n", buf); + + ret = dma_mmap_coherent(buf->edev->dev, vma, buf->cpu_addr, + buf->dma_addr_orig, + buf->capacity); + + return ret; +} + +static long ethosu_buffer_ioctl(struct file *file, + unsigned int cmd, + unsigned long arg) +{ + struct ethosu_buffer *buf = file->private_data; + void __user *udata = (void __user *)arg; + int ret = -EINVAL; + + ret = mutex_lock_interruptible(&buf->edev->mutex); + if (ret) + return ret; + + dev_info(buf->edev->dev, "Ioctl. cmd=%u, arg=%lu\n", cmd, arg); + + switch (cmd) { + case ETHOSU_IOCTL_BUFFER_SET: { + struct ethosu_uapi_buffer uapi; + + if (copy_from_user(&uapi, udata, sizeof(uapi))) + break; + + dev_info(buf->edev->dev, + "Ioctl: Buffer set. size=%u, offset=%u\n", + uapi.size, uapi.offset); + + ret = ethosu_buffer_resize(buf, uapi.size, uapi.offset); + break; + } + case ETHOSU_IOCTL_BUFFER_GET: { + struct ethosu_uapi_buffer uapi; + + uapi.size = buf->size; + uapi.offset = buf->offset; + + dev_info(buf->edev->dev, + "Ioctl: Buffer get. size=%u, offset=%u\n", + uapi.size, uapi.offset); + + if (copy_to_user(udata, &uapi, sizeof(uapi))) + break; + + ret = 0; + break; + } + default: { + dev_err(buf->edev->dev, "Invalid ioctl. cmd=%u, arg=%lu", + cmd, arg); + break; + } + } + + mutex_unlock(&buf->edev->mutex); + + return ret; +} + +int ethosu_buffer_create(struct ethosu_device *edev, + size_t capacity) +{ + struct ethosu_buffer *buf; + int ret = -ENOMEM; + + buf = devm_kzalloc(edev->dev, sizeof(*buf), GFP_KERNEL); + if (!buf) + return -ENOMEM; + + buf->edev = edev; + buf->capacity = capacity; + buf->offset = 0; + buf->size = 0; + kref_init(&buf->kref); + + buf->cpu_addr = dma_alloc_coherent(buf->edev->dev, capacity, + &buf->dma_addr_orig, GFP_KERNEL); + if (!buf->cpu_addr) + goto free_buf; + + buf->dma_addr = ethosu_buffer_dma_ranges(buf->edev->dev, + buf->dma_addr_orig, + buf->capacity); + + ret = anon_inode_getfd("ethosu-buffer", ðosu_buffer_fops, buf, + O_RDWR | O_CLOEXEC); + if (ret < 0) + goto free_dma; + + buf->file = fget(ret); + fput(buf->file); + + dev_info(buf->edev->dev, + "Buffer create. handle=0x%pK, capacity=%zu, cpu_addr=0x%pK, dma_addr=0x%llx, dma_addr_orig=0x%llx, phys_addr=0x%llx\n", + buf, capacity, buf->cpu_addr, buf->dma_addr, + buf->dma_addr_orig, virt_to_phys(buf->cpu_addr)); + + return ret; + +free_dma: + dma_free_coherent(buf->edev->dev, buf->capacity, buf->cpu_addr, + buf->dma_addr_orig); + +free_buf: + devm_kfree(buf->edev->dev, buf); + + return ret; +} + +struct ethosu_buffer *ethosu_buffer_get_from_fd(int fd) +{ + struct ethosu_buffer *buf; + struct file *file; + + file = fget(fd); + if (!file) + return ERR_PTR(-EINVAL); + + if (!ethosu_buffer_verify(file)) { + fput(file); + + return ERR_PTR(-EINVAL); + } + + buf = file->private_data; + ethosu_buffer_get(buf); + fput(file); + + return buf; +} + +void ethosu_buffer_get(struct ethosu_buffer *buf) +{ + kref_get(&buf->kref); +} + +void ethosu_buffer_put(struct ethosu_buffer *buf) +{ + kref_put(&buf->kref, ethosu_buffer_destroy); +} + +int ethosu_buffer_resize(struct ethosu_buffer *buf, + size_t size, + size_t offset) +{ + if ((size + offset) > buf->capacity) + return -EINVAL; + + buf->size = size; + buf->offset = offset; + + return 0; +} diff --git a/drivers/firmware/ethosu/ethosu_buffer.h b/drivers/firmware/ethosu/ethosu_buffer.h new file mode 100644 index 000000000000..14f26c2b0a9d --- /dev/null +++ b/drivers/firmware/ethosu/ethosu_buffer.h @@ -0,0 +1,106 @@ +/* + * (C) COPYRIGHT 2020 ARM Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +#ifndef ETHOSU_BUFFER_H +#define ETHOSU_BUFFER_H + +/**************************************************************************** + * Includes + ****************************************************************************/ + +#include +#include + +/**************************************************************************** + * Types + ****************************************************************************/ + +struct ethosu_device; +struct device; + +/** + * struct ethosu_buffer - Buffer + * @dev: Device + * @file: File + * @kref: Reference counting + * @capacity: Maximum capacity of the buffer + * @offset: Offset to first byte of buffer + * @size: Size of the data in the buffer + * @cpu_addr: Kernel mapped address + * @dma_addr: DMA address + * @dma_addr_orig: Original DMA address before range mapping + * + * 'offset + size' must not be larger than 'capacity'. + */ +struct ethosu_buffer { + struct ethosu_device *edev; + struct file *file; + struct kref kref; + size_t capacity; + size_t offset; + size_t size; + void *cpu_addr; + dma_addr_t dma_addr; + dma_addr_t dma_addr_orig; +}; + +/**************************************************************************** + * Functions + ****************************************************************************/ + +/** + * ethosu_buffer_create() - Create buffer + * + * This function must be called in the context of a user space process. + * + * Return: fd on success, else error code. + */ +int ethosu_buffer_create(struct ethosu_device *edev, + size_t capacity); + +/** + * ethosu_buffer_get_from_fd() - Get buffer handle from fd + * + * This function must be called from a user space context. + * + * Return: Pointer on success, else ERR_PTR. + */ +struct ethosu_buffer *ethosu_buffer_get_from_fd(int fd); + +/** + * ethosu_buffer_get() - Put buffer + */ +void ethosu_buffer_get(struct ethosu_buffer *buf); + +/** + * ethosu_buffer_put() - Put buffer + */ +void ethosu_buffer_put(struct ethosu_buffer *buf); + +/** + * ethosu_buffer_resize() - Resize and validate buffer + * + * Return: 0 on success, else error code. + */ +int ethosu_buffer_resize(struct ethosu_buffer *buf, + size_t size, + size_t offset); + +#endif /* ETHOSU_BUFFER_H */ diff --git a/drivers/firmware/ethosu/ethosu_core_interface.h b/drivers/firmware/ethosu/ethosu_core_interface.h new file mode 100644 index 000000000000..ef63c3b55352 --- /dev/null +++ b/drivers/firmware/ethosu/ethosu_core_interface.h @@ -0,0 +1,183 @@ +/* + * (C) COPYRIGHT 2020 ARM Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +#ifndef ETHOSU_CORE_INTERFACE_H +#define ETHOSU_CORE_INTERFACE_H + +#ifdef __KERNEL__ +#include +#else +#include +#endif + +#ifdef __cplusplus +namespace EthosU { +#endif + +/** Maximum number of IFM/OFM buffers per inference */ +#define ETHOSU_CORE_BUFFER_MAX 16 + +/** Maximum number of PMU counters to be returned for inference */ +#define ETHOSU_CORE_PMU_MAX 8 + +#define ETHOSU_CORE_MSG_MAGIC 0x41457631 +#define ETHOSU_CORE_MSG_VERSION_MAJOR 0 +#define ETHOSU_CORE_MSG_VERSION_MINOR 2 +#define ETHOSU_CORE_MSG_VERSION_PATCH 0 + +/** + * enum ethosu_core_msg_type - Message types + * + * Types for the messages sent between the host and the core subsystem. + */ +enum ethosu_core_msg_type { + ETHOSU_CORE_MSG_ERR = 1, + ETHOSU_CORE_MSG_PING, + ETHOSU_CORE_MSG_PONG, + ETHOSU_CORE_MSG_INFERENCE_REQ, + ETHOSU_CORE_MSG_INFERENCE_RSP, + ETHOSU_CORE_MSG_VERSION_REQ, + ETHOSU_CORE_MSG_VERSION_RSP, + ETHOSU_CORE_MSG_CAPABILITIES_REQ, + ETHOSU_CORE_MSG_CAPABILITIES_RSP, + ETHOSU_CORE_MSG_MAX +}; + +/** + * struct ethosu_core_msg - Message header + */ +struct ethosu_core_msg { + uint32_t magic; + uint32_t type; + uint32_t length; +}; + +/** + * struct ethosu_core_queue_header - Message queue header + */ +struct ethosu_core_queue_header { + uint32_t size; + uint32_t read; + uint32_t write; +}; + +/** + * struct ethosu_core_queue - Message queue + * + * Dynamically sized message queue. + */ +struct ethosu_core_queue { + struct ethosu_core_queue_header header; + uint8_t data[]; +}; + +enum ethosu_core_status { + ETHOSU_CORE_STATUS_OK, + ETHOSU_CORE_STATUS_ERROR +}; + +struct ethosu_core_buffer { + uint32_t ptr; + uint32_t size; +}; + +struct ethosu_core_inference_req { + uint64_t user_arg; + uint32_t ifm_count; + struct ethosu_core_buffer ifm[ETHOSU_CORE_BUFFER_MAX]; + uint32_t ofm_count; + struct ethosu_core_buffer ofm[ETHOSU_CORE_BUFFER_MAX]; + struct ethosu_core_buffer network; + uint8_t pmu_event_config[ETHOSU_CORE_PMU_MAX]; + uint32_t pmu_cycle_counter_enable; +}; + +struct ethosu_core_inference_rsp { + uint64_t user_arg; + uint32_t ofm_count; + uint32_t ofm_size[ETHOSU_CORE_BUFFER_MAX]; + uint32_t status; + uint8_t pmu_event_config[ETHOSU_CORE_PMU_MAX]; + uint32_t pmu_event_count[ETHOSU_CORE_PMU_MAX]; + uint32_t pmu_cycle_counter_enable; + uint64_t pmu_cycle_counter_count; +}; + +/** + * struct ethosu_core_msg_verson - Message protocol version + */ +struct ethosu_core_msg_version { + uint8_t major; + uint8_t minor; + uint8_t patch; + uint8_t _reserved; +}; + +/** + * struct ethosu_core_capabilities_req - Message capabilities request + */ +struct ethosu_core_capabilities_req { + uint64_t user_arg; +}; + +/** + * struct ethosu_core_capabilities_rsp - Message capabilities response + */ +struct ethosu_core_msg_capabilities_rsp { + uint64_t user_arg; + uint32_t version_status; + uint32_t version_minor; + uint32_t version_major; + uint32_t product_major; + uint32_t arch_patch_rev; + uint32_t arch_minor_rev; + uint32_t arch_major_rev; + uint32_t driver_patch_rev; + uint32_t driver_minor_rev; + uint32_t driver_major_rev; + uint32_t macs_per_cc; + uint32_t cmd_stream_version; + uint32_t custom_dma; +}; + +/** + * enum ethosu_core_msg_err_type - Error types + */ +enum ethosu_core_msg_err_type { + ETHOSU_CORE_MSG_ERR_GENERIC = 0, + ETHOSU_CORE_MSG_ERR_UNSUPPORTED_TYPE, + ETHOSU_CORE_MSG_ERR_INVALID_PAYLOAD, + ETHOSU_CORE_MSG_ERR_INVALID_SIZE, + ETHOSU_CORE_MSG_ERR_INVALID_MAGIC, + ETHOSU_CORE_MSG_ERR_MAX +}; + +/** + * struct ethosu_core_msg_err - Error message struct + */ +struct ethosu_core_msg_err { + uint32_t type; /* optional use of extra error code */ + char msg[128]; +}; +#ifdef __cplusplus +} /*namespace EthosU */ +#endif + +#endif diff --git a/drivers/firmware/ethosu/ethosu_device.c b/drivers/firmware/ethosu/ethosu_device.c new file mode 100644 index 000000000000..e6f1e8012b06 --- /dev/null +++ b/drivers/firmware/ethosu/ethosu_device.c @@ -0,0 +1,474 @@ +/* + * (C) COPYRIGHT 2020 ARM Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +/**************************************************************************** + * Includes + ****************************************************************************/ + +#include "ethosu_device.h" + +#include "ethosu_buffer.h" +#include "ethosu_core_interface.h" +#include "ethosu_inference.h" +#include "ethosu_network.h" +#include "uapi/ethosu.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/**************************************************************************** + * Defines + ****************************************************************************/ + +#define DMA_ADDR_BITS 32 /* Number of address bits */ + +#define CAPABILITIES_RESP_TIMEOUT_MS 2000 + +/**************************************************************************** + * Types + ****************************************************************************/ + +/**************************************************************************** + * Functions + ****************************************************************************/ + +static void ethosu_capabilities_destroy(struct kref *kref) +{ + struct ethosu_capabilities *cap = + container_of(kref, struct ethosu_capabilities, refcount); + + list_del(&cap->list); + + devm_kfree(cap->edev->dev, cap); +} + +static int ethosu_capabilities_find(struct ethosu_capabilities *cap, + struct list_head *capabilties_list) +{ + struct ethosu_capabilities *cur; + + list_for_each_entry(cur, capabilties_list, list) { + if (cur == cap) + return 0; + } + + return -EINVAL; +} + +static int ethosu_capability_rsp(struct ethosu_device *edev, + struct ethosu_core_msg_capabilities_rsp *msg) +{ + struct ethosu_capabilities *cap; + struct ethosu_uapi_device_capabilities *capabilities; + int ret; + + cap = (struct ethosu_capabilities *)msg->user_arg; + ret = ethosu_capabilities_find(cap, &edev->capabilities_list); + if (0 != ret) { + dev_warn(edev->dev, + "Handle not found in capabilities list. handle=0x%p\n", + cap); + + /* NOTE: do not call complete or kref_put on invalid data! */ + return ret; + } + + capabilities = cap->capabilities; + + capabilities->hw_id.version_status = msg->version_status; + capabilities->hw_id.version_minor = msg->version_minor; + capabilities->hw_id.version_major = msg->version_major; + capabilities->hw_id.product_major = msg->product_major; + capabilities->hw_id.arch_patch_rev = msg->arch_patch_rev; + capabilities->hw_id.arch_minor_rev = msg->arch_minor_rev; + capabilities->hw_id.arch_major_rev = msg->arch_major_rev; + capabilities->driver_patch_rev = msg->driver_patch_rev; + capabilities->driver_minor_rev = msg->driver_minor_rev; + capabilities->driver_major_rev = msg->driver_major_rev; + capabilities->hw_cfg.macs_per_cc = msg->macs_per_cc; + capabilities->hw_cfg.cmd_stream_version = msg->cmd_stream_version; + capabilities->hw_cfg.custom_dma = msg->custom_dma; + + complete(&cap->done); + + kref_put(&cap->refcount, ethosu_capabilities_destroy); + + return 0; +} + +/* Incoming messages */ +static int ethosu_handle_msg(struct ethosu_device *edev) +{ + int ret; + struct ethosu_core_msg header; + + union { + struct ethosu_core_msg_err error; + struct ethosu_core_inference_rsp inf; + struct ethosu_core_msg_version version; + struct ethosu_core_msg_capabilities_rsp capabilities; + } data; + + /* Read message */ + ret = ethosu_mailbox_read(&edev->mailbox, &header, &data, sizeof(data)); + if (ret) + return ret; + + switch (header.type) { + case ETHOSU_CORE_MSG_ERR: + if (header.length != sizeof(data.error)) { + dev_warn(edev->dev, + "Msg: Error message of incorrect size. size=%u, expected=%zu\n", header.length, + sizeof(data.error)); + ret = -EBADMSG; + break; + } + + data.error.msg[sizeof(data.error.msg) - 1] = '\0'; + dev_warn(edev->dev, "Msg: Error. type=%u, msg=\"%s\"\n", + data.error.type, data.error.msg); + ret = -EBADMSG; + break; + case ETHOSU_CORE_MSG_PING: + dev_info(edev->dev, "Msg: Ping\n"); + ret = ethosu_mailbox_pong(&edev->mailbox); + break; + case ETHOSU_CORE_MSG_PONG: + dev_info(edev->dev, "Msg: Pong\n"); + break; + case ETHOSU_CORE_MSG_INFERENCE_RSP: + if (header.length != sizeof(data.inf)) { + dev_warn(edev->dev, + "Msg: Inference response of incorrect size. size=%u, expected=%zu\n", header.length, + sizeof(data.inf)); + ret = -EBADMSG; + break; + } + + dev_info(edev->dev, + "Msg: Inference response. user_arg=0x%llx, ofm_count=%u, status=%u\n", + data.inf.user_arg, data.inf.ofm_count, + data.inf.status); + ethosu_inference_rsp(edev, &data.inf); + break; + case ETHOSU_CORE_MSG_VERSION_RSP: + if (header.length != sizeof(data.version)) { + dev_warn(edev->dev, + "Msg: Version response of incorrect size. size=%u, expected=%zu\n", header.length, + sizeof(data.version)); + ret = -EBADMSG; + break; + } + + dev_info(edev->dev, "Msg: Version response v%u.%u.%u\n", + data.version.major, data.version.minor, + data.version.patch); + + /* Check major and minor version match, else return error */ + if (data.version.major != ETHOSU_CORE_MSG_VERSION_MAJOR || + data.version.minor != ETHOSU_CORE_MSG_VERSION_MINOR) { + dev_warn(edev->dev, "Msg: Version mismatch detected! "); + dev_warn(edev->dev, "Local version: v%u.%u.%u\n", + ETHOSU_CORE_MSG_VERSION_MAJOR, + ETHOSU_CORE_MSG_VERSION_MINOR, + ETHOSU_CORE_MSG_VERSION_PATCH); + } + + break; + case ETHOSU_CORE_MSG_CAPABILITIES_RSP: + if (header.length != sizeof(data.capabilities)) { + dev_warn(edev->dev, + "Msg: Capabilities response of incorrect size. size=%u, expected=%zu\n", header.length, + sizeof(data.capabilities)); + ret = -EBADMSG; + break; + } + + dev_info(edev->dev, + "Msg: Capabilities response ua%llx vs%hhu v%hhu.%hhu p%hhu av%hhu.%hhu.%hhu dv%hhu.%hhu.%hhu mcc%hhu csv%hhu cd%hhu\n", + data.capabilities.user_arg, + data.capabilities.version_status, + data.capabilities.version_major, + data.capabilities.version_minor, + data.capabilities.product_major, + data.capabilities.arch_major_rev, + data.capabilities.arch_minor_rev, + data.capabilities.arch_patch_rev, + data.capabilities.driver_major_rev, + data.capabilities.driver_minor_rev, + data.capabilities.driver_patch_rev, + data.capabilities.macs_per_cc, + data.capabilities.cmd_stream_version, + data.capabilities.custom_dma); + + ret = ethosu_capability_rsp(edev, &data.capabilities); + break; + default: + /* This should not happen due to version checks */ + dev_warn(edev->dev, "Msg: Protocol error\n"); + ret = -EPROTO; + break; + } + + return ret; +} + +static int ethosu_open(struct inode *inode, + struct file *file) +{ + struct ethosu_device *edev = + container_of(inode->i_cdev, struct ethosu_device, cdev); + + file->private_data = edev; + + dev_info(edev->dev, "Opening device node.\n"); + + return nonseekable_open(inode, file); +} + +static int ethosu_send_capabilities_request(struct ethosu_device *edev, + void __user *udata) +{ + struct ethosu_uapi_device_capabilities uapi; + struct ethosu_capabilities *cap; + int ret; + int timeout; + + cap = devm_kzalloc(edev->dev, sizeof(struct ethosu_capabilities), + GFP_KERNEL); + if (!cap) + return -ENOMEM; + + cap->edev = edev; + cap->capabilities = &uapi; + kref_init(&cap->refcount); + init_completion(&cap->done); + list_add(&cap->list, &edev->capabilities_list); + + ret = ethosu_mailbox_capabilities_request(&edev->mailbox, cap); + if (0 != ret) + goto put_kref; + + /* + * Increase ref counter since we sent the pointer out to + * response handler thread. That thread is responsible to + * decrease the ref counter before exiting. So the memory + * can be freed. + * + * NOTE: if no response is received back, the memory is leaked. + */ + kref_get(&cap->refcount); + /* Unlock the mutex before going to block on the condition */ + mutex_unlock(&edev->mutex); + /* wait for response to arrive back */ + timeout = wait_for_completion_timeout(&cap->done, + msecs_to_jiffies( + CAPABILITIES_RESP_TIMEOUT_MS)); + /* take back the mutex before resuming to do anything */ + ret = mutex_lock_interruptible(&edev->mutex); + if (0 != ret) + goto put_kref; + + if (0 == timeout /* timed out*/) { + dev_warn(edev->dev, + "Msg: Capabilities response lost - timeout\n"); + ret = -EIO; + goto put_kref; + } + + ret = copy_to_user(udata, &uapi, sizeof(uapi)) ? -EFAULT : 0; + +put_kref: + kref_put(&cap->refcount, ethosu_capabilities_destroy); + + return ret; +} + +static long ethosu_ioctl(struct file *file, + unsigned int cmd, + unsigned long arg) +{ + struct ethosu_device *edev = file->private_data; + void __user *udata = (void __user *)arg; + int ret = -EINVAL; + + ret = mutex_lock_interruptible(&edev->mutex); + if (ret) + return ret; + + dev_info(edev->dev, "Ioctl. cmd=%u, arg=%lu\n", cmd, arg); + + switch (cmd) { + case ETHOSU_IOCTL_VERSION_REQ: + dev_info(edev->dev, "Ioctl: Send version request\n"); + ret = ethosu_mailbox_version_request(&edev->mailbox); + break; + case ETHOSU_IOCTL_CAPABILITIES_REQ: + dev_info(edev->dev, "Ioctl: Send capabilities request\n"); + ret = ethosu_send_capabilities_request(edev, udata); + break; + case ETHOSU_IOCTL_PING: { + dev_info(edev->dev, "Ioctl: Send ping\n"); + ret = ethosu_mailbox_ping(&edev->mailbox); + break; + } + case ETHOSU_IOCTL_BUFFER_CREATE: { + struct ethosu_uapi_buffer_create uapi; + + dev_info(edev->dev, "Ioctl: Buffer create\n"); + + if (copy_from_user(&uapi, udata, sizeof(uapi))) + break; + + dev_info(edev->dev, "Ioctl: Buffer. capacity=%u\n", + uapi.capacity); + + ret = ethosu_buffer_create(edev, uapi.capacity); + break; + } + case ETHOSU_IOCTL_NETWORK_CREATE: { + struct ethosu_uapi_network_create uapi; + + if (copy_from_user(&uapi, udata, sizeof(uapi))) + break; + + dev_info(edev->dev, "Ioctl: Network. fd=%u\n", uapi.fd); + + ret = ethosu_network_create(edev, &uapi); + break; + } + default: { + dev_err(edev->dev, "Invalid ioctl. cmd=%u, arg=%lu", + cmd, arg); + break; + } + } + + mutex_unlock(&edev->mutex); + + return ret; +} + +static void ethosu_mbox_rx(void *user_arg) +{ + struct ethosu_device *edev = user_arg; + int ret; + + mutex_lock(&edev->mutex); + + do { + ret = ethosu_handle_msg(edev); + if (ret && ret != -ENOMSG) + /* Need to start over in case of error, empty the queue + * by fast-forwarding read position to write position. + * */ + ethosu_mailbox_reset(&edev->mailbox); + } while (ret == 0); + + mutex_unlock(&edev->mutex); +} + +int ethosu_dev_init(struct ethosu_device *edev, + struct device *dev, + struct class *class, + dev_t devt, + struct resource *in_queue, + struct resource *out_queue) +{ + static const struct file_operations fops = { + .owner = THIS_MODULE, + .open = ðosu_open, + .unlocked_ioctl = ðosu_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = ðosu_ioctl, +#endif + }; + struct device *sysdev; + int ret; + + edev->dev = dev; + edev->class = class; + edev->devt = devt; + mutex_init(&edev->mutex); + INIT_LIST_HEAD(&edev->capabilities_list); + INIT_LIST_HEAD(&edev->inference_list); + + ret = of_reserved_mem_device_init(edev->dev); + if (ret) + return ret; + + dma_set_mask_and_coherent(edev->dev, DMA_BIT_MASK(DMA_ADDR_BITS)); + + ret = ethosu_mailbox_init(&edev->mailbox, dev, in_queue, out_queue, + ethosu_mbox_rx, edev); + if (ret) + goto release_reserved_mem; + + cdev_init(&edev->cdev, &fops); + edev->cdev.owner = THIS_MODULE; + + ret = cdev_add(&edev->cdev, edev->devt, 1); + if (ret) { + dev_err(edev->dev, "Failed to add character device.\n"); + goto deinit_mailbox; + } + + sysdev = device_create(edev->class, NULL, edev->devt, edev, + "ethosu%d", MINOR(edev->devt)); + if (IS_ERR(sysdev)) { + dev_err(edev->dev, "Failed to create device.\n"); + ret = PTR_ERR(sysdev); + goto del_cdev; + } + + dev_info(edev->dev, + "Created Arm Ethos-U device. name=%s, major=%d, minor=%d\n", + dev_name(sysdev), MAJOR(edev->devt), MINOR(edev->devt)); + + return 0; + +del_cdev: + cdev_del(&edev->cdev); + +deinit_mailbox: + ethosu_mailbox_deinit(&edev->mailbox); + +release_reserved_mem: + of_reserved_mem_device_release(edev->dev); + + return ret; +} + +void ethosu_dev_deinit(struct ethosu_device *edev) +{ + ethosu_mailbox_deinit(&edev->mailbox); + device_destroy(edev->class, edev->cdev.dev); + cdev_del(&edev->cdev); + of_reserved_mem_device_release(edev->dev); + + dev_info(edev->dev, "%s\n", __FUNCTION__); +} diff --git a/drivers/firmware/ethosu/ethosu_device.h b/drivers/firmware/ethosu/ethosu_device.h new file mode 100644 index 000000000000..3afdda84862d --- /dev/null +++ b/drivers/firmware/ethosu/ethosu_device.h @@ -0,0 +1,88 @@ +/* + * (C) COPYRIGHT 2020 ARM Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +#ifndef ETHOSU_DEVICE_H +#define ETHOSU_DEVICE_H + +/**************************************************************************** + * Includes + ****************************************************************************/ + +#include "uapi/ethosu.h" +#include "ethosu_mailbox.h" + +#include +#include +#include +#include +#include +#include + +/**************************************************************************** + * Types + ****************************************************************************/ + +/** + * struct ethosu_device - Device structure + */ +struct ethosu_device { + struct device *dev; + struct cdev cdev; + struct class *class; + dev_t devt; + struct mutex mutex; + struct ethosu_mailbox mailbox; + struct list_head capabilities_list; + struct list_head inference_list; +}; + +/** + * struct ethosu_capabilities - Capabilities internal struct + */ +struct ethosu_capabilities { + struct ethosu_device *edev; + struct completion done; + struct kref refcount; + struct ethosu_uapi_device_capabilities *capabilities; + struct list_head list; +}; + +/**************************************************************************** + * Functions + ****************************************************************************/ + +/** + * ethosu_dev_init() - Initialize the device + * + * Return: 0 on success, else error code. + */ +int ethosu_dev_init(struct ethosu_device *edev, + struct device *dev, + struct class *class, + dev_t devt, + struct resource *in_queue, + struct resource *out_queue); + +/** + * ethosu_dev_deinit() - Initialize the device + */ +void ethosu_dev_deinit(struct ethosu_device *edev); + +#endif /* ETHOSU_DEVICE_H */ diff --git a/drivers/firmware/ethosu/ethosu_driver.c b/drivers/firmware/ethosu/ethosu_driver.c new file mode 100644 index 000000000000..9d02431d3194 --- /dev/null +++ b/drivers/firmware/ethosu/ethosu_driver.c @@ -0,0 +1,191 @@ +/* + * (C) COPYRIGHT 2020 ARM Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "ethosu_device.h" + +/**************************************************************************** + * Defines + ****************************************************************************/ + +#define ETHOSU_DRIVER_VERSION "1.0" +#define ETHOSU_DRIVER_NAME "ethosu" + +#define MINOR_BASE 0 /* Minor version starts at 0 */ +#define MINOR_COUNT 64 /* Allocate minor versions */ + +/**************************************************************************** + * Variables + ****************************************************************************/ + +static struct class *ethosu_class; + +static dev_t devt; + +static DECLARE_BITMAP(minors, MINOR_COUNT); + +/**************************************************************************** + * Arm Ethos-U + ****************************************************************************/ + +static int ethosu_pdev_probe(struct platform_device *pdev) +{ + struct ethosu_device *edev; + struct resource *in_queue_res; + struct resource *out_queue_res; + int minor; + int ret; + + dev_info(&pdev->dev, "Probe\n"); + + minor = find_first_zero_bit(minors, MINOR_COUNT); + if (minor >= MINOR_COUNT) { + dev_err(&pdev->dev, "No more minor numbers.\n"); + + return -ENOMEM; + } + + /* Get path to TCM memory */ + in_queue_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, + "in_queue"); + if (IS_ERR(in_queue_res)) { + dev_err(&pdev->dev, "Failed to get in_queue resource.\n"); + + return PTR_ERR(in_queue_res); + } + + out_queue_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, + "out_queue"); + if (IS_ERR(out_queue_res)) { + dev_err(&pdev->dev, "Failed to get out_queue resource.\n"); + + return PTR_ERR(out_queue_res); + } + + /* Allocate memory for Arm Ethos-U device */ + edev = devm_kzalloc(&pdev->dev, sizeof(*edev), GFP_KERNEL); + if (!edev) + return -ENOMEM; + + platform_set_drvdata(pdev, edev); + + /* Initialize device */ + ret = ethosu_dev_init(edev, &pdev->dev, ethosu_class, + MKDEV(MAJOR(devt), minor), in_queue_res, + out_queue_res); + if (ret) + goto free_dev; + + set_bit(minor, minors); + + return 0; + +free_dev: + devm_kfree(&pdev->dev, edev); + + return ret; +} + +static int ethosu_pdev_remove(struct platform_device *pdev) +{ + struct ethosu_device *edev = platform_get_drvdata(pdev); + + clear_bit(MINOR(edev->devt), minors); + ethosu_dev_deinit(edev); + + return 0; +} + +static const struct of_device_id ethosu_pdev_match[] = { + { .compatible = "arm,ethosu" }, + { /* Sentinel */ }, +}; + +MODULE_DEVICE_TABLE(of, ethosu_pdev_match); + +static struct platform_driver ethosu_pdev_driver = { + .probe = ðosu_pdev_probe, + .remove = ðosu_pdev_remove, + .driver = { + .name = ETHOSU_DRIVER_NAME, + .owner = THIS_MODULE, + .of_match_table = of_match_ptr(ethosu_pdev_match), + }, +}; + +/**************************************************************************** + * Module init and exit + ****************************************************************************/ + +static int __init ethosu_init(void) +{ + int ret; + + ethosu_class = class_create(THIS_MODULE, ETHOSU_DRIVER_NAME); + if (IS_ERR(ethosu_class)) { + printk("Failed to create class '%s'.\n", ETHOSU_DRIVER_NAME); + + return PTR_ERR(ethosu_class); + } + + ret = alloc_chrdev_region(&devt, MINOR_BASE, MINOR_COUNT, + ETHOSU_DRIVER_NAME); + if (ret) { + printk("Failed to allocate chrdev region.\n"); + goto destroy_class; + } + + ret = platform_driver_register(ðosu_pdev_driver); + if (ret) { + printk("Failed to register Arm Ethos-U platform driver.\n"); + goto region_unregister; + } + + return 0; + +region_unregister: + unregister_chrdev_region(devt, MINOR_COUNT); + +destroy_class: + class_destroy(ethosu_class); + + return ret; +} + +static void __exit ethosu_exit(void) +{ + platform_driver_unregister(ðosu_pdev_driver); + unregister_chrdev_region(devt, MINOR_COUNT); + class_destroy(ethosu_class); +} + +module_init(ethosu_init) +module_exit(ethosu_exit) +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR("Arm Ltd"); +MODULE_DESCRIPTION("Arm Ethos-U NPU Driver"); +MODULE_VERSION(ETHOSU_DRIVER_VERSION); diff --git a/drivers/firmware/ethosu/ethosu_inference.c b/drivers/firmware/ethosu/ethosu_inference.c new file mode 100644 index 000000000000..6fde92c148a0 --- /dev/null +++ b/drivers/firmware/ethosu/ethosu_inference.c @@ -0,0 +1,417 @@ +/* + * (C) COPYRIGHT 2020 ARM Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +/**************************************************************************** + * Includes + ****************************************************************************/ + +#include "ethosu_inference.h" + +#include "ethosu_buffer.h" +#include "ethosu_core_interface.h" +#include "ethosu_device.h" +#include "ethosu_network.h" +#include "uapi/ethosu.h" + +#include +#include +#include +#include + +/**************************************************************************** + * Variables + ****************************************************************************/ + +static int ethosu_inference_release(struct inode *inode, + struct file *file); + +static unsigned int ethosu_inference_poll(struct file *file, + poll_table *wait); + +static long ethosu_inference_ioctl(struct file *file, + unsigned int cmd, + unsigned long arg); + +static const struct file_operations ethosu_inference_fops = { + .release = ðosu_inference_release, + .poll = ðosu_inference_poll, + .unlocked_ioctl = ðosu_inference_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = ðosu_inference_ioctl, +#endif +}; + +/**************************************************************************** + * Functions + ****************************************************************************/ + +static const char *status_to_string(const enum ethosu_uapi_status status) +{ + switch (status) { + case ETHOSU_UAPI_STATUS_OK: { + return "Ok"; + } + case ETHOSU_UAPI_STATUS_ERROR: { + return "Error"; + } + default: { + return "Unknown"; + } + } +} + +static int ethosu_inference_send(struct ethosu_inference *inf) +{ + int ret; + + if (inf->pending) + return -EINVAL; + + inf->status = ETHOSU_UAPI_STATUS_ERROR; + + ret = ethosu_mailbox_inference(&inf->edev->mailbox, inf, + inf->ifm_count, inf->ifm, + inf->ofm_count, inf->ofm, + inf->net->buf, + inf->pmu_event_config, + ETHOSU_PMU_EVENT_MAX, + inf->pmu_cycle_counter_enable); + if (ret) + return ret; + + inf->pending = true; + + ethosu_inference_get(inf); + + return 0; +} + +static int ethosu_inference_find(struct ethosu_inference *inf, + struct list_head *inference_list) +{ + struct ethosu_inference *cur; + + list_for_each_entry(cur, inference_list, list) { + if (cur == inf) + return 0; + } + + return -EINVAL; +} + +static bool ethosu_inference_verify(struct file *file) +{ + return file->f_op == ðosu_inference_fops; +} + +static void ethosu_inference_kref_destroy(struct kref *kref) +{ + struct ethosu_inference *inf = + container_of(kref, struct ethosu_inference, kref); + + dev_info(inf->edev->dev, + "Inference destroy. handle=0x%pK, status=%d\n", + inf, inf->status); + + list_del(&inf->list); + + while (inf->ifm_count-- > 0) + ethosu_buffer_put(inf->ifm[inf->ifm_count]); + + while (inf->ofm_count-- > 0) + ethosu_buffer_put(inf->ofm[inf->ofm_count]); + + ethosu_network_put(inf->net); + devm_kfree(inf->edev->dev, inf); +} + +static int ethosu_inference_release(struct inode *inode, + struct file *file) +{ + struct ethosu_inference *inf = file->private_data; + + dev_info(inf->edev->dev, + "Inference release. handle=0x%pK, status=%d\n", + inf, inf->status); + + ethosu_inference_put(inf); + + return 0; +} + +static unsigned int ethosu_inference_poll(struct file *file, + poll_table *wait) +{ + struct ethosu_inference *inf = file->private_data; + int ret = 0; + + poll_wait(file, &inf->waitq, wait); + + if (!inf->pending) + ret |= POLLIN; + + return ret; +} + +static long ethosu_inference_ioctl(struct file *file, + unsigned int cmd, + unsigned long arg) +{ + struct ethosu_inference *inf = file->private_data; + void __user *udata = (void __user *)arg; + int ret; + + ret = mutex_lock_interruptible(&inf->edev->mutex); + if (ret) + return ret; + + dev_info(inf->edev->dev, "Ioctl: cmd=%u, arg=%lu\n", cmd, arg); + + switch (cmd) { + case ETHOSU_IOCTL_INFERENCE_STATUS: { + struct ethosu_uapi_result_status uapi; + int i; + + uapi.status = inf->status; + + for (i = 0; i < ETHOSU_PMU_EVENT_MAX; i++) { + uapi.pmu_config.events[i] = + inf->pmu_event_config[i]; + uapi.pmu_count.events[i] = + inf->pmu_event_count[i]; + } + + uapi.pmu_config.cycle_count = inf->pmu_cycle_counter_enable; + uapi.pmu_count.cycle_count = inf->pmu_cycle_counter_count; + + dev_info(inf->edev->dev, + "Ioctl: Inference status. status=%s (%d)\n", + status_to_string(uapi.status), uapi.status); + + ret = copy_to_user(udata, &uapi, sizeof(uapi)) ? -EFAULT : 0; + + break; + } + default: { + dev_err(inf->edev->dev, "Invalid ioctl. cmd=%u, arg=%lu", + cmd, arg); + break; + } + } + + mutex_unlock(&inf->edev->mutex); + + return ret; +} + +int ethosu_inference_create(struct ethosu_device *edev, + struct ethosu_network *net, + struct ethosu_uapi_inference_create *uapi) +{ + struct ethosu_inference *inf; + uint32_t i; + int fd; + int ret = -ENOMEM; + + inf = devm_kzalloc(edev->dev, sizeof(*inf), GFP_KERNEL); + if (!inf) + return -ENOMEM; + + inf->edev = edev; + inf->net = net; + inf->pending = false; + inf->status = ETHOSU_UAPI_STATUS_ERROR; + kref_init(&inf->kref); + init_waitqueue_head(&inf->waitq); + + /* Get pointer to IFM buffers */ + for (i = 0; i < uapi->ifm_count; i++) { + inf->ifm[i] = ethosu_buffer_get_from_fd(uapi->ifm_fd[i]); + if (IS_ERR(inf->ifm[i])) { + ret = PTR_ERR(inf->ifm[i]); + goto put_ifm; + } + + inf->ifm_count++; + } + + /* Get pointer to OFM buffer */ + for (i = 0; i < uapi->ofm_count; i++) { + inf->ofm[i] = ethosu_buffer_get_from_fd(uapi->ofm_fd[i]); + if (IS_ERR(inf->ofm[i])) { + ret = PTR_ERR(inf->ofm[i]); + goto put_ofm; + } + + inf->ofm_count++; + } + + /* Configure PMU and cycle counter */ + dev_info(inf->edev->dev, + "Configuring events for PMU. events=[%u, %u, %u, %u]\n", + uapi->pmu_config.events[0], uapi->pmu_config.events[1], + uapi->pmu_config.events[2], uapi->pmu_config.events[3]); + + /* Configure events and reset count for all events */ + for (i = 0; i < ETHOSU_PMU_EVENT_MAX; i++) { + inf->pmu_event_config[i] = uapi->pmu_config.events[i]; + inf->pmu_event_count[i] = 0; + } + + if (uapi->pmu_config.cycle_count) + dev_info(inf->edev->dev, "Enabling cycle counter\n"); + + /* Configure cycle counter and reset any previous count */ + inf->pmu_cycle_counter_enable = uapi->pmu_config.cycle_count; + inf->pmu_cycle_counter_count = 0; + + /* Increment network reference count */ + ethosu_network_get(net); + + /* Create file descriptor */ + ret = fd = anon_inode_getfd("ethosu-inference", ðosu_inference_fops, + inf, O_RDWR | O_CLOEXEC); + if (ret < 0) + goto put_net; + + /* Store pointer to file structure */ + inf->file = fget(ret); + fput(inf->file); + + /* Add inference to inference list */ + list_add(&inf->list, &edev->inference_list); + + /* Send inference request to Arm Ethos-U subsystem */ + (void)ethosu_inference_send(inf); + + dev_info(edev->dev, "Inference create. handle=0x%pK, fd=%d", + inf, fd); + + return fd; + +put_net: + ethosu_network_put(inf->net); + +put_ofm: + while (inf->ofm_count-- > 0) + ethosu_buffer_put(inf->ofm[inf->ofm_count]); + +put_ifm: + while (inf->ifm_count-- > 0) + ethosu_buffer_put(inf->ifm[inf->ifm_count]); + + devm_kfree(edev->dev, inf); + + return ret; +} + +struct ethosu_inference *ethosu_inference_get_from_fd(int fd) +{ + struct ethosu_inference *inf; + struct file *file; + + file = fget(fd); + if (!file) + return ERR_PTR(-EINVAL); + + if (!ethosu_inference_verify(file)) { + fput(file); + + return ERR_PTR(-EINVAL); + } + + inf = file->private_data; + ethosu_inference_get(inf); + fput(file); + + return inf; +} + +void ethosu_inference_get(struct ethosu_inference *inf) +{ + kref_get(&inf->kref); +} + +void ethosu_inference_put(struct ethosu_inference *inf) +{ + kref_put(&inf->kref, ðosu_inference_kref_destroy); +} + +void ethosu_inference_rsp(struct ethosu_device *edev, + struct ethosu_core_inference_rsp *rsp) +{ + struct ethosu_inference *inf = + (struct ethosu_inference *)rsp->user_arg; + int ret; + int i; + + ret = ethosu_inference_find(inf, &edev->inference_list); + if (ret) { + dev_warn(edev->dev, + "Handle not found in inference list. handle=0x%p\n", + rsp); + + return; + } + + inf->pending = false; + + if (rsp->status == ETHOSU_CORE_STATUS_OK && + inf->ofm_count <= ETHOSU_CORE_BUFFER_MAX) { + uint32_t i; + + inf->status = ETHOSU_UAPI_STATUS_OK; + + for (i = 0; i < inf->ofm_count; i++) { + struct ethosu_buffer *ofm = inf->ofm[i]; + + ret = ethosu_buffer_resize( + ofm, ofm->size + rsp->ofm_size[i], + ofm->offset); + if (ret) + inf->status = ETHOSU_UAPI_STATUS_ERROR; + } + } else { + inf->status = ETHOSU_UAPI_STATUS_ERROR; + } + + for (i = 0; i < ETHOSU_CORE_PMU_MAX; i++) { + inf->pmu_event_config[i] = rsp->pmu_event_config[i]; + inf->pmu_event_count[i] = rsp->pmu_event_count[i]; + } + + inf->pmu_cycle_counter_enable = rsp->pmu_cycle_counter_enable; + inf->pmu_cycle_counter_count = rsp->pmu_cycle_counter_count; + + dev_info(edev->dev, + "PMU events. config=[%u, %u, %u, %u], count=[%u, %u, %u, %u]\n", + inf->pmu_event_config[0], inf->pmu_event_config[1], + inf->pmu_event_config[2], inf->pmu_event_config[3], + inf->pmu_event_count[0], inf->pmu_event_count[1], + inf->pmu_event_count[2], inf->pmu_event_count[3]); + + dev_info(edev->dev, + "PMU cycle counter. enable=%u, count=%llu\n", + inf->pmu_cycle_counter_enable, + inf->pmu_cycle_counter_count); + wake_up_interruptible(&inf->waitq); + + ethosu_inference_put(inf); +} diff --git a/drivers/firmware/ethosu/ethosu_inference.h b/drivers/firmware/ethosu/ethosu_inference.h new file mode 100644 index 000000000000..07370ca01f22 --- /dev/null +++ b/drivers/firmware/ethosu/ethosu_inference.h @@ -0,0 +1,120 @@ +/* + * (C) COPYRIGHT 2020 ARM Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +#ifndef ETHOSU_INFERENCE_H +#define ETHOSU_INFERENCE_H + +/**************************************************************************** + * Includes + ****************************************************************************/ + +#include "uapi/ethosu.h" + +#include +#include +#include + +/**************************************************************************** + * Types + ****************************************************************************/ + +struct ethosu_buffer; +struct ethosu_core_inference_rsp; +struct ethosu_device; +struct ethosu_network; +struct ethosu_uapi_inference_create; +struct file; + +/** + * struct ethosu_inference - Inference struct + * @edev: Arm Ethos-U device + * @file: File handle + * @kref: Reference counter + * @waitq: Wait queue + * @ifm: Pointer to IFM buffer + * @ofm: Pointer to OFM buffer + * @net: Pointer to network + * @pending: Pending response from the firmware + * @status: Inference status + * @pmu_event_config: PMU event configuration + * @pmu_event_count: PMU event count after inference + * @pmu_cycle_counter_enable: PMU cycle counter config + * @pmu_cycle_counter_count: PMU cycle counter count after inference + */ +struct ethosu_inference { + struct ethosu_device *edev; + struct file *file; + struct kref kref; + wait_queue_head_t waitq; + uint32_t ifm_count; + struct ethosu_buffer *ifm[ETHOSU_FD_MAX]; + uint32_t ofm_count; + struct ethosu_buffer *ofm[ETHOSU_FD_MAX]; + struct ethosu_network *net; + bool pending; + enum ethosu_uapi_status status; + uint8_t pmu_event_config[ETHOSU_PMU_EVENT_MAX]; + uint32_t pmu_event_count[ETHOSU_PMU_EVENT_MAX]; + uint32_t pmu_cycle_counter_enable; + uint64_t pmu_cycle_counter_count; + struct list_head list; +}; + +/**************************************************************************** + * Functions + ****************************************************************************/ + +/** + * ethosu_inference_create() - Create inference + * + * This function must be called in the context of a user space process. + * + * Return: fd on success, else error code. + */ +int ethosu_inference_create(struct ethosu_device *edev, + struct ethosu_network *net, + struct ethosu_uapi_inference_create *uapi); + +/** + * ethosu_inference_get_from_fd() - Get inference handle from fd + * + * This function must be called from a user space context. + * + * Return: Pointer on success, else ERR_PTR. + */ +struct ethosu_inference *ethosu_inference_get_from_fd(int fd); + +/** + * ethosu_inference_get() - Get inference + */ +void ethosu_inference_get(struct ethosu_inference *inf); + +/** + * ethosu_inference_put() - Put inference + */ +void ethosu_inference_put(struct ethosu_inference *inf); + +/** + * ethosu_inference_rsp() - Handle inference response + */ +void ethosu_inference_rsp(struct ethosu_device *edev, + struct ethosu_core_inference_rsp *rsp); + +#endif /* ETHOSU_INFERENCE_H */ diff --git a/drivers/firmware/ethosu/ethosu_mailbox.c b/drivers/firmware/ethosu/ethosu_mailbox.c new file mode 100644 index 000000000000..7f159f3b0a60 --- /dev/null +++ b/drivers/firmware/ethosu/ethosu_mailbox.c @@ -0,0 +1,377 @@ +/* + * (C) COPYRIGHT 2020 ARM Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +/**************************************************************************** + * Includes + ****************************************************************************/ + +#include "ethosu_mailbox.h" + +#include "ethosu_buffer.h" +#include "ethosu_core_interface.h" +#include "ethosu_device.h" + +#include +#include + +/**************************************************************************** + * Functions + ****************************************************************************/ + +static void ethosu_core_set_size(struct ethosu_buffer *buf, + struct ethosu_core_buffer *cbuf) +{ + cbuf->ptr = (uint32_t)buf->dma_addr + buf->offset; + cbuf->size = (uint32_t)buf->size; +} + +static void ethosu_core_set_capacity(struct ethosu_buffer *buf, + struct ethosu_core_buffer *cbuf) +{ + cbuf->ptr = (uint32_t)buf->dma_addr + buf->offset + buf->size; + cbuf->size = (uint32_t)buf->capacity - buf->offset - buf->size; +} + +static size_t ethosu_queue_available(struct ethosu_core_queue *queue) +{ + size_t size = queue->header.write - queue->header.read; + + if (queue->header.read > queue->header.write) + size += queue->header.size; + + return size; +} + +static size_t ethosu_queue_capacity(struct ethosu_core_queue *queue) +{ + return queue->header.size - ethosu_queue_available(queue); +} + +static int ethosu_queue_write(struct ethosu_mailbox *mbox, + const struct kvec *vec, + size_t length) +{ + struct ethosu_core_queue *queue = mbox->in_queue; + uint8_t *dst = &queue->data[0]; + uint32_t wpos = queue->header.write; + size_t total_size; + size_t i; + int ret; + + for (i = 0, total_size = 0; i < length; i++) + total_size += vec[i].iov_len; + + if (total_size > ethosu_queue_capacity(queue)) + return -EINVAL; + + for (i = 0; i < length; i++) { + const uint8_t *src = vec[i].iov_base; + const uint8_t *end = src + vec[i].iov_len; + + while (src < end) { + dst[wpos] = *src++; + wpos = (wpos + 1) % queue->header.size; + } + } + + queue->header.write = wpos; + + ret = mbox_send_message(mbox->tx, queue); + if (ret < 0) + return ret; + + return 0; +} + +static int ethosu_queue_write_msg(struct ethosu_mailbox *mbox, + uint32_t type, + void *data, + size_t length) +{ + struct ethosu_core_msg msg = { + .magic = ETHOSU_CORE_MSG_MAGIC, + .type = type, .length= length + }; + const struct kvec vec[2] = { + { &msg, sizeof(msg) }, + { data, length } + }; + + return ethosu_queue_write(mbox, vec, 2); +} + +static int ethosu_queue_read(struct ethosu_mailbox *mbox, + void *data, + size_t length) +{ + struct ethosu_core_queue *queue = mbox->out_queue; + uint8_t *src = &queue->data[0]; + uint8_t *dst = (uint8_t *)data; + const uint8_t *end = dst + length; + uint32_t rpos = queue->header.read; + size_t queue_avail = ethosu_queue_available(queue); + + if (length == 0) + return 0; + else if (queue_avail == 0) + return -ENOMSG; + else if (length > queue_avail) + return -EBADMSG; + + while (dst < end) { + *dst++ = src[rpos]; + rpos = (rpos + 1) % queue->header.size; + } + + queue->header.read = rpos; + + return 0; +} + +void ethosu_mailbox_reset(struct ethosu_mailbox *mbox) +{ + mbox->out_queue->header.read = mbox->out_queue->header.write; +} + +int ethosu_mailbox_read(struct ethosu_mailbox *mbox, + struct ethosu_core_msg *header, + void *data, + size_t length) +{ + int ret; + + /* Read message header magic */ + ret = ethosu_queue_read(mbox, header, sizeof(*header)); + if (ret) { + if (ret != -ENOMSG) + dev_warn(mbox->dev, + "Msg: Failed to read message header\n"); + + return ret; + } + + if (header->magic != ETHOSU_CORE_MSG_MAGIC) { + dev_warn(mbox->dev, + "Msg: Invalid magic. Got: %08X but expected %08X\n", + header->magic, ETHOSU_CORE_MSG_MAGIC); + + return -EINVAL; + } + + dev_info(mbox->dev, + "mbox: Read msg header. magic=%08X, type=%u, length=%u", + header->magic, header->type, header->length); + + /* Check that payload is not larger than allocated buffer */ + if (header->length > length) { + dev_warn(mbox->dev, + "Msg: Buffer size (%zu) too small for message (%u)\n", + sizeof(data), header->length); + + return -ENOMEM; + } + + /* Read payload data */ + ret = ethosu_queue_read(mbox, data, header->length); + if (ret) { + dev_warn(mbox->dev, "Msg: Failed to read payload data\n"); + + return -EBADMSG; + } + + return 0; +} + +int ethosu_mailbox_ping(struct ethosu_mailbox *mbox) +{ + return ethosu_queue_write_msg(mbox, ETHOSU_CORE_MSG_PING, NULL, 0); +} + +int ethosu_mailbox_pong(struct ethosu_mailbox *mbox) +{ + return ethosu_queue_write_msg(mbox, ETHOSU_CORE_MSG_PONG, NULL, 0); +} + +int ethosu_mailbox_version_request(struct ethosu_mailbox *mbox) +{ + return ethosu_queue_write_msg(mbox, ETHOSU_CORE_MSG_VERSION_REQ, NULL, + 0); +} + +int ethosu_mailbox_capabilities_request(struct ethosu_mailbox *mbox, + void *user_arg) +{ + struct ethosu_core_capabilities_req req = { + .user_arg = (ptrdiff_t)user_arg + }; + + return ethosu_queue_write_msg(mbox, ETHOSU_CORE_MSG_CAPABILITIES_REQ, + &req, + sizeof(req)); +} + +int ethosu_mailbox_inference(struct ethosu_mailbox *mbox, + void *user_arg, + uint32_t ifm_count, + struct ethosu_buffer **ifm, + uint32_t ofm_count, + struct ethosu_buffer **ofm, + struct ethosu_buffer *network, + uint8_t *pmu_event_config, + uint8_t pmu_event_config_count, + uint8_t pmu_cycle_counter_enable) +{ + struct ethosu_core_inference_req inf; + uint32_t i; + + /* Verify that the uapi and core has the same number of pmus */ + if (pmu_event_config_count != ETHOSU_CORE_PMU_MAX) { + dev_err(mbox->dev, "PMU count misconfigured.\n"); + + return -EINVAL; + } + + inf.user_arg = (ptrdiff_t)user_arg; + inf.ifm_count = ifm_count; + inf.ofm_count = ofm_count; + inf.pmu_cycle_counter_enable = pmu_cycle_counter_enable; + + for (i = 0; i < ifm_count; i++) + ethosu_core_set_size(ifm[i], &inf.ifm[i]); + + for (i = 0; i < ofm_count; i++) + ethosu_core_set_capacity(ofm[i], &inf.ofm[i]); + + for (i = 0; i < ETHOSU_CORE_PMU_MAX; i++) + inf.pmu_event_config[i] = pmu_event_config[i]; + + ethosu_core_set_size(network, &inf.network); + + return ethosu_queue_write_msg(mbox, ETHOSU_CORE_MSG_INFERENCE_REQ, + &inf, sizeof(inf)); +} + +static void ethosu_mailbox_rx_work(struct work_struct *work) +{ + struct ethosu_mailbox *mbox = container_of(work, typeof(*mbox), work); + + mbox->callback(mbox->user_arg); +} + +static void ethosu_mailbox_rx_callback(struct mbox_client *client, + void *message) +{ + struct ethosu_mailbox *mbox = + container_of(client, typeof(*mbox), client); + + dev_info(mbox->dev, "mbox: Received message.\n"); + + queue_work(mbox->wq, &mbox->work); +} + +static void ethosu_mailbox_tx_done(struct mbox_client *client, + void *message, + int r) +{ + if (r) + dev_warn(client->dev, "mbox: Failed sending message (%d)\n", r); + else + dev_info(client->dev, "mbox: Message sent\n"); +} + +int ethosu_mailbox_init(struct ethosu_mailbox *mbox, + struct device *dev, + struct resource *in_queue, + struct resource *out_queue, + ethosu_mailbox_cb callback, + void *user_arg) +{ + int ret; + + mbox->dev = dev; + mbox->callback = callback; + mbox->user_arg = user_arg; + + mbox->client.dev = dev; + mbox->client.rx_callback = ethosu_mailbox_rx_callback; + mbox->client.tx_prepare = NULL; /* preparation of data is handled + * through the + * queue functions */ + mbox->client.tx_done = ethosu_mailbox_tx_done; + mbox->client.tx_block = true; + mbox->client.knows_txdone = false; + mbox->client.tx_tout = 500; + + mbox->in_queue = devm_ioremap_resource(mbox->dev, in_queue); + if (IS_ERR(mbox->in_queue)) + return PTR_ERR(mbox->in_queue); + + mbox->out_queue = devm_ioremap_resource(mbox->dev, out_queue); + if (IS_ERR(mbox->out_queue)) { + ret = PTR_ERR(mbox->out_queue); + goto unmap_in_queue; + } + + mbox->wq = create_singlethread_workqueue("ethosu_workqueue"); + if (!mbox->wq) { + dev_err(mbox->dev, "Failed to create work queue\n"); + ret = -EINVAL; + goto unmap_out_queue; + } + + INIT_WORK(&mbox->work, ethosu_mailbox_rx_work); + + mbox->tx = mbox_request_channel_byname(&mbox->client, "tx"); + if (IS_ERR(mbox->tx)) { + dev_warn(mbox->dev, "mbox: Failed to request tx channel\n"); + ret = PTR_ERR(mbox->tx); + goto workqueue_destroy; + } + + mbox->rx = mbox_request_channel_byname(&mbox->client, "rx"); + if (IS_ERR(mbox->rx)) { + dev_info(dev, "mbox: Using same channel for RX and TX\n"); + mbox->rx = mbox->tx; + } + + return 0; + +workqueue_destroy: + destroy_workqueue(mbox->wq); + +unmap_out_queue: + devm_iounmap(mbox->dev, mbox->out_queue); + +unmap_in_queue: + devm_iounmap(mbox->dev, mbox->in_queue); + + return ret; +} + +void ethosu_mailbox_deinit(struct ethosu_mailbox *mbox) +{ + if (mbox->rx != mbox->tx) + mbox_free_channel(mbox->rx); + + mbox_free_channel(mbox->tx); + destroy_workqueue(mbox->wq); + devm_iounmap(mbox->dev, mbox->out_queue); + devm_iounmap(mbox->dev, mbox->in_queue); +} diff --git a/drivers/firmware/ethosu/ethosu_mailbox.h b/drivers/firmware/ethosu/ethosu_mailbox.h new file mode 100644 index 000000000000..5cd5e62198b8 --- /dev/null +++ b/drivers/firmware/ethosu/ethosu_mailbox.h @@ -0,0 +1,140 @@ +/* + * (C) COPYRIGHT 2020 ARM Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +#ifndef ETHOSU_MAILBOX_H +#define ETHOSU_MAILBOX_H + +/**************************************************************************** + * Includes + ****************************************************************************/ +#include "ethosu_core_interface.h" + +#include +#include +#include + +/**************************************************************************** + * Types + ****************************************************************************/ + +struct device; +struct ethosu_buffer; +struct ethosu_device; +struct ethosu_core_msg; +struct ethosu_core_queue; +struct resource; + +typedef void (*ethosu_mailbox_cb)(void *user_arg); + +struct ethosu_mailbox { + struct device *dev; + struct workqueue_struct *wq; + struct work_struct work; + struct ethosu_core_queue __iomem *in_queue; + struct ethosu_core_queue __iomem *out_queue; + struct mbox_client client; + struct mbox_chan *rx; + struct mbox_chan *tx; + ethosu_mailbox_cb callback; + void *user_arg; +}; + +/**************************************************************************** + * Functions + ****************************************************************************/ + +/** + * ethosu_mailbox_init() - Initialize mailbox + * + * Return: 0 on success, else error code. + */ +int ethosu_mailbox_init(struct ethosu_mailbox *mbox, + struct device *dev, + struct resource *in_queue, + struct resource *out_queue, + ethosu_mailbox_cb callback, + void *user_arg); + +/** + * ethosu_mailbox_deinit() - Deinitialize mailbox + */ +void ethosu_mailbox_deinit(struct ethosu_mailbox *mbox); + +/** + * ethosu_mailbox_read() - Read message from mailbox + * + * Return: 0 message read, else error code. + */ +int ethosu_mailbox_read(struct ethosu_mailbox *mbox, + struct ethosu_core_msg *header, + void *data, + size_t length); + +/** + * ethosu_mailbox_reset() - Reset to end of queue + */ +void ethosu_mailbox_reset(struct ethosu_mailbox *mbox); + +/** + * ethosu_mailbox_ping() - Send ping message + * + * Return: 0 on success, else error code. + */ +int ethosu_mailbox_ping(struct ethosu_mailbox *mbox); + +/** + * ethosu_mailbox_pong() - Send pong response + * + * Return: 0 on success, else error code. + */ +int ethosu_mailbox_pong(struct ethosu_mailbox *mbox); + +/** + * ethosu_mailbox_version_response - Send version request + * + * Return: 0 on succes, else error code + */ +int ethosu_mailbox_version_request(struct ethosu_mailbox *mbox); + +/** + * ethosu_mailbox_capabilities_request() - Send capabilities request + * + * Return: 0 on success, else error code. + */ +int ethosu_mailbox_capabilities_request(struct ethosu_mailbox *mbox, + void *user_arg); + +/** + * ethosu_mailbox_inference() - Send inference + * + * Return: 0 on success, else error code. + */ +int ethosu_mailbox_inference(struct ethosu_mailbox *mbox, + void *user_arg, + uint32_t ifm_count, + struct ethosu_buffer **ifm, + uint32_t ofm_count, + struct ethosu_buffer **ofm, + struct ethosu_buffer *network, + uint8_t *pmu_event_config, + uint8_t pmu_event_config_count, + uint8_t pmu_cycle_counter_enable); + +#endif /* ETHOSU_MAILBOX_H */ diff --git a/drivers/firmware/ethosu/ethosu_network.c b/drivers/firmware/ethosu/ethosu_network.c new file mode 100644 index 000000000000..4d68f0537e38 --- /dev/null +++ b/drivers/firmware/ethosu/ethosu_network.c @@ -0,0 +1,201 @@ +/* + * (C) COPYRIGHT 2020 ARM Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +/**************************************************************************** + * Includes + ****************************************************************************/ + +#include "ethosu_network.h" + +#include "ethosu_buffer.h" +#include "ethosu_device.h" +#include "ethosu_inference.h" +#include "uapi/ethosu.h" + +#include +#include +#include +#include + +/**************************************************************************** + * Variables + ****************************************************************************/ + +static int ethosu_network_release(struct inode *inode, + struct file *file); + +static long ethosu_network_ioctl(struct file *file, + unsigned int cmd, + unsigned long arg); + +static const struct file_operations ethosu_network_fops = { + .release = ðosu_network_release, + .unlocked_ioctl = ðosu_network_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = ðosu_network_ioctl, +#endif +}; + +/**************************************************************************** + * Functions + ****************************************************************************/ + +static bool ethosu_network_verify(struct file *file) +{ + return file->f_op == ðosu_network_fops; +} + +static void ethosu_network_destroy(struct kref *kref) +{ + struct ethosu_network *net = + container_of(kref, struct ethosu_network, kref); + + dev_info(net->edev->dev, "Network destroy. handle=0x%pK\n", net); + + ethosu_buffer_put(net->buf); + devm_kfree(net->edev->dev, net); +} + +static int ethosu_network_release(struct inode *inode, + struct file *file) +{ + struct ethosu_network *net = file->private_data; + + dev_info(net->edev->dev, "Network release. handle=0x%pK\n", net); + + ethosu_network_put(net); + + return 0; +} + +static long ethosu_network_ioctl(struct file *file, + unsigned int cmd, + unsigned long arg) +{ + struct ethosu_network *net = file->private_data; + void __user *udata = (void __user *)arg; + int ret = -EINVAL; + + ret = mutex_lock_interruptible(&net->edev->mutex); + if (ret) + return ret; + + dev_info(net->edev->dev, "Ioctl: cmd=%u, arg=%lu\n", cmd, arg); + + switch (cmd) { + case ETHOSU_IOCTL_INFERENCE_CREATE: { + struct ethosu_uapi_inference_create uapi; + + if (copy_from_user(&uapi, udata, sizeof(uapi))) + break; + + dev_info(net->edev->dev, + "Ioctl: Inference. ifm_fd=%u, ofm_fd=%u\n", + uapi.ifm_fd[0], uapi.ofm_fd[0]); + + ret = ethosu_inference_create(net->edev, net, &uapi); + break; + } + default: { + dev_err(net->edev->dev, "Invalid ioctl. cmd=%u, arg=%lu", + cmd, arg); + break; + } + } + + mutex_unlock(&net->edev->mutex); + + return ret; +} + +int ethosu_network_create(struct ethosu_device *edev, + struct ethosu_uapi_network_create *uapi) +{ + struct ethosu_buffer *buf; + struct ethosu_network *net; + int ret = -ENOMEM; + + buf = ethosu_buffer_get_from_fd(uapi->fd); + if (IS_ERR(buf)) + return PTR_ERR(buf); + + net = devm_kzalloc(edev->dev, sizeof(*net), GFP_KERNEL); + if (!net) { + ret = -ENOMEM; + goto put_buf; + } + + net->edev = edev; + net->buf = buf; + kref_init(&net->kref); + + ret = anon_inode_getfd("ethosu-network", ðosu_network_fops, net, + O_RDWR | O_CLOEXEC); + if (ret < 0) + goto free_net; + + net->file = fget(ret); + fput(net->file); + + dev_info(edev->dev, "Network create. handle=0x%pK", + net); + + return ret; + +free_net: + devm_kfree(edev->dev, net); + +put_buf: + ethosu_buffer_put(buf); + + return ret; +} + +struct ethosu_network *ethosu_network_get_from_fd(int fd) +{ + struct ethosu_network *net; + struct file *file; + + file = fget(fd); + if (!file) + return ERR_PTR(-EINVAL); + + if (!ethosu_network_verify(file)) { + fput(file); + + return ERR_PTR(-EINVAL); + } + + net = file->private_data; + ethosu_network_get(net); + fput(file); + + return net; +} + +void ethosu_network_get(struct ethosu_network *net) +{ + kref_get(&net->kref); +} + +void ethosu_network_put(struct ethosu_network *net) +{ + kref_put(&net->kref, ethosu_network_destroy); +} diff --git a/drivers/firmware/ethosu/ethosu_network.h b/drivers/firmware/ethosu/ethosu_network.h new file mode 100644 index 000000000000..bb70afcb2572 --- /dev/null +++ b/drivers/firmware/ethosu/ethosu_network.h @@ -0,0 +1,81 @@ +/* + * (C) COPYRIGHT 2020 ARM Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +#ifndef ETHOSU_NETWORK_H +#define ETHOSU_NETWORK_H + +/**************************************************************************** + * Includes + ****************************************************************************/ + +#include +#include + +/**************************************************************************** + * Types + ****************************************************************************/ + +struct ethosu_buffer; +struct ethosu_device; +struct ethosu_uapi_network_create; +struct device; +struct file; + +struct ethosu_network { + struct ethosu_device *edev; + struct file *file; + struct kref kref; + struct ethosu_buffer *buf; +}; + +/**************************************************************************** + * Functions + ****************************************************************************/ + +/** + * ethosu_network_create() - Create network + * + * This function must be called in the context of a user space process. + * + * Return: fd on success, else error code. + */ +int ethosu_network_create(struct ethosu_device *edev, + struct ethosu_uapi_network_create *uapi); + +/** + * ethosu_network_get_from_fd() - Get network handle from fd + * + * This function must be called from a user space context. + * + * Return: Pointer on success, else ERR_PTR. + */ +struct ethosu_network *ethosu_network_get_from_fd(int fd); + +/** + * ethosu_network_get() - Get network + */ +void ethosu_network_get(struct ethosu_network *net); + +/** + * ethosu_network_put() - Put network + */ +void ethosu_network_put(struct ethosu_network *net); + +#endif /* ETHOSU_NETWORK_H */ diff --git a/drivers/firmware/ethosu/uapi/ethosu.h b/drivers/firmware/ethosu/uapi/ethosu.h new file mode 100644 index 000000000000..903316dff7b3 --- /dev/null +++ b/drivers/firmware/ethosu/uapi/ethosu.h @@ -0,0 +1,207 @@ +/* + * (C) COPYRIGHT 2020 ARM Limited. All rights reserved. + * + * This program is free software and is provided to you under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation, and any use by you of this program is subject to the terms + * of such GNU licence. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you can access it online at + * http://www.gnu.org/licenses/gpl-2.0.html. + * + * SPDX-License-Identifier: GPL-2.0-only + */ + +#ifndef ETHOSU_H +#define ETHOSU_H + +/**************************************************************************** + * Includes + ****************************************************************************/ + +#include +#include + +#ifdef __cplusplus +namespace EthosU { +#endif + +/**************************************************************************** + * Defines + ****************************************************************************/ + +#define ETHOSU_IOCTL_BASE 0x01 +#define ETHOSU_IO(nr) _IO(ETHOSU_IOCTL_BASE, nr) +#define ETHOSU_IOR(nr, type) _IOR(ETHOSU_IOCTL_BASE, nr, type) +#define ETHOSU_IOW(nr, type) _IOW(ETHOSU_IOCTL_BASE, nr, type) +#define ETHOSU_IOWR(nr, type) _IOWR(ETHOSU_IOCTL_BASE, nr, type) + +#define ETHOSU_IOCTL_PING ETHOSU_IO(0x00) +#define ETHOSU_IOCTL_VERSION_REQ ETHOSU_IO(0x01) +#define ETHOSU_IOCTL_CAPABILITIES_REQ ETHOSU_IO(0x02) +#define ETHOSU_IOCTL_BUFFER_CREATE ETHOSU_IOR(0x10, \ + struct ethosu_uapi_buffer_create) +#define ETHOSU_IOCTL_BUFFER_SET ETHOSU_IOR(0x11, \ + struct ethosu_uapi_buffer) +#define ETHOSU_IOCTL_BUFFER_GET ETHOSU_IOW(0x12, \ + struct ethosu_uapi_buffer) +#define ETHOSU_IOCTL_NETWORK_CREATE ETHOSU_IOR(0x20, \ + struct ethosu_uapi_network_create) +#define ETHOSU_IOCTL_INFERENCE_CREATE ETHOSU_IOR(0x30, \ + struct ethosu_uapi_inference_create) +#define ETHOSU_IOCTL_INFERENCE_STATUS ETHOSU_IOR(0x31, \ + struct ethosu_uapi_result_status) + +/* Maximum number of IFM/OFM file descriptors per network */ +#define ETHOSU_FD_MAX 16 + +/* Maximum number of PMUs available */ +#define ETHOSU_PMU_EVENT_MAX 8 + +/**************************************************************************** + * Types + ****************************************************************************/ + +/** + * enum ethosu_uapi_status - Status + */ +enum ethosu_uapi_status { + ETHOSU_UAPI_STATUS_OK, + ETHOSU_UAPI_STATUS_ERROR +}; + +/** + * struct ethosu_uapi_buffer_create - Create buffer request + * @capacity: Maximum capacity of the buffer + */ +struct ethosu_uapi_buffer_create { + __u32 capacity; +}; + +/** + * struct ethosu_uapi_buffer - Buffer descriptor + * @offset: Offset to where the data starts + * @size: Size of the data + * + * 'offset + size' must not exceed the capacity of the buffer. + */ +struct ethosu_uapi_buffer { + __u32 offset; + __u32 size; +}; + +/** + * struct ethosu_uapi_network_create - Create network request + * @fd: Buffer file descriptor + */ +struct ethosu_uapi_network_create { + __u32 fd; +}; + +/** + * struct ethosu_uapi_pmu_config - Configure performance counters + * @events: Array of counters to configure, set to non-zero for + * each counter to enable corresponding event. + * @cycle_count: Set to enable the cycle counter. + */ +struct ethosu_uapi_pmu_config { + __u32 events[ETHOSU_PMU_EVENT_MAX]; + __u32 cycle_count; +}; + +/** + * struct ethosu_uapi_pmu_counts - Status of performance counters + * @events: Count for respective configured events. + * @cycle_count: Count for cycle counter. + */ +struct ethosu_uapi_pmu_counts { + __u32 events[ETHOSU_PMU_EVENT_MAX]; + __u64 cycle_count; +}; + +/** + * struct ethosu_uapi_device_hw_id - Device hardware identification + * @version_status: Version status + * @version_minor: Version minor + * @version_major: Version major + * @product_major: Product major + * @arch_patch_rev: Architecture version patch + * @arch_minor_rev: Architecture version minor + * @arch_major_rev: Architecture version major + */ +struct ethosu_uapi_device_hw_id { + __u32 version_status; + __u32 version_minor; + __u32 version_major; + __u32 product_major; + __u32 arch_patch_rev; + __u32 arch_minor_rev; + __u32 arch_major_rev; +}; + +/** + * struct ethosu_uapi_device_hw_cfg - Device hardware configuration + * @macs_per_cc: MACs per clock cycle + * @cmd_stream_version: NPU command stream version + * @custom_dma: Custom DMA enabled + */ +struct ethosu_uapi_device_hw_cfg { + __u32 macs_per_cc; + __u32 cmd_stream_version; + __u32 custom_dma; +}; + +/** + * struct ethosu_uapi_capabilities - Device capabilities + * @hw_id: Hardware identification + * @hw_cfg: Hardware configuration + * @driver_patch_rev: Driver version patch + * @driver_minor_rev: Driver version minor + * @driver_major_rev: Driver version major + */ +struct ethosu_uapi_device_capabilities { + struct ethosu_uapi_device_hw_id hw_id; + struct ethosu_uapi_device_hw_cfg hw_cfg; + __u32 driver_patch_rev; + __u32 driver_minor_rev; + __u32 driver_major_rev; +}; + +/** + * struct ethosu_uapi_inference_create - Create network request + * @ifm_count: Number of IFM file descriptors + * @ifm_fd: IFM buffer file descriptors + * @ofm_count: Number of OFM file descriptors + * @ofm_fd: OFM buffer file descriptors + */ +struct ethosu_uapi_inference_create { + __u32 ifm_count; + __u32 ifm_fd[ETHOSU_FD_MAX]; + __u32 ofm_count; + __u32 ofm_fd[ETHOSU_FD_MAX]; + struct ethosu_uapi_pmu_config pmu_config; +}; + +/** + * struct ethosu_uapi_result_status - Status of inference + * @status Status of run inference. + * @pmu_config Configured performance counters. + * @pmu_count Perfomance counters values, when status is + * ETHOSU_UAPI_STATUS_OK. + */ +struct ethosu_uapi_result_status { + enum ethosu_uapi_status status; + struct ethosu_uapi_pmu_config pmu_config; + struct ethosu_uapi_pmu_counts pmu_count; +}; + +#ifdef __cplusplus +} /* namespace EthosU */ +#endif +#endif -- 2.17.1