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 C7CE7C433F5 for ; Wed, 11 May 2022 02:47:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230379AbiEKCrm (ORCPT ); Tue, 10 May 2022 22:47:42 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54038 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S245016AbiEKCqw (ORCPT ); Tue, 10 May 2022 22:46:52 -0400 Received: from NAM10-MW2-obe.outbound.protection.outlook.com (mail-mw2nam10on2056.outbound.protection.outlook.com [40.107.94.56]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 13E2E54F91; Tue, 10 May 2022 19:46:49 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=dnAO7tM/J4O3X1Xa+flDBM74hCsqjODJlJ1vsoHNycpUbvnog7KD2M4tngyQWFyRWDPgdBg9yCVmEss3v/fdveWIy4UMxB9SfWDbZol8tRmXyt8ySiIwr9Zs41xwUVpqG+7a5MPhyAi0csr9WEtEyq6IrpWhAdtokuKYLEcsYESQCbGZzwquxHIx3IUkwzCpxhSuIzarBJ7A/pxuY//L/XupXIL/QTe9AqD6ctTwnKkryTVTqmQ7sRVQnfG6Ikt2yLlasI59Em8EjjHQpwSG3nZNhYjL75WEfoHdKC1Haz4v5eacjFggaY14X4MR2QxgCpenkZWowXhrDRc44thxIw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=dZC9+18/mhTYmhXEHnYhIPbQCGjX9oNTNd6uG3Uea9I=; b=NpHCOyqu1glfs2ONjQ6BryhuiBWlkmlfGROWt13Bn5p9vL4WRoBUE8/Z3KkMr3PmM1rhjHqa9YosKLLYoNxXjU/MpFz//Doh805Pv9OOOx/BtZxPRl5qVqS03TyNaD+23kWWYd5ZK4x85gBm/Y3ZrKFnYETyZUjRi9DxUS0yhJC9wgCFyu1AoVy3BCaVBNoGFiyuJAgisRr/gl9DAO4XQOL52NC4XxLmb7rdfSEQhqHoQOSMV/dbMVeqYxtkQph7MaDWzhoY2HJwjlumzdUXc9FzsuDK/Mi4Yf+xiTgzEreAaVp3uzuqE/eML8RaK3DORuMNw+g0SNqkLqr4It1XOg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nvidia.com; dmarc=pass action=none header.from=nvidia.com; dkim=pass header.d=nvidia.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=Nvidia.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=dZC9+18/mhTYmhXEHnYhIPbQCGjX9oNTNd6uG3Uea9I=; b=MliSI7ZY2RzTT7bgNE/wt3oBITwmxB2g6l4bF8tyvNYwv2QgjZM/UUivZBi/rnPVupcz+1W6OFCk+ounQNP+Vg7yJvPfCfH/2Gw5qk64COAtpto469BHZidr7V9QbDKKNUpk+yMWZGHQYKkSyiBdFnXOekBgGt7Xpo/JIJUYUq0x9lgh1BnEf73Vx/zCJfiXPOz/A9KluH9yUmmUjgIEpqIO55d4CYyj5w6NTFb9K5J+SkMfqzdg4Pi5HuXeFyc+hh5i1jDlm40ZSm1mddrstC7ynjZzhdt3y3e4d3CIFca6sxlCHHF8gBewb+++G8kvlJFgPpYDjGBRdWbRHsaXqw== Received: from SJ0PR12MB5676.namprd12.prod.outlook.com (2603:10b6:a03:42e::8) by MN0PR12MB6056.namprd12.prod.outlook.com (2603:10b6:208:3cc::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5227.21; Wed, 11 May 2022 02:46:45 +0000 Received: from SJ0PR12MB5676.namprd12.prod.outlook.com ([fe80::7526:b8f5:b10:1c4c]) by SJ0PR12MB5676.namprd12.prod.outlook.com ([fe80::7526:b8f5:b10:1c4c%7]) with mapi id 15.20.5227.021; Wed, 11 May 2022 02:46:44 +0000 From: Besar Wicaksono To: Robin Murphy CC: "catalin.marinas@arm.com" , "will@kernel.org" , "mark.rutland@arm.com" , "linux-arm-kernel@lists.infradead.org" , "linux-kernel@vger.kernel.org" , "linux-tegra@vger.kernel.org" , "sudeep.holla@arm.com" , "thanu.rangarajan@arm.com" , "Michael.Williams@arm.com" , "suzuki.poulose@arm.com" , Thierry Reding , Jonathan Hunter , Vikram Sethi Subject: RE: [PATCH 1/2] perf: coresight_pmu: Add support for ARM CoreSight PMU driver Thread-Topic: [PATCH 1/2] perf: coresight_pmu: Add support for ARM CoreSight PMU driver Thread-Index: AQHYYzvGd2L8FJXMJUqVqSGGzm8HA60Wdd0AgAJxVWA= Date: Wed, 11 May 2022 02:46:44 +0000 Message-ID: References: <20220509002810.12412-1-bwicaksono@nvidia.com> <20220509002810.12412-2-bwicaksono@nvidia.com> <756ac2c8-6530-03b0-53d3-ee7493509579@arm.com> In-Reply-To: <756ac2c8-6530-03b0-53d3-ee7493509579@arm.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: authentication-results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nvidia.com; x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: 38d42aae-23f0-4370-2583-08da32f87c5d x-ms-traffictypediagnostic: MN0PR12MB6056:EE_ x-microsoft-antispam-prvs: x-ms-exchange-senderadcheck: 1 x-ms-exchange-antispam-relay: 0 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: zPI4F+bjjl5FcADYKSd8ASehsJ+kC/ZCdzrPpuRcOGKnwopsVQtlAoCYpMjPZeqLSjtyb9h2E3Lfo3kC4ePE3s1nuukcnJfyjN7x6dciswDEAdGYabteaqOZn2XlKp3iI+6/SWa5H59tyCGgn3D1+/C8BSF/gS5/JIWpPKuPS0ZTDEP9JbPwxk1C9RQK9C+GDCH4UCyI3wE+ipE/IfB03Y7+sLWMIKRfuMWWzGRibjl0EkH2Wr+ziutHc443q6mca0jVfVJoZASIv7KZxT9ywGhBtKQJpOiLohYZEn7MH1SWnnnEnfGuD6LPAZXk9VTVnwATWObvpvfXCywSqlISZGVBUwPtncfKrEKpEtFTPZbfIoqfp/mbkic6F33XyrNPnMu13TtmaZy7Vk/TZ8b/WPpqwMCvi0koYQjSGSGgT8rcrt960HlmYqy/E5RKx8e6/2rh4fZF8pviJSOPjXm5TGQVW9RodgeZJYVfvVPENLn6Oz8Enh1g9VV7D5SFjbnrPMYd2M5f2S27S9K/3HaM0YVOhpk3K9eOkmCMxeVnVaHnYH5zHQEmVs00IhjeJUiMyiw4LwRcAjsBat3KZ1e6goAb7IFmryHZ4iWSwECu/SUR6xWQDq4UqZ4Tp1iQcJyFTS4xTaiuh/DTH5oE9+wEeDTus+rbncbLIqjo3aQNHU86Y/K4fRN9Om3143pNd1y/SD4X1HEDk7S47VE2Iqh6eF6wt12YYoJm/PG1oKnyo8UkAuVH6SgU4MGztNUYjsO1tyWmo7hyVw2EiynFrcUvczob8ihVcm2GmlSiwf1IpOxCHYITebZ2jA0KTsY68pUHJtMrbABhbTZIkwoeQok0Pw== x-forefront-antispam-report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:SJ0PR12MB5676.namprd12.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230001)(4636009)(366004)(122000001)(33656002)(38100700002)(53546011)(5660300002)(6506007)(83380400001)(8936002)(52536014)(38070700005)(7416002)(107886003)(86362001)(64756008)(66446008)(55016003)(508600001)(9686003)(66946007)(30864003)(66556008)(26005)(966005)(316002)(76116006)(66476007)(8676002)(4326008)(54906003)(6916009)(71200400001)(7696005)(186003)(2906002)(559001)(579004);DIR:OUT;SFP:1101; x-ms-exchange-antispam-messagedata-chunkcount: 1 x-ms-exchange-antispam-messagedata-0: =?utf-8?B?MVNIQ2RhVVloMm4yejVDYTl1SkdibGpKaTVhYTYvejZzcVhnTmsrejB3NTRa?= =?utf-8?B?a2p4OVBtczA4Z09ZS3VQeHkrSkZFekNkbitMZDA5RFkzSGZoelQxS2RJVXNW?= =?utf-8?B?bUVsTEs4MEo2bmw1T3dpb3d5VXRjRjhkemYwQW9pS0ZhYnphRW1LWEVHamhi?= =?utf-8?B?c2k3WmpMKzhJYjRiVm9TcmRlUE53R1Q4NU9kbXlpdWQ4OVhSek1pT0h6ZjIv?= =?utf-8?B?R25wZzFhUTJaYmhpV1piWnFYT0VxZGlXQ0tvbkhjWkVEWmRzdEVIVVdESWdR?= =?utf-8?B?cURMeUNCRVFURkxSQzBhTlYycHhHMlNxT1pvT0QwdkIwUzJiVWI2UGNNOXN3?= =?utf-8?B?K1prYTFjdjU1V05ENndpejhPRWllVm8rMkJ2NTlTZ3BmT2IzWSs0dXlWNnVq?= =?utf-8?B?am80MnlpOWgyTDdvL1k3TGczK1pnVTZIQlQ1ZEUvZXl6LzRFbEJOU1BoOURW?= =?utf-8?B?b3VyK3IyREk4bWVOWmlDY0RRdjVudjdFMFdMSXNWTUhDU2ptb2ZaVE1FRk1K?= =?utf-8?B?djdIUmdqZk1sa0RqMlBRTTdRUm5CZnE1UjQ5NjBQU25YYXU2VG9zM3p4bUE0?= =?utf-8?B?SFVEckk4Q3dEbkJJa0p1RThMblhwM2Z2ekhFSkhTTnlkQUxPSG4rMnF4ekZD?= =?utf-8?B?RkNsTmtNRlQzYTdsQUhhSVVkSzY1bWNlREZ5REpOU1Jma2wzU2JYK1BPS25t?= =?utf-8?B?cDcyT043N0pDb0dLN3UxSVpJWmNNSXZiYXVTaS9lclZhRVVZNnB6QSs1eEd6?= =?utf-8?B?SjRqMjAzaTNPMS9hbEhMeWprZ0t2Uk13V0laRWMrcjd5SG5ob0cwUFlTcW4v?= =?utf-8?B?aXcwYWsydEo5WEYrUFo0K0hFMUR2S1FRbEFEVVFJUTUrVTJhMUhLODFNbFM5?= =?utf-8?B?Rk0rMmZuZWVtWm1ja1dYNGpiZVFrMHdtaVkzdGJ3LzR5NDJIL1ovYWIxRUFJ?= =?utf-8?B?bnMwNnBWN3JVcWtmMFRGMDFObjlKcHFqMjJZVld2bFpXTS9rRjBLdlo5WWll?= =?utf-8?B?cjVGTDNIUTg5bHJCTVJKWE5HRFFQWkJ3a3JiT3JhcENRQUM2MDhFUVM5SXR5?= =?utf-8?B?dWR2eWJoU2VTVmkwQTNRSU00TmZiemNib3dLRTNlWWY1NnI0YWZIUUFzZTBQ?= =?utf-8?B?QkV1ekpVNWVKcElxczJXd2xINEM5N1BDMjVOOThoNy9TV3VMdUZGWC9LRkV5?= =?utf-8?B?NVRRNXg1ajJjRFJHYXZqbTdZcDMvMTdnMnRyWFVEVUx2NHRFRUZCTWN6U0ds?= =?utf-8?B?M3ZpMlBIMlZxdUJZMmZRdW5Bakk5WGlqcFkyaDlNZndlSkhUTEg1WTAxdk0y?= =?utf-8?B?S1RLKzZrOTZCQW9jaWdpMGZxM3lOYnlDODRFN21lUlJLcitzNWxlelBhUUVR?= =?utf-8?B?Z1ZqU3YzTE82T3RGazdOSHZNdktkM0FNNzNsNmxtVml6cjlVNFlKNm54a3VC?= =?utf-8?B?eSt0RTkwQUxFSDZJYXkyend3ZTgwWnZHa0E3a3NsZjBhb0FicTU2cEJVaHpn?= =?utf-8?B?UEpZVmxxeXJ4RTFjcnc0Ky8xNHNaVW1zWGNKWUswQk13ZE9MRHEwdzVpYjkr?= =?utf-8?B?eG10dUw5eWxhYk9HTWgrbDhIenRmb2ptVEkvNWY1QkJ3b251SVNLTkR1Y0U2?= =?utf-8?B?dTI1aGJzVDBQaXUweWZYeHkxT3RKSTIwRndTTHF2QlFQQ1p4WkR5dXhvdlcr?= =?utf-8?B?UTZQbEZPT0JjMGR3WnZIKzcxUVlmYkQ4eXFmRkM0cTloN0lLWDBqOGs2WmdZ?= =?utf-8?B?b2toci9jN1hmQjZJU3JpNGRWTkdoY2ZxVHMrdFVDa1hLYzRKUXFvYW5CTmI2?= =?utf-8?B?Ni9Ca2Z2ejdtMTQyMTJKR01Xa1IvMXdFaGIrMCtjd3ZZTWhSQlpMcmx3cnhp?= =?utf-8?B?eTM1ZmEzZ0hkK0pWbkorWFNYRVdUS1RvazFXSlA3OERRWXUvOC9JaHI1alhs?= =?utf-8?B?L25ydEEyK1BiaTduYmsxNXh4NzlkdUpwWGVIQllsZm16cDNXZ2FMNG1nNTFz?= =?utf-8?B?VGZocjcxNzVoei91R0NkTHJDNlljby9NMkR2ankzT1BsSER2OS84LzJ3MjMz?= =?utf-8?B?WjlWSG1CdDFVYUFnQXFmWG03UEtrVGh3RGszYmVVM20xME8xSXF3dWxMSTZ0?= =?utf-8?B?Z0ZtMTlkQWlkSGdnL25ac0QxV2dFWWE3VVIzM3dwMi9ySE9DbzZ3d0tlSlZi?= =?utf-8?B?SzBhZ09HTm5tY0NEZ3ZidFYvWGlna3RKYjRXc2Q4VUN2czdWcUdKOTV1VDZ5?= =?utf-8?B?UkJYbnZVTyttbndyZXFaR0hEQm9ETVhncmhSaVVvc2o1dTY5YWpYa1poK2s3?= =?utf-8?B?dnBxUk1yajVMN2U4S0FQZkJNdC8wRkt3N0c3SEgvUllSaUsrMGEwZz09?= Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 MIME-Version: 1.0 X-OriginatorOrg: Nvidia.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-AuthSource: SJ0PR12MB5676.namprd12.prod.outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 38d42aae-23f0-4370-2583-08da32f87c5d X-MS-Exchange-CrossTenant-originalarrivaltime: 11 May 2022 02:46:44.5635 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: 43083d15-7273-40c1-b7db-39efd9ccc17a X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: 9bihzWQcK5mC9vnWr8dPRnJCsbl4sGB0p3rY2nqlx1cS/rSU4M68Yum3X9Jh+hX5WzMXnKmaCSqxa+IecUYC+w== X-MS-Exchange-Transport-CrossTenantHeadersStamped: MN0PR12MB6056 Precedence: bulk List-ID: X-Mailing-List: linux-tegra@vger.kernel.org DQoNCj4gLS0tLS1PcmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gRnJvbTogUm9iaW4gTXVycGh5IDxy b2Jpbi5tdXJwaHlAYXJtLmNvbT4NCj4gU2VudDogTW9uZGF5LCBNYXkgOSwgMjAyMiA3OjEzIEFN DQo+IFRvOiBCZXNhciBXaWNha3Nvbm8gPGJ3aWNha3Nvbm9AbnZpZGlhLmNvbT47IGNhdGFsaW4u bWFyaW5hc0Bhcm0uY29tOw0KPiB3aWxsQGtlcm5lbC5vcmc7IG1hcmsucnV0bGFuZEBhcm0uY29t DQo+IENjOiBsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmc7IGxpbnV4LWtlcm5l bEB2Z2VyLmtlcm5lbC5vcmc7DQo+IGxpbnV4LXRlZ3JhQHZnZXIua2VybmVsLm9yZzsgc3VkZWVw LmhvbGxhQGFybS5jb207DQo+IHRoYW51LnJhbmdhcmFqYW5AYXJtLmNvbTsgTWljaGFlbC5XaWxs aWFtc0Bhcm0uY29tOw0KPiBzdXp1a2kucG91bG9zZUBhcm0uY29tOyBUaGllcnJ5IFJlZGluZyA8 dHJlZGluZ0BudmlkaWEuY29tPjsgSm9uYXRoYW4NCj4gSHVudGVyIDxqb25hdGhhbmhAbnZpZGlh LmNvbT47IFZpa3JhbSBTZXRoaSA8dnNldGhpQG52aWRpYS5jb20+DQo+IFN1YmplY3Q6IFJlOiBb UEFUQ0ggMS8yXSBwZXJmOiBjb3Jlc2lnaHRfcG11OiBBZGQgc3VwcG9ydCBmb3IgQVJNDQo+IENv cmVTaWdodCBQTVUgZHJpdmVyDQo+IA0KPiBFeHRlcm5hbCBlbWFpbDogVXNlIGNhdXRpb24gb3Bl bmluZyBsaW5rcyBvciBhdHRhY2htZW50cw0KPiANCj4gDQo+IE9uIDIwMjItMDUtMDkgMDE6Mjgs IEJlc2FyIFdpY2Frc29ubyB3cm90ZToNCj4gPiBBZGQgc3VwcG9ydCBmb3IgQVJNIENvcmVTaWdo dCBQTVUgZHJpdmVyIGZyYW1ld29yayBhbmQgaW50ZXJmYWNlcy4NCj4gPiBUaGUgZHJpdmVyIHBy b3ZpZGVzIGdlbmVyaWMgaW1wbGVtZW50YXRpb24gdG8gb3BlcmF0ZSB1bmNvcmUgUE1VIGJhc2Vk DQo+ID4gb24gQVJNIENvcmVTaWdodCBQTVUgYXJjaGl0ZWN0dXJlLiBUaGUgZHJpdmVyIGFsc28g cHJvdmlkZXMgaW50ZXJmYWNlDQo+ID4gdG8gZ2V0IHZlbmRvci9pbXBsZW1lbnRhdGlvbiBzcGVj aWZpYyBpbmZvcm1hdGlvbiwgZm9yIGV4YW1wbGUgZXZlbnQNCj4gPiBhdHRyaWJ1dGVzIGFuZCBm b3JtYXRpbmcuDQo+ID4NCj4gPiBUaGUgc3BlY2lmaWNhdGlvbiB1c2VkIGluIHRoaXMgaW1wbGVt ZW50YXRpb24gY2FuIGJlIGZvdW5kIGJlbG93Og0KPiA+ICAgKiBBQ1BJIEFybSBQZXJmb3JtYW5j ZSBNb25pdG9yaW5nIFVuaXQgdGFibGU6DQo+ID4gICAgICAgICAgaHR0cHM6Ly9kZXZlbG9wZXIu YXJtLmNvbS9kb2N1bWVudGF0aW9uL2RlbjAxMTcvbGF0ZXN0DQo+ID4gICAqIEFSTSBDb3Jlc2ln aHQgUE1VIGFyY2hpdGVjdHVyZToNCj4gPiAgICAgICAgICBodHRwczovL2RldmVsb3Blci5hcm0u Y29tL2RvY3VtZW50YXRpb24vaWhpMDA5MS9sYXRlc3QNCj4gPg0KPiA+IFNpZ25lZC1vZmYtYnk6 IEJlc2FyIFdpY2Frc29ubyA8YndpY2Frc29ub0BudmlkaWEuY29tPg0KPiA+IC0tLQ0KPiA+ICAg YXJjaC9hcm02NC9jb25maWdzL2RlZmNvbmZpZyAgICAgICAgICAgICAgICAgIHwgICAgMSArDQo+ ID4gICBkcml2ZXJzL3BlcmYvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAy ICsNCj4gPiAgIGRyaXZlcnMvcGVyZi9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICAgICB8 ICAgIDEgKw0KPiA+ICAgZHJpdmVycy9wZXJmL2NvcmVzaWdodF9wbXUvS2NvbmZpZyAgICAgICAg ICAgIHwgICAxMCArDQo+ID4gICBkcml2ZXJzL3BlcmYvY29yZXNpZ2h0X3BtdS9NYWtlZmlsZSAg ICAgICAgICAgfCAgICA2ICsNCj4gPiAgIC4uLi9wZXJmL2NvcmVzaWdodF9wbXUvYXJtX2NvcmVz aWdodF9wbXUuYyAgICB8IDEzMTUNCj4gKysrKysrKysrKysrKysrKysNCj4gPiAgIC4uLi9wZXJm L2NvcmVzaWdodF9wbXUvYXJtX2NvcmVzaWdodF9wbXUuaCAgICB8ICAxNDcgKysNCj4gPiAgIDcg ZmlsZXMgY2hhbmdlZCwgMTQ4MiBpbnNlcnRpb25zKCspDQo+ID4gICBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9wZXJmL2NvcmVzaWdodF9wbXUvS2NvbmZpZw0KPiA+ICAgY3JlYXRlIG1vZGUg MTAwNjQ0IGRyaXZlcnMvcGVyZi9jb3Jlc2lnaHRfcG11L01ha2VmaWxlDQo+ID4gICBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9wZXJmL2NvcmVzaWdodF9wbXUvYXJtX2NvcmVzaWdodF9wbXUu Yw0KPiA+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvcGVyZi9jb3Jlc2lnaHRfcG11L2Fy bV9jb3Jlc2lnaHRfcG11LmgNCj4gPg0KPiA+IGRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2NvbmZp Z3MvZGVmY29uZmlnIGIvYXJjaC9hcm02NC9jb25maWdzL2RlZmNvbmZpZw0KPiA+IGluZGV4IDJj YThiMWIzMzZkMi4uOGYyMTIwMTgyYjI1IDEwMDY0NA0KPiA+IC0tLSBhL2FyY2gvYXJtNjQvY29u Zmlncy9kZWZjb25maWcNCj4gPiArKysgYi9hcmNoL2FybTY0L2NvbmZpZ3MvZGVmY29uZmlnDQo+ ID4gQEAgLTExOTYsNiArMTE5Niw3IEBAIENPTkZJR19QSFlfVU5JUEhJRVJfVVNCMz15DQo+ID4g ICBDT05GSUdfUEhZX1RFR1JBX1hVU0I9eQ0KPiA+ICAgQ09ORklHX1BIWV9BTTY1NF9TRVJERVM9 bQ0KPiA+ICAgQ09ORklHX1BIWV9KNzIxRV9XSVo9bQ0KPiA+ICtDT05GSUdfQVJNX0NPUkVTSUdI VF9QTVU9eQ0KPiA+ICAgQ09ORklHX0FSTV9TTU1VX1YzX1BNVT1tDQo+ID4gICBDT05GSUdfRlNM X0lNWDhfRERSX1BNVT1tDQo+ID4gICBDT05GSUdfUUNPTV9MMl9QTVU9eQ0KPiA+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL3BlcmYvS2NvbmZpZyBiL2RyaXZlcnMvcGVyZi9LY29uZmlnDQo+ID4gaW5k ZXggMWUyZDY5NDUzNzcxLi5jNGU3Y2Q1YjQxNjIgMTAwNjQ0DQo+ID4gLS0tIGEvZHJpdmVycy9w ZXJmL0tjb25maWcNCj4gPiArKysgYi9kcml2ZXJzL3BlcmYvS2NvbmZpZw0KPiA+IEBAIC0xOTIs NCArMTkyLDYgQEAgY29uZmlnIE1BUlZFTExfQ04xMEtfRERSX1BNVQ0KPiA+ICAgICAgICAgRW5h YmxlIHBlcmYgc3VwcG9ydCBmb3IgTWFydmVsbCBERFIgUGVyZm9ybWFuY2UgbW9uaXRvcmluZw0K PiA+ICAgICAgICAgZXZlbnQgb24gQ04xMEsgcGxhdGZvcm0uDQo+ID4NCj4gPiArc291cmNlICJk cml2ZXJzL3BlcmYvY29yZXNpZ2h0X3BtdS9LY29uZmlnIg0KPiA+ICsNCj4gPiAgIGVuZG1lbnUN Cj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9wZXJmL01ha2VmaWxlIGIvZHJpdmVycy9wZXJmL01h a2VmaWxlDQo+ID4gaW5kZXggNTdhMjc5YzYxZGY1Li40MTI2YTA0YjU1ODMgMTAwNjQ0DQo+ID4g LS0tIGEvZHJpdmVycy9wZXJmL01ha2VmaWxlDQo+ID4gKysrIGIvZHJpdmVycy9wZXJmL01ha2Vm aWxlDQo+ID4gQEAgLTIwLDMgKzIwLDQgQEAgb2JqLSQoQ09ORklHX0FSTV9ETUM2MjBfUE1VKSAr PQ0KPiBhcm1fZG1jNjIwX3BtdS5vDQo+ID4gICBvYmotJChDT05GSUdfTUFSVkVMTF9DTjEwS19U QURfUE1VKSArPQ0KPiBtYXJ2ZWxsX2NuMTBrX3RhZF9wbXUubw0KPiA+ICAgb2JqLSQoQ09ORklH X01BUlZFTExfQ04xMEtfRERSX1BNVSkgKz0NCj4gbWFydmVsbF9jbjEwa19kZHJfcG11Lm8NCj4g PiAgIG9iai0kKENPTkZJR19BUFBMRV9NMV9DUFVfUE1VKSArPSBhcHBsZV9tMV9jcHVfcG11Lm8N Cj4gPiArb2JqLSQoQ09ORklHX0FSTV9DT1JFU0lHSFRfUE1VKSArPSBjb3Jlc2lnaHRfcG11Lw0K PiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3BlcmYvY29yZXNpZ2h0X3BtdS9LY29uZmlnDQo+IGIv ZHJpdmVycy9wZXJmL2NvcmVzaWdodF9wbXUvS2NvbmZpZw0KPiA+IG5ldyBmaWxlIG1vZGUgMTAw NjQ0DQo+ID4gaW5kZXggMDAwMDAwMDAwMDAwLi40ODdkZmVlNzFhZDENCj4gPiAtLS0gL2Rldi9u dWxsDQo+ID4gKysrIGIvZHJpdmVycy9wZXJmL2NvcmVzaWdodF9wbXUvS2NvbmZpZw0KPiA+IEBA IC0wLDAgKzEsMTAgQEANCj4gPiArIyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMA0K PiA+ICsjDQo+ID4gKyMgQ29weXJpZ2h0IChjKSAyMDIyLCBOVklESUEgQ09SUE9SQVRJT04gJiBB RkZJTElBVEVTLg0KPiA+ICsNCj4gPiArY29uZmlnIEFSTV9DT1JFU0lHSFRfUE1VDQo+ID4gKyAg ICAgdHJpc3RhdGUgIkFSTSBDb3Jlc2lnaHQgUE1VIg0KPiA+ICsgICAgIGRlcGVuZHMgb24gQVJN NjQgJiYgQUNQSV9BUE1UDQo+IA0KPiBUaGVyZSBzaG91bGRuJ3QgYmUgYW55IGZ1bmN0aW9uYWwg ZGVwZW5kZW5jeSBvbiBhbnkgQ1BVIGFyY2hpdGVjdHVyZSBoZXJlLg0KDQpUaGUgc3BlYyBpcyB0 YXJnZXRlZCB0b3dhcmRzIEFSTSBiYXNlZCBzeXN0ZW0sIHNob3VsZG4ndCB3ZSBleHBsaWNpdGx5 IGxpbWl0IGl0IHRvIEFSTT8NCg0KPiANCj4gPiArICAgICBoZWxwDQo+ID4gKyAgICAgICBQcm92 aWRlcyBzdXBwb3J0IGZvciBQZXJmb3JtYW5jZSBNb25pdG9yaW5nIFVuaXQgKFBNVSkgZXZlbnRz DQo+IGJhc2VkIG9uDQo+ID4gKyAgICAgICBBUk0gQ29yZVNpZ2h0IFBNVSBhcmNoaXRlY3R1cmUu DQo+ID4gXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlDQo+ID4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvcGVyZi9jb3Jlc2lnaHRfcG11L01ha2VmaWxlDQo+IGIvZHJpdmVycy9wZXJmL2NvcmVzaWdo dF9wbXUvTWFrZWZpbGUNCj4gPiBuZXcgZmlsZSBtb2RlIDEwMDY0NA0KPiA+IGluZGV4IDAwMDAw MDAwMDAwMC4uYTJhN2E1ZmJiYzE2DQo+ID4gLS0tIC9kZXYvbnVsbA0KPiA+ICsrKyBiL2RyaXZl cnMvcGVyZi9jb3Jlc2lnaHRfcG11L01ha2VmaWxlDQo+ID4gQEAgLTAsMCArMSw2IEBADQo+ID4g KyMgQ29weXJpZ2h0IChjKSAyMDIyLCBOVklESUEgQ09SUE9SQVRJT04gJiBBRkZJTElBVEVTLg0K PiA+ICsjDQo+ID4gKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjANCj4gPiArDQo+ ID4gK29iai0kKENPTkZJR19BUk1fQ09SRVNJR0hUX1BNVSkgKz0gXA0KPiA+ICsgICAgIGFybV9j b3Jlc2lnaHRfcG11Lm8NCj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9wZXJmL2NvcmVzaWdodF9w bXUvYXJtX2NvcmVzaWdodF9wbXUuYw0KPiBiL2RyaXZlcnMvcGVyZi9jb3Jlc2lnaHRfcG11L2Fy bV9jb3Jlc2lnaHRfcG11LmMNCj4gPiBuZXcgZmlsZSBtb2RlIDEwMDY0NA0KPiA+IGluZGV4IDAw MDAwMDAwMDAwMC4uMWU5NTUzZDI5NzE3DQo+ID4gLS0tIC9kZXYvbnVsbA0KPiA+ICsrKyBiL2Ry aXZlcnMvcGVyZi9jb3Jlc2lnaHRfcG11L2FybV9jb3Jlc2lnaHRfcG11LmMNCj4gPiBAQCAtMCww ICsxLDEzMTUgQEANCj4gPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjANCj4g PiArLyoNCj4gPiArICogQVJNIENvcmVTaWdodCBQTVUgZHJpdmVyLg0KPiA+ICsgKg0KPiA+ICsg KiBUaGlzIGRyaXZlciBhZGRzIHN1cHBvcnQgZm9yIHVuY29yZSBQTVUgYmFzZWQgb24gQVJNIENv cmVTaWdodA0KPiBQZXJmb3JtYW5jZQ0KPiA+ICsgKiBNb25pdG9yaW5nIFVuaXQgQXJjaGl0ZWN0 dXJlLiBUaGUgUE1VIGlzIGFjY2Vzc2libGUgdmlhIE1NSU8gcmVnaXN0ZXJzDQo+IGFuZA0KPiA+ ICsgKiBsaWtlIG90aGVyIHVuY29yZSBQTVVzLCBpdCBkb2VzIG5vdCBzdXBwb3J0IHByb2Nlc3Mg c3BlY2lmaWMgZXZlbnRzIGFuZA0KPiA+ICsgKiBjYW5ub3QgYmUgdXNlZCBpbiBzYW1wbGluZyBt b2RlLg0KPiA+ICsgKg0KPiA+ICsgKiBUaGlzIGNvZGUgaXMgYmFzZWQgb24gb3RoZXIgdW5jb3Jl IFBNVXMgbGlrZSBBUk0gRFNVIFBNVS4gSXQNCj4gcHJvdmlkZXMgYQ0KPiA+ICsgKiBnZW5lcmlj IGltcGxlbWVudGF0aW9uIHRvIG9wZXJhdGUgdGhlIFBNVSBhY2NvcmRpbmcgdG8gQ29yZVNpZ2h0 DQo+IFBNVQ0KPiA+ICsgKiBhcmNoaXRlY3R1cmUgYW5kIEFDUEkgQVJNIFBNVSB0YWJsZSAoQVBN VCkgZG9jdW1lbnRzIGJlbG93Og0KPiA+ICsgKiAgIC0gQVJNIENvcmVTaWdodCBQTVUgYXJjaGl0 ZWN0dXJlIGRvY3VtZW50IG51bWJlcjogQVJNIElISSAwMDkxDQo+IEEuYS0wMGJldDAuDQo+ID4g KyAqICAgLSBBUE1UIGRvY3VtZW50IG51bWJlcjogQVJNIERFTjAxMTcuDQo+ID4gKyAqIFRoZSBk ZXNjcmlwdGlvbiBvZiB0aGUgUE1VLCBsaWtlIHRoZSBQTVUgZGV2aWNlIGlkZW50aWZpY2F0aW9u LA0KPiBhdmFpbGFibGUNCj4gPiArICogZXZlbnRzLCBhbmQgY29uZmlndXJhdGlvbiBvcHRpb25z LCBpcyB2ZW5kb3Igc3BlY2lmaWMuIFRoZSBkcml2ZXINCj4gcHJvdmlkZXMNCj4gPiArICogaW50 ZXJmYWNlIGZvciB2ZW5kb3Igc3BlY2lmaWMgY29kZSB0byBnZXQgdGhpcyBpbmZvcm1hdGlvbi4g VGhpcyBhbGxvd3MNCj4gdGhlDQo+ID4gKyAqIGRyaXZlciB0byBiZSBzaGFyZWQgd2l0aCBQTVUg ZnJvbSBkaWZmZXJlbnQgdmVuZG9ycy4NCj4gPiArICoNCj4gPiArICogQ29yZVNpZ2h0IFBNVSBk ZXZpY2VzIGFyZSBuYW1lZCBhcyBhcm1fY29yZXNpZ2h0X3BtdTxub2RlX2lkPg0KPiB3aGVyZSA8 bm9kZV9pZD4NCj4gPiArICogaXMgQVBNVCBub2RlIGlkLiBUaGUgZGVzY3JpcHRpb24gb2YgdGhl IGRldmljZSwgbGlrZSB0aGUgaWRlbnRpZmllciwNCj4gPiArICogc3VwcG9ydGVkIGV2ZW50cywg YW5kIGZvcm1hdHMgY2FuIGJlIGZvdW5kIGluIHN5c2ZzDQo+ID4gKyAqIC9zeXMvYnVzL2V2ZW50 X3NvdXJjZS9kZXZpY2VzL2FybV9jb3Jlc2lnaHRfcG11PG5vZGVfaWQ+DQo+ID4gKyAqDQo+ID4g KyAqIFRoZSB1c2VyIHNob3VsZCByZWZlciB0byB0aGUgdmVuZG9yIHRlY2huaWNhbCBkb2N1bWVu dGF0aW9uIHRvIGdldA0KPiBkZXRhaWxzDQo+ID4gKyAqIGFib3V0IHRoZSBzdXBwb3J0ZWQgZXZl bnRzLg0KPiA+ICsgKg0KPiA+ICsgKiBDb3B5cmlnaHQgKGMpIDIwMjIsIE5WSURJQSBDT1JQT1JB VElPTiAmIEFGRklMSUFURVMuDQo+ID4gKyAqDQo+ID4gKyAqLw0KPiA+ICsNCj4gPiArI2luY2x1 ZGUgPGxpbnV4L2FjcGkuaD4NCj4gPiArI2luY2x1ZGUgPGxpbnV4L2NhY2hlaW5mby5oPg0KPiA+ ICsjaW5jbHVkZSA8bGludXgvY3R5cGUuaD4NCj4gPiArI2luY2x1ZGUgPGxpbnV4L2ludGVycnVw dC5oPg0KPiA+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+DQo+ID4gKyNpbmNsdWRlIDxsaW51 eC9wZXJmX2V2ZW50Lmg+DQo+ID4gKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4N Cj4gPiArI2luY2x1ZGUgPGFjcGkvcHJvY2Vzc29yLmg+DQo+ID4gKw0KPiA+ICsjaW5jbHVkZSAi YXJtX2NvcmVzaWdodF9wbXUuaCINCj4gPiArDQo+ID4gKyNkZWZpbmUgUE1VTkFNRSAiYXJtX2Nv cmVzaWdodF9wbXUiDQo+ID4gKw0KPiA+ICsjZGVmaW5lIENPUkVTSUdIVF9DUFVNQVNLX0FUVFIo X25hbWUsIF9jb25maWcpICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwNCj4gPiArICAg ICBDT1JFU0lHSFRfRVhUX0FUVFIoX25hbWUsIGNvcmVzaWdodF9wbXVfY3B1bWFza19zaG93LCAg ICAgICAgICAgXA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAodW5zaWduZWQgbG9uZylf Y29uZmlnKQ0KPiA+ICsNCj4gPiArLyoqDQo+ID4gKyAqIFJlZ2lzdGVyIG9mZnNldHMgYmFzZWQg b24gQ29yZVNpZ2h0IFBlcmZvcm1hbmNlIE1vbml0b3JpbmcgVW5pdA0KPiBBcmNoaXRlY3R1cmUN Cj4gPiArICogRG9jdW1lbnQgbnVtYmVyOiBBUk0tRUNNLTA2NDAxNjkgMDBhbHA2DQo+ID4gKyAq Lw0KPiA+ICsjZGVmaW5lIFBNRVZDTlRSX0xPICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIDB4MA0KPiA+ICsjZGVmaW5lIFBNRVZDTlRSX0hJICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIDB4NA0KPiA+ICsjZGVmaW5lIFBNRVZUWVBFUiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIDB4NDAwDQo+ID4gKyNkZWZpbmUgUE1DQ0ZJTFRSICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgMHg0N0MNCj4gPiArI2RlZmluZSBQTUVWRklMVFIgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweEEwMA0KPiA+ICsjZGVmaW5lIFBNQ05U RU5TRVQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDB4QzAwDQo+ID4gKyNkZWZp bmUgUE1DTlRFTkNMUiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMHhDMjANCj4g PiArI2RlZmluZSBQTUlOVEVOU0VUICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAw eEM0MA0KPiA+ICsjZGVmaW5lIFBNSU5URU5DTFIgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIDB4QzYwDQo+ID4gKyNkZWZpbmUgUE1PVlNDTFIgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgMHhDODANCj4gPiArI2RlZmluZSBQTU9WU1NFVCAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAweENDMA0KPiA+ICsjZGVmaW5lIFBNQ0ZHUiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMHhFMDANCj4gPiArI2RlZmlu ZSBQTUNSICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweEUwNA0KPiA+ ICsjZGVmaW5lIFBNSUlEUiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgMHhFMDgNCj4gPiArDQo+ID4gKy8qIFBNQ0ZHUiByZWdpc3RlciBmaWVsZCAqLw0KPiA+ ICsjZGVmaW5lIFBNQ0ZHUl9OQ0dfU0hJRlQgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDI4 DQo+ID4gKyNkZWZpbmUgUE1DRkdSX05DR19NQVNLICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAweGYNCj4gPiArI2RlZmluZSBQTUNGR1JfSERCRyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBCSVQoMjQpDQo+ID4gKyNkZWZpbmUgUE1DRkdSX1RSTyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgQklUKDIzKQ0KPiA+ICsjZGVmaW5lIFBNQ0ZHUl9T UyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEJJVCgyMikNCj4gPiArI2RlZmlu ZSBQTUNGR1JfRlpPICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBCSVQoMjEpDQo+ ID4gKyNkZWZpbmUgUE1DRkdSX01TSSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg QklUKDIwKQ0KPiA+ICsjZGVmaW5lIFBNQ0ZHUl9VRU4gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIEJJVCgxOSkNCj4gPiArI2RlZmluZSBQTUNGR1JfTkEgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBCSVQoMTcpDQo+ID4gKyNkZWZpbmUgUE1DRkdSX0VYICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQklUKDE2KQ0KPiA+ICsjZGVmaW5lIFBNQ0ZH Ul9DQ0QgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEJJVCgxNSkNCj4gPiArI2Rl ZmluZSBQTUNGR1JfQ0MgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBCSVQoMTQp DQo+ID4gKyNkZWZpbmUgUE1DRkdSX1NJWkVfU0hJRlQgICAgICAgICAgICAgICAgICAgICAgICAg ICAgOA0KPiA+ICsjZGVmaW5lIFBNQ0ZHUl9TSVpFX01BU0sgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIDB4M2YNCj4gPiArI2RlZmluZSBQTUNGR1JfTl9TSElGVCAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIDANCj4gPiArI2RlZmluZSBQTUNGR1JfTl9NQVNLICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDB4ZmYNCj4gPiArDQo+ID4gKy8qIFBN Q1IgcmVnaXN0ZXIgZmllbGQgKi8NCj4gPiArI2RlZmluZSBQTUNSX1RSTyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBCSVQoMTEpDQo+ID4gKyNkZWZpbmUgUE1DUl9IREJHICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQklUKDEwKQ0KPiA+ICsjZGVmaW5lIFBN Q1JfRlpPICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEJJVCg5KQ0KPiA+ICsj ZGVmaW5lIFBNQ1JfTkEgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgQklUKDgpDQo+ID4gKyNkZWZpbmUgUE1DUl9EUCAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBCSVQoNSkNCj4gPiArI2RlZmluZSBQTUNSX1ggICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEJJVCg0KQ0KPiA+ICsjZGVmaW5l IFBNQ1JfRCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQklU KDMpDQo+ID4gKyNkZWZpbmUgUE1DUl9DICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBCSVQoMikNCj4gPiArI2RlZmluZSBQTUNSX1AgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEJJVCgxKQ0KPiA+ICsjZGVmaW5lIFBNQ1Jf RSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQklUKDApDQo+ ID4gKw0KPiA+ICsvKiBQTUlJRFIgcmVnaXN0ZXIgZmllbGQgKi8NCj4gPiArI2RlZmluZSBQTUlJ RFJfSU1QTEVNRU5URVJfTUFTSyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDB4RkZGDQo+ ID4gKyNkZWZpbmUgUE1JSURSX1BST0RVQ1RJRF9NQVNLICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAweEZGRg0KPiA+ICsjZGVmaW5lIFBNSUlEUl9QUk9EVUNUSURfU0hJRlQgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgMjANCj4gPiArDQo+ID4gKy8qIEVhY2ggU0VUL0NMUiBy ZWdpc3RlciBzdXBwb3J0cyB1cCB0byAzMiBjb3VudGVycy4gKi8NCj4gPiArI2RlZmluZSBDT1JF U0lHSFRfU0VUX0NMUl9SRUdfQ09VTlRFUl9OVU0gICAgICAgICAgICAzMg0KPiA+ICsjZGVmaW5l IENPUkVTSUdIVF9TRVRfQ0xSX1JFR19DT1VOVEVSX1NISUZUICAgICAgICAgIDUNCj4gPiArDQo+ ID4gKy8qIFRoZSBudW1iZXIgb2YgMzItYml0IFNFVC9DTFIgcmVnaXN0ZXIgdGhhdCBjYW4gYmUg c3VwcG9ydGVkLiAqLw0KPiA+ICsjZGVmaW5lIENPUkVTSUdIVF9TRVRfQ0xSX1JFR19NQVhfTlVN ICgoUE1DTlRFTkNMUiAtDQo+IFBNQ05URU5TRVQpIC8gc2l6ZW9mKHUzMikpDQo+ID4gKw0KPiA+ ICtzdGF0aWNfYXNzZXJ0KChDT1JFU0lHSFRfU0VUX0NMUl9SRUdfTUFYX05VTSAqDQo+ID4gKyAg ICAgICAgICAgIENPUkVTSUdIVF9TRVRfQ0xSX1JFR19DT1VOVEVSX05VTSkgPj0NCj4gPiArICAg ICAgICAgICBDT1JFU0lHSFRfUE1VX01BWF9IV19DTlRSUyk7DQo+ID4gKw0KPiA+ICsvKiBDb252 ZXJ0IGNvdW50ZXIgaWR4IGludG8gU0VUL0NMUiByZWdpc3RlciBudW1iZXIuICovDQo+ID4gKyNk ZWZpbmUgQ09SRVNJR0hUX0lEWF9UT19TRVRfQ0xSX1JFR19JRChpZHgpICAgICAgICAgICAgICAg ICAgICAgICAgIFwNCj4gPiArICAgICAoaWR4ID4+IENPUkVTSUdIVF9TRVRfQ0xSX1JFR19DT1VO VEVSX1NISUZUKQ0KPiA+ICsNCj4gPiArLyogQ29udmVydCBjb3VudGVyIGlkeCBpbnRvIFNFVC9D TFIgcmVnaXN0ZXIgYml0LiAqLw0KPiA+ICsjZGVmaW5lIENPUkVTSUdIVF9JRFhfVE9fU0VUX0NM Ul9SRUdfQklUKGlkeCkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwNCj4gPiArICAg ICAoaWR4ICYgKENPUkVTSUdIVF9TRVRfQ0xSX1JFR19DT1VOVEVSX05VTSAtIDEpKQ0KPiA+ICsN Cj4gPiArI2RlZmluZSBDT1JFU0lHSFRfQUNUSVZFX0NQVV9NQVNLICAgICAgICAgICAgICAgICAg ICAweDANCj4gPiArI2RlZmluZSBDT1JFU0lHSFRfQVNTT0NJQVRFRF9DUFVfTUFTSyAgICAgICAg ICAgICAgICAgICAgICAgIDB4MQ0KPiA+ICsNCj4gPiArI2RlZmluZSBDT1JFU0lHSFRfRVZFTlRf TUFTSyAgICAgICAgICAgICAgICAgICAgICAgICAweEZGRkZGRkZGVUxMDQo+ID4gKyNkZWZpbmUg Q09SRVNJR0hUX0ZJTFRFUl9NQVNLICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAweEZG RkZGRkZGVUxMDQo+ID4gKyNkZWZpbmUgQ09SRVNJR0hUX0ZJTFRFUl9TSElGVCAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAzMlVMTA0KPiA+ICsNCj4gPiArLyogQ2hlY2sgaWYgZmllbGQg ZiBpbiBmbGFncyBpcyBzZXQgd2l0aCB2YWx1ZSB2ICovDQo+ID4gKyNkZWZpbmUgQ0hFQ0tfQVBN VF9GTEFHKGZsYWdzLCBmLCB2KSBcDQo+ID4gKyAgICAgKChmbGFncyAmIChBQ1BJX0FQTVRfRkxB R1NfICMjIGYpKSA9PSAoQUNQSV9BUE1UX0ZMQUdTXyAjIyBmICMjDQo+IF8gIyMgdikpDQo+ID4g Kw0KPiA+ICtzdGF0aWMgdW5zaWduZWQgbG9uZyBjb3Jlc2lnaHRfcG11X2NwdWhwX3N0YXRlOw0K PiA+ICsNCj4gPiArLyoNCj4gPiArICogSW4gQ29yZVNpZ2h0IFBNVSBhcmNoaXRlY3R1cmUsIGFs bCBvZiB0aGUgTU1JTyByZWdpc3RlcnMgYXJlIDMyLWJpdA0KPiBleGNlcHQNCj4gPiArICogY291 bnRlciByZWdpc3Rlci4gVGhlIGNvdW50ZXIgcmVnaXN0ZXIgY2FuIGJlIGltcGxlbWVudGVkIGFz IDMyLWJpdCBvcg0KPiA2NC1iaXQNCj4gPiArICogcmVnaXN0ZXIgZGVwZW5kaW5nIG9uIHRoZSB2 YWx1ZSBvZiBQTUNGR1IuU0laRSBmaWVsZC4gRm9yIDY0LWJpdA0KPiBhY2Nlc3MsDQo+ID4gKyAq IHNpbmdsZS1jb3B5IDY0LWJpdCBhdG9taWMgc3VwcG9ydCBpcyBpbXBsZW1lbnRhdGlvbiBkZWZp bmVkLiBBUE1UDQo+IG5vZGUgZmxhZw0KPiA+ICsgKiBpcyB1c2VkIHRvIGlkZW50aWZ5IGlmIHRo ZSBQTVUgc3VwcG9ydHMgNjQtYml0IHNpbmdsZSBjb3B5IGF0b21pYy4gSWYgNjQtDQo+IGJpdA0K PiA+ICsgKiBzaW5nbGUgY29weSBhdG9taWMgaXMgbm90IHN1cHBvcnRlZCwgdGhlIGRyaXZlciB0 cmVhdHMgdGhlIHJlZ2lzdGVyIGFzIGENCj4gcGFpcg0KPiA+ICsgKiBvZiAzMi1iaXQgcmVnaXN0 ZXIuDQo+ID4gKyAqLw0KPiA+ICsNCj4gPiArLyoNCj4gPiArICogUmVhZCAzMi1iaXQgcmVnaXN0 ZXIuDQo+ID4gKyAqDQo+ID4gKyAqIEBiYXNlICAgIDogYmFzZSBhZGRyZXNzIG9mIHBhZ2UtMCBv ciBwYWdlLTEgaWYgZHVhbC1wYWdlIGV4dC4gaXMgZW5hYmxlZC4NCj4gPiArICogQG9mZnNldCAg OiByZWdpc3RlciBvZmZzZXQuDQo+ID4gKyAqDQo+ID4gKyAqIEByZXR1cm4gMzItYml0IHZhbHVl IG9mIHRoZSByZWdpc3Rlci4NCj4gPiArICovDQo+ID4gK3N0YXRpYyBpbmxpbmUgdTMyIHJlYWRf cmVnMzIodm9pZCBfX2lvbWVtICpiYXNlLCB1MzIgb2Zmc2V0KQ0KPiA+ICt7DQo+ID4gKyAgICAg cmV0dXJuIHJlYWRsKGJhc2UgKyBvZmZzZXQpOw0KPiA+ICt9DQo+IA0KPiByZWFkX3JlZzMyKHgs IHkpOw0KPiByZWFkbCh4ICsgeSk7DQo+IA0KPiBUaGVzZSBraW5kIG9mIHdyYXBwZXJzIGFyZSBq dXN0IGFib3V0IHJlYXNvbmFibGUgd2hlbiB0aGV5IGVuY2Fwc3VsYXRlIGENCj4gc3RydWN0dXJl IGRlcmVmZXJlbmNlIG9yIHNvbWUgY29tcHV0YXRpb24gdG8gdHJhbnNmb3JtIHRoZSBvZmZzZXQs IGJ1dA0KPiBoYXZpbmcgMTMgZXh0cmEgbGluZXMgcGx1cyA0IGV4dHJhIGNoYXJhY3RlcnMgcGVy IGNhbGxzaXRlIHB1cmVseSB0bw0KPiBvYmZ1c2NhdGUgYW4gYWRkaXRpb24gc2VlbXMgb2JqZWN0 aXZlbHkgd29yc2UgdGhhbiBub3QgZG9pbmcgdGhhdC4NCg0KU3VyZSwgd2Ugd2lsbCByZXBsYWNl IHRoZXNlIGNhbGxzLg0KDQo+IA0KPiA+ICsNCj4gPiArLyoNCj4gPiArICogUmVhZCA2NC1iaXQg cmVnaXN0ZXIgdXNpbmcgc2luZ2xlIDY0LWJpdCBhdG9taWMgY29weS4NCj4gPiArICoNCj4gPiAr ICogQGJhc2UgICAgOiBiYXNlIGFkZHJlc3Mgb2YgcGFnZS0wIG9yIHBhZ2UtMSBpZiBkdWFsLXBh Z2UgZXh0LiBpcyBlbmFibGVkLg0KPiA+ICsgKiBAb2Zmc2V0ICA6IHJlZ2lzdGVyIG9mZnNldC4N Cj4gPiArICoNCj4gPiArICogQHJldHVybiA2NC1iaXQgdmFsdWUgb2YgdGhlIHJlZ2lzdGVyLg0K PiA+ICsgKi8NCj4gPiArc3RhdGljIHU2NCByZWFkX3JlZzY0KHZvaWQgX19pb21lbSAqYmFzZSwg dTMyIG9mZnNldCkNCj4gPiArew0KPiA+ICsgICAgIHJldHVybiByZWFkcShiYXNlICsgb2Zmc2V0 KTsNCj4gPiArfQ0KPiA+ICsNCj4gPiArLyoNCj4gPiArICogUmVhZCA2NC1iaXQgcmVnaXN0ZXIg YXMgYSBwYWlyIG9mIDMyLWJpdCByZWdpc3RlcnMgdXNpbmcgaGktbG8taGkgc2VxdWVuY2UuDQo+ ID4gKyAqDQo+ID4gKyAqIEBiYXNlICAgIDogYmFzZSBhZGRyZXNzIG9mIHBhZ2UtMCBvciBwYWdl LTEgaWYgZHVhbC1wYWdlIGV4dC4gaXMgZW5hYmxlZC4NCj4gPiArICogQG9mZnNldCAgOiByZWdp c3RlciBvZmZzZXQuDQo+ID4gKyAqDQo+ID4gKyAqIEByZXR1cm4gNjQtYml0IHZhbHVlIG9mIHRo ZSByZWdpc3RlciBwYWlyLg0KPiA+ICsgKi8NCj4gPiArc3RhdGljIHU2NCByZWFkX3JlZzY0X2hp bG9oaSh2b2lkIF9faW9tZW0gKmJhc2UsIHUzMiBvZmZzZXQpDQo+ID4gK3sNCj4gPiArICAgICB1 MzIgdmFsX2xvLCB2YWxfaGk7DQo+ID4gKyAgICAgdTY0IHZhbDsNCj4gPiArDQo+ID4gKyAgICAg LyogVXNlIGhpZ2gtbG93LWhpZ2ggc2VxdWVuY2UgdG8gYXZvaWQgdGVhcmluZyAqLw0KPiA+ICsg ICAgIGRvIHsNCj4gPiArICAgICAgICAgICAgIHZhbF9oaSA9IHJlYWRfcmVnMzIoYmFzZSwgb2Zm c2V0ICsgNCk7DQo+ID4gKyAgICAgICAgICAgICB2YWxfbG8gPSByZWFkX3JlZzMyKGJhc2UsIG9m ZnNldCk7DQo+ID4gKyAgICAgfSB3aGlsZSAodmFsX2hpICE9IHJlYWRfcmVnMzIoYmFzZSwgb2Zm c2V0ICsgNCkpOw0KPiA+ICsNCj4gPiArICAgICB2YWwgPSAoKCh1NjQpdmFsX2hpIDw8IDMyKSB8 IHZhbF9sbyk7DQo+ID4gKw0KPiA+ICsgICAgIHJldHVybiB2YWw7DQo+ID4gK30NCj4gPiArDQo+ ID4gKy8qDQo+ID4gKyAqIFdyaXRlIHRvIDMyLWJpdCByZWdpc3Rlci4NCj4gPiArICoNCj4gPiAr ICogQHZhbCAgICAgOiAzMi1iaXQgdmFsdWUgdG8gd3JpdGUuDQo+ID4gKyAqIEBiYXNlICAgIDog YmFzZSBhZGRyZXNzIG9mIHBhZ2UtMCBvciBwYWdlLTEgaWYgZHVhbC1wYWdlIGV4dC4gaXMgZW5h YmxlZC4NCj4gPiArICogQG9mZnNldCAgOiByZWdpc3RlciBvZmZzZXQuDQo+ID4gKyAqDQo+ID4g KyAqLw0KPiA+ICtzdGF0aWMgaW5saW5lIHZvaWQgd3JpdGVfcmVnMzIodTMyIHZhbCwgdm9pZCBf X2lvbWVtICpiYXNlLCB1MzIgb2Zmc2V0KQ0KPiA+ICt7DQo+ID4gKyAgICAgd3JpdGVsKHZhbCwg YmFzZSArIG9mZnNldCk7DQo+ID4gK30NCj4gPiArDQo+ID4gKy8qDQo+ID4gKyAqIFdyaXRlIHRv IDY0LWJpdCByZWdpc3RlciB1c2luZyBzaW5nbGUgNjQtYml0IGF0b21pYyBjb3B5Lg0KPiA+ICsg Kg0KPiA+ICsgKiBAdmFsICAgICA6IDY0LWJpdCB2YWx1ZSB0byB3cml0ZS4NCj4gPiArICogQGJh c2UgICAgOiBiYXNlIGFkZHJlc3Mgb2YgcGFnZS0wIG9yIHBhZ2UtMSBpZiBkdWFsLXBhZ2UgZXh0 LiBpcyBlbmFibGVkLg0KPiA+ICsgKiBAb2Zmc2V0ICA6IHJlZ2lzdGVyIG9mZnNldC4NCj4gPiAr ICoNCj4gPiArICovDQo+ID4gK3N0YXRpYyB2b2lkIHdyaXRlX3JlZzY0KHU2NCB2YWwsIHZvaWQg X19pb21lbSAqYmFzZSwgdTMyIG9mZnNldCkNCj4gPiArew0KPiA+ICsgICAgIHdyaXRlcSh2YWws IGJhc2UgKyBvZmZzZXQpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICsvKg0KPiA+ICsgKiBXcml0ZSB0 byA2NC1iaXQgcmVnaXN0ZXIgYXMgYSBwYWlyIG9mIDMyLWJpdCByZWdpc3RlcnMuDQo+ID4gKyAq DQo+ID4gKyAqIEB2YWwgICAgIDogNjQtYml0IHZhbHVlIHRvIHdyaXRlLg0KPiA+ICsgKiBAYmFz ZSAgICA6IGJhc2UgYWRkcmVzcyBvZiBwYWdlLTAgb3IgcGFnZS0xIGlmIGR1YWwtcGFnZSBleHQu IGlzIGVuYWJsZWQuDQo+ID4gKyAqIEBvZmZzZXQgIDogcmVnaXN0ZXIgb2Zmc2V0Lg0KPiA+ICsg Kg0KPiA+ICsgKi8NCj4gPiArc3RhdGljIHZvaWQgd3JpdGVfcmVnNjRfbG9oaSh1NjQgdmFsLCB2 b2lkIF9faW9tZW0gKmJhc2UsIHUzMiBvZmZzZXQpDQo+ID4gK3sNCj4gPiArICAgICB1MzIgdmFs X2xvLCB2YWxfaGk7DQo+ID4gKw0KPiA+ICsgICAgIHZhbF9oaSA9IHVwcGVyXzMyX2JpdHModmFs KTsNCj4gPiArICAgICB2YWxfbG8gPSBsb3dlcl8zMl9iaXRzKHZhbCk7DQo+ID4gKw0KPiA+ICsg ICAgIHdyaXRlX3JlZzMyKHZhbF9sbywgYmFzZSwgb2Zmc2V0KTsNCj4gPiArICAgICB3cml0ZV9y ZWczMih2YWxfaGksIGJhc2UsIG9mZnNldCArIDQpOw0KPiA+ICt9DQo+IA0KPiAjaW5jbHVkZSA8 bGludXgvaW8tNjQtbm9uYXRvbWljLWxvLWhpLmg+DQoNClRoYW5rcyBmb3IgcG9pbnRpbmcgdGhp cyBvdXQuIFdlIHdpbGwgcmVwbGFjZSBpdCB3aXRoIGxvX2hpX3dyaXRlcS4NCg0KPiANCj4gPiAr DQo+ID4gKy8qIENoZWNrIGlmIGN5Y2xlIGNvdW50ZXIgaXMgc3VwcG9ydGVkLiAqLw0KPiA+ICtz dGF0aWMgaW5saW5lIGJvb2wgc3VwcG9ydF9jYyhjb25zdCBzdHJ1Y3QgY29yZXNpZ2h0X3BtdSAq Y29yZXNpZ2h0X3BtdSkNCj4gPiArew0KPiA+ICsgICAgIHJldHVybiAoY29yZXNpZ2h0X3BtdS0+ cG1jZmdyICYgUE1DRkdSX0NDKTsNCj4gPiArfQ0KPiA+ICsNCj4gPiArLyogR2V0IGNvdW50ZXIg c2l6ZS4gKi8NCj4gPiArc3RhdGljIGlubGluZSB1MzIgcG1jZmdyX3NpemUoY29uc3Qgc3RydWN0 IGNvcmVzaWdodF9wbXUgKmNvcmVzaWdodF9wbXUpDQo+ID4gK3sNCj4gPiArICAgICByZXR1cm4g KGNvcmVzaWdodF9wbXUtPnBtY2ZnciA+PiBQTUNGR1JfU0laRV9TSElGVCkgJg0KPiBQTUNGR1Jf U0laRV9NQVNLOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICsvKiBDaGVjayBpZiBjb3VudGVyIGlzIGlt cGxlbWVudGVkIGFzIDY0LWJpdCByZWdpc3Rlci4gKi8NCj4gPiArc3RhdGljIGlubGluZSBib29s DQo+ID4gK3VzZV82NGJfY291bnRlcl9yZWcoY29uc3Qgc3RydWN0IGNvcmVzaWdodF9wbXUgKmNv cmVzaWdodF9wbXUpDQo+ID4gK3sNCj4gPiArICAgICByZXR1cm4gKHBtY2Zncl9zaXplKGNvcmVz aWdodF9wbXUpID4gMzEpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICsvKiBHZXQgbnVtYmVyIG9mIGNv dW50ZXJzLCBtaW51cyBvbmUuICovDQo+ID4gK3N0YXRpYyBpbmxpbmUgdTMyIHBtY2Zncl9uKGNv bnN0IHN0cnVjdCBjb3Jlc2lnaHRfcG11ICpjb3Jlc2lnaHRfcG11KQ0KPiA+ICt7DQo+ID4gKyAg ICAgcmV0dXJuIChjb3Jlc2lnaHRfcG11LT5wbWNmZ3IgPj4gUE1DRkdSX05fU0hJRlQpICYNCj4g UE1DRkdSX05fTUFTSzsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3NpemVfdCBjb3Jlc2lnaHRfcG11 X3N5c2ZzX2V2ZW50X3Nob3coc3RydWN0IGRldmljZSAqZGV2LA0KPiA+ICsgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hh ciAqYnVmKQ0KPiA+ICt7DQo+ID4gKyAgICAgc3RydWN0IGRldl9leHRfYXR0cmlidXRlICplYXR0 ciA9DQo+ID4gKyAgICAgICAgICAgICBjb250YWluZXJfb2YoYXR0ciwgc3RydWN0IGRldl9leHRf YXR0cmlidXRlLCBhdHRyKTsNCj4gPiArICAgICByZXR1cm4gc3lzZnNfZW1pdChidWYsICJldmVu dD0weCVsbHhcbiIsDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgKHVuc2lnbmVkIGxvbmcg bG9uZyllYXR0ci0+dmFyKTsNCj4gPiArfQ0KPiA+ICtFWFBPUlRfU1lNQk9MX0dQTChjb3Jlc2ln aHRfcG11X3N5c2ZzX2V2ZW50X3Nob3cpOw0KPiA+ICsNCj4gPiArLyoqDQo+ID4gKyAqIEV2ZW50 IGxpc3Qgb2YgUE1VIHRoYXQgZG9lcyBub3Qgc3VwcG9ydCBjeWNsZSBjb3VudGVyLiBDdXJyZW50 bHkgdGhlDQo+ID4gKyAqIENvcmVTaWdodCBQTVUgc3BlYyBkb2VzIG5vdCBkZWZpbmUgc3RhbmRh cmQgZXZlbnRzLCBzbyBpdCBpcyBlbXB0eQ0KPiBub3cuDQo+ID4gKyAqLw0KPiA+ICtzdGF0aWMg c3RydWN0IGF0dHJpYnV0ZSAqY29yZXNpZ2h0X3BtdV9ldmVudF9hdHRyc1tdID0gew0KPiA+ICsg ICAgIE5VTEwsDQo+ID4gK307DQo+ID4gKw0KPiA+ICsvKiBFdmVudCBsaXN0IG9mIFBNVSBzdXBw b3J0aW5nIGN5Y2xlIGNvdW50ZXIuICovDQo+ID4gK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpj b3Jlc2lnaHRfcG11X2V2ZW50X2F0dHJzX2NjW10gPSB7DQo+ID4gKyAgICAgQ09SRVNJR0hUX0VW RU5UX0FUVFIoY3ljbGVzLA0KPiBDT1JFU0lHSFRfUE1VX0VWVF9DWUNMRVNfREVGQVVMVCksDQo+ ID4gKyAgICAgTlVMTCwNCj4gPiArfTsNCj4gPiArDQo+ID4gK3N0cnVjdCBhdHRyaWJ1dGUgKioN Cj4gPiArY29yZXNpZ2h0X3BtdV9nZXRfZXZlbnRfYXR0cnMoY29uc3Qgc3RydWN0IGNvcmVzaWdo dF9wbXUNCj4gKmNvcmVzaWdodF9wbXUpDQo+ID4gK3sNCj4gPiArICAgICByZXR1cm4gKHN1cHBv cnRfY2MoY29yZXNpZ2h0X3BtdSkpID8gY29yZXNpZ2h0X3BtdV9ldmVudF9hdHRyc19jYyA6DQo+ ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvcmVzaWdodF9w bXVfZXZlbnRfYXR0cnM7DQo+ID4gK30NCj4gPiArRVhQT1JUX1NZTUJPTF9HUEwoY29yZXNpZ2h0 X3BtdV9nZXRfZXZlbnRfYXR0cnMpOw0KPiANCj4gSWYgY3ljbGUgY291bnQgaXMgYSBzdGFuZGFy ZCBidXQgb3B0aW9uYWwgZXZlbnQsIGp1c3QgaW5jbHVkZSBpdCBpbiB0aGUNCj4gc3RuZGFyZCBl dmVudCBhdHRycyBhbmQgdXNlIC5pc192aXNpYmxlIHRvIGZpbHRlciBpdCBvdXIgd2hlbiBub3QN Cj4gcHJlc2VudC4gTm8gbmVlZCBmb3IgdGhpcyBvdmVyY29tcGxpY2F0ZWQgbWFjaGluZXJ5Lg0K PiANCg0KU3VyZSwgdGhhbmtzIGZvciBwb2ludGluZyB0aGF0IG91dC4NCg0KPiA+ICsNCj4gPiAr c3NpemVfdCBjb3Jlc2lnaHRfcG11X3N5c2ZzX2Zvcm1hdF9zaG93KHN0cnVjdCBkZXZpY2UgKmRl diwNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBkZXZp Y2VfYXR0cmlidXRlICphdHRyLA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgY2hhciAqYnVmKQ0KPiA+ICt7DQo+ID4gKyAgICAgc3RydWN0IGRldl9leHRfYXR0cmli dXRlICplYXR0ciA9DQo+ID4gKyAgICAgICAgICAgICBjb250YWluZXJfb2YoYXR0ciwgc3RydWN0 IGRldl9leHRfYXR0cmlidXRlLCBhdHRyKTsNCj4gPiArICAgICByZXR1cm4gc3lzZnNfZW1pdChi dWYsICIlc1xuIiwgKGNoYXIgKillYXR0ci0+dmFyKTsNCj4gPiArfQ0KPiA+ICtFWFBPUlRfU1lN Qk9MX0dQTChjb3Jlc2lnaHRfcG11X3N5c2ZzX2Zvcm1hdF9zaG93KTsNCj4gPiArDQo+ID4gK3N0 YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpjb3Jlc2lnaHRfcG11X2Zvcm1hdF9hdHRyc1tdID0gew0K PiA+ICsgICAgIENPUkVTSUdIVF9GT1JNQVRfQVRUUihldmVudCwgImNvbmZpZzowLTMxIiksDQo+ ID4gKyAgICAgQ09SRVNJR0hUX0ZPUk1BVF9BVFRSKGZpbHRlciwgImNvbmZpZzozMi02MyIpLA0K PiA+ICsgICAgIE5VTEwsDQo+ID4gK307DQo+ID4gKw0KPiA+ICtzdHJ1Y3QgYXR0cmlidXRlICoq DQo+ID4gK2NvcmVzaWdodF9wbXVfZ2V0X2Zvcm1hdF9hdHRycyhjb25zdCBzdHJ1Y3QgY29yZXNp Z2h0X3BtdQ0KPiAqY29yZXNpZ2h0X3BtdSkNCj4gPiArew0KPiA+ICsgICAgIHJldHVybiBjb3Jl c2lnaHRfcG11X2Zvcm1hdF9hdHRyczsNCj4gPiArfQ0KPiA+ICtFWFBPUlRfU1lNQk9MX0dQTChj b3Jlc2lnaHRfcG11X2dldF9mb3JtYXRfYXR0cnMpOw0KPiA+ICsNCj4gPiArdTMyIGNvcmVzaWdo dF9wbXVfZXZlbnRfdHlwZShjb25zdCBzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpDQo+ID4gK3sN Cj4gPiArICAgICByZXR1cm4gZXZlbnQtPmF0dHIuY29uZmlnICYgQ09SRVNJR0hUX0VWRU5UX01B U0s7DQo+ID4gK30NCj4gPiArRVhQT1JUX1NZTUJPTF9HUEwoY29yZXNpZ2h0X3BtdV9ldmVudF90 eXBlKTsNCj4gPiArDQo+ID4gK3UzMiBjb3Jlc2lnaHRfcG11X2V2ZW50X2ZpbHRlcihjb25zdCBz dHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpDQo+ID4gK3sNCj4gPiArICAgICByZXR1cm4gKGV2ZW50 LT5hdHRyLmNvbmZpZyA+PiBDT1JFU0lHSFRfRklMVEVSX1NISUZUKSAmDQo+ID4gKyAgICAgICAg ICAgIENPUkVTSUdIVF9GSUxURVJfTUFTSzsNCj4gPiArfQ0KPiA+ICtFWFBPUlRfU1lNQk9MX0dQ TChjb3Jlc2lnaHRfcG11X2V2ZW50X2ZpbHRlcik7DQo+ID4gKw0KPiA+ICtzdGF0aWMgc3NpemVf dCBjb3Jlc2lnaHRfcG11X2lkZW50aWZpZXJfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsDQo+ID4g KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBkZXZpY2Vf YXR0cmlidXRlICphdHRyLA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBjaGFyICpwYWdlKQ0KPiA+ICt7DQo+ID4gKyAgICAgc3RydWN0IGNvcmVzaWdodF9w bXUgKmNvcmVzaWdodF9wbXUgPQ0KPiA+ICsgICAgICAgICAgICAgdG9fY29yZXNpZ2h0X3BtdShk ZXZfZ2V0X2RydmRhdGEoZGV2KSk7DQo+ID4gKw0KPiA+ICsgICAgIHJldHVybiBzeXNmc19lbWl0 KHBhZ2UsICIlc1xuIiwgY29yZXNpZ2h0X3BtdS0+aWRlbnRpZmllcik7DQo+ID4gK30NCj4gPiAr DQo+ID4gK3N0YXRpYyBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSBjb3Jlc2lnaHRfcG11X2lkZW50 aWZpZXJfYXR0ciA9DQo+ID4gKyAgICAgX19BVFRSKGlkZW50aWZpZXIsIDA0NDQsIGNvcmVzaWdo dF9wbXVfaWRlbnRpZmllcl9zaG93LCBOVUxMKTsNCj4gPiArDQo+ID4gK3N0YXRpYyBzdHJ1Y3Qg YXR0cmlidXRlICpjb3Jlc2lnaHRfcG11X2lkZW50aWZpZXJfYXR0cnNbXSA9IHsNCj4gPiArICAg ICAmY29yZXNpZ2h0X3BtdV9pZGVudGlmaWVyX2F0dHIuYXR0ciwNCj4gPiArICAgICBOVUxMLA0K PiA+ICt9Ow0KPiA+ICsNCj4gPiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgY29yZXNp Z2h0X3BtdV9pZGVudGlmaWVyX2F0dHJfZ3JvdXAgPSB7DQo+ID4gKyAgICAgLmF0dHJzID0gY29y ZXNpZ2h0X3BtdV9pZGVudGlmaWVyX2F0dHJzLA0KPiA+ICt9Ow0KPiA+ICsNCj4gPiArY29uc3Qg Y2hhciAqDQo+ID4gK2NvcmVzaWdodF9wbXVfZ2V0X2lkZW50aWZpZXIoY29uc3Qgc3RydWN0IGNv cmVzaWdodF9wbXUNCj4gKmNvcmVzaWdodF9wbXUpDQo+ID4gK3sNCj4gPiArICAgICBjb25zdCBj aGFyICppZGVudGlmaWVyID0NCj4gPiArICAgICAgICAgICAgIGRldm1fa2FzcHJpbnRmKGNvcmVz aWdodF9wbXUtPmRldiwgR0ZQX0tFUk5FTCwgIiV4IiwNCj4gPiArICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGNvcmVzaWdodF9wbXUtPmltcGwucG1paWRyKTsNCj4gPiArICAgICByZXR1cm4g aWRlbnRpZmllcjsNCj4gPiArfQ0KPiA+ICtFWFBPUlRfU1lNQk9MX0dQTChjb3Jlc2lnaHRfcG11 X2dldF9pZGVudGlmaWVyKTsNCj4gPiArDQo+ID4gK3N0YXRpYyBzc2l6ZV90IGNvcmVzaWdodF9w bXVfY3B1bWFza19zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwNCj4gPiArICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsDQo+ ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNoYXIgKmJ1ZikNCj4g PiArew0KPiA+ICsgICAgIHN0cnVjdCBwbXUgKnBtdSA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOw0K PiA+ICsgICAgIHN0cnVjdCBjb3Jlc2lnaHRfcG11ICpjb3Jlc2lnaHRfcG11ID0gdG9fY29yZXNp Z2h0X3BtdShwbXUpOw0KPiA+ICsgICAgIHN0cnVjdCBkZXZfZXh0X2F0dHJpYnV0ZSAqZWF0dHIg PQ0KPiA+ICsgICAgICAgICAgICAgY29udGFpbmVyX29mKGF0dHIsIHN0cnVjdCBkZXZfZXh0X2F0 dHJpYnV0ZSwgYXR0cik7DQo+ID4gKyAgICAgdW5zaWduZWQgbG9uZyBtYXNrX2lkID0gKHVuc2ln bmVkIGxvbmcpZWF0dHItPnZhcjsNCj4gPiArICAgICBjb25zdCBjcHVtYXNrX3QgKmNwdW1hc2s7 DQo+ID4gKw0KPiA+ICsgICAgIHN3aXRjaCAobWFza19pZCkgew0KPiA+ICsgICAgIGNhc2UgQ09S RVNJR0hUX0FDVElWRV9DUFVfTUFTSzoNCj4gPiArICAgICAgICAgICAgIGNwdW1hc2sgPSAmY29y ZXNpZ2h0X3BtdS0+YWN0aXZlX2NwdTsNCj4gPiArICAgICAgICAgICAgIGJyZWFrOw0KPiA+ICsg ICAgIGNhc2UgQ09SRVNJR0hUX0FTU09DSUFURURfQ1BVX01BU0s6DQo+ID4gKyAgICAgICAgICAg ICBjcHVtYXNrID0gJmNvcmVzaWdodF9wbXUtPmFzc29jaWF0ZWRfY3B1czsNCj4gPiArICAgICAg ICAgICAgIGJyZWFrOw0KPiA+ICsgICAgIGRlZmF1bHQ6DQo+ID4gKyAgICAgICAgICAgICByZXR1 cm4gMDsNCj4gPiArICAgICB9DQo+ID4gKyAgICAgcmV0dXJuIGNwdW1hcF9wcmludF90b19wYWdl YnVmKHRydWUsIGJ1ZiwgY3B1bWFzayk7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyBzdHJ1 Y3QgYXR0cmlidXRlICpjb3Jlc2lnaHRfcG11X2NwdW1hc2tfYXR0cnNbXSA9IHsNCj4gPiArICAg ICBDT1JFU0lHSFRfQ1BVTUFTS19BVFRSKGNwdW1hc2ssDQo+IENPUkVTSUdIVF9BQ1RJVkVfQ1BV X01BU0spLA0KPiA+ICsgICAgIENPUkVTSUdIVF9DUFVNQVNLX0FUVFIoYXNzb2NpYXRlZF9jcHVz LA0KPiBDT1JFU0lHSFRfQVNTT0NJQVRFRF9DUFVfTUFTSyksDQo+ID4gKyAgICAgTlVMTCwNCj4g PiArfTsNCj4gPiArDQo+ID4gK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwIGNvcmVzaWdo dF9wbXVfY3B1bWFza19hdHRyX2dyb3VwID0gew0KPiA+ICsgICAgIC5hdHRycyA9IGNvcmVzaWdo dF9wbXVfY3B1bWFza19hdHRycywNCj4gPiArfTsNCj4gPiArDQo+ID4gK3N0YXRpYyBjb25zdCBz dHJ1Y3QgY29yZXNpZ2h0X3BtdV9pbXBsX29wcyBkZWZhdWx0X2ltcGxfb3BzID0gew0KPiA+ICsg ICAgIC5nZXRfZXZlbnRfYXR0cnMgICAgICAgID0gY29yZXNpZ2h0X3BtdV9nZXRfZXZlbnRfYXR0 cnMsDQo+ID4gKyAgICAgLmdldF9mb3JtYXRfYXR0cnMgICAgICAgPSBjb3Jlc2lnaHRfcG11X2dl dF9mb3JtYXRfYXR0cnMsDQo+ID4gKyAgICAgLmdldF9pZGVudGlmaWVyICAgICAgICAgPSBjb3Jl c2lnaHRfcG11X2dldF9pZGVudGlmaWVyLA0KPiA+ICsgICAgIC5pc19jY19ldmVudCAgICAgICAg ICAgID0gY29yZXNpZ2h0X3BtdV9pc19jY19ldmVudCwNCj4gPiArICAgICAuZXZlbnRfdHlwZSAg ICAgICAgICAgICA9IGNvcmVzaWdodF9wbXVfZXZlbnRfdHlwZSwNCj4gPiArICAgICAuZXZlbnRf ZmlsdGVyICAgICAgICAgICA9IGNvcmVzaWdodF9wbXVfZXZlbnRfZmlsdGVyDQo+ID4gK307DQo+ ID4gKw0KPiA+ICtzdHJ1Y3QgaW1wbF9tYXRjaCB7DQo+ID4gKyAgICAgdTMyIGplZGVjX2plcDEw Nl9pZDsNCj4gPiArICAgICBpbnQgKCppbXBsX2luaXRfb3BzKShzdHJ1Y3QgY29yZXNpZ2h0X3Bt dSAqY29yZXNpZ2h0X3BtdSk7DQo+ID4gK307DQo+ID4gKw0KPiA+ICtzdGF0aWMgY29uc3Qgc3Ry dWN0IGltcGxfbWF0Y2ggaW1wbF9tYXRjaFtdID0gew0KPiA+ICsgICAgIHt9DQo+ID4gK307DQo+ ID4gKw0KPiA+ICtzdGF0aWMgaW50IGNvcmVzaWdodF9wbXVfaW5pdF9pbXBsX29wcyhzdHJ1Y3Qg Y29yZXNpZ2h0X3BtdQ0KPiAqY29yZXNpZ2h0X3BtdSkNCj4gPiArew0KPiA+ICsgICAgIGludCBp ZHgsIHJldDsNCj4gPiArICAgICB1MzIgamVkZWNfaWQ7DQo+ID4gKyAgICAgc3RydWN0IGFjcGlf YXBtdF9ub2RlICphcG10X25vZGUgPSBjb3Jlc2lnaHRfcG11LT5hcG10X25vZGU7DQo+ID4gKyAg ICAgY29uc3Qgc3RydWN0IGltcGxfbWF0Y2ggKm1hdGNoID0gaW1wbF9tYXRjaDsNCj4gPiArDQo+ ID4gKyAgICAgLyoNCj4gPiArICAgICAgKiBHZXQgUE1VIGltcGxlbWVudGVyIGFuZCBwcm9kdWN0 IGlkIGZyb20gQVBNVCBub2RlLg0KPiA+ICsgICAgICAqIElmIEFQTVQgbm9kZSBkb2Vzbid0IGhh dmUgaW1wbGVtZW50ZXIvcHJvZHVjdCBpZCwgdHJ5IGdldCBpdA0KPiA+ICsgICAgICAqIGZyb20g UE1JSURSLg0KPiA+ICsgICAgICAqLw0KPiA+ICsgICAgIGNvcmVzaWdodF9wbXUtPmltcGwucG1p aWRyID0NCj4gPiArICAgICAgICAgICAgIChhcG10X25vZGUtPmltcGxfaWQpID8gYXBtdF9ub2Rl LT5pbXBsX2lkIDoNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVh ZF9yZWczMihjb3Jlc2lnaHRfcG11LT5iYXNlMCwgUE1JSURSKTsNCj4gDQo+IFRoZSBzcGVjIHNh eXMgdGhlIG9wcG9zaXRlLCB0aGF0IHRoZSBBUE1UIGZpZWxkIHNob3VsZCBiZSBpZ25vcmVkIGlm DQo+IFBNSUlEUiBvciBQTVBJRFIgaXMgcHJlc2VudC4NCj4gDQoNClRoaXMgaXMgdG8gY292ZXIg Y2FzZSB3aGVyZSBwbWlpZHIgdmFsdWUgaXMgaW5jb3JyZWN0IGR1ZSB0byBtaXN0YWtlIGluIEhX Lg0KSG9wZWZ1bGx5LCB3ZSBjYW4gZ2V0IGFuIHVwZGF0ZSB0byB0aGUgc3BlYyBzb29uLg0KDQo+ ID4gKyAgICAgamVkZWNfaWQgPSBjb3Jlc2lnaHRfcG11LT5pbXBsLnBtaWlkciAmDQo+IFBNSUlE Ul9JTVBMRU1FTlRFUl9NQVNLOw0KPiA+ICsNCj4gPiArICAgICAvKiBGaW5kIGltcGxlbWVudGVy IHNwZWNpZmljIGF0dHJpYnV0ZSBvcHMuICovDQo+ID4gKyAgICAgZm9yIChpZHggPSAwOyBtYXRj aC0+amVkZWNfamVwMTA2X2lkOyBtYXRjaCsrLCBpZHgrKykgew0KPiA+ICsgICAgICAgICAgICAg aWYgKG1hdGNoLT5qZWRlY19qZXAxMDZfaWQgPT0gamVkZWNfaWQpIHsNCj4gDQo+IEkgcmVja29u IHdlIGNvdWxkIHNpbXBseSBoYXZlICh2YWx1ZSxtYXNrKSBwYWlycyBpbiBpbXBsX21hdGNoIHRv DQo+IGRpcmVjdGx5IG1hdGNoIHRoZSB3aG9sZSBJSURSIHZhbHVlIHRvIHNvbWUgaW1wbGVtZW50 YXRpb24gb3BzLCBhbmQgc2F2ZQ0KPiBzb21lIGJvdGhlciBoZXJlLiBJdCBjb3VsZCBhbHdheXMg YmUgcmVmYWN0b3JlZCBpZiBhbmQgd2hlbiBhIHN1ZmZpY2llbnQNCj4gbnVtYmVyIG9mIGRpZmZl cmVudCBpbXBsZW1lbnRhdGlvbnMgZXhpc3QgdG8gbWFrZSB0aGF0IGFwcHJvYWNoIHVud2llbGR5 Lg0KDQpTdXJlLCB0aGF0J3MgcmVhc29uYWJsZS4NCg0KPiANCj4gPiArICAgICAgICAgICAgICAg ICAgICAgcmV0ID0gbWF0Y2gtPmltcGxfaW5pdF9vcHMoY29yZXNpZ2h0X3BtdSk7DQo+ID4gKyAg ICAgICAgICAgICAgICAgICAgIGlmIChyZXQpDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIHJldDsNCj4gPiArDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgIHJldHVy biAwOw0KPiA+ICsgICAgICAgICAgICAgfQ0KPiA+ICsgICAgIH0NCj4gPiArDQo+ID4gKyAgICAg LyogV2UgZG9uJ3QgZmluZCBpbXBsZW1lbnRlciBzcGVjaWZpYyBhdHRyaWJ1dGUgb3BzLCB1c2Ug ZGVmYXVsdC4gKi8NCj4gPiArICAgICBjb3Jlc2lnaHRfcG11LT5pbXBsLm9wcyA9ICZkZWZhdWx0 X2ltcGxfb3BzOw0KPiA+ICsgICAgIHJldHVybiAwOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0 aWMgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCAqDQo+ID4gK2NvcmVzaWdodF9wbXVfYWxsb2NfZXZl bnRfYXR0cl9ncm91cChzdHJ1Y3QgY29yZXNpZ2h0X3BtdQ0KPiAqY29yZXNpZ2h0X3BtdSkNCj4g PiArew0KPiA+ICsgICAgIHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgKmV2ZW50X2dyb3VwOw0KPiA+ ICsgICAgIHN0cnVjdCBkZXZpY2UgKmRldiA9IGNvcmVzaWdodF9wbXUtPmRldjsNCj4gPiArDQo+ ID4gKyAgICAgZXZlbnRfZ3JvdXAgPQ0KPiA+ICsgICAgICAgICAgICAgZGV2bV9remFsbG9jKGRl diwgc2l6ZW9mKHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXApLCBHRlBfS0VSTkVMKTsNCj4gPiArICAg ICBpZiAoIWV2ZW50X2dyb3VwKQ0KPiA+ICsgICAgICAgICAgICAgcmV0dXJuIE5VTEw7DQo+ID4g Kw0KPiA+ICsgICAgIGV2ZW50X2dyb3VwLT5uYW1lID0gImV2ZW50cyI7DQo+ID4gKyAgICAgZXZl bnRfZ3JvdXAtPmF0dHJzID0NCj4gPiArICAgICAgICAgICAgIGNvcmVzaWdodF9wbXUtPmltcGwu b3BzLT5nZXRfZXZlbnRfYXR0cnMoY29yZXNpZ2h0X3BtdSk7DQo+ID4gKw0KPiA+ICsgICAgIHJl dHVybiBldmVudF9ncm91cDsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIHN0cnVjdCBhdHRy aWJ1dGVfZ3JvdXAgKg0KPiA+ICtjb3Jlc2lnaHRfcG11X2FsbG9jX2Zvcm1hdF9hdHRyX2dyb3Vw KHN0cnVjdCBjb3Jlc2lnaHRfcG11DQo+ICpjb3Jlc2lnaHRfcG11KQ0KPiA+ICt7DQo+ID4gKyAg ICAgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCAqZm9ybWF0X2dyb3VwOw0KPiA+ICsgICAgIHN0cnVj dCBkZXZpY2UgKmRldiA9IGNvcmVzaWdodF9wbXUtPmRldjsNCj4gPiArDQo+ID4gKyAgICAgZm9y bWF0X2dyb3VwID0NCj4gPiArICAgICAgICAgICAgIGRldm1fa3phbGxvYyhkZXYsIHNpemVvZihz dHJ1Y3QgYXR0cmlidXRlX2dyb3VwKSwgR0ZQX0tFUk5FTCk7DQo+ID4gKyAgICAgaWYgKCFmb3Jt YXRfZ3JvdXApDQo+ID4gKyAgICAgICAgICAgICByZXR1cm4gTlVMTDsNCj4gPiArDQo+ID4gKyAg ICAgZm9ybWF0X2dyb3VwLT5uYW1lID0gImZvcm1hdCI7DQo+ID4gKyAgICAgZm9ybWF0X2dyb3Vw LT5hdHRycyA9DQo+ID4gKyAgICAgICAgICAgICBjb3Jlc2lnaHRfcG11LT5pbXBsLm9wcy0+Z2V0 X2Zvcm1hdF9hdHRycyhjb3Jlc2lnaHRfcG11KTsNCj4gPiArDQo+ID4gKyAgICAgcmV0dXJuIGZv cm1hdF9ncm91cDsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGVf Z3JvdXAgKioNCj4gPiArY29yZXNpZ2h0X3BtdV9hbGxvY19hdHRyX2dyb3VwKHN0cnVjdCBjb3Jl c2lnaHRfcG11ICpjb3Jlc2lnaHRfcG11KQ0KPiA+ICt7DQo+ID4gKyAgICAgY29uc3Qgc3RydWN0 IGNvcmVzaWdodF9wbXVfaW1wbF9vcHMgKmltcGxfb3BzOw0KPiA+ICsgICAgIHN0cnVjdCBhdHRy aWJ1dGVfZ3JvdXAgKiphdHRyX2dyb3VwcyA9IE5VTEw7DQo+ID4gKyAgICAgc3RydWN0IGRldmlj ZSAqZGV2ID0gY29yZXNpZ2h0X3BtdS0+ZGV2Ow0KPiA+ICsgICAgIGludCByZXQ7DQo+ID4gKw0K PiA+ICsgICAgIHJldCA9IGNvcmVzaWdodF9wbXVfaW5pdF9pbXBsX29wcyhjb3Jlc2lnaHRfcG11 KTsNCj4gPiArICAgICBpZiAocmV0KQ0KPiA+ICsgICAgICAgICAgICAgcmV0dXJuIE5VTEw7DQo+ ID4gKw0KPiA+ICsgICAgIGltcGxfb3BzID0gY29yZXNpZ2h0X3BtdS0+aW1wbC5vcHM7DQo+ID4g Kw0KPiA+ICsgICAgIGNvcmVzaWdodF9wbXUtPmlkZW50aWZpZXIgPSBpbXBsX29wcy0+Z2V0X2lk ZW50aWZpZXIoY29yZXNpZ2h0X3BtdSk7DQo+ID4gKw0KPiA+ICsgICAgIGF0dHJfZ3JvdXBzID0g ZGV2bV9remFsbG9jKGRldiwgNSAqIHNpemVvZihzdHJ1Y3QgYXR0cmlidXRlX2dyb3VwICopLA0K PiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdGUF9LRVJORUwpOw0KPiA+ICsg ICAgIGlmICghYXR0cl9ncm91cHMpDQo+ID4gKyAgICAgICAgICAgICByZXR1cm4gTlVMTDsNCj4g PiArDQo+ID4gKyAgICAgYXR0cl9ncm91cHNbMF0gPQ0KPiBjb3Jlc2lnaHRfcG11X2FsbG9jX2V2 ZW50X2F0dHJfZ3JvdXAoY29yZXNpZ2h0X3BtdSk7DQo+ID4gKyAgICAgYXR0cl9ncm91cHNbMV0g PQ0KPiBjb3Jlc2lnaHRfcG11X2FsbG9jX2Zvcm1hdF9hdHRyX2dyb3VwKGNvcmVzaWdodF9wbXUp Ow0KPiA+ICsgICAgIGF0dHJfZ3JvdXBzWzJdID0gJmNvcmVzaWdodF9wbXVfaWRlbnRpZmllcl9h dHRyX2dyb3VwOw0KPiA+ICsgICAgIGF0dHJfZ3JvdXBzWzNdID0gJmNvcmVzaWdodF9wbXVfY3B1 bWFza19hdHRyX2dyb3VwOw0KPiA+ICsNCj4gPiArICAgICByZXR1cm4gYXR0cl9ncm91cHM7DQo+ ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyBpbmxpbmUgdm9pZA0KPiA+ICtjb3Jlc2lnaHRfcG11 X3N0YXJ0X2NvdW50ZXJzKHN0cnVjdCBjb3Jlc2lnaHRfcG11ICpjb3Jlc2lnaHRfcG11KQ0KPiA+ ICt7DQo+ID4gKyAgICAgdTMyIHBtY3I7DQo+ID4gKw0KPiA+ICsgICAgIHBtY3IgPSByZWFkX3Jl ZzMyKGNvcmVzaWdodF9wbXUtPmJhc2UwLCBQTUNSKTsNCj4gPiArICAgICBwbWNyIHw9IFBNQ1Jf RTsNCj4gPiArICAgICB3cml0ZV9yZWczMihwbWNyLCBjb3Jlc2lnaHRfcG11LT5iYXNlMCwgUE1D Uik7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyBpbmxpbmUgdm9pZA0KPiA+ICtjb3Jlc2ln aHRfcG11X3N0b3BfY291bnRlcnMoc3RydWN0IGNvcmVzaWdodF9wbXUgKmNvcmVzaWdodF9wbXUp DQo+ID4gK3sNCj4gPiArICAgICB1MzIgcG1jcjsNCj4gPiArDQo+ID4gKyAgICAgcG1jciA9IHJl YWRfcmVnMzIoY29yZXNpZ2h0X3BtdS0+YmFzZTAsIFBNQ1IpOw0KPiA+ICsgICAgIHBtY3IgJj0g flBNQ1JfRTsNCj4gPiArICAgICB3cml0ZV9yZWczMihwbWNyLCBjb3Jlc2lnaHRfcG11LT5iYXNl MCwgUE1DUik7ID4gK30NCj4gDQo+IEknbSBpbmNsaW5lZCB0byB0aGluayB0aGVzZSBzaG91bGRu J3QgYmUgcmVhZC1tb2RpZnktd3JpdGUNCj4gaW1wbGVtZW50YXRpb25zLiBBcmd1YWJseSB0aGUg ZHJpdmVyIHNob3VsZCByZXNldCB0aGUgY29udHJvbCByZWdpc3Rlcg0KPiB0byBhIGtub3duIHN0 YXRlIGluaXRpYWxseSwgc28gZnJvbSB0aGVuIG9uIGl0IGNhbiBzaW1wbHkgd3JpdGUgbmV3DQo+ IHZhbHVlcyBiYXNlZCBvaW4gd2hhdCBpdCBrbm93cyBpdCdzIGNoYW5naW5nLg0KPiANCj4gQUZB SUNTIGZyb20gdGhlIHNwZWMgb25seSB0aGUgUE1DUi5FIGJpdCBoYXMgYSBkZWZpbmVkIHJlc2V0 IHZhbHVlLCBzbw0KPiBwcmVzZXJ2aW5nIHJhbmRvbSB2YWx1ZXMgaW4gb3RoZXIgYml0cyBsaWtl IEZaTyBhbmQgRCBpcyBzdXJlIHRvIGJlIGZ1bi4NCj4gDQoNClRoYW5rcywgd2Ugd2lsbCByZXNl dCBQTUNSIGR1cmluZyBkcml2ZXIgaW5pdC4NCg0KPiA+ICsNCj4gPiArc3RhdGljIHZvaWQgY29y ZXNpZ2h0X3BtdV9lbmFibGUoc3RydWN0IHBtdSAqcG11KQ0KPiA+ICt7DQo+ID4gKyAgICAgaW50 IGVuYWJsZWQ7DQo+ID4gKyAgICAgc3RydWN0IGNvcmVzaWdodF9wbXUgKmNvcmVzaWdodF9wbXUg PSB0b19jb3Jlc2lnaHRfcG11KHBtdSk7DQo+ID4gKw0KPiA+ICsgICAgIGVuYWJsZWQgPSBiaXRt YXBfd2VpZ2h0KGNvcmVzaWdodF9wbXUtPmh3X2V2ZW50cy51c2VkX2N0cnMsDQo+ID4gKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgQ09SRVNJR0hUX1BNVV9NQVhfSFdfQ05UUlMpOw0KPiA+ ICsNCj4gPiArICAgICBpZiAoIWVuYWJsZWQpDQo+ID4gKyAgICAgICAgICAgICByZXR1cm47DQo+ IA0KPiBVc2UgYml0bWFwX2VtcHR5KCkgZm9yIGNoZWNraW5nIGlmIGEgYml0bWFwIGlzIGVtcHR5 Lg0KDQpTdXJlLCB3ZSBjYW4gdXNlIHRoaXMuDQoNCj4gDQo+ID4gKw0KPiA+ICsgICAgIGNvcmVz aWdodF9wbXVfc3RhcnRfY291bnRlcnMoY29yZXNpZ2h0X3BtdSk7DQo+ID4gK30NCj4gPiArDQo+ ID4gK3N0YXRpYyB2b2lkIGNvcmVzaWdodF9wbXVfZGlzYWJsZShzdHJ1Y3QgcG11ICpwbXUpDQo+ ID4gK3sNCj4gPiArICAgICBzdHJ1Y3QgY29yZXNpZ2h0X3BtdSAqY29yZXNpZ2h0X3BtdSA9IHRv X2NvcmVzaWdodF9wbXUocG11KTsNCj4gPiArDQo+ID4gKyAgICAgY29yZXNpZ2h0X3BtdV9zdG9w X2NvdW50ZXJzKGNvcmVzaWdodF9wbXUpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgaW5s aW5lIGJvb2wgaXNfY3ljbGVfY250cl9pZHgoY29uc3Qgc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50 KQ0KPiA+ICt7DQo+ID4gKyAgICAgc3RydWN0IGNvcmVzaWdodF9wbXUgKmNvcmVzaWdodF9wbXUg PSB0b19jb3Jlc2lnaHRfcG11KGV2ZW50LQ0KPiA+cG11KTsNCj4gPiArICAgICBpbnQgaWR4ID0g ZXZlbnQtPmh3LmlkeDsNCj4gPiArDQo+ID4gKyAgICAgcmV0dXJuIChzdXBwb3J0X2NjKGNvcmVz aWdodF9wbXUpICYmIGlkeCA9PQ0KPiBDT1JFU0lHSFRfUE1VX0lEWF9DQ05UUik7DQo+IA0KPiBJ ZiB3ZSBkb24ndCBzdXBwb3J0IGN5Y2xlIGNvdW50aW5nLCBjeWNsZXMgY291bnQgZXZlbnRzIHNo b3VsZCBoYXZlIGJlZW4NCj4gcmVqZWN0ZWQgaW4gZXZlbnRfaW5pdC4gSWYgdGhleSdyZSBhYmxl IHRvIHByb3BhZ2F0ZSBmdXJ0aGVyIHRoYW4gdGhhdA0KPiANCg0KTm90IHN1cmUgSSB1bmRlcnN0 YW5kLCBkbyB5b3UgbWVhbiB0aGUgY2hlY2sgZm9yIGN5Y2xlIGNvdW50ZXIgc3VwcG9ydCBpcyB1 bm5lY2Vzc2FyeSA/DQpUaGlzIGZ1bmN0aW9uIGlzIGFjdHVhbGx5IGNhbGxlZCBieSBjb3Jlc2ln aHRfcG11X3N0YXJ0LCB3aGljaCBpcyBhZnRlciBldmVudF9pbml0IGhhZCBwYXNzZWQuDQpjb3Jl c2lnaHRfcG11X3N0YXJ0IGlzIG5vdCBhd2FyZSBpZiBjeWNsZSBjb3VudGVyIGlzIHN1cHBvcnRl ZCBvciBub3QsIHNvIHdlIG5lZWQgdG8ga2VlcCBjaGVja2luZyBpdC4NCg0KPiA+ICt9DQo+ID4g Kw0KPiA+ICtib29sIGNvcmVzaWdodF9wbXVfaXNfY2NfZXZlbnQoY29uc3Qgc3RydWN0IHBlcmZf ZXZlbnQgKmV2ZW50KQ0KPiA+ICt7DQo+ID4gKyAgICAgc3RydWN0IGNvcmVzaWdodF9wbXUgKmNv cmVzaWdodF9wbXUgPSB0b19jb3Jlc2lnaHRfcG11KGV2ZW50LQ0KPiA+cG11KTsNCj4gPiArICAg ICB1MzIgZXZ0eXBlID0gY29yZXNpZ2h0X3BtdS0+aW1wbC5vcHMtPmV2ZW50X3R5cGUoZXZlbnQp Ow0KPiA+ICsNCj4gPiArICAgICByZXR1cm4gKHN1cHBvcnRfY2MoY29yZXNpZ2h0X3BtdSkgJiYN Cj4gDQo+IERpdHRvLg0KDQpUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCBieSBldmVudF9pbml0IHRv IHZhbGlkYXRlIHRoZSBldmVudCBhbmQgZmluZCBhdmFpbGFibGUgY291bnRlcnMuDQoNCj4gDQo+ ID4gKyAgICAgICAgICAgICBldnR5cGUgPT0gQ09SRVNJR0hUX1BNVV9FVlRfQ1lDTEVTX0RFRkFV TFQpOw0KPiA+ICt9DQo+ID4gK0VYUE9SVF9TWU1CT0xfR1BMKGNvcmVzaWdodF9wbXVfaXNfY2Nf ZXZlbnQpOw0KPiA+ICsNCj4gPiArc3RhdGljIGludA0KPiA+ICtjb3Jlc2lnaHRfcG11X2dldF9l dmVudF9pZHgoc3RydWN0IGNvcmVzaWdodF9wbXVfaHdfZXZlbnRzDQo+ICpod19ldmVudHMsDQo+ ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpDQo+ ID4gK3sNCj4gPiArICAgICBpbnQgaWR4LCByZXNlcnZlX2NjOw0KPiA+ICsgICAgIHN0cnVjdCBj b3Jlc2lnaHRfcG11ICpjb3Jlc2lnaHRfcG11ID0gdG9fY29yZXNpZ2h0X3BtdShldmVudC0NCj4g PnBtdSk7DQo+ID4gKw0KPiA+ICsgICAgIGlmIChjb3Jlc2lnaHRfcG11LT5pbXBsLm9wcy0+aXNf Y2NfZXZlbnQoZXZlbnQpKSB7DQo+ID4gKyAgICAgICAgICAgICAvKiBTZWFyY2ggZm9yIGF2YWls YWJsZSBjeWNsZSBjb3VudGVyLiAqLw0KPiA+ICsgICAgICAgICAgICAgaWYgKHRlc3RfYW5kX3Nl dF9iaXQoQ09SRVNJR0hUX1BNVV9JRFhfQ0NOVFIsDQo+ID4gKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBod19ldmVudHMtPnVzZWRfY3RycykpDQo+ID4gKyAgICAgICAgICAgICAg ICAgICAgIHJldHVybiAtRUFHQUlOOw0KPiA+ICsNCj4gPiArICAgICAgICAgICAgIHJldHVybiBD T1JFU0lHSFRfUE1VX0lEWF9DQ05UUjsNCj4gPiArICAgICB9DQo+ID4gKw0KPiA+ICsgICAgIC8q DQo+ID4gKyAgICAgICogQ29yZVNpZ2h0IFBNVSBjYW4gc3VwcG9ydCB1cCB0byAyNTYgY291bnRl cnMuIFRoZSBjeWNsZSBjb3VudGVyIGlzDQo+ID4gKyAgICAgICogYWx3YXlzIG9uIGNvdW50ZXJb MzFdLiBUbyBwcmV2ZW50IHJlZ3VsYXIgZXZlbnQgZnJvbSB1c2luZyBjeWNsZQ0KPiA+ICsgICAg ICAqIGNvdW50ZXIsIHdlIHJlc2VydmUgdGhlIGN5Y2xlIGNvdW50ZXIgYml0IHRlbXBvcmFyaWx5 Lg0KPiA+ICsgICAgICAqLw0KPiA+ICsgICAgIHJlc2VydmVfY2MgPSAwOw0KPiA+ICsgICAgIGlm IChzdXBwb3J0X2NjKGNvcmVzaWdodF9wbXUpICYmDQo+ID4gKyAgICAgICAgIGNvcmVzaWdodF9w bXUtPm51bV9hZGpfY291bnRlcnMgPj0NCj4gQ09SRVNJR0hUX1BNVV9JRFhfQ0NOVFIpDQo+ID4g KyAgICAgICAgICAgICByZXNlcnZlX2NjID0gKHRlc3RfYW5kX3NldF9iaXQoQ09SRVNJR0hUX1BN VV9JRFhfQ0NOVFIsDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgaHdfZXZlbnRzLT51c2VkX2N0cnMpID09IDApOw0KPiANCj4gSXQgd291bGQgc2VlbSBh IGxvdCBlYXNpZXIgdG8gcmVzZXJ2ZSBQTUVWQ05UUlszMV0gcGVybWFuZW50bHkgYW5kIHRyYWNr DQo+IGFsbG9jYXRpb24gb2YgUE1DQ05UUiB3aXRoIGEgc2VwYXJhdGUgZmxhZywgd2hlbiBhcHBy b3ByaWF0ZS4NCg0KVGhlIHB1cnBvc2Ugd2FzIHRvIGF2b2lkIHVzaW5nIHR3byBmbGFncyB3aGVu IGtlZXBpbmcgdHJhY2sgb2YgdGhlIHVzZWQgY291bnRlcnMuDQpCdXQgeW91IGhhdmUgdmFsaWQg Y29uY2VybiBvbiBwb3RlbnRpYWwgc2lnbmlmaWNhbnQgbnVtYmVyIG9mIHVudXNlZCBiaXRzIGFu ZCBjb21waWxlcg0Kd2FybmluZyBkdWUgdG8gdGhlIGxhcmdlIHN0YWNrIHNpemUuIFdlIHdpbGwg cmV2aXNpdCB0aGlzLg0KDQo+IA0KPiA+ICsNCj4gPiArICAgICAvKiBTZWFyY2ggYXZhaWxhYmxl IHJlZ3VsYXIgY291bnRlciBmcm9tIHRoZSB1c2VkIGNvdW50ZXIgYml0bWFwLiAqLw0KPiA+ICsg ICAgIGlkeCA9IGZpbmRfZmlyc3RfemVyb19iaXQoaHdfZXZlbnRzLT51c2VkX2N0cnMsDQo+ID4g KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb3Jlc2lnaHRfcG11LT5udW1fYWRqX2Nv dW50ZXJzKTsNCj4gPiArDQo+ID4gKyAgICAgLyogUmVzdG9yZSBjeWNsZSBjb3VudGVyIGJpdC4g Ki8NCj4gPiArICAgICBpZiAocmVzZXJ2ZV9jYykNCj4gPiArICAgICAgICAgICAgIGNsZWFyX2Jp dChDT1JFU0lHSFRfUE1VX0lEWF9DQ05UUiwgaHdfZXZlbnRzLT51c2VkX2N0cnMpOw0KPiA+ICsN Cj4gPiArICAgICBpZiAoaWR4ID49IGNvcmVzaWdodF9wbXUtPm51bV9hZGpfY291bnRlcnMpDQo+ ID4gKyAgICAgICAgICAgICByZXR1cm4gLUVBR0FJTjsNCj4gPiArDQo+ID4gKyAgICAgc2V0X2Jp dChpZHgsIGh3X2V2ZW50cy0+dXNlZF9jdHJzKTsNCj4gPiArDQo+ID4gKyAgICAgcmV0dXJuIGlk eDsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIGJvb2wNCj4gPiArY29yZXNpZ2h0X3BtdV92 YWxpZGF0ZV9ldmVudChzdHJ1Y3QgcG11ICpwbXUsDQo+ID4gKyAgICAgICAgICAgICAgICAgICAg ICAgICAgc3RydWN0IGNvcmVzaWdodF9wbXVfaHdfZXZlbnRzICpod19ldmVudHMsDQo+ID4gKyAg ICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQ0KPiA+ICt7 DQo+ID4gKyAgICAgaWYgKGlzX3NvZnR3YXJlX2V2ZW50KGV2ZW50KSkNCj4gPiArICAgICAgICAg ICAgIHJldHVybiB0cnVlOw0KPiA+ICsNCj4gPiArICAgICAvKiBSZWplY3QgZ3JvdXBzIHNwYW5u aW5nIG11bHRpcGxlIEhXIFBNVXMuICovDQo+ID4gKyAgICAgaWYgKGV2ZW50LT5wbXUgIT0gcG11 KQ0KPiA+ICsgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOw0KPiA+ICsNCj4gPiArICAgICByZXR1 cm4gKGNvcmVzaWdodF9wbXVfZ2V0X2V2ZW50X2lkeChod19ldmVudHMsIGV2ZW50KSA+PSAwKTsN Cj4gPiArfQ0KPiA+ICsNCj4gPiArLyoqDQo+ID4gKyAqIE1ha2Ugc3VyZSB0aGUgZ3JvdXAgb2Yg ZXZlbnRzIGNhbiBiZSBzY2hlZHVsZWQgYXQgb25jZQ0KPiA+ICsgKiBvbiB0aGUgUE1VLg0KPiA+ ICsgKi8NCj4gPiArc3RhdGljIGJvb2wgY29yZXNpZ2h0X3BtdV92YWxpZGF0ZV9ncm91cChzdHJ1 Y3QgcGVyZl9ldmVudCAqZXZlbnQpDQo+ID4gK3sNCj4gPiArICAgICBzdHJ1Y3QgcGVyZl9ldmVu dCAqc2libGluZywgKmxlYWRlciA9IGV2ZW50LT5ncm91cF9sZWFkZXI7DQo+ID4gKyAgICAgc3Ry dWN0IGNvcmVzaWdodF9wbXVfaHdfZXZlbnRzIGZha2VfaHdfZXZlbnRzOw0KPiANCj4gRG8geW91 IG5vdCBnZXQgYSBjb21waWxlLXRpbWUgd2FybmluZyBhYm91dCB0aGlzPw0KDQpUaGFua3MgZm9y IHNwb3R0aW5nIHRoaXMuIEkgY2hlY2tlZCBteSBidWlsZCBsb2cgYW5kIEkgY2FuIHNlZSB0aGUg d2FybmluZy4NCldlIHdpbGwgdXBkYXRlIGl0Lg0KDQo+IA0KPiA+ICsgICAgIGlmIChldmVudC0+ Z3JvdXBfbGVhZGVyID09IGV2ZW50KQ0KPiA+ICsgICAgICAgICAgICAgcmV0dXJuIHRydWU7DQo+ ID4gKw0KPiA+ICsgICAgIG1lbXNldCgmZmFrZV9od19ldmVudHMsIDAsIHNpemVvZihmYWtlX2h3 X2V2ZW50cykpOw0KPiA+ICsNCj4gPiArICAgICBpZiAoIWNvcmVzaWdodF9wbXVfdmFsaWRhdGVf ZXZlbnQoZXZlbnQtPnBtdSwgJmZha2VfaHdfZXZlbnRzLA0KPiBsZWFkZXIpKQ0KPiA+ICsgICAg ICAgICAgICAgcmV0dXJuIGZhbHNlOw0KPiA+ICsNCj4gPiArICAgICBmb3JfZWFjaF9zaWJsaW5n X2V2ZW50KHNpYmxpbmcsIGxlYWRlcikgew0KPiA+ICsgICAgICAgICAgICAgaWYgKCFjb3Jlc2ln aHRfcG11X3ZhbGlkYXRlX2V2ZW50KGV2ZW50LT5wbXUsDQo+ICZmYWtlX2h3X2V2ZW50cywNCj4g PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzaWJsaW5n KSkNCj4gPiArICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOw0KPiA+ICsgICAgIH0N Cj4gPiArDQo+ID4gKyAgICAgcmV0dXJuIGNvcmVzaWdodF9wbXVfdmFsaWRhdGVfZXZlbnQoZXZl bnQtPnBtdSwNCj4gJmZha2VfaHdfZXZlbnRzLCBldmVudCk7DQo+ID4gK30NCj4gPiArDQo+ID4g K3N0YXRpYyBpbnQgY29yZXNpZ2h0X3BtdV9ldmVudF9pbml0KHN0cnVjdCBwZXJmX2V2ZW50ICpl dmVudCkNCj4gPiArew0KPiA+ICsgICAgIHN0cnVjdCBjb3Jlc2lnaHRfcG11ICpjb3Jlc2lnaHRf cG11Ow0KPiA+ICsgICAgIHN0cnVjdCBod19wZXJmX2V2ZW50ICpod2MgPSAmZXZlbnQtPmh3Ow0K PiA+ICsNCj4gPiArICAgICBjb3Jlc2lnaHRfcG11ID0gdG9fY29yZXNpZ2h0X3BtdShldmVudC0+ cG11KTsNCj4gPiArDQo+ID4gKyAgICAgLyoqDQo+IA0KPiBUaGlzIGlzbid0IGtlcm5lbGRvYy4N Cg0KU3VyZSwgd2Ugd2lsbCBtYWtlIHRoZSB1cGRhdGUuDQoNCj4gDQo+ID4gKyAgICAgICogRm9s bG93aW5nIG90aGVyICJ1bmNvcmUiIFBNVXMsIHdlIGRvIG5vdCBzdXBwb3J0IHNhbXBsaW5nIG1v ZGUNCj4gb3INCj4gPiArICAgICAgKiBhdHRhY2ggdG8gYSB0YXNrIChwZXItcHJvY2VzcyBtb2Rl KS4NCj4gPiArICAgICAgKi8NCj4gPiArICAgICBpZiAoaXNfc2FtcGxpbmdfZXZlbnQoZXZlbnQp KSB7DQo+ID4gKyAgICAgICAgICAgICBkZXZfZGJnKGNvcmVzaWdodF9wbXUtPnBtdS5kZXYsDQo+ ID4gKyAgICAgICAgICAgICAgICAgICAgICJDYW4ndCBzdXBwb3J0IHNhbXBsaW5nIGV2ZW50c1xu Iik7DQo+ID4gKyAgICAgICAgICAgICByZXR1cm4gLUVPUE5PVFNVUFA7DQo+ID4gKyAgICAgfQ0K PiA+ICsNCj4gPiArICAgICBpZiAoZXZlbnQtPmNwdSA8IDAgfHwgZXZlbnQtPmF0dGFjaF9zdGF0 ZSAmIFBFUkZfQVRUQUNIX1RBU0spIHsNCj4gPiArICAgICAgICAgICAgIGRldl9kYmcoY29yZXNp Z2h0X3BtdS0+cG11LmRldiwNCj4gPiArICAgICAgICAgICAgICAgICAgICAgIkNhbid0IHN1cHBv cnQgcGVyLXRhc2sgY291bnRlcnNcbiIpOw0KPiA+ICsgICAgICAgICAgICAgcmV0dXJuIC1FSU5W QUw7DQo+ID4gKyAgICAgfQ0KPiA+ICsNCj4gPiArICAgICAvKioNCj4gDQo+IERpdHRvLg0KPiAN Cj4gPiArICAgICAgKiBNYWtlIHN1cmUgdGhlIENQVSBhc3NpZ25tZW50IGlzIG9uIG9uZSBvZiB0 aGUgQ1BVcyBhc3NvY2lhdGVkIHdpdGgNCj4gPiArICAgICAgKiB0aGlzIFBNVS4NCj4gPiArICAg ICAgKi8NCj4gPiArICAgICBpZiAoIWNwdW1hc2tfdGVzdF9jcHUoZXZlbnQtPmNwdSwgJmNvcmVz aWdodF9wbXUtDQo+ID5hc3NvY2lhdGVkX2NwdXMpKSB7DQo+ID4gKyAgICAgICAgICAgICBkZXZf ZGJnKGNvcmVzaWdodF9wbXUtPnBtdS5kZXYsDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICJS ZXF1ZXN0ZWQgY3B1IGlzIG5vdCBhc3NvY2lhdGVkIHdpdGggdGhlIFBNVVxuIik7DQo+ID4gKyAg ICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsNCj4gPiArICAgICB9DQo+ID4gKw0KPiA+ICsgICAg IC8qIEVuZm9yY2UgdGhlIGN1cnJlbnQgYWN0aXZlIENQVSB0byBoYW5kbGUgdGhlIGV2ZW50cyBp biB0aGlzIFBNVS4gKi8NCj4gPiArICAgICBldmVudC0+Y3B1ID0gY3B1bWFza19maXJzdCgmY29y ZXNpZ2h0X3BtdS0+YWN0aXZlX2NwdSk7DQo+ID4gKyAgICAgaWYgKGV2ZW50LT5jcHUgPj0gbnJf Y3B1X2lkcykNCj4gPiArICAgICAgICAgICAgIHJldHVybiAtRUlOVkFMOw0KPiA+ICsNCj4gPiAr ICAgICBpZiAoIWNvcmVzaWdodF9wbXVfdmFsaWRhdGVfZ3JvdXAoZXZlbnQpKQ0KPiA+ICsgICAg ICAgICAgICAgcmV0dXJuIC1FSU5WQUw7DQo+ID4gKw0KPiA+ICsgICAgIC8qKg0KPiANCj4gRGl0 dG8uDQo+IA0KPiA+ICsgICAgICAqIFdlIGRvbid0IGFzc2lnbiBhbiBpbmRleCB1bnRpbCB3ZSBh Y3R1YWxseSBwbGFjZSB0aGUgZXZlbnQgb250bw0KPiA+ICsgICAgICAqIGhhcmR3YXJlLiBVc2Ug LTEgdG8gc2lnbmlmeSB0aGF0IHdlIGhhdmVuJ3QgZGVjaWRlZCB3aGVyZSB0byBwdXQgaXQNCj4g PiArICAgICAgKiB5ZXQuDQo+ID4gKyAgICAgICovDQo+ID4gKyAgICAgaHdjLT5pZHggPSAtMTsN Cj4gPiArICAgICBod2MtPmNvbmZpZ19iYXNlID0gY29yZXNpZ2h0X3BtdS0+aW1wbC5vcHMtPmV2 ZW50X3R5cGUoZXZlbnQpOw0KPiA+ICsNCj4gPiArICAgICByZXR1cm4gMDsNCj4gPiArfQ0KPiA+ ICsNCj4gPiArc3RhdGljIGlubGluZSB1MzIgY291bnRlcl9vZmZzZXQodTMyIHJlZ19zeiwgdTMy IGN0cl9pZHgpDQo+ID4gK3sNCj4gPiArICAgICByZXR1cm4gKFBNRVZDTlRSX0xPICsgKHJlZ19z eiAqIGN0cl9pZHgpKTsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIHZvaWQgY29yZXNpZ2h0 X3BtdV93cml0ZV9jb3VudGVyKHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCwgdTY0DQo+IHZhbCkN Cj4gPiArew0KPiA+ICsgICAgIHUzMiBvZmZzZXQ7DQo+ID4gKyAgICAgc3RydWN0IGNvcmVzaWdo dF9wbXUgKmNvcmVzaWdodF9wbXUgPSB0b19jb3Jlc2lnaHRfcG11KGV2ZW50LQ0KPiA+cG11KTsN Cj4gPiArDQo+ID4gKyAgICAgaWYgKHVzZV82NGJfY291bnRlcl9yZWcoY29yZXNpZ2h0X3BtdSkp IHsNCj4gPiArICAgICAgICAgICAgIG9mZnNldCA9IGNvdW50ZXJfb2Zmc2V0KHNpemVvZih1NjQp LCBldmVudC0+aHcuaWR4KTsNCj4gPiArDQo+ID4gKyAgICAgICAgICAgICBjb3Jlc2lnaHRfcG11 LT53cml0ZV9yZWc2NCh2YWwsIGNvcmVzaWdodF9wbXUtPmJhc2UxLCBvZmZzZXQpOw0KPiA+ICsg ICAgIH0gZWxzZSB7DQo+ID4gKyAgICAgICAgICAgICBvZmZzZXQgPSBjb3VudGVyX29mZnNldChz aXplb2YodTMyKSwgZXZlbnQtPmh3LmlkeCk7DQo+ID4gKw0KPiA+ICsgICAgICAgICAgICAgd3Jp dGVfcmVnMzIobG93ZXJfMzJfYml0cyh2YWwpLCBjb3Jlc2lnaHRfcG11LT5iYXNlMSwgb2Zmc2V0 KTsNCj4gPiArICAgICB9DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyB1NjQgY29yZXNpZ2h0 X3BtdV9yZWFkX2NvdW50ZXIoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQ0KPiA+ICt7DQo+ID4g KyAgICAgdTMyIG9mZnNldDsNCj4gPiArICAgICBzdHJ1Y3QgY29yZXNpZ2h0X3BtdSAqY29yZXNp Z2h0X3BtdSA9IHRvX2NvcmVzaWdodF9wbXUoZXZlbnQtDQo+ID5wbXUpOw0KPiA+ICsNCj4gPiAr ICAgICBpZiAodXNlXzY0Yl9jb3VudGVyX3JlZyhjb3Jlc2lnaHRfcG11KSkgew0KPiA+ICsgICAg ICAgICAgICAgb2Zmc2V0ID0gY291bnRlcl9vZmZzZXQoc2l6ZW9mKHU2NCksIGV2ZW50LT5ody5p ZHgpOw0KPiA+ICsgICAgICAgICAgICAgcmV0dXJuIGNvcmVzaWdodF9wbXUtPnJlYWRfcmVnNjQo Y29yZXNpZ2h0X3BtdS0+YmFzZTEsDQo+IG9mZnNldCk7DQo+ID4gKyAgICAgfQ0KPiA+ICsNCj4g PiArICAgICBvZmZzZXQgPSBjb3VudGVyX29mZnNldChzaXplb2YodTMyKSwgZXZlbnQtPmh3Lmlk eCk7DQo+ID4gKyAgICAgcmV0dXJuIHJlYWRfcmVnMzIoY29yZXNpZ2h0X3BtdS0+YmFzZTEsIG9m ZnNldCk7DQo+ID4gK30NCj4gPiArDQo+ID4gKy8qKg0KPiA+ICsgKiBjb3Jlc2lnaHRfcG11X3Nl dF9ldmVudF9wZXJpb2Q6IFNldCB0aGUgcGVyaW9kIGZvciB0aGUgY291bnRlci4NCj4gPiArICoN Cj4gPiArICogVG8gaGFuZGxlIGNhc2VzIG9mIGV4dHJlbWUgaW50ZXJydXB0IGxhdGVuY3ksIHdl IHByb2dyYW0NCj4gPiArICogdGhlIGNvdW50ZXIgd2l0aCBoYWxmIG9mIHRoZSBtYXggY291bnQg Zm9yIHRoZSBjb3VudGVycy4NCj4gPiArICovDQo+ID4gK3N0YXRpYyB2b2lkIGNvcmVzaWdodF9w bXVfc2V0X2V2ZW50X3BlcmlvZChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQpDQo+ID4gK3sNCj4g PiArICAgICBzdHJ1Y3QgY29yZXNpZ2h0X3BtdSAqY29yZXNpZ2h0X3BtdSA9IHRvX2NvcmVzaWdo dF9wbXUoZXZlbnQtDQo+ID5wbXUpOw0KPiA+ICsgICAgIHU2NCB2YWwgPSBHRU5NQVNLX1VMTChw bWNmZ3Jfc2l6ZShjb3Jlc2lnaHRfcG11KSwgMCkgPj4gMTsNCj4gPiArDQo+ID4gKyAgICAgbG9j YWw2NF9zZXQoJmV2ZW50LT5ody5wcmV2X2NvdW50LCB2YWwpOw0KPiA+ICsgICAgIGNvcmVzaWdo dF9wbXVfd3JpdGVfY291bnRlcihldmVudCwgdmFsKTsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3Rh dGljIHZvaWQgY29yZXNpZ2h0X3BtdV9lbmFibGVfY291bnRlcihzdHJ1Y3QgY29yZXNpZ2h0X3Bt dQ0KPiAqY29yZXNpZ2h0X3BtdSwNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBpbnQgaWR4KQ0KPiA+ICt7DQo+ID4gKyAgICAgdTMyIHJlZ19pZCwgcmVnX2JpdCwg aW50ZW5fb2ZmLCBjbnRlbl9vZmY7DQo+ID4gKw0KPiA+ICsgICAgIHJlZ19pZCA9IENPUkVTSUdI VF9JRFhfVE9fU0VUX0NMUl9SRUdfSUQoaWR4KTsNCj4gPiArICAgICByZWdfYml0ID0gQ09SRVNJ R0hUX0lEWF9UT19TRVRfQ0xSX1JFR19CSVQoaWR4KTsNCj4gPiArDQo+ID4gKyAgICAgaW50ZW5f b2ZmID0gUE1JTlRFTlNFVCArICg0ICogcmVnX2lkKTsNCj4gPiArICAgICBjbnRlbl9vZmYgPSBQ TUNOVEVOU0VUICsgKDQgKiByZWdfaWQpOw0KPiA+ICsNCj4gPiArICAgICB3cml0ZV9yZWczMihC SVQocmVnX2JpdCksIGNvcmVzaWdodF9wbXUtPmJhc2UwLCBpbnRlbl9vZmYpOw0KPiA+ICsgICAg IHdyaXRlX3JlZzMyKEJJVChyZWdfYml0KSwgY29yZXNpZ2h0X3BtdS0+YmFzZTAsIGNudGVuX29m Zik7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyB2b2lkIGNvcmVzaWdodF9wbXVfZGlzYWJs ZV9jb3VudGVyKHN0cnVjdCBjb3Jlc2lnaHRfcG11DQo+ICpjb3Jlc2lnaHRfcG11LA0KPiA+ICsg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnQgaWR4KQ0KPiA+ICt7DQo+ ID4gKyAgICAgdTMyIHJlZ19pZCwgcmVnX2JpdCwgaW50ZW5fb2ZmLCBjbnRlbl9vZmY7DQo+ID4g Kw0KPiA+ICsgICAgIHJlZ19pZCA9IENPUkVTSUdIVF9JRFhfVE9fU0VUX0NMUl9SRUdfSUQoaWR4 KTsNCj4gPiArICAgICByZWdfYml0ID0gQ09SRVNJR0hUX0lEWF9UT19TRVRfQ0xSX1JFR19CSVQo aWR4KTsNCj4gPiArDQo+ID4gKyAgICAgaW50ZW5fb2ZmID0gUE1JTlRFTkNMUiArICg0ICogcmVn X2lkKTsNCj4gPiArICAgICBjbnRlbl9vZmYgPSBQTUNOVEVOQ0xSICsgKDQgKiByZWdfaWQpOw0K PiA+ICsNCj4gPiArICAgICB3cml0ZV9yZWczMihCSVQocmVnX2JpdCksIGNvcmVzaWdodF9wbXUt PmJhc2UwLCBjbnRlbl9vZmYpOw0KPiA+ICsgICAgIHdyaXRlX3JlZzMyKEJJVChyZWdfYml0KSwg Y29yZXNpZ2h0X3BtdS0+YmFzZTAsIGludGVuX29mZik7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0 YXRpYyB2b2lkIGNvcmVzaWdodF9wbXVfZXZlbnRfdXBkYXRlKHN0cnVjdCBwZXJmX2V2ZW50ICpl dmVudCkNCj4gPiArew0KPiA+ICsgICAgIHN0cnVjdCBjb3Jlc2lnaHRfcG11ICpjb3Jlc2lnaHRf cG11ID0gdG9fY29yZXNpZ2h0X3BtdShldmVudC0NCj4gPnBtdSk7DQo+ID4gKyAgICAgc3RydWN0 IGh3X3BlcmZfZXZlbnQgKmh3YyA9ICZldmVudC0+aHc7DQo+ID4gKyAgICAgdTY0IGRlbHRhLCBw cmV2LCBub3c7DQo+ID4gKw0KPiA+ICsgICAgIGRvIHsNCj4gPiArICAgICAgICAgICAgIHByZXYg PSBsb2NhbDY0X3JlYWQoJmh3Yy0+cHJldl9jb3VudCk7DQo+ID4gKyAgICAgICAgICAgICBub3cg PSBjb3Jlc2lnaHRfcG11X3JlYWRfY291bnRlcihldmVudCk7DQo+ID4gKyAgICAgfSB3aGlsZSAo bG9jYWw2NF9jbXB4Y2hnKCZod2MtPnByZXZfY291bnQsIHByZXYsIG5vdykgIT0gcHJldik7DQo+ ID4gKw0KPiA+ICsgICAgIGRlbHRhID0gKG5vdyAtIHByZXYpICYgR0VOTUFTS19VTEwocG1jZmdy X3NpemUoY29yZXNpZ2h0X3BtdSksIDApOw0KPiA+ICsgICAgIGxvY2FsNjRfYWRkKGRlbHRhLCAm ZXZlbnQtPmNvdW50KTsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIGlubGluZSB2b2lkIGNv cmVzaWdodF9wbXVfc2V0X2V2ZW50KHN0cnVjdCBjb3Jlc2lnaHRfcG11DQo+ICpjb3Jlc2lnaHRf cG11LA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0 IGh3X3BlcmZfZXZlbnQgKmh3YykNCj4gPiArew0KPiA+ICsgICAgIHUzMiBvZmZzZXQgPSBQTUVW VFlQRVIgKyAoNCAqIGh3Yy0+aWR4KTsNCj4gPiArDQo+ID4gKyAgICAgd3JpdGVfcmVnMzIoaHdj LT5jb25maWdfYmFzZSwgY29yZXNpZ2h0X3BtdS0+YmFzZTAsIG9mZnNldCk7DQo+ID4gK30NCj4g PiArDQo+ID4gK3N0YXRpYyBpbmxpbmUgdm9pZA0KPiA+ICtjb3Jlc2lnaHRfcG11X3NldF9ldl9m aWx0ZXIoc3RydWN0IGNvcmVzaWdodF9wbXUgKmNvcmVzaWdodF9wbXUsDQo+ID4gKyAgICAgICAg ICAgICAgICAgICAgICAgICBzdHJ1Y3QgaHdfcGVyZl9ldmVudCAqaHdjLCB1MzIgZmlsdGVyKQ0K PiA+ICt7DQo+ID4gKyAgICAgdTMyIG9mZnNldCA9IFBNRVZGSUxUUiArICg0ICogaHdjLT5pZHgp Ow0KPiA+ICsNCj4gPiArICAgICB3cml0ZV9yZWczMihmaWx0ZXIsIGNvcmVzaWdodF9wbXUtPmJh c2UwLCBvZmZzZXQpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgaW5saW5lIHZvaWQNCj4g PiArY29yZXNpZ2h0X3BtdV9zZXRfY2NfZmlsdGVyKHN0cnVjdCBjb3Jlc2lnaHRfcG11ICpjb3Jl c2lnaHRfcG11LCB1MzINCj4gZmlsdGVyKQ0KPiA+ICt7DQo+ID4gKyAgICAgdTMyIG9mZnNldCA9 IFBNQ0NGSUxUUjsNCj4gPiArDQo+ID4gKyAgICAgd3JpdGVfcmVnMzIoZmlsdGVyLCBjb3Jlc2ln aHRfcG11LT5iYXNlMCwgb2Zmc2V0KTsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIHZvaWQg Y29yZXNpZ2h0X3BtdV9zdGFydChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIGludCBwbXVfZmxh Z3MpDQo+ID4gK3sNCj4gPiArICAgICBzdHJ1Y3QgY29yZXNpZ2h0X3BtdSAqY29yZXNpZ2h0X3Bt dSA9IHRvX2NvcmVzaWdodF9wbXUoZXZlbnQtDQo+ID5wbXUpOw0KPiA+ICsgICAgIHN0cnVjdCBo d19wZXJmX2V2ZW50ICpod2MgPSAmZXZlbnQtPmh3Ow0KPiA+ICsgICAgIHUzMiBmaWx0ZXI7DQo+ ID4gKw0KPiA+ICsgICAgIC8qIFdlIGFsd2F5cyByZXByb2dyYW0gdGhlIGNvdW50ZXIgKi8NCj4g PiArICAgICBpZiAocG11X2ZsYWdzICYgUEVSRl9FRl9SRUxPQUQpDQo+ID4gKyAgICAgICAgICAg ICBXQVJOX09OKCEoaHdjLT5zdGF0ZSAmIFBFUkZfSEVTX1VQVE9EQVRFKSk7DQo+ID4gKw0KPiA+ ICsgICAgIGNvcmVzaWdodF9wbXVfc2V0X2V2ZW50X3BlcmlvZChldmVudCk7DQo+ID4gKw0KPiA+ ICsgICAgIGZpbHRlciA9IGNvcmVzaWdodF9wbXUtPmltcGwub3BzLT5ldmVudF9maWx0ZXIoZXZl bnQpOw0KPiA+ICsNCj4gPiArICAgICBpZiAoaXNfY3ljbGVfY250cl9pZHgoZXZlbnQpKSB7DQo+ ID4gKyAgICAgICAgICAgICBjb3Jlc2lnaHRfcG11X3NldF9jY19maWx0ZXIoY29yZXNpZ2h0X3Bt dSwgZmlsdGVyKTsNCj4gPiArICAgICB9IGVsc2Ugew0KPiA+ICsgICAgICAgICAgICAgY29yZXNp Z2h0X3BtdV9zZXRfZXZlbnQoY29yZXNpZ2h0X3BtdSwgaHdjKTsNCj4gPiArICAgICAgICAgICAg IGNvcmVzaWdodF9wbXVfc2V0X2V2X2ZpbHRlcihjb3Jlc2lnaHRfcG11LCBod2MsIGZpbHRlcik7 DQo+ID4gKyAgICAgfQ0KPiA+ICsNCj4gPiArICAgICBod2MtPnN0YXRlID0gMDsNCj4gPiArDQo+ ID4gKyAgICAgY29yZXNpZ2h0X3BtdV9lbmFibGVfY291bnRlcihjb3Jlc2lnaHRfcG11LCBod2Mt PmlkeCk7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyB2b2lkIGNvcmVzaWdodF9wbXVfc3Rv cChzdHJ1Y3QgcGVyZl9ldmVudCAqZXZlbnQsIGludCBwbXVfZmxhZ3MpDQo+ID4gK3sNCj4gPiAr ICAgICBzdHJ1Y3QgY29yZXNpZ2h0X3BtdSAqY29yZXNpZ2h0X3BtdSA9IHRvX2NvcmVzaWdodF9w bXUoZXZlbnQtDQo+ID5wbXUpOw0KPiA+ICsgICAgIHN0cnVjdCBod19wZXJmX2V2ZW50ICpod2Mg PSAmZXZlbnQtPmh3Ow0KPiA+ICsNCj4gPiArICAgICBpZiAoaHdjLT5zdGF0ZSAmIFBFUkZfSEVT X1NUT1BQRUQpDQo+ID4gKyAgICAgICAgICAgICByZXR1cm47DQo+ID4gKw0KPiA+ICsgICAgIGNv cmVzaWdodF9wbXVfZGlzYWJsZV9jb3VudGVyKGNvcmVzaWdodF9wbXUsIGh3Yy0+aWR4KTsNCj4g PiArICAgICBjb3Jlc2lnaHRfcG11X2V2ZW50X3VwZGF0ZShldmVudCk7DQo+ID4gKw0KPiA+ICsg ICAgIGh3Yy0+c3RhdGUgfD0gUEVSRl9IRVNfU1RPUFBFRCB8IFBFUkZfSEVTX1VQVE9EQVRFOw0K PiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgaW50IGNvcmVzaWdodF9wbXVfYWRkKHN0cnVjdCBw ZXJmX2V2ZW50ICpldmVudCwgaW50IGZsYWdzKQ0KPiA+ICt7DQo+ID4gKyAgICAgc3RydWN0IGNv cmVzaWdodF9wbXUgKmNvcmVzaWdodF9wbXUgPSB0b19jb3Jlc2lnaHRfcG11KGV2ZW50LQ0KPiA+ cG11KTsNCj4gPiArICAgICBzdHJ1Y3QgY29yZXNpZ2h0X3BtdV9od19ldmVudHMgKmh3X2V2ZW50 cyA9ICZjb3Jlc2lnaHRfcG11LQ0KPiA+aHdfZXZlbnRzOw0KPiA+ICsgICAgIHN0cnVjdCBod19w ZXJmX2V2ZW50ICpod2MgPSAmZXZlbnQtPmh3Ow0KPiA+ICsgICAgIGludCBpZHg7DQo+ID4gKw0K PiA+ICsgICAgIGlmIChXQVJOX09OX09OQ0UoIWNwdW1hc2tfdGVzdF9jcHUoc21wX3Byb2Nlc3Nv cl9pZCgpLA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJmNv cmVzaWdodF9wbXUtPmFzc29jaWF0ZWRfY3B1cykpKQ0KPiA+ICsgICAgICAgICAgICAgcmV0dXJu IC1FTk9FTlQ7DQo+ID4gKw0KPiA+ICsgICAgIGlkeCA9IGNvcmVzaWdodF9wbXVfZ2V0X2V2ZW50 X2lkeChod19ldmVudHMsIGV2ZW50KTsNCj4gPiArICAgICBpZiAoaWR4IDwgMCkNCj4gPiArICAg ICAgICAgICAgIHJldHVybiBpZHg7DQo+ID4gKw0KPiA+ICsgICAgIGh3X2V2ZW50cy0+ZXZlbnRz W2lkeF0gPSBldmVudDsNCj4gPiArICAgICBod2MtPmlkeCA9IGlkeDsNCj4gPiArICAgICBod2Mt PnN0YXRlID0gUEVSRl9IRVNfU1RPUFBFRCB8IFBFUkZfSEVTX1VQVE9EQVRFOw0KPiA+ICsNCj4g PiArICAgICBpZiAoZmxhZ3MgJiBQRVJGX0VGX1NUQVJUKQ0KPiA+ICsgICAgICAgICAgICAgY29y ZXNpZ2h0X3BtdV9zdGFydChldmVudCwgUEVSRl9FRl9SRUxPQUQpOw0KPiA+ICsNCj4gPiArICAg ICAvKiBQcm9wYWdhdGUgY2hhbmdlcyB0byB0aGUgdXNlcnNwYWNlIG1hcHBpbmcuICovDQo+ID4g KyAgICAgcGVyZl9ldmVudF91cGRhdGVfdXNlcnBhZ2UoZXZlbnQpOw0KPiA+ICsNCj4gPiArICAg ICByZXR1cm4gMDsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIHZvaWQgY29yZXNpZ2h0X3Bt dV9kZWwoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50LCBpbnQgZmxhZ3MpDQo+ID4gK3sNCj4gPiAr ICAgICBzdHJ1Y3QgY29yZXNpZ2h0X3BtdSAqY29yZXNpZ2h0X3BtdSA9IHRvX2NvcmVzaWdodF9w bXUoZXZlbnQtDQo+ID5wbXUpOw0KPiA+ICsgICAgIHN0cnVjdCBjb3Jlc2lnaHRfcG11X2h3X2V2 ZW50cyAqaHdfZXZlbnRzID0gJmNvcmVzaWdodF9wbXUtDQo+ID5od19ldmVudHM7DQo+ID4gKyAg ICAgc3RydWN0IGh3X3BlcmZfZXZlbnQgKmh3YyA9ICZldmVudC0+aHc7DQo+ID4gKyAgICAgaW50 IGlkeCA9IGh3Yy0+aWR4Ow0KPiA+ICsNCj4gPiArICAgICBjb3Jlc2lnaHRfcG11X3N0b3AoZXZl bnQsIFBFUkZfRUZfVVBEQVRFKTsNCj4gPiArDQo+ID4gKyAgICAgaHdfZXZlbnRzLT5ldmVudHNb aWR4XSA9IE5VTEw7DQo+ID4gKw0KPiA+ICsgICAgIGNsZWFyX2JpdChpZHgsIGh3X2V2ZW50cy0+ dXNlZF9jdHJzKTsNCj4gPiArDQo+ID4gKyAgICAgcGVyZl9ldmVudF91cGRhdGVfdXNlcnBhZ2Uo ZXZlbnQpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgdm9pZCBjb3Jlc2lnaHRfcG11X3Jl YWQoc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KQ0KPiA+ICt7DQo+ID4gKyAgICAgY29yZXNpZ2h0 X3BtdV9ldmVudF91cGRhdGUoZXZlbnQpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgaW50 IGNvcmVzaWdodF9wbXVfYWxsb2Moc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwNCj4gPiAr ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBjb3Jlc2lnaHRfcG11ICoqY29yZXNp Z2h0X3BtdSkNCj4gPiArew0KPiA+ICsgICAgIHN0cnVjdCBhY3BpX2FwbXRfbm9kZSAqYXBtdF9u b2RlOw0KPiA+ICsgICAgIHN0cnVjdCBkZXZpY2UgKmRldjsNCj4gPiArICAgICBzdHJ1Y3QgY29y ZXNpZ2h0X3BtdSAqcG11Ow0KPiA+ICsNCj4gPiArICAgICBkZXYgPSAmcGRldi0+ZGV2Ow0KPiA+ ICsgICAgIGFwbXRfbm9kZSA9ICooc3RydWN0IGFjcGlfYXBtdF9ub2RlICoqKWRldl9nZXRfcGxh dGRhdGEoZGV2KTsNCj4gPiArICAgICBpZiAoIWFwbXRfbm9kZSkgew0KPiA+ICsgICAgICAgICAg ICAgZGV2X2VycihkZXYsICJmYWlsZWQgdG8gZ2V0IEFQTVQgbm9kZVxuIik7DQo+ID4gKyAgICAg ICAgICAgICByZXR1cm4gLUVOT01FTTsNCj4gPiArICAgICB9DQo+ID4gKw0KPiA+ICsgICAgIHBt dSA9IGRldm1fa3phbGxvYyhkZXYsIHNpemVvZigqcG11KSwgR0ZQX0tFUk5FTCk7DQo+ID4gKyAg ICAgaWYgKCFwbXUpDQo+ID4gKyAgICAgICAgICAgICByZXR1cm4gLUVOT01FTTsNCj4gPiArDQo+ ID4gKyAgICAgKmNvcmVzaWdodF9wbXUgPSBwbXU7DQo+ID4gKw0KPiA+ICsgICAgIHBtdS0+ZGV2 ID0gZGV2Ow0KPiA+ICsgICAgIHBtdS0+YXBtdF9ub2RlID0gYXBtdF9ub2RlOw0KPiA+ICsgICAg IHBtdS0+bmFtZSA9DQo+ID4gKyAgICAgICAgICAgICBkZXZtX2thc3ByaW50ZihkZXYsIEdGUF9L RVJORUwsIFBNVU5BTUUgIiV1IiwgYXBtdF9ub2RlLQ0KPiA+aWQpOw0KPiA+ICsNCj4gPiArICAg ICBwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBjb3Jlc2lnaHRfcG11KTsNCj4gPiArDQo+ID4g KyAgICAgcmV0dXJuIDA7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyBpbnQgY29yZXNpZ2h0 X3BtdV9pbml0X21taW8oc3RydWN0IGNvcmVzaWdodF9wbXUNCj4gKmNvcmVzaWdodF9wbXUpDQo+ ID4gK3sNCj4gPiArICAgICBzdHJ1Y3QgZGV2aWNlICpkZXY7DQo+ID4gKyAgICAgc3RydWN0IHBs YXRmb3JtX2RldmljZSAqcGRldjsNCj4gPiArICAgICBzdHJ1Y3QgcmVzb3VyY2UgKnJlczsNCj4g PiArICAgICBzdHJ1Y3QgYWNwaV9hcG10X25vZGUgKmFwbXRfbm9kZTsNCj4gPiArDQo+ID4gKyAg ICAgZGV2ID0gY29yZXNpZ2h0X3BtdS0+ZGV2Ow0KPiA+ICsgICAgIHBkZXYgPSB0b19wbGF0Zm9y bV9kZXZpY2UoZGV2KTsNCj4gPiArICAgICBhcG10X25vZGUgPSBjb3Jlc2lnaHRfcG11LT5hcG10 X25vZGU7DQo+ID4gKw0KPiA+ICsgICAgIC8qIEJhc2UgYWRkcmVzcyBmb3IgcGFnZSAwLiAqLw0K PiA+ICsgICAgIHJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX01F TSwgMCk7DQo+ID4gKyAgICAgaWYgKCFyZXMpIHsNCj4gPiArICAgICAgICAgICAgIGRldl9lcnIo ZGV2LCAiZmFpbGVkIHRvIGdldCBwYWdlLTAgcmVzb3VyY2VcbiIpOw0KPiA+ICsgICAgICAgICAg ICAgcmV0dXJuIC1FTk9NRU07DQo+ID4gKyAgICAgfQ0KPiA+ICsNCj4gPiArICAgICBjb3Jlc2ln aHRfcG11LT5iYXNlMCA9IGRldm1faW9yZW1hcF9yZXNvdXJjZShkZXYsIHJlcyk7DQo+ID4gKyAg ICAgaWYgKElTX0VSUihjb3Jlc2lnaHRfcG11LT5iYXNlMCkpIHsNCj4gPiArICAgICAgICAgICAg IGRldl9lcnIoZGV2LCAiaW9yZW1hcCBmYWlsZWQgZm9yIHBhZ2UtMCByZXNvdXJjZVxuIik7DQo+ ID4gKyAgICAgICAgICAgICByZXR1cm4gUFRSX0VSUihjb3Jlc2lnaHRfcG11LT5iYXNlMCk7DQo+ ID4gKyAgICAgfQ0KPiANCj4gZGV2bV9wbGF0Zm9ybV9pb3JlbWFwX3Jlc291cmNlKCkNCg0KVGhh bmtzLCB3ZSB3aWxsIHVwZGF0ZSBpdC4NCg0KPiANCj4gPiArICAgICAvKiBCYXNlIGFkZHJlc3Mg Zm9yIHBhZ2UgMSBpZiBzdXBwb3J0ZWQuIE90aGVyd2lzZSBwb2ludCBpdCB0byBwYWdlIDAuICov DQo+ID4gKyAgICAgY29yZXNpZ2h0X3BtdS0+YmFzZTEgPSBjb3Jlc2lnaHRfcG11LT5iYXNlMDsN Cj4gPiArICAgICBpZiAoQ0hFQ0tfQVBNVF9GTEFHKGFwbXRfbm9kZS0+ZmxhZ3MsIERVQUxfUEFH RSwgU1VQUCkpIHsNCj4gPiArICAgICAgICAgICAgIHJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJj ZShwZGV2LCBJT1JFU09VUkNFX01FTSwgMSk7DQo+ID4gKyAgICAgICAgICAgICBpZiAoIXJlcykg ew0KPiA+ICsgICAgICAgICAgICAgICAgICAgICBkZXZfZXJyKGRldiwgImZhaWxlZCB0byBnZXQg cGFnZS0xIHJlc291cmNlXG4iKTsNCj4gPiArICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIC1F Tk9NRU07DQo+ID4gKyAgICAgICAgICAgICB9DQo+ID4gKw0KPiA+ICsgICAgICAgICAgICAgY29y ZXNpZ2h0X3BtdS0+YmFzZTEgPSBkZXZtX2lvcmVtYXBfcmVzb3VyY2UoZGV2LCByZXMpOw0KPiA+ ICsgICAgICAgICAgICAgaWYgKElTX0VSUihjb3Jlc2lnaHRfcG11LT5iYXNlMSkpIHsNCj4gPiAr ICAgICAgICAgICAgICAgICAgICAgZGV2X2VycihkZXYsICJpb3JlbWFwIGZhaWxlZCBmb3IgcGFn ZS0xIHJlc291cmNlXG4iKTsNCj4gPiArICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIFBUUl9F UlIoY29yZXNpZ2h0X3BtdS0+YmFzZTEpOw0KPiA+ICsgICAgICAgICAgICAgfQ0KPiANCj4gRGl0 dG8uDQo+IA0KPiA+ICsgICAgIH0NCj4gPiArDQo+ID4gKyAgICAgaWYgKENIRUNLX0FQTVRfRkxB RyhhcG10X25vZGUtPmZsYWdzLCBBVE9NSUMsIFNVUFApKSB7DQo+ID4gKyAgICAgICAgICAgICBj b3Jlc2lnaHRfcG11LT5yZWFkX3JlZzY0ID0gJnJlYWRfcmVnNjQ7DQo+ID4gKyAgICAgICAgICAg ICBjb3Jlc2lnaHRfcG11LT53cml0ZV9yZWc2NCA9ICZ3cml0ZV9yZWc2NDsNCj4gPiArICAgICB9 IGVsc2Ugew0KPiA+ICsgICAgICAgICAgICAgY29yZXNpZ2h0X3BtdS0+cmVhZF9yZWc2NCA9ICZy ZWFkX3JlZzY0X2hpbG9oaTsNCj4gPiArICAgICAgICAgICAgIGNvcmVzaWdodF9wbXUtPndyaXRl X3JlZzY0ID0gJndyaXRlX3JlZzY0X2xvaGk7DQo+ID4gKyAgICAgfQ0KPiA+ICsNCj4gPiArICAg ICBjb3Jlc2lnaHRfcG11LT5wbWNmZ3IgPSByZWFkX3JlZzMyKGNvcmVzaWdodF9wbXUtPmJhc2Uw LA0KPiBQTUNGR1IpOw0KPiA+ICsNCj4gPiArICAgICBjb3Jlc2lnaHRfcG11LT5udW1fYWRqX2Nv dW50ZXJzID0gcG1jZmdyX24oY29yZXNpZ2h0X3BtdSkgKyAxOw0KPiA+ICsNCj4gPiArICAgICBp ZiAoc3VwcG9ydF9jYyhjb3Jlc2lnaHRfcG11KSkgew0KPiA+ICsgICAgICAgICAgICAgLyoqDQo+ ID4gKyAgICAgICAgICAgICAgKiBFeGNsdWRlIHRoZSBjeWNsZSBjb3VudGVyIGlmIHRoZXJlIGlz IGEgZ2FwIGJldHdlZW4NCj4gPiArICAgICAgICAgICAgICAqIGN5Y2xlIGNvdW50ZXIgaWQgYW5k IHRoZSBsYXN0IHJlZ3VsYXIgZXZlbnQgY291bnRlciBpZC4NCj4gPiArICAgICAgICAgICAgICAq Lw0KPiA+ICsgICAgICAgICAgICAgaWYgKGNvcmVzaWdodF9wbXUtPm51bV9hZGpfY291bnRlcnMg PD0NCj4gQ09SRVNJR0hUX1BNVV9JRFhfQ0NOVFIpDQo+ID4gKyAgICAgICAgICAgICAgICAgICAg IGNvcmVzaWdodF9wbXUtPm51bV9hZGpfY291bnRlcnMgLT0gMTsNCj4gDQo+IEFzIGJlZm9yZSwg SSB0aGluayBpdCB3b3VsZCBiZSBhIGZhaXIgYml0IGNsZWFyZXIgdG8gbWFpbnRhaW4gYQ0KPiBk aXN0aW5jdGlvbiBiZXR3ZWVuIHRoZSBudW1iZXIgb2YgUE1FVntUWVBFLENOVCxGSUxUfVIgcmVn aXN0ZXJzIHByZXNlbnQNCj4gYW5kIHRoZSBudW1iZXIgb2YgbG9naWNhbCBjb3VudGVycyBhY3R1 YWxseSB1c2FibGUuDQo+IA0KDQpXZSB3aWxsIHJldmlzaXQgdGhpcy4NCg0KPiA+ICsgICAgIH0N Cj4gPiArDQo+ID4gKyAgICAgY29yZXNpZ2h0X3BtdS0+bnVtX3NldF9jbHJfcmVnID0NCj4gPiAr ICAgICAgICAgICAgIHJvdW5kX3VwKGNvcmVzaWdodF9wbXUtPm51bV9hZGpfY291bnRlcnMsDQo+ ID4gKyAgICAgICAgICAgICAgICAgICAgICBDT1JFU0lHSFRfU0VUX0NMUl9SRUdfQ09VTlRFUl9O VU0pIC8NCj4gPiArICAgICAgICAgICAgIENPUkVTSUdIVF9TRVRfQ0xSX1JFR19DT1VOVEVSX05V TTsNCj4gDQo+IERJVl9ST1VORF9VUCgpDQoNClRoYW5rcywgd2Ugd2lsbCB1cGRhdGUgaXQuDQoN Cj4gDQo+ID4gKw0KPiA+ICsgICAgIHJldHVybiAwOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0 aWMgaW5saW5lIGludA0KPiA+ICtjb3Jlc2lnaHRfcG11X2dldF9yZXNldF9vdmVyZmxvdyhzdHJ1 Y3QgY29yZXNpZ2h0X3BtdQ0KPiAqY29yZXNpZ2h0X3BtdSwNCj4gPiArICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgdTMyICpwbW92cykNCj4gPiArew0KPiA+ICsgICAgIGludCBpOw0KPiA+ ICsgICAgIHUzMiBwbW92Y2xyX29mZnNldCA9IFBNT1ZTQ0xSOw0KPiA+ICsgICAgIHUzMiBoYXNf b3ZlcmZsb3dlZCA9IDA7DQo+ID4gKw0KPiA+ICsgICAgIGZvciAoaSA9IDA7IGkgPCBjb3Jlc2ln aHRfcG11LT5udW1fc2V0X2Nscl9yZWc7ICsraSkgew0KPiA+ICsgICAgICAgICAgICAgcG1vdnNb aV0gPSByZWFkX3JlZzMyKGNvcmVzaWdodF9wbXUtPmJhc2UxLCBwbW92Y2xyX29mZnNldCk7DQo+ ID4gKyAgICAgICAgICAgICBoYXNfb3ZlcmZsb3dlZCB8PSBwbW92c1tpXTsNCj4gPiArICAgICAg ICAgICAgIHdyaXRlX3JlZzMyKHBtb3ZzW2ldLCBjb3Jlc2lnaHRfcG11LT5iYXNlMSwgcG1vdmNs cl9vZmZzZXQpOw0KPiA+ICsgICAgICAgICAgICAgcG1vdmNscl9vZmZzZXQgKz0gc2l6ZW9mKHUz Mik7DQo+ID4gKyAgICAgfQ0KPiA+ICsNCj4gPiArICAgICByZXR1cm4gaGFzX292ZXJmbG93ZWQg IT0gMDsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIGlycXJldHVybl90IGNvcmVzaWdodF9w bXVfaGFuZGxlX2lycShpbnQgaXJxX251bSwgdm9pZCAqZGV2KQ0KPiA+ICt7DQo+ID4gKyAgICAg aW50IGlkeCwgaGFzX292ZXJmbG93ZWQ7DQo+ID4gKyAgICAgc3RydWN0IGNvcmVzaWdodF9wbXUg KmNvcmVzaWdodF9wbXUgPSBkZXY7DQo+ID4gKyAgICAgdTMyIHBtb3ZzW0NPUkVTSUdIVF9TRVRf Q0xSX1JFR19NQVhfTlVNXSA9IHsgMCB9Ow0KPiA+ICsgICAgIGJvb2wgaGFuZGxlZCA9IGZhbHNl Ow0KPiA+ICsNCj4gPiArICAgICBjb3Jlc2lnaHRfcG11X3N0b3BfY291bnRlcnMoY29yZXNpZ2h0 X3BtdSk7DQo+ID4gKw0KPiA+ICsgICAgIGhhc19vdmVyZmxvd2VkID0NCj4gY29yZXNpZ2h0X3Bt dV9nZXRfcmVzZXRfb3ZlcmZsb3coY29yZXNpZ2h0X3BtdSwgcG1vdnMpOw0KPiA+ICsgICAgIGlm ICghaGFzX292ZXJmbG93ZWQpDQo+ID4gKyAgICAgICAgICAgICBnb3RvIGRvbmU7DQo+ID4gKw0K PiA+ICsgICAgIGZvcl9lYWNoX3NldF9iaXQoaWR4LCAodW5zaWduZWQgbG9uZyAqKXBtb3ZzLA0K PiA+ICsgICAgICAgICAgICAgICAgICAgICAgQ09SRVNJR0hUX1BNVV9NQVhfSFdfQ05UUlMpIHsN Cj4gDQo+IFdoeSB3YXN0ZSB0aW1lIGl0ZXJhdGluZyBvdmVyIGEgcHJvYmFibHkgc2lnbmlmaWNh bnQgbnVtYmVyIG9mDQo+IGlycmVsZXZhbnQgYml0cz8NCg0KWXVwLCB0aGlzIGlzIHVubmVjZXNz YXJ5LiBXZSB3aWxsIHVwZGF0ZSBpdCBhbG9uZyB3aXRoIGNoYW5nZSBvbg0KdHJhY2tpbmcgdGhl IHVzZWQgY291bnRlcnMuDQoNCj4gDQo+ID4gKyAgICAgICAgICAgICBzdHJ1Y3QgcGVyZl9ldmVu dCAqZXZlbnQgPSBjb3Jlc2lnaHRfcG11LQ0KPiA+aHdfZXZlbnRzLmV2ZW50c1tpZHhdOw0KPiA+ ICsNCj4gPiArICAgICAgICAgICAgIGlmICghZXZlbnQpDQo+ID4gKyAgICAgICAgICAgICAgICAg ICAgIGNvbnRpbnVlOw0KPiA+ICsNCj4gPiArICAgICAgICAgICAgIGNvcmVzaWdodF9wbXVfZXZl bnRfdXBkYXRlKGV2ZW50KTsNCj4gPiArICAgICAgICAgICAgIGNvcmVzaWdodF9wbXVfc2V0X2V2 ZW50X3BlcmlvZChldmVudCk7DQo+ID4gKw0KPiA+ICsgICAgICAgICAgICAgaGFuZGxlZCA9IHRy dWU7DQo+ID4gKyAgICAgfQ0KPiA+ICsNCj4gPiArZG9uZToNCj4gPiArICAgICBjb3Jlc2lnaHRf cG11X3N0YXJ0X2NvdW50ZXJzKGNvcmVzaWdodF9wbXUpOw0KPiA+ICsgICAgIHJldHVybiBJUlFf UkVUVkFMKGhhbmRsZWQpOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgaW50IGNvcmVzaWdo dF9wbXVfcmVxdWVzdF9pcnEoc3RydWN0IGNvcmVzaWdodF9wbXUNCj4gKmNvcmVzaWdodF9wbXUp DQo+ID4gK3sNCj4gPiArICAgICBpbnQgaXJxLCByZXQ7DQo+ID4gKyAgICAgc3RydWN0IGRldmlj ZSAqZGV2Ow0KPiA+ICsgICAgIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXY7DQo+ID4gKyAg ICAgc3RydWN0IGFjcGlfYXBtdF9ub2RlICphcG10X25vZGU7DQo+ID4gKw0KPiA+ICsgICAgIGRl diA9IGNvcmVzaWdodF9wbXUtPmRldjsNCj4gPiArICAgICBwZGV2ID0gdG9fcGxhdGZvcm1fZGV2 aWNlKGRldik7DQo+ID4gKyAgICAgYXBtdF9ub2RlID0gY29yZXNpZ2h0X3BtdS0+YXBtdF9ub2Rl Ow0KPiA+ICsNCj4gPiArICAgICAvKiBTa2lwIElSUSByZXF1ZXN0IGlmIHRoZSBQTVUgZG9lcyBu b3Qgc3VwcG9ydCBvdmVyZmxvdyBpbnRlcnJ1cHQuICovDQo+ID4gKyAgICAgaWYgKGFwbXRfbm9k ZS0+b3ZmbHdfaXJxID09IDApDQo+ID4gKyAgICAgICAgICAgICByZXR1cm4gMDsNCj4gPiArDQo+ ID4gKyAgICAgaXJxID0gcGxhdGZvcm1fZ2V0X2lycShwZGV2LCAwKTsNCj4gPiArICAgICBpZiAo aXJxIDwgMCkNCj4gPiArICAgICAgICAgICAgIHJldHVybiBpcnE7DQo+ID4gKw0KPiA+ICsgICAg IHJldCA9IGRldm1fcmVxdWVzdF9pcnEoZGV2LCBpcnEsIGNvcmVzaWdodF9wbXVfaGFuZGxlX2ly cSwNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgIElSUUZfTk9CQUxBTkNJTkcgfCBJ UlFGX05PX1RIUkVBRCwNCj4gZGV2X25hbWUoZGV2KSwNCj4gPiArICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGNvcmVzaWdodF9wbXUpOw0KPiA+ICsgICAgIGlmIChyZXQpIHsNCj4gPiArICAg ICAgICAgICAgIGRldl9lcnIoZGV2LCAiQ291bGQgbm90IHJlcXVlc3QgSVJRICVkXG4iLCBpcnEp Ow0KPiA+ICsgICAgICAgICAgICAgcmV0dXJuIHJldDsNCj4gPiArICAgICB9DQo+ID4gKw0KPiA+ ICsgICAgIGNvcmVzaWdodF9wbXUtPmlycSA9IGlycTsNCj4gPiArDQo+ID4gKyAgICAgcmV0dXJu IDA7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyBpbmxpbmUgaW50IGNvcmVzaWdodF9wbXVf ZmluZF9jcHVfY29udGFpbmVyKGludCBjcHUsIHUzMg0KPiBjb250YWluZXJfdWlkKQ0KPiA+ICt7 DQo+ID4gKyAgICAgdTMyIGFjcGlfdWlkOw0KPiA+ICsgICAgIHN0cnVjdCBkZXZpY2UgKmNwdV9k ZXYgPSBnZXRfY3B1X2RldmljZShjcHUpOw0KPiA+ICsgICAgIHN0cnVjdCBhY3BpX2RldmljZSAq YWNwaV9kZXYgPSBBQ1BJX0NPTVBBTklPTihjcHVfZGV2KTsNCj4gPiArICAgICBpbnQgbGV2ZWwg PSAwOw0KPiA+ICsNCj4gPiArICAgICBpZiAoIWNwdV9kZXYpDQo+ID4gKyAgICAgICAgICAgICBy ZXR1cm4gLUVOT0RFVjsNCj4gPiArDQo+ID4gKyAgICAgd2hpbGUgKGFjcGlfZGV2KSB7DQo+ID4g KyAgICAgICAgICAgICBpZiAoIXN0cmNtcChhY3BpX2RldmljZV9oaWQoYWNwaV9kZXYpLA0KPiA+ ICsgICAgICAgICAgICAgICAgICAgICAgICAgQUNQSV9QUk9DRVNTT1JfQ09OVEFJTkVSX0hJRCkg JiYNCj4gPiArICAgICAgICAgICAgICAgICAha3N0cnRvdWludChhY3BpX2RldmljZV91aWQoYWNw aV9kZXYpLCAwLCAmYWNwaV91aWQpICYmDQo+ID4gKyAgICAgICAgICAgICAgICAgYWNwaV91aWQg PT0gY29udGFpbmVyX3VpZCkNCj4gPiArICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIDA7DQo+ ID4gKw0KPiA+ICsgICAgICAgICAgICAgYWNwaV9kZXYgPSBhY3BpX2Rldi0+cGFyZW50Ow0KPiA+ ICsgICAgICAgICAgICAgbGV2ZWwrKzsNCj4gPiArICAgICB9DQo+ID4gKw0KPiA+ICsgICAgIHJl dHVybiAtRU5PREVWOw0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgaW50IGNvcmVzaWdodF9w bXVfZ2V0X2NwdXMoc3RydWN0IGNvcmVzaWdodF9wbXUNCj4gKmNvcmVzaWdodF9wbXUpDQo+ID4g K3sNCj4gPiArICAgICBzdHJ1Y3QgYWNwaV9hcG10X25vZGUgKmFwbXRfbm9kZTsNCj4gPiArICAg ICBpbnQgYWZmaW5pdHlfZmxhZzsNCj4gPiArICAgICBpbnQgY3B1Ow0KPiA+ICsNCj4gPiArICAg ICBhcG10X25vZGUgPSBjb3Jlc2lnaHRfcG11LT5hcG10X25vZGU7DQo+ID4gKyAgICAgYWZmaW5p dHlfZmxhZyA9IGFwbXRfbm9kZS0+ZmxhZ3MgJiBBQ1BJX0FQTVRfRkxBR1NfQUZGSU5JVFk7DQo+ ID4gKw0KPiA+ICsgICAgIGlmIChhZmZpbml0eV9mbGFnID09IEFDUElfQVBNVF9GTEFHU19BRkZJ TklUWV9QUk9DKSB7DQo+ID4gKyAgICAgICAgICAgICBmb3JfZWFjaF9wb3NzaWJsZV9jcHUoY3B1 KSB7DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgIGlmIChhcG10X25vZGUtPnByb2NfYWZmaW5p dHkgPT0NCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgIGdldF9hY3BpX2lkX2Zvcl9jcHUo Y3B1KSkgew0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNwdW1hc2tfc2V0X2Nw dSgNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNwdSwgJmNvcmVz aWdodF9wbXUtPmFzc29jaWF0ZWRfY3B1cyk7DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgYnJlYWs7DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgIH0NCj4gPiArICAgICAgICAg ICAgIH0NCj4gPiArICAgICB9IGVsc2Ugew0KPiA+ICsgICAgICAgICAgICAgZm9yX2VhY2hfcG9z c2libGVfY3B1KGNwdSkgew0KPiA+ICsgICAgICAgICAgICAgICAgICAgICBpZiAoY29yZXNpZ2h0 X3BtdV9maW5kX2NwdV9jb250YWluZXIoDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGNwdSwgYXBtdF9ub2RlLT5wcm9jX2FmZmluaXR5KSkNCj4gPiArICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBjb250aW51ZTsNCj4gPiArDQo+ID4gKyAgICAgICAgICAgICAgICAg ICAgIGNwdW1hc2tfc2V0X2NwdShjcHUsICZjb3Jlc2lnaHRfcG11LT5hc3NvY2lhdGVkX2NwdXMp Ow0KPiA+ICsgICAgICAgICAgICAgfQ0KPiA+ICsgICAgIH0NCj4gPiArDQo+ID4gKyAgICAgcmV0 dXJuIDA7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0YXRpYyBpbnQgY29yZXNpZ2h0X3BtdV9yZWdp c3Rlcl9wbXUoc3RydWN0IGNvcmVzaWdodF9wbXUNCj4gKmNvcmVzaWdodF9wbXUpDQo+ID4gK3sN Cj4gPiArICAgICBpbnQgcmV0Ow0KPiA+ICsgICAgIHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgKiph dHRyX2dyb3VwczsNCj4gPiArDQo+ID4gKyAgICAgYXR0cl9ncm91cHMgPSBjb3Jlc2lnaHRfcG11 X2FsbG9jX2F0dHJfZ3JvdXAoY29yZXNpZ2h0X3BtdSk7DQo+ID4gKyAgICAgaWYgKCFhdHRyX2dy b3Vwcykgew0KPiA+ICsgICAgICAgICAgICAgcmV0ID0gLUVOT01FTTsNCj4gPiArICAgICAgICAg ICAgIHJldHVybiByZXQ7DQo+ID4gKyAgICAgfQ0KPiA+ICsNCj4gPiArICAgICByZXQgPSBjcHVo cF9zdGF0ZV9hZGRfaW5zdGFuY2UoY29yZXNpZ2h0X3BtdV9jcHVocF9zdGF0ZSwNCj4gPiArICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJmNvcmVzaWdodF9wbXUtPmNwdWhwX25v ZGUpOw0KPiA+ICsgICAgIGlmIChyZXQpDQo+ID4gKyAgICAgICAgICAgICByZXR1cm4gcmV0Ow0K PiA+ICsNCj4gPiArICAgICBjb3Jlc2lnaHRfcG11LT5wbXUgPSAoc3RydWN0IHBtdSl7DQo+ID4g KyAgICAgICAgICAgICAudGFza19jdHhfbnIgICAgPSBwZXJmX2ludmFsaWRfY29udGV4dCwNCj4g PiArICAgICAgICAgICAgIC5tb2R1bGUgICAgICAgICA9IFRISVNfTU9EVUxFLA0KPiA+ICsgICAg ICAgICAgICAgLnBtdV9lbmFibGUgICAgID0gY29yZXNpZ2h0X3BtdV9lbmFibGUsDQo+ID4gKyAg ICAgICAgICAgICAucG11X2Rpc2FibGUgICAgPSBjb3Jlc2lnaHRfcG11X2Rpc2FibGUsDQo+ID4g KyAgICAgICAgICAgICAuZXZlbnRfaW5pdCAgICAgPSBjb3Jlc2lnaHRfcG11X2V2ZW50X2luaXQs DQo+ID4gKyAgICAgICAgICAgICAuYWRkICAgICAgICAgICAgPSBjb3Jlc2lnaHRfcG11X2FkZCwN Cj4gPiArICAgICAgICAgICAgIC5kZWwgICAgICAgICAgICA9IGNvcmVzaWdodF9wbXVfZGVsLA0K PiA+ICsgICAgICAgICAgICAgLnN0YXJ0ICAgICAgICAgID0gY29yZXNpZ2h0X3BtdV9zdGFydCwN Cj4gPiArICAgICAgICAgICAgIC5zdG9wICAgICAgICAgICA9IGNvcmVzaWdodF9wbXVfc3RvcCwN Cj4gPiArICAgICAgICAgICAgIC5yZWFkICAgICAgICAgICA9IGNvcmVzaWdodF9wbXVfcmVhZCwN Cj4gPiArICAgICAgICAgICAgIC5hdHRyX2dyb3VwcyAgICA9IChjb25zdCBzdHJ1Y3QgYXR0cmli dXRlX2dyb3VwICoqKWF0dHJfZ3JvdXBzLA0KPiA+ICsgICAgICAgICAgICAgLmNhcGFiaWxpdGll cyAgID0gUEVSRl9QTVVfQ0FQX05PX0VYQ0xVREUsDQo+ID4gKyAgICAgfTsNCj4gPiArDQo+ID4g KyAgICAgcmV0ID0gcGVyZl9wbXVfcmVnaXN0ZXIoJmNvcmVzaWdodF9wbXUtPnBtdSwgY29yZXNp Z2h0X3BtdS0NCj4gPm5hbWUsIC0xKTsNCj4gPiArICAgICBpZiAocmV0KSB7DQo+ID4gKyAgICAg ICAgICAgICBjcHVocF9zdGF0ZV9yZW1vdmVfaW5zdGFuY2UoY29yZXNpZ2h0X3BtdV9jcHVocF9z dGF0ZSwNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmY29y ZXNpZ2h0X3BtdS0+Y3B1aHBfbm9kZSk7DQo+ID4gKyAgICAgfQ0KPiA+ICsNCj4gPiArICAgICBy ZXR1cm4gcmV0Ow0KPiA+ICt9DQo+ID4gKw0KPiA+ICtzdGF0aWMgaW50IGNvcmVzaWdodF9wbXVf ZGV2aWNlX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpDQo+ID4gK3sNCj4gPiAr ICAgICBpbnQgcmV0Ow0KPiA+ICsgICAgIHN0cnVjdCBjb3Jlc2lnaHRfcG11ICpjb3Jlc2lnaHRf cG11Ow0KPiA+ICsNCj4gPiArICAgICByZXQgPSBjb3Jlc2lnaHRfcG11X2FsbG9jKHBkZXYsICZj b3Jlc2lnaHRfcG11KTsNCj4gPiArICAgICBpZiAocmV0KQ0KPiA+ICsgICAgICAgICAgICAgcmV0 dXJuIHJldDsNCj4gPiArDQo+ID4gKyAgICAgcmV0ID0gY29yZXNpZ2h0X3BtdV9pbml0X21taW8o Y29yZXNpZ2h0X3BtdSk7DQo+ID4gKyAgICAgaWYgKHJldCkNCj4gPiArICAgICAgICAgICAgIHJl dHVybiByZXQ7DQo+ID4gKw0KPiA+ICsgICAgIHJldCA9IGNvcmVzaWdodF9wbXVfcmVxdWVzdF9p cnEoY29yZXNpZ2h0X3BtdSk7DQo+ID4gKyAgICAgaWYgKHJldCkNCj4gPiArICAgICAgICAgICAg IHJldHVybiByZXQ7DQo+ID4gKw0KPiA+ICsgICAgIHJldCA9IGNvcmVzaWdodF9wbXVfZ2V0X2Nw dXMoY29yZXNpZ2h0X3BtdSk7DQo+ID4gKyAgICAgaWYgKHJldCkNCj4gPiArICAgICAgICAgICAg IHJldHVybiByZXQ7DQo+ID4gKw0KPiA+ICsgICAgIHJldCA9IGNvcmVzaWdodF9wbXVfcmVnaXN0 ZXJfcG11KGNvcmVzaWdodF9wbXUpOw0KPiA+ICsgICAgIGlmIChyZXQpDQo+ID4gKyAgICAgICAg ICAgICByZXR1cm4gcmV0Ow0KPiA+ICsNCj4gPiArICAgICByZXR1cm4gMDsNCj4gPiArfQ0KPiA+ ICsNCj4gPiArc3RhdGljIGludCBjb3Jlc2lnaHRfcG11X2RldmljZV9yZW1vdmUoc3RydWN0IHBs YXRmb3JtX2RldmljZSAqcGRldikNCj4gPiArew0KPiA+ICsgICAgIHN0cnVjdCBjb3Jlc2lnaHRf cG11ICpjb3Jlc2lnaHRfcG11ID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7DQo+ID4gKw0K PiA+ICsgICAgIHBlcmZfcG11X3VucmVnaXN0ZXIoJmNvcmVzaWdodF9wbXUtPnBtdSk7DQo+ID4g KyAgICAgY3B1aHBfc3RhdGVfcmVtb3ZlX2luc3RhbmNlKGNvcmVzaWdodF9wbXVfY3B1aHBfc3Rh dGUsDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZjb3Jlc2lnaHRfcG11 LT5jcHVocF9ub2RlKTsNCj4gPiArDQo+ID4gKyAgICAgcmV0dXJuIDA7DQo+ID4gK30NCj4gPiAr DQo+ID4gK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGNvcmVzaWdodF9wbXVfZHJpdmVy ID0gew0KPiA+ICsgICAgIC5kcml2ZXIgPSB7DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgIC5u YW1lID0gImFybS1jb3Jlc2lnaHQtcG11IiwNCj4gPiArICAgICAgICAgICAgICAgICAgICAgLnN1 cHByZXNzX2JpbmRfYXR0cnMgPSB0cnVlLA0KPiA+ICsgICAgICAgICAgICAgfSwNCj4gPiArICAg ICAucHJvYmUgPSBjb3Jlc2lnaHRfcG11X2RldmljZV9wcm9iZSwNCj4gPiArICAgICAucmVtb3Zl ID0gY29yZXNpZ2h0X3BtdV9kZXZpY2VfcmVtb3ZlLA0KPiA+ICt9Ow0KPiA+ICsNCj4gPiArc3Rh dGljIHZvaWQgY29yZXNpZ2h0X3BtdV9zZXRfYWN0aXZlX2NwdShpbnQgY3B1LA0KPiA+ICsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBjb3Jlc2lnaHRfcG11ICpj b3Jlc2lnaHRfcG11KQ0KPiA+ICt7DQo+ID4gKyAgICAgY3B1bWFza19zZXRfY3B1KGNwdSwgJmNv cmVzaWdodF9wbXUtPmFjdGl2ZV9jcHUpOw0KPiA+ICsgICAgIFdBUk5fT04oaXJxX3NldF9hZmZp bml0eShjb3Jlc2lnaHRfcG11LT5pcnEsDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICZjb3Jlc2lnaHRfcG11LT5hY3RpdmVfY3B1KSk7DQo+ID4gK30NCj4gPiArDQo+ID4gK3N0 YXRpYyBpbnQgY29yZXNpZ2h0X3BtdV9jcHVfb25saW5lKHVuc2lnbmVkIGludCBjcHUsIHN0cnVj dCBobGlzdF9ub2RlDQo+ICpub2RlKQ0KPiA+ICt7DQo+ID4gKyAgICAgc3RydWN0IGNvcmVzaWdo dF9wbXUgKmNvcmVzaWdodF9wbXUgPQ0KPiA+ICsgICAgICAgICAgICAgaGxpc3RfZW50cnlfc2Fm ZShub2RlLCBzdHJ1Y3QgY29yZXNpZ2h0X3BtdSwgY3B1aHBfbm9kZSk7DQo+ID4gKw0KPiA+ICsg ICAgIGlmICghY3B1bWFza190ZXN0X2NwdShjcHUsICZjb3Jlc2lnaHRfcG11LT5hc3NvY2lhdGVk X2NwdXMpKQ0KPiA+ICsgICAgICAgICAgICAgcmV0dXJuIDA7DQo+ID4gKw0KPiA+ICsgICAgIC8q IElmIHRoZSBQTVUgaXMgYWxyZWFkeSBtYW5hZ2VkLCB0aGVyZSBpcyBub3RoaW5nIHRvIGRvICov DQo+ID4gKyAgICAgaWYgKCFjcHVtYXNrX2VtcHR5KCZjb3Jlc2lnaHRfcG11LT5hY3RpdmVfY3B1 KSkNCj4gPiArICAgICAgICAgICAgIHJldHVybiAwOw0KPiA+ICsNCj4gPiArICAgICAvKiBVc2Ug dGhpcyBDUFUgZm9yIGV2ZW50IGNvdW50aW5nICovDQo+ID4gKyAgICAgY29yZXNpZ2h0X3BtdV9z ZXRfYWN0aXZlX2NwdShjcHUsIGNvcmVzaWdodF9wbXUpOw0KPiA+ICsNCj4gPiArICAgICByZXR1 cm4gMDsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIGludCBjb3Jlc2lnaHRfcG11X2NwdV90 ZWFyZG93bih1bnNpZ25lZCBpbnQgY3B1LCBzdHJ1Y3QNCj4gaGxpc3Rfbm9kZSAqbm9kZSkNCj4g PiArew0KPiA+ICsgICAgIGludCBkc3Q7DQo+ID4gKyAgICAgc3RydWN0IGNwdW1hc2sgb25saW5l X3N1cHBvcnRlZDsNCj4gPiArDQo+ID4gKyAgICAgc3RydWN0IGNvcmVzaWdodF9wbXUgKmNvcmVz aWdodF9wbXUgPQ0KPiA+ICsgICAgICAgICAgICAgaGxpc3RfZW50cnlfc2FmZShub2RlLCBzdHJ1 Y3QgY29yZXNpZ2h0X3BtdSwgY3B1aHBfbm9kZSk7DQo+ID4gKw0KPiA+ICsgICAgIC8qIE5vdGhp bmcgdG8gZG8gaWYgdGhpcyBDUFUgZG9lc24ndCBvd24gdGhlIFBNVSAqLw0KPiA+ICsgICAgIGlm ICghY3B1bWFza190ZXN0X2FuZF9jbGVhcl9jcHUoY3B1LCAmY29yZXNpZ2h0X3BtdS0+YWN0aXZl X2NwdSkpDQo+ID4gKyAgICAgICAgICAgICByZXR1cm4gMDsNCj4gPiArDQo+ID4gKyAgICAgLyog Q2hvb3NlIGEgbmV3IENQVSB0byBtaWdyYXRlIG93bmVyc2hpcCBvZiB0aGUgUE1VIHRvICovDQo+ ID4gKyAgICAgY3B1bWFza19hbmQoJm9ubGluZV9zdXBwb3J0ZWQsICZjb3Jlc2lnaHRfcG11LT5h c3NvY2lhdGVkX2NwdXMsDQo+ID4gKyAgICAgICAgICAgICAgICAgY3B1X29ubGluZV9tYXNrKTsN Cj4gPiArICAgICBkc3QgPSBjcHVtYXNrX2FueV9idXQoJm9ubGluZV9zdXBwb3J0ZWQsIGNwdSk7 DQo+ID4gKyAgICAgaWYgKGRzdCA+PSBucl9jcHVfaWRzKQ0KPiA+ICsgICAgICAgICAgICAgcmV0 dXJuIDA7DQo+ID4gKw0KPiA+ICsgICAgIC8qIFVzZSB0aGlzIENQVSBmb3IgZXZlbnQgY291bnRp bmcgKi8NCj4gPiArICAgICBwZXJmX3BtdV9taWdyYXRlX2NvbnRleHQoJmNvcmVzaWdodF9wbXUt PnBtdSwgY3B1LCBkc3QpOw0KPiA+ICsgICAgIGNvcmVzaWdodF9wbXVfc2V0X2FjdGl2ZV9jcHUo ZHN0LCBjb3Jlc2lnaHRfcG11KTsNCj4gPiArDQo+ID4gKyAgICAgcmV0dXJuIDA7DQo+ID4gK30N Cj4gPiArDQo+ID4gK3N0YXRpYyBpbnQgX19pbml0IGNvcmVzaWdodF9wbXVfaW5pdCh2b2lkKQ0K PiA+ICt7DQo+ID4gKyAgICAgaW50IHJldDsNCj4gPiArDQo+ID4gKyAgICAgcmV0ID0gY3B1aHBf c2V0dXBfc3RhdGVfbXVsdGkoQ1BVSFBfQVBfT05MSU5FX0RZTiwgUE1VTkFNRSwNCj4gPiArICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb3Jlc2lnaHRfcG11X2NwdV9vbmxpbmUs DQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29yZXNpZ2h0X3BtdV9j cHVfdGVhcmRvd24pOw0KPiA+ICsgICAgIGlmIChyZXQgPCAwKQ0KPiA+ICsgICAgICAgICAgICAg cmV0dXJuIHJldDsNCj4gPiArICAgICBjb3Jlc2lnaHRfcG11X2NwdWhwX3N0YXRlID0gcmV0Ow0K PiA+ICsgICAgIHJldHVybiBwbGF0Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJmNvcmVzaWdodF9wbXVf ZHJpdmVyKTsNCj4gPiArfQ0KPiA+ICsNCj4gPiArc3RhdGljIHZvaWQgX19leGl0IGNvcmVzaWdo dF9wbXVfZXhpdCh2b2lkKQ0KPiA+ICt7DQo+ID4gKyAgICAgcGxhdGZvcm1fZHJpdmVyX3VucmVn aXN0ZXIoJmNvcmVzaWdodF9wbXVfZHJpdmVyKTsNCj4gPiArICAgICBjcHVocF9yZW1vdmVfbXVs dGlfc3RhdGUoY29yZXNpZ2h0X3BtdV9jcHVocF9zdGF0ZSk7DQo+ID4gK30NCj4gPiArDQo+ID4g K21vZHVsZV9pbml0KGNvcmVzaWdodF9wbXVfaW5pdCk7DQo+ID4gK21vZHVsZV9leGl0KGNvcmVz aWdodF9wbXVfZXhpdCk7DQo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGVyZi9jb3Jlc2lnaHRf cG11L2FybV9jb3Jlc2lnaHRfcG11LmgNCj4gYi9kcml2ZXJzL3BlcmYvY29yZXNpZ2h0X3BtdS9h cm1fY29yZXNpZ2h0X3BtdS5oDQo+ID4gbmV3IGZpbGUgbW9kZSAxMDA2NDQNCj4gPiBpbmRleCAw MDAwMDAwMDAwMDAuLjU5ZmI0MGVhZmU0NQ0KPiA+IC0tLSAvZGV2L251bGwNCj4gPiArKysgYi9k cml2ZXJzL3BlcmYvY29yZXNpZ2h0X3BtdS9hcm1fY29yZXNpZ2h0X3BtdS5oDQo+ID4gQEAgLTAs MCArMSwxNDcgQEANCj4gPiArLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjANCj4g PiArICoNCj4gPiArICogQVJNIENvcmVTaWdodCBQTVUgZHJpdmVyLg0KPiA+ICsgKiBDb3B5cmln aHQgKGMpIDIwMjIsIE5WSURJQSBDT1JQT1JBVElPTiAmIEFGRklMSUFURVMuDQo+ID4gKyAqDQo+ ID4gKyAqLw0KPiA+ICsNCj4gPiArI2lmbmRlZiBfX0FSTV9DT1JFU0lHSFRfUE1VX0hfXw0KPiA+ ICsjZGVmaW5lIF9fQVJNX0NPUkVTSUdIVF9QTVVfSF9fDQo+ID4gKw0KPiA+ICsjaW5jbHVkZSA8 bGludXgvYWNwaS5oPg0KPiA+ICsjaW5jbHVkZSA8bGludXgvYml0ZmllbGQuaD4NCj4gPiArI2lu Y2x1ZGUgPGxpbnV4L2NwdW1hc2suaD4NCj4gPiArI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPg0K PiA+ICsjaW5jbHVkZSA8bGludXgva2VybmVsLmg+DQo+ID4gKyNpbmNsdWRlIDxsaW51eC9tb2R1 bGUuaD4NCj4gPiArI2luY2x1ZGUgPGxpbnV4L3BlcmZfZXZlbnQuaD4NCj4gPiArI2luY2x1ZGUg PGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPg0KPiA+ICsjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4N Cj4gPiArDQo+ID4gKyNkZWZpbmUgdG9fY29yZXNpZ2h0X3BtdShwKSAoY29udGFpbmVyX29mKHAs IHN0cnVjdCBjb3Jlc2lnaHRfcG11LA0KPiBwbXUpKQ0KPiA+ICsNCj4gPiArI2RlZmluZSBDT1JF U0lHSFRfRVhUX0FUVFIoX25hbWUsIF9mdW5jLCBfY29uZmlnKSAgICAgICAgICAgICAgICAgICAg XA0KPiA+ICsgICAgICgmKChzdHJ1Y3QgZGV2X2V4dF9hdHRyaWJ1dGVbXSl7ICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBcDQo+ID4gKyAgICAgICAgICAgICB7ICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwNCj4gPiArICAgICAgICAg ICAgICAgICAgICAgLmF0dHIgPSBfX0FUVFIoX25hbWUsIDA0NDQsIF9mdW5jLCBOVUxMKSwgICAg ICAgXA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAudmFyID0gKHZvaWQgKilfY29uZmlnICAg ICAgICAgICAgICAgICAgICAgICAgICBcDQo+ID4gKyAgICAgICAgICAgICB9ICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwNCj4gPiArICAgICB9 KVswXS5hdHRyLmF0dHIpDQo+ID4gKw0KPiA+ICsjZGVmaW5lIENPUkVTSUdIVF9GT1JNQVRfQVRU UihfbmFtZSwgX2NvbmZpZykgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwNCj4gPiAr ICAgICBDT1JFU0lHSFRfRVhUX0FUVFIoX25hbWUsIGNvcmVzaWdodF9wbXVfc3lzZnNfZm9ybWF0 X3Nob3csDQo+IFwNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgKGNoYXIgKilfY29uZmln KQ0KPiA+ICsNCj4gPiArI2RlZmluZSBDT1JFU0lHSFRfRVZFTlRfQVRUUihfbmFtZSwgX2NvbmZp ZykgICAgICAgICAgICAgICAgICAgICAgICAgXA0KPiA+ICsgICAgIFBNVV9FVkVOVF9BVFRSX0lE KF9uYW1lLCBjb3Jlc2lnaHRfcG11X3N5c2ZzX2V2ZW50X3Nob3csDQo+IF9jb25maWcpDQo+ID4g Kw0KPiA+ICsvKioNCj4gPiArICogVGhpcyBpcyB0aGUgZGVmYXVsdCBldmVudCBudW1iZXIgZm9y IGN5Y2xlIGNvdW50LCBpZiBzdXBwb3J0ZWQsIHNpbmNlIHRoZQ0KPiA+ICsgKiBBUk0gQ29yZXNp Z2h0IFBNVSBzcGVjaWZpY2F0aW9uIGRvZXMgbm90IGRlZmluZSBhIHN0YW5kYXJkIGV2ZW50DQo+ IGNvZGUNCj4gPiArICogZm9yIGN5Y2xlIGNvdW50Lg0KPiA+ICsgKi8NCj4gPiArI2RlZmluZSBD T1JFU0lHSFRfUE1VX0VWVF9DWUNMRVNfREVGQVVMVCAoMHgxVUxMIDw8IDMxKQ0KPiANCj4gQW5k IHdoYXQgZG8gd2UgZG8gd2hlbiBhbiBpbXBsZW1lbnRhdGlvbiBkZWZpbmVzIDB4ODAwMDAwMDAg YXMgb25lIG9mDQo+IGl0cyBvd24gZXZlbnQgc3BlY2lmaWVycz8gVGhlIHN0YW5kYXJkIGN5Y2xl IGNvdW50IGlzIGluZGVwZW5kZW50IG9mIGFueQ0KPiBvdGhlciBldmVudHMsIHNvIGl0IG5lZWRz IHRvIGJlIGVuY29kZWQgaW4gYSBtYW5uZXIgd2hpY2ggaXMgZGlzdGluY3QNCj4gZnJvbSAqYW55 KiBwb3RlbnRpYWxseS12YWxpZCBQTUVWVFlQRVIgdmFsdWUuDQoNCldlIHdlcmUgdGhpbmtpbmcg dGhhdCBpbiBzdWNoIGNhc2UsIHRoZSBpbXBsZW1lbnRvciB3b3VsZCBwcm92aWRlIGNvcmVzaWdo dF9wbXVfaW1wbF9vcHMuDQpUbyBhdm9pZCBpdCwgSSBndWVzcyB3ZSBjYW4gdXNlIGNvbmZpZ1sz Ml0gZm9yIHRoZSBkZWZhdWx0IGN5Y2xlIGNvdW50IGV2ZW50IGlkLg0KVGhlIGZpbHRlciB2YWx1 ZSB3aWxsIG5lZWQgdG8gYmUgbW92ZWQgdG8gY29uZmlnMVszMTowXS4NCkRvZXMgaXQgc291bmQg cmVhc29uYWJsZSA/DQoNCj4gDQo+ID4gKw0KPiA+ICsvKioNCj4gPiArICogVGhlIEFSTSBDb3Jl c2lnaHQgUE1VIHN1cHBvcnRzIHVwIHRvIDI1NiBldmVudCBjb3VudGVycy4NCj4gPiArICogSWYg dGhlIGNvdW50ZXJzIGFyZSBsYXJnZXItdGhhbiAzMi1iaXRzLCB0aGVuIHRoZSBQTVUgaW5jbHVk ZXMgYXQNCj4gPiArICogbW9zdCAxMjggY291bnRlcnMuDQo+ID4gKyAqLw0KPiA+ICsjZGVmaW5l IENPUkVTSUdIVF9QTVVfTUFYX0hXX0NOVFJTIDI1Ng0KPiA+ICsNCj4gPiArLyogVGhlIGN5Y2xl IGNvdW50ZXIsIGlmIGltcGxlbWVudGVkLCBpcyBsb2NhdGVkIGF0IGNvdW50ZXJbMzFdLiAqLw0K PiA+ICsjZGVmaW5lIENPUkVTSUdIVF9QTVVfSURYX0NDTlRSIDMxDQo+ID4gKw0KPiA+ICtzdHJ1 Y3QgY29yZXNpZ2h0X3BtdTsNCj4gPiArDQo+ID4gKy8qIFRoaXMgdHJhY2tzIHRoZSBldmVudHMg YXNzaWduZWQgdG8gZWFjaCBjb3VudGVyIGluIHRoZSBQTVUuICovDQo+ID4gK3N0cnVjdCBjb3Jl c2lnaHRfcG11X2h3X2V2ZW50cyB7DQo+ID4gKyAgICAgLyogVGhlIGV2ZW50cyB0aGF0IGFyZSBh Y3RpdmUgb24gdGhlIFBNVSBmb3IgdGhlIGdpdmVuIGluZGV4LiAqLw0KPiA+ICsgICAgIHN0cnVj dCBwZXJmX2V2ZW50ICpldmVudHNbQ09SRVNJR0hUX1BNVV9NQVhfSFdfQ05UUlNdOw0KPiANCj4g VGhpcyBpcyByZWFsbHkgcXVpdGUgYmlnIC0gMktCIHBlciBQTVUgb24gNjQtYml0IC0gZ2l2ZW4g dGhlIGxpa2VsaWhvb2QNCj4gdGhhdCB0eXBpY2FsbHkgb25seSBhIGZyYWN0aW9uIG9mIHRoYXQg bWlnaHQgYmUgbmVlZGVkLiBBcyBtZW50aW9uZWQsIGl0DQo+IHNob3VsZCBhbHJlYWR5IGJlIHRp Y2tsaW5nIENPTkZJR19GUkFNRV9XQVJOIGluDQo+IGNvcmVzaWdodF9wbXVfdmFsaWRhdGVfZ3Jv dXAoKS4NCg0KV2Ugd2lsbCByZXdvcmsgaXQuDQoNClRoYW5rcyBmb3IgYWxsIHlvdXIgY29tbWVu dHMsIFJvYmluLg0KDQpSZWdhcmRzLA0KQmVzYXINCg0KPiANCj4gVGhhbmtzLA0KPiBSb2Jpbi4N Cj4gDQo+ID4gKyAgICAgLyogRWFjaCBiaXQgaW5kaWNhdGVzIGEgY291bnRlciBpcyBiZWluZyB1 c2VkIChvciBub3QpIGZvciBhbiBldmVudC4gKi8NCj4gPiArICAgICBERUNMQVJFX0JJVE1BUCh1 c2VkX2N0cnMsIENPUkVTSUdIVF9QTVVfTUFYX0hXX0NOVFJTKTsNCj4gPiArfTsNCj4gPiArDQo+ ID4gKy8qIENvbnRhaW5zIG9wcyB0byBxdWVyeSB2ZW5kb3IvaW1wbGVtZW50ZXIgc3BlY2lmaWMg YXR0cmlidXRlLiAqLw0KPiA+ICtzdHJ1Y3QgY29yZXNpZ2h0X3BtdV9pbXBsX29wcyB7DQo+ID4g KyAgICAgLyogR2V0IGV2ZW50IGF0dHJpYnV0ZXMgKi8NCj4gPiArICAgICBzdHJ1Y3QgYXR0cmli dXRlICoqKCpnZXRfZXZlbnRfYXR0cnMpKA0KPiA+ICsgICAgICAgICAgICAgY29uc3Qgc3RydWN0 IGNvcmVzaWdodF9wbXUgKmNvcmVzaWdodF9wbXUpOw0KPiA+ICsgICAgIC8qIEdldCBmb3JtYXQg YXR0cmlidXRlcyAqLw0KPiA+ICsgICAgIHN0cnVjdCBhdHRyaWJ1dGUgKiooKmdldF9mb3JtYXRf YXR0cnMpKA0KPiA+ICsgICAgICAgICAgICAgY29uc3Qgc3RydWN0IGNvcmVzaWdodF9wbXUgKmNv cmVzaWdodF9wbXUpOw0KPiA+ICsgICAgIC8qIEdldCBzdHJpbmcgaWRlbnRpZmllciAqLw0KPiA+ ICsgICAgIGNvbnN0IGNoYXIgKigqZ2V0X2lkZW50aWZpZXIpKGNvbnN0IHN0cnVjdCBjb3Jlc2ln aHRfcG11DQo+ICpjb3Jlc2lnaHRfcG11KTsNCj4gPiArICAgICAvKiBDaGVjayBpZiB0aGUgZXZl bnQgY29ycmVzcG9uZHMgdG8gY3ljbGUgY291bnQgZXZlbnQgKi8NCj4gPiArICAgICBib29sICgq aXNfY2NfZXZlbnQpKGNvbnN0IHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCk7DQo+ID4gKyAgICAg LyogRGVjb2RlIGV2ZW50IHR5cGUvaWQgZnJvbSBjb25maWdzICovDQo+ID4gKyAgICAgdTMyICgq ZXZlbnRfdHlwZSkoY29uc3Qgc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KTsNCj4gPiArICAgICAv KiBEZWNvZGUgZmlsdGVyIHZhbHVlIGZyb20gY29uZmlncyAqLw0KPiA+ICsgICAgIHUzMiAoKmV2 ZW50X2ZpbHRlcikoY29uc3Qgc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KTsNCj4gPiArfTsNCj4g PiArDQo+ID4gKy8qIFZlbmRvci9pbXBsZW1lbnRlciBkZXNjcmlwdG9yLiAqLw0KPiA+ICtzdHJ1 Y3QgY29yZXNpZ2h0X3BtdV9pbXBsIHsNCj4gPiArICAgICB1MzIgcG1paWRyOw0KPiA+ICsgICAg IGNvbnN0IHN0cnVjdCBjb3Jlc2lnaHRfcG11X2ltcGxfb3BzICpvcHM7DQo+ID4gK307DQo+ID4g Kw0KPiA+ICsvKiBDb3Jlc2lnaHQgUE1VIGRlc2NyaXB0b3IuICovDQo+ID4gK3N0cnVjdCBjb3Jl c2lnaHRfcG11IHsNCj4gPiArICAgICBzdHJ1Y3QgcG11IHBtdTsNCj4gPiArICAgICBzdHJ1Y3Qg ZGV2aWNlICpkZXY7DQo+ID4gKyAgICAgc3RydWN0IGFjcGlfYXBtdF9ub2RlICphcG10X25vZGU7 DQo+ID4gKyAgICAgY29uc3QgY2hhciAqbmFtZTsNCj4gPiArICAgICBjb25zdCBjaGFyICppZGVu dGlmaWVyOw0KPiA+ICsgICAgIHZvaWQgX19pb21lbSAqYmFzZTA7DQo+ID4gKyAgICAgdm9pZCBf X2lvbWVtICpiYXNlMTsNCj4gPiArICAgICBpbnQgaXJxOw0KPiA+ICsgICAgIGNwdW1hc2tfdCBh c3NvY2lhdGVkX2NwdXM7DQo+ID4gKyAgICAgY3B1bWFza190IGFjdGl2ZV9jcHU7DQo+ID4gKyAg ICAgc3RydWN0IGhsaXN0X25vZGUgY3B1aHBfbm9kZTsNCj4gPiArDQo+ID4gKyAgICAgdTMyIHBt Y2ZncjsNCj4gPiArICAgICB1MzIgbnVtX2Fkal9jb3VudGVyczsNCj4gPiArICAgICB1MzIgbnVt X3NldF9jbHJfcmVnOw0KPiA+ICsNCj4gPiArICAgICBzdHJ1Y3QgY29yZXNpZ2h0X3BtdV9od19l dmVudHMgaHdfZXZlbnRzOw0KPiA+ICsNCj4gPiArICAgICB2b2lkICgqd3JpdGVfcmVnNjQpKHU2 NCB2YWwsIHZvaWQgX19pb21lbSAqYmFzZSwgdTMyIG9mZnNldCk7DQo+ID4gKyAgICAgdTY0ICgq cmVhZF9yZWc2NCkodm9pZCBfX2lvbWVtICpiYXNlLCB1MzIgb2Zmc2V0KTsNCj4gPiArDQo+ID4g KyAgICAgc3RydWN0IGNvcmVzaWdodF9wbXVfaW1wbCBpbXBsOw0KPiA+ICt9Ow0KPiA+ICsNCj4g PiArLyogRGVmYXVsdCBmdW5jdGlvbiB0byBzaG93IGV2ZW50IGF0dHJpYnV0ZSBpbiBzeXNmcy4g Ki8NCj4gPiArc3NpemVfdCBjb3Jlc2lnaHRfcG11X3N5c2ZzX2V2ZW50X3Nob3coc3RydWN0IGRl dmljZSAqZGV2LA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1 Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwNCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgY2hhciAqYnVmKTsNCj4gPiArDQo+ID4gKy8qIERlZmF1bHQgZnVuY3Rpb24g dG8gc2hvdyBmb3JtYXQgYXR0cmlidXRlIGluIHN5c2ZzLiAqLw0KPiA+ICtzc2l6ZV90IGNvcmVz aWdodF9wbXVfc3lzZnNfZm9ybWF0X3Nob3coc3RydWN0IGRldmljZSAqZGV2LA0KPiA+ICsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUg KmF0dHIsDQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjaGFyICpi dWYpOw0KPiA+ICsNCj4gPiArLyogR2V0IHRoZSBkZWZhdWx0IENvcmVzaWdodCBQTVUgZXZlbnQg YXR0cmlidXRlcy4gKi8NCj4gPiArc3RydWN0IGF0dHJpYnV0ZSAqKg0KPiA+ICtjb3Jlc2lnaHRf cG11X2dldF9ldmVudF9hdHRycyhjb25zdCBzdHJ1Y3QgY29yZXNpZ2h0X3BtdQ0KPiAqY29yZXNp Z2h0X3BtdSk7DQo+ID4gKw0KPiA+ICsvKiBHZXQgdGhlIGRlZmF1bHQgQ29yZXNpZ2h0IFBNVSBm b3JtYXQgYXR0cmlidXRlcy4gKi8NCj4gPiArc3RydWN0IGF0dHJpYnV0ZSAqKg0KPiA+ICtjb3Jl c2lnaHRfcG11X2dldF9mb3JtYXRfYXR0cnMoY29uc3Qgc3RydWN0IGNvcmVzaWdodF9wbXUNCj4g KmNvcmVzaWdodF9wbXUpOw0KPiA+ICsNCj4gPiArLyogR2V0IHRoZSBkZWZhdWx0IENvcmVzaWdo dCBQTVUgZGV2aWNlIGlkZW50aWZpZXIuICovDQo+ID4gK2NvbnN0IGNoYXIgKg0KPiA+ICtjb3Jl c2lnaHRfcG11X2dldF9pZGVudGlmaWVyKGNvbnN0IHN0cnVjdCBjb3Jlc2lnaHRfcG11DQo+ICpj b3Jlc2lnaHRfcG11KTsNCj4gPiArDQo+ID4gKy8qIERlZmF1bHQgZnVuY3Rpb24gdG8gcXVlcnkg aWYgYW4gZXZlbnQgaXMgYSBjeWNsZSBjb3VudGVyIGV2ZW50LiAqLw0KPiA+ICtib29sIGNvcmVz aWdodF9wbXVfaXNfY2NfZXZlbnQoY29uc3Qgc3RydWN0IHBlcmZfZXZlbnQgKmV2ZW50KTsNCj4g PiArDQo+ID4gKy8qIERlZmF1bHQgZnVuY3Rpb24gdG8gcXVlcnkgdGhlIHR5cGUvaWQgb2YgYW4g ZXZlbnQuICovDQo+ID4gK3UzMiBjb3Jlc2lnaHRfcG11X2V2ZW50X3R5cGUoY29uc3Qgc3RydWN0 IHBlcmZfZXZlbnQgKmV2ZW50KTsNCj4gPiArDQo+ID4gKy8qIERlZmF1bHQgZnVuY3Rpb24gdG8g cXVlcnkgdGhlIGZpbHRlciB2YWx1ZSBvZiBhbiBldmVudC4gKi8NCj4gPiArdTMyIGNvcmVzaWdo dF9wbXVfZXZlbnRfZmlsdGVyKGNvbnN0IHN0cnVjdCBwZXJmX2V2ZW50ICpldmVudCk7DQo+ID4g Kw0KPiA+ICsjZW5kaWYgLyogX19BUk1fQ09SRVNJR0hUX1BNVV9IX18gKi8NCg== 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 3BE0EC433EF for ; Wed, 11 May 2022 02:48:39 +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:In-Reply-To:References: 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=OeViyNvnfd1fZLuLLcukx7K/Qw2qgdP6uL0mi0kaLQ4=; b=Bndj8sj/eBzxi5 D9CkDrcTBIToP6/8qJWAW+VrbWk/qCe+Q/piRvmxg39x60loUZI8YI/ZtT1n4nigO3VEjDvyZPcD5 OZpX5ZTA9w/5xn+AAHt51GKksGB/wIFZZi3s9Dfr7ytONylA6+y1JXRwgBT8498MluQkspW/XxoXJ b5TBEK5Z23dUkCcrvTSBbCj+9voJgxV4V17JM3NdbXH2VFKXurQGJZYbFzOZPcxwnaW5CIgQpFXb/ o8TGzdHgtNKO/InudjW2+dmC8DhOEzMFZzabIWS0N39GU15qI5vSE6kRv9YQRE/W5606e+BQEFYQ+ QZt7JqSh/Mjw/ZFDXZ6w==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nocNa-004rsV-NY; Wed, 11 May 2022 02:47:10 +0000 Received: from mail-bn8nam12on20619.outbound.protection.outlook.com ([2a01:111:f400:fe5b::619] helo=NAM12-BN8-obe.outbound.protection.outlook.com) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nocNM-004rhN-L2 for linux-arm-kernel@lists.infradead.org; Wed, 11 May 2022 02:47:09 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=dnAO7tM/J4O3X1Xa+flDBM74hCsqjODJlJ1vsoHNycpUbvnog7KD2M4tngyQWFyRWDPgdBg9yCVmEss3v/fdveWIy4UMxB9SfWDbZol8tRmXyt8ySiIwr9Zs41xwUVpqG+7a5MPhyAi0csr9WEtEyq6IrpWhAdtokuKYLEcsYESQCbGZzwquxHIx3IUkwzCpxhSuIzarBJ7A/pxuY//L/XupXIL/QTe9AqD6ctTwnKkryTVTqmQ7sRVQnfG6Ikt2yLlasI59Em8EjjHQpwSG3nZNhYjL75WEfoHdKC1Haz4v5eacjFggaY14X4MR2QxgCpenkZWowXhrDRc44thxIw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=dZC9+18/mhTYmhXEHnYhIPbQCGjX9oNTNd6uG3Uea9I=; b=NpHCOyqu1glfs2ONjQ6BryhuiBWlkmlfGROWt13Bn5p9vL4WRoBUE8/Z3KkMr3PmM1rhjHqa9YosKLLYoNxXjU/MpFz//Doh805Pv9OOOx/BtZxPRl5qVqS03TyNaD+23kWWYd5ZK4x85gBm/Y3ZrKFnYETyZUjRi9DxUS0yhJC9wgCFyu1AoVy3BCaVBNoGFiyuJAgisRr/gl9DAO4XQOL52NC4XxLmb7rdfSEQhqHoQOSMV/dbMVeqYxtkQph7MaDWzhoY2HJwjlumzdUXc9FzsuDK/Mi4Yf+xiTgzEreAaVp3uzuqE/eML8RaK3DORuMNw+g0SNqkLqr4It1XOg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nvidia.com; dmarc=pass action=none header.from=nvidia.com; dkim=pass header.d=nvidia.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=Nvidia.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=dZC9+18/mhTYmhXEHnYhIPbQCGjX9oNTNd6uG3Uea9I=; b=MliSI7ZY2RzTT7bgNE/wt3oBITwmxB2g6l4bF8tyvNYwv2QgjZM/UUivZBi/rnPVupcz+1W6OFCk+ounQNP+Vg7yJvPfCfH/2Gw5qk64COAtpto469BHZidr7V9QbDKKNUpk+yMWZGHQYKkSyiBdFnXOekBgGt7Xpo/JIJUYUq0x9lgh1BnEf73Vx/zCJfiXPOz/A9KluH9yUmmUjgIEpqIO55d4CYyj5w6NTFb9K5J+SkMfqzdg4Pi5HuXeFyc+hh5i1jDlm40ZSm1mddrstC7ynjZzhdt3y3e4d3CIFca6sxlCHHF8gBewb+++G8kvlJFgPpYDjGBRdWbRHsaXqw== Received: from SJ0PR12MB5676.namprd12.prod.outlook.com (2603:10b6:a03:42e::8) by MN0PR12MB6056.namprd12.prod.outlook.com (2603:10b6:208:3cc::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5227.21; Wed, 11 May 2022 02:46:45 +0000 Received: from SJ0PR12MB5676.namprd12.prod.outlook.com ([fe80::7526:b8f5:b10:1c4c]) by SJ0PR12MB5676.namprd12.prod.outlook.com ([fe80::7526:b8f5:b10:1c4c%7]) with mapi id 15.20.5227.021; Wed, 11 May 2022 02:46:44 +0000 From: Besar Wicaksono To: Robin Murphy CC: "catalin.marinas@arm.com" , "will@kernel.org" , "mark.rutland@arm.com" , "linux-arm-kernel@lists.infradead.org" , "linux-kernel@vger.kernel.org" , "linux-tegra@vger.kernel.org" , "sudeep.holla@arm.com" , "thanu.rangarajan@arm.com" , "Michael.Williams@arm.com" , "suzuki.poulose@arm.com" , Thierry Reding , Jonathan Hunter , Vikram Sethi Subject: RE: [PATCH 1/2] perf: coresight_pmu: Add support for ARM CoreSight PMU driver Thread-Topic: [PATCH 1/2] perf: coresight_pmu: Add support for ARM CoreSight PMU driver Thread-Index: AQHYYzvGd2L8FJXMJUqVqSGGzm8HA60Wdd0AgAJxVWA= Date: Wed, 11 May 2022 02:46:44 +0000 Message-ID: References: <20220509002810.12412-1-bwicaksono@nvidia.com> <20220509002810.12412-2-bwicaksono@nvidia.com> <756ac2c8-6530-03b0-53d3-ee7493509579@arm.com> In-Reply-To: <756ac2c8-6530-03b0-53d3-ee7493509579@arm.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: authentication-results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nvidia.com; x-ms-publictraffictype: Email x-ms-office365-filtering-correlation-id: 38d42aae-23f0-4370-2583-08da32f87c5d x-ms-traffictypediagnostic: MN0PR12MB6056:EE_ x-microsoft-antispam-prvs: x-ms-exchange-senderadcheck: 1 x-ms-exchange-antispam-relay: 0 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: zPI4F+bjjl5FcADYKSd8ASehsJ+kC/ZCdzrPpuRcOGKnwopsVQtlAoCYpMjPZeqLSjtyb9h2E3Lfo3kC4ePE3s1nuukcnJfyjN7x6dciswDEAdGYabteaqOZn2XlKp3iI+6/SWa5H59tyCGgn3D1+/C8BSF/gS5/JIWpPKuPS0ZTDEP9JbPwxk1C9RQK9C+GDCH4UCyI3wE+ipE/IfB03Y7+sLWMIKRfuMWWzGRibjl0EkH2Wr+ziutHc443q6mca0jVfVJoZASIv7KZxT9ywGhBtKQJpOiLohYZEn7MH1SWnnnEnfGuD6LPAZXk9VTVnwATWObvpvfXCywSqlISZGVBUwPtncfKrEKpEtFTPZbfIoqfp/mbkic6F33XyrNPnMu13TtmaZy7Vk/TZ8b/WPpqwMCvi0koYQjSGSGgT8rcrt960HlmYqy/E5RKx8e6/2rh4fZF8pviJSOPjXm5TGQVW9RodgeZJYVfvVPENLn6Oz8Enh1g9VV7D5SFjbnrPMYd2M5f2S27S9K/3HaM0YVOhpk3K9eOkmCMxeVnVaHnYH5zHQEmVs00IhjeJUiMyiw4LwRcAjsBat3KZ1e6goAb7IFmryHZ4iWSwECu/SUR6xWQDq4UqZ4Tp1iQcJyFTS4xTaiuh/DTH5oE9+wEeDTus+rbncbLIqjo3aQNHU86Y/K4fRN9Om3143pNd1y/SD4X1HEDk7S47VE2Iqh6eF6wt12YYoJm/PG1oKnyo8UkAuVH6SgU4MGztNUYjsO1tyWmo7hyVw2EiynFrcUvczob8ihVcm2GmlSiwf1IpOxCHYITebZ2jA0KTsY68pUHJtMrbABhbTZIkwoeQok0Pw== x-forefront-antispam-report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:SJ0PR12MB5676.namprd12.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230001)(4636009)(366004)(122000001)(33656002)(38100700002)(53546011)(5660300002)(6506007)(83380400001)(8936002)(52536014)(38070700005)(7416002)(107886003)(86362001)(64756008)(66446008)(55016003)(508600001)(9686003)(66946007)(30864003)(66556008)(26005)(966005)(316002)(76116006)(66476007)(8676002)(4326008)(54906003)(6916009)(71200400001)(7696005)(186003)(2906002)(559001)(579004); DIR:OUT; SFP:1101; x-ms-exchange-antispam-messagedata-chunkcount: 1 x-ms-exchange-antispam-messagedata-0: =?utf-8?B?MVNIQ2RhVVloMm4yejVDYTl1SkdibGpKaTVhYTYvejZzcVhnTmsrejB3NTRa?= =?utf-8?B?a2p4OVBtczA4Z09ZS3VQeHkrSkZFekNkbitMZDA5RFkzSGZoelQxS2RJVXNW?= =?utf-8?B?bUVsTEs4MEo2bmw1T3dpb3d5VXRjRjhkemYwQW9pS0ZhYnphRW1LWEVHamhi?= =?utf-8?B?c2k3WmpMKzhJYjRiVm9TcmRlUE53R1Q4NU9kbXlpdWQ4OVhSek1pT0h6ZjIv?= =?utf-8?B?R25wZzFhUTJaYmhpV1piWnFYT0VxZGlXQ0tvbkhjWkVEWmRzdEVIVVdESWdR?= =?utf-8?B?cURMeUNCRVFURkxSQzBhTlYycHhHMlNxT1pvT0QwdkIwUzJiVWI2UGNNOXN3?= =?utf-8?B?K1prYTFjdjU1V05ENndpejhPRWllVm8rMkJ2NTlTZ3BmT2IzWSs0dXlWNnVq?= =?utf-8?B?am80MnlpOWgyTDdvL1k3TGczK1pnVTZIQlQ1ZEUvZXl6LzRFbEJOU1BoOURW?= =?utf-8?B?b3VyK3IyREk4bWVOWmlDY0RRdjVudjdFMFdMSXNWTUhDU2ptb2ZaVE1FRk1K?= =?utf-8?B?djdIUmdqZk1sa0RqMlBRTTdRUm5CZnE1UjQ5NjBQU25YYXU2VG9zM3p4bUE0?= =?utf-8?B?SFVEckk4Q3dEbkJJa0p1RThMblhwM2Z2ekhFSkhTTnlkQUxPSG4rMnF4ekZD?= =?utf-8?B?RkNsTmtNRlQzYTdsQUhhSVVkSzY1bWNlREZ5REpOU1Jma2wzU2JYK1BPS25t?= =?utf-8?B?cDcyT043N0pDb0dLN3UxSVpJWmNNSXZiYXVTaS9lclZhRVVZNnB6QSs1eEd6?= =?utf-8?B?SjRqMjAzaTNPMS9hbEhMeWprZ0t2Uk13V0laRWMrcjd5SG5ob0cwUFlTcW4v?= =?utf-8?B?aXcwYWsydEo5WEYrUFo0K0hFMUR2S1FRbEFEVVFJUTUrVTJhMUhLODFNbFM5?= =?utf-8?B?Rk0rMmZuZWVtWm1ja1dYNGpiZVFrMHdtaVkzdGJ3LzR5NDJIL1ovYWIxRUFJ?= =?utf-8?B?bnMwNnBWN3JVcWtmMFRGMDFObjlKcHFqMjJZVld2bFpXTS9rRjBLdlo5WWll?= =?utf-8?B?cjVGTDNIUTg5bHJCTVJKWE5HRFFQWkJ3a3JiT3JhcENRQUM2MDhFUVM5SXR5?= =?utf-8?B?dWR2eWJoU2VTVmkwQTNRSU00TmZiemNib3dLRTNlWWY1NnI0YWZIUUFzZTBQ?= =?utf-8?B?QkV1ekpVNWVKcElxczJXd2xINEM5N1BDMjVOOThoNy9TV3VMdUZGWC9LRkV5?= =?utf-8?B?NVRRNXg1ajJjRFJHYXZqbTdZcDMvMTdnMnRyWFVEVUx2NHRFRUZCTWN6U0ds?= =?utf-8?B?M3ZpMlBIMlZxdUJZMmZRdW5Bakk5WGlqcFkyaDlNZndlSkhUTEg1WTAxdk0y?= =?utf-8?B?S1RLKzZrOTZCQW9jaWdpMGZxM3lOYnlDODRFN21lUlJLcitzNWxlelBhUUVR?= =?utf-8?B?Z1ZqU3YzTE82T3RGazdOSHZNdktkM0FNNzNsNmxtVml6cjlVNFlKNm54a3VC?= =?utf-8?B?eSt0RTkwQUxFSDZJYXkyend3ZTgwWnZHa0E3a3NsZjBhb0FicTU2cEJVaHpn?= =?utf-8?B?UEpZVmxxeXJ4RTFjcnc0Ky8xNHNaVW1zWGNKWUswQk13ZE9MRHEwdzVpYjkr?= =?utf-8?B?eG10dUw5eWxhYk9HTWgrbDhIenRmb2ptVEkvNWY1QkJ3b251SVNLTkR1Y0U2?= =?utf-8?B?dTI1aGJzVDBQaXUweWZYeHkxT3RKSTIwRndTTHF2QlFQQ1p4WkR5dXhvdlcr?= =?utf-8?B?UTZQbEZPT0JjMGR3WnZIKzcxUVlmYkQ4eXFmRkM0cTloN0lLWDBqOGs2WmdZ?= =?utf-8?B?b2toci9jN1hmQjZJU3JpNGRWTkdoY2ZxVHMrdFVDa1hLYzRKUXFvYW5CTmI2?= =?utf-8?B?Ni9Ca2Z2ejdtMTQyMTJKR01Xa1IvMXdFaGIrMCtjd3ZZTWhSQlpMcmx3cnhp?= =?utf-8?B?eTM1ZmEzZ0hkK0pWbkorWFNYRVdUS1RvazFXSlA3OERRWXUvOC9JaHI1alhs?= =?utf-8?B?L25ydEEyK1BiaTduYmsxNXh4NzlkdUpwWGVIQllsZm16cDNXZ2FMNG1nNTFz?= =?utf-8?B?VGZocjcxNzVoei91R0NkTHJDNlljby9NMkR2ankzT1BsSER2OS84LzJ3MjMz?= =?utf-8?B?WjlWSG1CdDFVYUFnQXFmWG03UEtrVGh3RGszYmVVM20xME8xSXF3dWxMSTZ0?= =?utf-8?B?Z0ZtMTlkQWlkSGdnL25ac0QxV2dFWWE3VVIzM3dwMi9ySE9DbzZ3d0tlSlZi?= =?utf-8?B?SzBhZ09HTm5tY0NEZ3ZidFYvWGlna3RKYjRXc2Q4VUN2czdWcUdKOTV1VDZ5?= =?utf-8?B?UkJYbnZVTyttbndyZXFaR0hEQm9ETVhncmhSaVVvc2o1dTY5YWpYa1poK2s3?= =?utf-8?B?dnBxUk1yajVMN2U4S0FQZkJNdC8wRkt3N0c3SEgvUllSaUsrMGEwZz09?= MIME-Version: 1.0 X-OriginatorOrg: Nvidia.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-AuthSource: SJ0PR12MB5676.namprd12.prod.outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 38d42aae-23f0-4370-2583-08da32f87c5d X-MS-Exchange-CrossTenant-originalarrivaltime: 11 May 2022 02:46:44.5635 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: 43083d15-7273-40c1-b7db-39efd9ccc17a X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: 9bihzWQcK5mC9vnWr8dPRnJCsbl4sGB0p3rY2nqlx1cS/rSU4M68Yum3X9Jh+hX5WzMXnKmaCSqxa+IecUYC+w== X-MS-Exchange-Transport-CrossTenantHeadersStamped: MN0PR12MB6056 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220510_194659_107487_AC4B92B5 X-CRM114-Status: GOOD ( 24.25 ) 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="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org > -----Original Message----- > From: Robin Murphy > Sent: Monday, May 9, 2022 7:13 AM > To: Besar Wicaksono ; catalin.marinas@arm.com; > will@kernel.org; mark.rutland@arm.com > Cc: linux-arm-kernel@lists.infradead.org; linux-kernel@vger.kernel.org; > linux-tegra@vger.kernel.org; sudeep.holla@arm.com; > thanu.rangarajan@arm.com; Michael.Williams@arm.com; > suzuki.poulose@arm.com; Thierry Reding ; Jonathan > Hunter ; Vikram Sethi > Subject: Re: [PATCH 1/2] perf: coresight_pmu: Add support for ARM > CoreSight PMU driver > > External email: Use caution opening links or attachments > > > On 2022-05-09 01:28, Besar Wicaksono wrote: > > Add support for ARM CoreSight PMU driver framework and interfaces. > > The driver provides generic implementation to operate uncore PMU based > > on ARM CoreSight PMU architecture. The driver also provides interface > > to get vendor/implementation specific information, for example event > > attributes and formating. > > > > The specification used in this implementation can be found below: > > * ACPI Arm Performance Monitoring Unit table: > > https://developer.arm.com/documentation/den0117/latest > > * ARM Coresight PMU architecture: > > https://developer.arm.com/documentation/ihi0091/latest > > > > Signed-off-by: Besar Wicaksono > > --- > > arch/arm64/configs/defconfig | 1 + > > drivers/perf/Kconfig | 2 + > > drivers/perf/Makefile | 1 + > > drivers/perf/coresight_pmu/Kconfig | 10 + > > drivers/perf/coresight_pmu/Makefile | 6 + > > .../perf/coresight_pmu/arm_coresight_pmu.c | 1315 > +++++++++++++++++ > > .../perf/coresight_pmu/arm_coresight_pmu.h | 147 ++ > > 7 files changed, 1482 insertions(+) > > create mode 100644 drivers/perf/coresight_pmu/Kconfig > > create mode 100644 drivers/perf/coresight_pmu/Makefile > > create mode 100644 drivers/perf/coresight_pmu/arm_coresight_pmu.c > > create mode 100644 drivers/perf/coresight_pmu/arm_coresight_pmu.h > > > > diff --git a/arch/arm64/configs/defconfig b/arch/arm64/configs/defconfig > > index 2ca8b1b336d2..8f2120182b25 100644 > > --- a/arch/arm64/configs/defconfig > > +++ b/arch/arm64/configs/defconfig > > @@ -1196,6 +1196,7 @@ CONFIG_PHY_UNIPHIER_USB3=y > > CONFIG_PHY_TEGRA_XUSB=y > > CONFIG_PHY_AM654_SERDES=m > > CONFIG_PHY_J721E_WIZ=m > > +CONFIG_ARM_CORESIGHT_PMU=y > > CONFIG_ARM_SMMU_V3_PMU=m > > CONFIG_FSL_IMX8_DDR_PMU=m > > CONFIG_QCOM_L2_PMU=y > > diff --git a/drivers/perf/Kconfig b/drivers/perf/Kconfig > > index 1e2d69453771..c4e7cd5b4162 100644 > > --- a/drivers/perf/Kconfig > > +++ b/drivers/perf/Kconfig > > @@ -192,4 +192,6 @@ config MARVELL_CN10K_DDR_PMU > > Enable perf support for Marvell DDR Performance monitoring > > event on CN10K platform. > > > > +source "drivers/perf/coresight_pmu/Kconfig" > > + > > endmenu > > diff --git a/drivers/perf/Makefile b/drivers/perf/Makefile > > index 57a279c61df5..4126a04b5583 100644 > > --- a/drivers/perf/Makefile > > +++ b/drivers/perf/Makefile > > @@ -20,3 +20,4 @@ obj-$(CONFIG_ARM_DMC620_PMU) += > arm_dmc620_pmu.o > > obj-$(CONFIG_MARVELL_CN10K_TAD_PMU) += > marvell_cn10k_tad_pmu.o > > obj-$(CONFIG_MARVELL_CN10K_DDR_PMU) += > marvell_cn10k_ddr_pmu.o > > obj-$(CONFIG_APPLE_M1_CPU_PMU) += apple_m1_cpu_pmu.o > > +obj-$(CONFIG_ARM_CORESIGHT_PMU) += coresight_pmu/ > > diff --git a/drivers/perf/coresight_pmu/Kconfig > b/drivers/perf/coresight_pmu/Kconfig > > new file mode 100644 > > index 000000000000..487dfee71ad1 > > --- /dev/null > > +++ b/drivers/perf/coresight_pmu/Kconfig > > @@ -0,0 +1,10 @@ > > +# SPDX-License-Identifier: GPL-2.0 > > +# > > +# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. > > + > > +config ARM_CORESIGHT_PMU > > + tristate "ARM Coresight PMU" > > + depends on ARM64 && ACPI_APMT > > There shouldn't be any functional dependency on any CPU architecture here. The spec is targeted towards ARM based system, shouldn't we explicitly limit it to ARM? > > > + help > > + Provides support for Performance Monitoring Unit (PMU) events > based on > > + ARM CoreSight PMU architecture. > > \ No newline at end of file > > diff --git a/drivers/perf/coresight_pmu/Makefile > b/drivers/perf/coresight_pmu/Makefile > > new file mode 100644 > > index 000000000000..a2a7a5fbbc16 > > --- /dev/null > > +++ b/drivers/perf/coresight_pmu/Makefile > > @@ -0,0 +1,6 @@ > > +# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. > > +# > > +# SPDX-License-Identifier: GPL-2.0 > > + > > +obj-$(CONFIG_ARM_CORESIGHT_PMU) += \ > > + arm_coresight_pmu.o > > diff --git a/drivers/perf/coresight_pmu/arm_coresight_pmu.c > b/drivers/perf/coresight_pmu/arm_coresight_pmu.c > > new file mode 100644 > > index 000000000000..1e9553d29717 > > --- /dev/null > > +++ b/drivers/perf/coresight_pmu/arm_coresight_pmu.c > > @@ -0,0 +1,1315 @@ > > +// SPDX-License-Identifier: GPL-2.0 > > +/* > > + * ARM CoreSight PMU driver. > > + * > > + * This driver adds support for uncore PMU based on ARM CoreSight > Performance > > + * Monitoring Unit Architecture. The PMU is accessible via MMIO registers > and > > + * like other uncore PMUs, it does not support process specific events and > > + * cannot be used in sampling mode. > > + * > > + * This code is based on other uncore PMUs like ARM DSU PMU. It > provides a > > + * generic implementation to operate the PMU according to CoreSight > PMU > > + * architecture and ACPI ARM PMU table (APMT) documents below: > > + * - ARM CoreSight PMU architecture document number: ARM IHI 0091 > A.a-00bet0. > > + * - APMT document number: ARM DEN0117. > > + * The description of the PMU, like the PMU device identification, > available > > + * events, and configuration options, is vendor specific. The driver > provides > > + * interface for vendor specific code to get this information. This allows > the > > + * driver to be shared with PMU from different vendors. > > + * > > + * CoreSight PMU devices are named as arm_coresight_pmu > where > > + * is APMT node id. The description of the device, like the identifier, > > + * supported events, and formats can be found in sysfs > > + * /sys/bus/event_source/devices/arm_coresight_pmu > > + * > > + * The user should refer to the vendor technical documentation to get > details > > + * about the supported events. > > + * > > + * Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. > > + * > > + */ > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +#include "arm_coresight_pmu.h" > > + > > +#define PMUNAME "arm_coresight_pmu" > > + > > +#define CORESIGHT_CPUMASK_ATTR(_name, _config) \ > > + CORESIGHT_EXT_ATTR(_name, coresight_pmu_cpumask_show, \ > > + (unsigned long)_config) > > + > > +/** > > + * Register offsets based on CoreSight Performance Monitoring Unit > Architecture > > + * Document number: ARM-ECM-0640169 00alp6 > > + */ > > +#define PMEVCNTR_LO 0x0 > > +#define PMEVCNTR_HI 0x4 > > +#define PMEVTYPER 0x400 > > +#define PMCCFILTR 0x47C > > +#define PMEVFILTR 0xA00 > > +#define PMCNTENSET 0xC00 > > +#define PMCNTENCLR 0xC20 > > +#define PMINTENSET 0xC40 > > +#define PMINTENCLR 0xC60 > > +#define PMOVSCLR 0xC80 > > +#define PMOVSSET 0xCC0 > > +#define PMCFGR 0xE00 > > +#define PMCR 0xE04 > > +#define PMIIDR 0xE08 > > + > > +/* PMCFGR register field */ > > +#define PMCFGR_NCG_SHIFT 28 > > +#define PMCFGR_NCG_MASK 0xf > > +#define PMCFGR_HDBG BIT(24) > > +#define PMCFGR_TRO BIT(23) > > +#define PMCFGR_SS BIT(22) > > +#define PMCFGR_FZO BIT(21) > > +#define PMCFGR_MSI BIT(20) > > +#define PMCFGR_UEN BIT(19) > > +#define PMCFGR_NA BIT(17) > > +#define PMCFGR_EX BIT(16) > > +#define PMCFGR_CCD BIT(15) > > +#define PMCFGR_CC BIT(14) > > +#define PMCFGR_SIZE_SHIFT 8 > > +#define PMCFGR_SIZE_MASK 0x3f > > +#define PMCFGR_N_SHIFT 0 > > +#define PMCFGR_N_MASK 0xff > > + > > +/* PMCR register field */ > > +#define PMCR_TRO BIT(11) > > +#define PMCR_HDBG BIT(10) > > +#define PMCR_FZO BIT(9) > > +#define PMCR_NA BIT(8) > > +#define PMCR_DP BIT(5) > > +#define PMCR_X BIT(4) > > +#define PMCR_D BIT(3) > > +#define PMCR_C BIT(2) > > +#define PMCR_P BIT(1) > > +#define PMCR_E BIT(0) > > + > > +/* PMIIDR register field */ > > +#define PMIIDR_IMPLEMENTER_MASK 0xFFF > > +#define PMIIDR_PRODUCTID_MASK 0xFFF > > +#define PMIIDR_PRODUCTID_SHIFT 20 > > + > > +/* Each SET/CLR register supports up to 32 counters. */ > > +#define CORESIGHT_SET_CLR_REG_COUNTER_NUM 32 > > +#define CORESIGHT_SET_CLR_REG_COUNTER_SHIFT 5 > > + > > +/* The number of 32-bit SET/CLR register that can be supported. */ > > +#define CORESIGHT_SET_CLR_REG_MAX_NUM ((PMCNTENCLR - > PMCNTENSET) / sizeof(u32)) > > + > > +static_assert((CORESIGHT_SET_CLR_REG_MAX_NUM * > > + CORESIGHT_SET_CLR_REG_COUNTER_NUM) >= > > + CORESIGHT_PMU_MAX_HW_CNTRS); > > + > > +/* Convert counter idx into SET/CLR register number. */ > > +#define CORESIGHT_IDX_TO_SET_CLR_REG_ID(idx) \ > > + (idx >> CORESIGHT_SET_CLR_REG_COUNTER_SHIFT) > > + > > +/* Convert counter idx into SET/CLR register bit. */ > > +#define CORESIGHT_IDX_TO_SET_CLR_REG_BIT(idx) \ > > + (idx & (CORESIGHT_SET_CLR_REG_COUNTER_NUM - 1)) > > + > > +#define CORESIGHT_ACTIVE_CPU_MASK 0x0 > > +#define CORESIGHT_ASSOCIATED_CPU_MASK 0x1 > > + > > +#define CORESIGHT_EVENT_MASK 0xFFFFFFFFULL > > +#define CORESIGHT_FILTER_MASK 0xFFFFFFFFULL > > +#define CORESIGHT_FILTER_SHIFT 32ULL > > + > > +/* Check if field f in flags is set with value v */ > > +#define CHECK_APMT_FLAG(flags, f, v) \ > > + ((flags & (ACPI_APMT_FLAGS_ ## f)) == (ACPI_APMT_FLAGS_ ## f ## > _ ## v)) > > + > > +static unsigned long coresight_pmu_cpuhp_state; > > + > > +/* > > + * In CoreSight PMU architecture, all of the MMIO registers are 32-bit > except > > + * counter register. The counter register can be implemented as 32-bit or > 64-bit > > + * register depending on the value of PMCFGR.SIZE field. For 64-bit > access, > > + * single-copy 64-bit atomic support is implementation defined. APMT > node flag > > + * is used to identify if the PMU supports 64-bit single copy atomic. If 64- > bit > > + * single copy atomic is not supported, the driver treats the register as a > pair > > + * of 32-bit register. > > + */ > > + > > +/* > > + * Read 32-bit register. > > + * > > + * @base : base address of page-0 or page-1 if dual-page ext. is enabled. > > + * @offset : register offset. > > + * > > + * @return 32-bit value of the register. > > + */ > > +static inline u32 read_reg32(void __iomem *base, u32 offset) > > +{ > > + return readl(base + offset); > > +} > > read_reg32(x, y); > readl(x + y); > > These kind of wrappers are just about reasonable when they encapsulate a > structure dereference or some computation to transform the offset, but > having 13 extra lines plus 4 extra characters per callsite purely to > obfuscate an addition seems objectively worse than not doing that. Sure, we will replace these calls. > > > + > > +/* > > + * Read 64-bit register using single 64-bit atomic copy. > > + * > > + * @base : base address of page-0 or page-1 if dual-page ext. is enabled. > > + * @offset : register offset. > > + * > > + * @return 64-bit value of the register. > > + */ > > +static u64 read_reg64(void __iomem *base, u32 offset) > > +{ > > + return readq(base + offset); > > +} > > + > > +/* > > + * Read 64-bit register as a pair of 32-bit registers using hi-lo-hi sequence. > > + * > > + * @base : base address of page-0 or page-1 if dual-page ext. is enabled. > > + * @offset : register offset. > > + * > > + * @return 64-bit value of the register pair. > > + */ > > +static u64 read_reg64_hilohi(void __iomem *base, u32 offset) > > +{ > > + u32 val_lo, val_hi; > > + u64 val; > > + > > + /* Use high-low-high sequence to avoid tearing */ > > + do { > > + val_hi = read_reg32(base, offset + 4); > > + val_lo = read_reg32(base, offset); > > + } while (val_hi != read_reg32(base, offset + 4)); > > + > > + val = (((u64)val_hi << 32) | val_lo); > > + > > + return val; > > +} > > + > > +/* > > + * Write to 32-bit register. > > + * > > + * @val : 32-bit value to write. > > + * @base : base address of page-0 or page-1 if dual-page ext. is enabled. > > + * @offset : register offset. > > + * > > + */ > > +static inline void write_reg32(u32 val, void __iomem *base, u32 offset) > > +{ > > + writel(val, base + offset); > > +} > > + > > +/* > > + * Write to 64-bit register using single 64-bit atomic copy. > > + * > > + * @val : 64-bit value to write. > > + * @base : base address of page-0 or page-1 if dual-page ext. is enabled. > > + * @offset : register offset. > > + * > > + */ > > +static void write_reg64(u64 val, void __iomem *base, u32 offset) > > +{ > > + writeq(val, base + offset); > > +} > > + > > +/* > > + * Write to 64-bit register as a pair of 32-bit registers. > > + * > > + * @val : 64-bit value to write. > > + * @base : base address of page-0 or page-1 if dual-page ext. is enabled. > > + * @offset : register offset. > > + * > > + */ > > +static void write_reg64_lohi(u64 val, void __iomem *base, u32 offset) > > +{ > > + u32 val_lo, val_hi; > > + > > + val_hi = upper_32_bits(val); > > + val_lo = lower_32_bits(val); > > + > > + write_reg32(val_lo, base, offset); > > + write_reg32(val_hi, base, offset + 4); > > +} > > #include Thanks for pointing this out. We will replace it with lo_hi_writeq. > > > + > > +/* Check if cycle counter is supported. */ > > +static inline bool support_cc(const struct coresight_pmu *coresight_pmu) > > +{ > > + return (coresight_pmu->pmcfgr & PMCFGR_CC); > > +} > > + > > +/* Get counter size. */ > > +static inline u32 pmcfgr_size(const struct coresight_pmu *coresight_pmu) > > +{ > > + return (coresight_pmu->pmcfgr >> PMCFGR_SIZE_SHIFT) & > PMCFGR_SIZE_MASK; > > +} > > + > > +/* Check if counter is implemented as 64-bit register. */ > > +static inline bool > > +use_64b_counter_reg(const struct coresight_pmu *coresight_pmu) > > +{ > > + return (pmcfgr_size(coresight_pmu) > 31); > > +} > > + > > +/* Get number of counters, minus one. */ > > +static inline u32 pmcfgr_n(const struct coresight_pmu *coresight_pmu) > > +{ > > + return (coresight_pmu->pmcfgr >> PMCFGR_N_SHIFT) & > PMCFGR_N_MASK; > > +} > > + > > +ssize_t coresight_pmu_sysfs_event_show(struct device *dev, > > + struct device_attribute *attr, char *buf) > > +{ > > + struct dev_ext_attribute *eattr = > > + container_of(attr, struct dev_ext_attribute, attr); > > + return sysfs_emit(buf, "event=0x%llx\n", > > + (unsigned long long)eattr->var); > > +} > > +EXPORT_SYMBOL_GPL(coresight_pmu_sysfs_event_show); > > + > > +/** > > + * Event list of PMU that does not support cycle counter. Currently the > > + * CoreSight PMU spec does not define standard events, so it is empty > now. > > + */ > > +static struct attribute *coresight_pmu_event_attrs[] = { > > + NULL, > > +}; > > + > > +/* Event list of PMU supporting cycle counter. */ > > +static struct attribute *coresight_pmu_event_attrs_cc[] = { > > + CORESIGHT_EVENT_ATTR(cycles, > CORESIGHT_PMU_EVT_CYCLES_DEFAULT), > > + NULL, > > +}; > > + > > +struct attribute ** > > +coresight_pmu_get_event_attrs(const struct coresight_pmu > *coresight_pmu) > > +{ > > + return (support_cc(coresight_pmu)) ? coresight_pmu_event_attrs_cc : > > + coresight_pmu_event_attrs; > > +} > > +EXPORT_SYMBOL_GPL(coresight_pmu_get_event_attrs); > > If cycle count is a standard but optional event, just include it in the > stndard event attrs and use .is_visible to filter it our when not > present. No need for this overcomplicated machinery. > Sure, thanks for pointing that out. > > + > > +ssize_t coresight_pmu_sysfs_format_show(struct device *dev, > > + struct device_attribute *attr, > > + char *buf) > > +{ > > + struct dev_ext_attribute *eattr = > > + container_of(attr, struct dev_ext_attribute, attr); > > + return sysfs_emit(buf, "%s\n", (char *)eattr->var); > > +} > > +EXPORT_SYMBOL_GPL(coresight_pmu_sysfs_format_show); > > + > > +static struct attribute *coresight_pmu_format_attrs[] = { > > + CORESIGHT_FORMAT_ATTR(event, "config:0-31"), > > + CORESIGHT_FORMAT_ATTR(filter, "config:32-63"), > > + NULL, > > +}; > > + > > +struct attribute ** > > +coresight_pmu_get_format_attrs(const struct coresight_pmu > *coresight_pmu) > > +{ > > + return coresight_pmu_format_attrs; > > +} > > +EXPORT_SYMBOL_GPL(coresight_pmu_get_format_attrs); > > + > > +u32 coresight_pmu_event_type(const struct perf_event *event) > > +{ > > + return event->attr.config & CORESIGHT_EVENT_MASK; > > +} > > +EXPORT_SYMBOL_GPL(coresight_pmu_event_type); > > + > > +u32 coresight_pmu_event_filter(const struct perf_event *event) > > +{ > > + return (event->attr.config >> CORESIGHT_FILTER_SHIFT) & > > + CORESIGHT_FILTER_MASK; > > +} > > +EXPORT_SYMBOL_GPL(coresight_pmu_event_filter); > > + > > +static ssize_t coresight_pmu_identifier_show(struct device *dev, > > + struct device_attribute *attr, > > + char *page) > > +{ > > + struct coresight_pmu *coresight_pmu = > > + to_coresight_pmu(dev_get_drvdata(dev)); > > + > > + return sysfs_emit(page, "%s\n", coresight_pmu->identifier); > > +} > > + > > +static struct device_attribute coresight_pmu_identifier_attr = > > + __ATTR(identifier, 0444, coresight_pmu_identifier_show, NULL); > > + > > +static struct attribute *coresight_pmu_identifier_attrs[] = { > > + &coresight_pmu_identifier_attr.attr, > > + NULL, > > +}; > > + > > +static struct attribute_group coresight_pmu_identifier_attr_group = { > > + .attrs = coresight_pmu_identifier_attrs, > > +}; > > + > > +const char * > > +coresight_pmu_get_identifier(const struct coresight_pmu > *coresight_pmu) > > +{ > > + const char *identifier = > > + devm_kasprintf(coresight_pmu->dev, GFP_KERNEL, "%x", > > + coresight_pmu->impl.pmiidr); > > + return identifier; > > +} > > +EXPORT_SYMBOL_GPL(coresight_pmu_get_identifier); > > + > > +static ssize_t coresight_pmu_cpumask_show(struct device *dev, > > + struct device_attribute *attr, > > + char *buf) > > +{ > > + struct pmu *pmu = dev_get_drvdata(dev); > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(pmu); > > + struct dev_ext_attribute *eattr = > > + container_of(attr, struct dev_ext_attribute, attr); > > + unsigned long mask_id = (unsigned long)eattr->var; > > + const cpumask_t *cpumask; > > + > > + switch (mask_id) { > > + case CORESIGHT_ACTIVE_CPU_MASK: > > + cpumask = &coresight_pmu->active_cpu; > > + break; > > + case CORESIGHT_ASSOCIATED_CPU_MASK: > > + cpumask = &coresight_pmu->associated_cpus; > > + break; > > + default: > > + return 0; > > + } > > + return cpumap_print_to_pagebuf(true, buf, cpumask); > > +} > > + > > +static struct attribute *coresight_pmu_cpumask_attrs[] = { > > + CORESIGHT_CPUMASK_ATTR(cpumask, > CORESIGHT_ACTIVE_CPU_MASK), > > + CORESIGHT_CPUMASK_ATTR(associated_cpus, > CORESIGHT_ASSOCIATED_CPU_MASK), > > + NULL, > > +}; > > + > > +static struct attribute_group coresight_pmu_cpumask_attr_group = { > > + .attrs = coresight_pmu_cpumask_attrs, > > +}; > > + > > +static const struct coresight_pmu_impl_ops default_impl_ops = { > > + .get_event_attrs = coresight_pmu_get_event_attrs, > > + .get_format_attrs = coresight_pmu_get_format_attrs, > > + .get_identifier = coresight_pmu_get_identifier, > > + .is_cc_event = coresight_pmu_is_cc_event, > > + .event_type = coresight_pmu_event_type, > > + .event_filter = coresight_pmu_event_filter > > +}; > > + > > +struct impl_match { > > + u32 jedec_jep106_id; > > + int (*impl_init_ops)(struct coresight_pmu *coresight_pmu); > > +}; > > + > > +static const struct impl_match impl_match[] = { > > + {} > > +}; > > + > > +static int coresight_pmu_init_impl_ops(struct coresight_pmu > *coresight_pmu) > > +{ > > + int idx, ret; > > + u32 jedec_id; > > + struct acpi_apmt_node *apmt_node = coresight_pmu->apmt_node; > > + const struct impl_match *match = impl_match; > > + > > + /* > > + * Get PMU implementer and product id from APMT node. > > + * If APMT node doesn't have implementer/product id, try get it > > + * from PMIIDR. > > + */ > > + coresight_pmu->impl.pmiidr = > > + (apmt_node->impl_id) ? apmt_node->impl_id : > > + read_reg32(coresight_pmu->base0, PMIIDR); > > The spec says the opposite, that the APMT field should be ignored if > PMIIDR or PMPIDR is present. > This is to cover case where pmiidr value is incorrect due to mistake in HW. Hopefully, we can get an update to the spec soon. > > + jedec_id = coresight_pmu->impl.pmiidr & > PMIIDR_IMPLEMENTER_MASK; > > + > > + /* Find implementer specific attribute ops. */ > > + for (idx = 0; match->jedec_jep106_id; match++, idx++) { > > + if (match->jedec_jep106_id == jedec_id) { > > I reckon we could simply have (value,mask) pairs in impl_match to > directly match the whole IIDR value to some implementation ops, and save > some bother here. It could always be refactored if and when a sufficient > number of different implementations exist to make that approach unwieldy. Sure, that's reasonable. > > > + ret = match->impl_init_ops(coresight_pmu); > > + if (ret) > > + return ret; > > + > > + return 0; > > + } > > + } > > + > > + /* We don't find implementer specific attribute ops, use default. */ > > + coresight_pmu->impl.ops = &default_impl_ops; > > + return 0; > > +} > > + > > +static struct attribute_group * > > +coresight_pmu_alloc_event_attr_group(struct coresight_pmu > *coresight_pmu) > > +{ > > + struct attribute_group *event_group; > > + struct device *dev = coresight_pmu->dev; > > + > > + event_group = > > + devm_kzalloc(dev, sizeof(struct attribute_group), GFP_KERNEL); > > + if (!event_group) > > + return NULL; > > + > > + event_group->name = "events"; > > + event_group->attrs = > > + coresight_pmu->impl.ops->get_event_attrs(coresight_pmu); > > + > > + return event_group; > > +} > > + > > +static struct attribute_group * > > +coresight_pmu_alloc_format_attr_group(struct coresight_pmu > *coresight_pmu) > > +{ > > + struct attribute_group *format_group; > > + struct device *dev = coresight_pmu->dev; > > + > > + format_group = > > + devm_kzalloc(dev, sizeof(struct attribute_group), GFP_KERNEL); > > + if (!format_group) > > + return NULL; > > + > > + format_group->name = "format"; > > + format_group->attrs = > > + coresight_pmu->impl.ops->get_format_attrs(coresight_pmu); > > + > > + return format_group; > > +} > > + > > +static struct attribute_group ** > > +coresight_pmu_alloc_attr_group(struct coresight_pmu *coresight_pmu) > > +{ > > + const struct coresight_pmu_impl_ops *impl_ops; > > + struct attribute_group **attr_groups = NULL; > > + struct device *dev = coresight_pmu->dev; > > + int ret; > > + > > + ret = coresight_pmu_init_impl_ops(coresight_pmu); > > + if (ret) > > + return NULL; > > + > > + impl_ops = coresight_pmu->impl.ops; > > + > > + coresight_pmu->identifier = impl_ops->get_identifier(coresight_pmu); > > + > > + attr_groups = devm_kzalloc(dev, 5 * sizeof(struct attribute_group *), > > + GFP_KERNEL); > > + if (!attr_groups) > > + return NULL; > > + > > + attr_groups[0] = > coresight_pmu_alloc_event_attr_group(coresight_pmu); > > + attr_groups[1] = > coresight_pmu_alloc_format_attr_group(coresight_pmu); > > + attr_groups[2] = &coresight_pmu_identifier_attr_group; > > + attr_groups[3] = &coresight_pmu_cpumask_attr_group; > > + > > + return attr_groups; > > +} > > + > > +static inline void > > +coresight_pmu_start_counters(struct coresight_pmu *coresight_pmu) > > +{ > > + u32 pmcr; > > + > > + pmcr = read_reg32(coresight_pmu->base0, PMCR); > > + pmcr |= PMCR_E; > > + write_reg32(pmcr, coresight_pmu->base0, PMCR); > > +} > > + > > +static inline void > > +coresight_pmu_stop_counters(struct coresight_pmu *coresight_pmu) > > +{ > > + u32 pmcr; > > + > > + pmcr = read_reg32(coresight_pmu->base0, PMCR); > > + pmcr &= ~PMCR_E; > > + write_reg32(pmcr, coresight_pmu->base0, PMCR); > +} > > I'm inclined to think these shouldn't be read-modify-write > implementations. Arguably the driver should reset the control register > to a known state initially, so from then on it can simply write new > values based oin what it knows it's changing. > > AFAICS from the spec only the PMCR.E bit has a defined reset value, so > preserving random values in other bits like FZO and D is sure to be fun. > Thanks, we will reset PMCR during driver init. > > + > > +static void coresight_pmu_enable(struct pmu *pmu) > > +{ > > + int enabled; > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(pmu); > > + > > + enabled = bitmap_weight(coresight_pmu->hw_events.used_ctrs, > > + CORESIGHT_PMU_MAX_HW_CNTRS); > > + > > + if (!enabled) > > + return; > > Use bitmap_empty() for checking if a bitmap is empty. Sure, we can use this. > > > + > > + coresight_pmu_start_counters(coresight_pmu); > > +} > > + > > +static void coresight_pmu_disable(struct pmu *pmu) > > +{ > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(pmu); > > + > > + coresight_pmu_stop_counters(coresight_pmu); > > +} > > + > > +static inline bool is_cycle_cntr_idx(const struct perf_event *event) > > +{ > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(event- > >pmu); > > + int idx = event->hw.idx; > > + > > + return (support_cc(coresight_pmu) && idx == > CORESIGHT_PMU_IDX_CCNTR); > > If we don't support cycle counting, cycles count events should have been > rejected in event_init. If they're able to propagate further than that > Not sure I understand, do you mean the check for cycle counter support is unnecessary ? This function is actually called by coresight_pmu_start, which is after event_init had passed. coresight_pmu_start is not aware if cycle counter is supported or not, so we need to keep checking it. > > +} > > + > > +bool coresight_pmu_is_cc_event(const struct perf_event *event) > > +{ > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(event- > >pmu); > > + u32 evtype = coresight_pmu->impl.ops->event_type(event); > > + > > + return (support_cc(coresight_pmu) && > > Ditto. This function is called by event_init to validate the event and find available counters. > > > + evtype == CORESIGHT_PMU_EVT_CYCLES_DEFAULT); > > +} > > +EXPORT_SYMBOL_GPL(coresight_pmu_is_cc_event); > > + > > +static int > > +coresight_pmu_get_event_idx(struct coresight_pmu_hw_events > *hw_events, > > + struct perf_event *event) > > +{ > > + int idx, reserve_cc; > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(event- > >pmu); > > + > > + if (coresight_pmu->impl.ops->is_cc_event(event)) { > > + /* Search for available cycle counter. */ > > + if (test_and_set_bit(CORESIGHT_PMU_IDX_CCNTR, > > + hw_events->used_ctrs)) > > + return -EAGAIN; > > + > > + return CORESIGHT_PMU_IDX_CCNTR; > > + } > > + > > + /* > > + * CoreSight PMU can support up to 256 counters. The cycle counter is > > + * always on counter[31]. To prevent regular event from using cycle > > + * counter, we reserve the cycle counter bit temporarily. > > + */ > > + reserve_cc = 0; > > + if (support_cc(coresight_pmu) && > > + coresight_pmu->num_adj_counters >= > CORESIGHT_PMU_IDX_CCNTR) > > + reserve_cc = (test_and_set_bit(CORESIGHT_PMU_IDX_CCNTR, > > + hw_events->used_ctrs) == 0); > > It would seem a lot easier to reserve PMEVCNTR[31] permanently and track > allocation of PMCCNTR with a separate flag, when appropriate. The purpose was to avoid using two flags when keeping track of the used counters. But you have valid concern on potential significant number of unused bits and compiler warning due to the large stack size. We will revisit this. > > > + > > + /* Search available regular counter from the used counter bitmap. */ > > + idx = find_first_zero_bit(hw_events->used_ctrs, > > + coresight_pmu->num_adj_counters); > > + > > + /* Restore cycle counter bit. */ > > + if (reserve_cc) > > + clear_bit(CORESIGHT_PMU_IDX_CCNTR, hw_events->used_ctrs); > > + > > + if (idx >= coresight_pmu->num_adj_counters) > > + return -EAGAIN; > > + > > + set_bit(idx, hw_events->used_ctrs); > > + > > + return idx; > > +} > > + > > +static bool > > +coresight_pmu_validate_event(struct pmu *pmu, > > + struct coresight_pmu_hw_events *hw_events, > > + struct perf_event *event) > > +{ > > + if (is_software_event(event)) > > + return true; > > + > > + /* Reject groups spanning multiple HW PMUs. */ > > + if (event->pmu != pmu) > > + return false; > > + > > + return (coresight_pmu_get_event_idx(hw_events, event) >= 0); > > +} > > + > > +/** > > + * Make sure the group of events can be scheduled at once > > + * on the PMU. > > + */ > > +static bool coresight_pmu_validate_group(struct perf_event *event) > > +{ > > + struct perf_event *sibling, *leader = event->group_leader; > > + struct coresight_pmu_hw_events fake_hw_events; > > Do you not get a compile-time warning about this? Thanks for spotting this. I checked my build log and I can see the warning. We will update it. > > > + if (event->group_leader == event) > > + return true; > > + > > + memset(&fake_hw_events, 0, sizeof(fake_hw_events)); > > + > > + if (!coresight_pmu_validate_event(event->pmu, &fake_hw_events, > leader)) > > + return false; > > + > > + for_each_sibling_event(sibling, leader) { > > + if (!coresight_pmu_validate_event(event->pmu, > &fake_hw_events, > > + sibling)) > > + return false; > > + } > > + > > + return coresight_pmu_validate_event(event->pmu, > &fake_hw_events, event); > > +} > > + > > +static int coresight_pmu_event_init(struct perf_event *event) > > +{ > > + struct coresight_pmu *coresight_pmu; > > + struct hw_perf_event *hwc = &event->hw; > > + > > + coresight_pmu = to_coresight_pmu(event->pmu); > > + > > + /** > > This isn't kerneldoc. Sure, we will make the update. > > > + * Following other "uncore" PMUs, we do not support sampling mode > or > > + * attach to a task (per-process mode). > > + */ > > + if (is_sampling_event(event)) { > > + dev_dbg(coresight_pmu->pmu.dev, > > + "Can't support sampling events\n"); > > + return -EOPNOTSUPP; > > + } > > + > > + if (event->cpu < 0 || event->attach_state & PERF_ATTACH_TASK) { > > + dev_dbg(coresight_pmu->pmu.dev, > > + "Can't support per-task counters\n"); > > + return -EINVAL; > > + } > > + > > + /** > > Ditto. > > > + * Make sure the CPU assignment is on one of the CPUs associated with > > + * this PMU. > > + */ > > + if (!cpumask_test_cpu(event->cpu, &coresight_pmu- > >associated_cpus)) { > > + dev_dbg(coresight_pmu->pmu.dev, > > + "Requested cpu is not associated with the PMU\n"); > > + return -EINVAL; > > + } > > + > > + /* Enforce the current active CPU to handle the events in this PMU. */ > > + event->cpu = cpumask_first(&coresight_pmu->active_cpu); > > + if (event->cpu >= nr_cpu_ids) > > + return -EINVAL; > > + > > + if (!coresight_pmu_validate_group(event)) > > + return -EINVAL; > > + > > + /** > > Ditto. > > > + * We don't assign an index until we actually place the event onto > > + * hardware. Use -1 to signify that we haven't decided where to put it > > + * yet. > > + */ > > + hwc->idx = -1; > > + hwc->config_base = coresight_pmu->impl.ops->event_type(event); > > + > > + return 0; > > +} > > + > > +static inline u32 counter_offset(u32 reg_sz, u32 ctr_idx) > > +{ > > + return (PMEVCNTR_LO + (reg_sz * ctr_idx)); > > +} > > + > > +static void coresight_pmu_write_counter(struct perf_event *event, u64 > val) > > +{ > > + u32 offset; > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(event- > >pmu); > > + > > + if (use_64b_counter_reg(coresight_pmu)) { > > + offset = counter_offset(sizeof(u64), event->hw.idx); > > + > > + coresight_pmu->write_reg64(val, coresight_pmu->base1, offset); > > + } else { > > + offset = counter_offset(sizeof(u32), event->hw.idx); > > + > > + write_reg32(lower_32_bits(val), coresight_pmu->base1, offset); > > + } > > +} > > + > > +static u64 coresight_pmu_read_counter(struct perf_event *event) > > +{ > > + u32 offset; > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(event- > >pmu); > > + > > + if (use_64b_counter_reg(coresight_pmu)) { > > + offset = counter_offset(sizeof(u64), event->hw.idx); > > + return coresight_pmu->read_reg64(coresight_pmu->base1, > offset); > > + } > > + > > + offset = counter_offset(sizeof(u32), event->hw.idx); > > + return read_reg32(coresight_pmu->base1, offset); > > +} > > + > > +/** > > + * coresight_pmu_set_event_period: Set the period for the counter. > > + * > > + * To handle cases of extreme interrupt latency, we program > > + * the counter with half of the max count for the counters. > > + */ > > +static void coresight_pmu_set_event_period(struct perf_event *event) > > +{ > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(event- > >pmu); > > + u64 val = GENMASK_ULL(pmcfgr_size(coresight_pmu), 0) >> 1; > > + > > + local64_set(&event->hw.prev_count, val); > > + coresight_pmu_write_counter(event, val); > > +} > > + > > +static void coresight_pmu_enable_counter(struct coresight_pmu > *coresight_pmu, > > + int idx) > > +{ > > + u32 reg_id, reg_bit, inten_off, cnten_off; > > + > > + reg_id = CORESIGHT_IDX_TO_SET_CLR_REG_ID(idx); > > + reg_bit = CORESIGHT_IDX_TO_SET_CLR_REG_BIT(idx); > > + > > + inten_off = PMINTENSET + (4 * reg_id); > > + cnten_off = PMCNTENSET + (4 * reg_id); > > + > > + write_reg32(BIT(reg_bit), coresight_pmu->base0, inten_off); > > + write_reg32(BIT(reg_bit), coresight_pmu->base0, cnten_off); > > +} > > + > > +static void coresight_pmu_disable_counter(struct coresight_pmu > *coresight_pmu, > > + int idx) > > +{ > > + u32 reg_id, reg_bit, inten_off, cnten_off; > > + > > + reg_id = CORESIGHT_IDX_TO_SET_CLR_REG_ID(idx); > > + reg_bit = CORESIGHT_IDX_TO_SET_CLR_REG_BIT(idx); > > + > > + inten_off = PMINTENCLR + (4 * reg_id); > > + cnten_off = PMCNTENCLR + (4 * reg_id); > > + > > + write_reg32(BIT(reg_bit), coresight_pmu->base0, cnten_off); > > + write_reg32(BIT(reg_bit), coresight_pmu->base0, inten_off); > > +} > > + > > +static void coresight_pmu_event_update(struct perf_event *event) > > +{ > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(event- > >pmu); > > + struct hw_perf_event *hwc = &event->hw; > > + u64 delta, prev, now; > > + > > + do { > > + prev = local64_read(&hwc->prev_count); > > + now = coresight_pmu_read_counter(event); > > + } while (local64_cmpxchg(&hwc->prev_count, prev, now) != prev); > > + > > + delta = (now - prev) & GENMASK_ULL(pmcfgr_size(coresight_pmu), 0); > > + local64_add(delta, &event->count); > > +} > > + > > +static inline void coresight_pmu_set_event(struct coresight_pmu > *coresight_pmu, > > + struct hw_perf_event *hwc) > > +{ > > + u32 offset = PMEVTYPER + (4 * hwc->idx); > > + > > + write_reg32(hwc->config_base, coresight_pmu->base0, offset); > > +} > > + > > +static inline void > > +coresight_pmu_set_ev_filter(struct coresight_pmu *coresight_pmu, > > + struct hw_perf_event *hwc, u32 filter) > > +{ > > + u32 offset = PMEVFILTR + (4 * hwc->idx); > > + > > + write_reg32(filter, coresight_pmu->base0, offset); > > +} > > + > > +static inline void > > +coresight_pmu_set_cc_filter(struct coresight_pmu *coresight_pmu, u32 > filter) > > +{ > > + u32 offset = PMCCFILTR; > > + > > + write_reg32(filter, coresight_pmu->base0, offset); > > +} > > + > > +static void coresight_pmu_start(struct perf_event *event, int pmu_flags) > > +{ > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(event- > >pmu); > > + struct hw_perf_event *hwc = &event->hw; > > + u32 filter; > > + > > + /* We always reprogram the counter */ > > + if (pmu_flags & PERF_EF_RELOAD) > > + WARN_ON(!(hwc->state & PERF_HES_UPTODATE)); > > + > > + coresight_pmu_set_event_period(event); > > + > > + filter = coresight_pmu->impl.ops->event_filter(event); > > + > > + if (is_cycle_cntr_idx(event)) { > > + coresight_pmu_set_cc_filter(coresight_pmu, filter); > > + } else { > > + coresight_pmu_set_event(coresight_pmu, hwc); > > + coresight_pmu_set_ev_filter(coresight_pmu, hwc, filter); > > + } > > + > > + hwc->state = 0; > > + > > + coresight_pmu_enable_counter(coresight_pmu, hwc->idx); > > +} > > + > > +static void coresight_pmu_stop(struct perf_event *event, int pmu_flags) > > +{ > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(event- > >pmu); > > + struct hw_perf_event *hwc = &event->hw; > > + > > + if (hwc->state & PERF_HES_STOPPED) > > + return; > > + > > + coresight_pmu_disable_counter(coresight_pmu, hwc->idx); > > + coresight_pmu_event_update(event); > > + > > + hwc->state |= PERF_HES_STOPPED | PERF_HES_UPTODATE; > > +} > > + > > +static int coresight_pmu_add(struct perf_event *event, int flags) > > +{ > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(event- > >pmu); > > + struct coresight_pmu_hw_events *hw_events = &coresight_pmu- > >hw_events; > > + struct hw_perf_event *hwc = &event->hw; > > + int idx; > > + > > + if (WARN_ON_ONCE(!cpumask_test_cpu(smp_processor_id(), > > + &coresight_pmu->associated_cpus))) > > + return -ENOENT; > > + > > + idx = coresight_pmu_get_event_idx(hw_events, event); > > + if (idx < 0) > > + return idx; > > + > > + hw_events->events[idx] = event; > > + hwc->idx = idx; > > + hwc->state = PERF_HES_STOPPED | PERF_HES_UPTODATE; > > + > > + if (flags & PERF_EF_START) > > + coresight_pmu_start(event, PERF_EF_RELOAD); > > + > > + /* Propagate changes to the userspace mapping. */ > > + perf_event_update_userpage(event); > > + > > + return 0; > > +} > > + > > +static void coresight_pmu_del(struct perf_event *event, int flags) > > +{ > > + struct coresight_pmu *coresight_pmu = to_coresight_pmu(event- > >pmu); > > + struct coresight_pmu_hw_events *hw_events = &coresight_pmu- > >hw_events; > > + struct hw_perf_event *hwc = &event->hw; > > + int idx = hwc->idx; > > + > > + coresight_pmu_stop(event, PERF_EF_UPDATE); > > + > > + hw_events->events[idx] = NULL; > > + > > + clear_bit(idx, hw_events->used_ctrs); > > + > > + perf_event_update_userpage(event); > > +} > > + > > +static void coresight_pmu_read(struct perf_event *event) > > +{ > > + coresight_pmu_event_update(event); > > +} > > + > > +static int coresight_pmu_alloc(struct platform_device *pdev, > > + struct coresight_pmu **coresight_pmu) > > +{ > > + struct acpi_apmt_node *apmt_node; > > + struct device *dev; > > + struct coresight_pmu *pmu; > > + > > + dev = &pdev->dev; > > + apmt_node = *(struct acpi_apmt_node **)dev_get_platdata(dev); > > + if (!apmt_node) { > > + dev_err(dev, "failed to get APMT node\n"); > > + return -ENOMEM; > > + } > > + > > + pmu = devm_kzalloc(dev, sizeof(*pmu), GFP_KERNEL); > > + if (!pmu) > > + return -ENOMEM; > > + > > + *coresight_pmu = pmu; > > + > > + pmu->dev = dev; > > + pmu->apmt_node = apmt_node; > > + pmu->name = > > + devm_kasprintf(dev, GFP_KERNEL, PMUNAME "%u", apmt_node- > >id); > > + > > + platform_set_drvdata(pdev, coresight_pmu); > > + > > + return 0; > > +} > > + > > +static int coresight_pmu_init_mmio(struct coresight_pmu > *coresight_pmu) > > +{ > > + struct device *dev; > > + struct platform_device *pdev; > > + struct resource *res; > > + struct acpi_apmt_node *apmt_node; > > + > > + dev = coresight_pmu->dev; > > + pdev = to_platform_device(dev); > > + apmt_node = coresight_pmu->apmt_node; > > + > > + /* Base address for page 0. */ > > + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); > > + if (!res) { > > + dev_err(dev, "failed to get page-0 resource\n"); > > + return -ENOMEM; > > + } > > + > > + coresight_pmu->base0 = devm_ioremap_resource(dev, res); > > + if (IS_ERR(coresight_pmu->base0)) { > > + dev_err(dev, "ioremap failed for page-0 resource\n"); > > + return PTR_ERR(coresight_pmu->base0); > > + } > > devm_platform_ioremap_resource() Thanks, we will update it. > > > + /* Base address for page 1 if supported. Otherwise point it to page 0. */ > > + coresight_pmu->base1 = coresight_pmu->base0; > > + if (CHECK_APMT_FLAG(apmt_node->flags, DUAL_PAGE, SUPP)) { > > + res = platform_get_resource(pdev, IORESOURCE_MEM, 1); > > + if (!res) { > > + dev_err(dev, "failed to get page-1 resource\n"); > > + return -ENOMEM; > > + } > > + > > + coresight_pmu->base1 = devm_ioremap_resource(dev, res); > > + if (IS_ERR(coresight_pmu->base1)) { > > + dev_err(dev, "ioremap failed for page-1 resource\n"); > > + return PTR_ERR(coresight_pmu->base1); > > + } > > Ditto. > > > + } > > + > > + if (CHECK_APMT_FLAG(apmt_node->flags, ATOMIC, SUPP)) { > > + coresight_pmu->read_reg64 = &read_reg64; > > + coresight_pmu->write_reg64 = &write_reg64; > > + } else { > > + coresight_pmu->read_reg64 = &read_reg64_hilohi; > > + coresight_pmu->write_reg64 = &write_reg64_lohi; > > + } > > + > > + coresight_pmu->pmcfgr = read_reg32(coresight_pmu->base0, > PMCFGR); > > + > > + coresight_pmu->num_adj_counters = pmcfgr_n(coresight_pmu) + 1; > > + > > + if (support_cc(coresight_pmu)) { > > + /** > > + * Exclude the cycle counter if there is a gap between > > + * cycle counter id and the last regular event counter id. > > + */ > > + if (coresight_pmu->num_adj_counters <= > CORESIGHT_PMU_IDX_CCNTR) > > + coresight_pmu->num_adj_counters -= 1; > > As before, I think it would be a fair bit clearer to maintain a > distinction between the number of PMEV{TYPE,CNT,FILT}R registers present > and the number of logical counters actually usable. > We will revisit this. > > + } > > + > > + coresight_pmu->num_set_clr_reg = > > + round_up(coresight_pmu->num_adj_counters, > > + CORESIGHT_SET_CLR_REG_COUNTER_NUM) / > > + CORESIGHT_SET_CLR_REG_COUNTER_NUM; > > DIV_ROUND_UP() Thanks, we will update it. > > > + > > + return 0; > > +} > > + > > +static inline int > > +coresight_pmu_get_reset_overflow(struct coresight_pmu > *coresight_pmu, > > + u32 *pmovs) > > +{ > > + int i; > > + u32 pmovclr_offset = PMOVSCLR; > > + u32 has_overflowed = 0; > > + > > + for (i = 0; i < coresight_pmu->num_set_clr_reg; ++i) { > > + pmovs[i] = read_reg32(coresight_pmu->base1, pmovclr_offset); > > + has_overflowed |= pmovs[i]; > > + write_reg32(pmovs[i], coresight_pmu->base1, pmovclr_offset); > > + pmovclr_offset += sizeof(u32); > > + } > > + > > + return has_overflowed != 0; > > +} > > + > > +static irqreturn_t coresight_pmu_handle_irq(int irq_num, void *dev) > > +{ > > + int idx, has_overflowed; > > + struct coresight_pmu *coresight_pmu = dev; > > + u32 pmovs[CORESIGHT_SET_CLR_REG_MAX_NUM] = { 0 }; > > + bool handled = false; > > + > > + coresight_pmu_stop_counters(coresight_pmu); > > + > > + has_overflowed = > coresight_pmu_get_reset_overflow(coresight_pmu, pmovs); > > + if (!has_overflowed) > > + goto done; > > + > > + for_each_set_bit(idx, (unsigned long *)pmovs, > > + CORESIGHT_PMU_MAX_HW_CNTRS) { > > Why waste time iterating over a probably significant number of > irrelevant bits? Yup, this is unnecessary. We will update it along with change on tracking the used counters. > > > + struct perf_event *event = coresight_pmu- > >hw_events.events[idx]; > > + > > + if (!event) > > + continue; > > + > > + coresight_pmu_event_update(event); > > + coresight_pmu_set_event_period(event); > > + > > + handled = true; > > + } > > + > > +done: > > + coresight_pmu_start_counters(coresight_pmu); > > + return IRQ_RETVAL(handled); > > +} > > + > > +static int coresight_pmu_request_irq(struct coresight_pmu > *coresight_pmu) > > +{ > > + int irq, ret; > > + struct device *dev; > > + struct platform_device *pdev; > > + struct acpi_apmt_node *apmt_node; > > + > > + dev = coresight_pmu->dev; > > + pdev = to_platform_device(dev); > > + apmt_node = coresight_pmu->apmt_node; > > + > > + /* Skip IRQ request if the PMU does not support overflow interrupt. */ > > + if (apmt_node->ovflw_irq == 0) > > + return 0; > > + > > + irq = platform_get_irq(pdev, 0); > > + if (irq < 0) > > + return irq; > > + > > + ret = devm_request_irq(dev, irq, coresight_pmu_handle_irq, > > + IRQF_NOBALANCING | IRQF_NO_THREAD, > dev_name(dev), > > + coresight_pmu); > > + if (ret) { > > + dev_err(dev, "Could not request IRQ %d\n", irq); > > + return ret; > > + } > > + > > + coresight_pmu->irq = irq; > > + > > + return 0; > > +} > > + > > +static inline int coresight_pmu_find_cpu_container(int cpu, u32 > container_uid) > > +{ > > + u32 acpi_uid; > > + struct device *cpu_dev = get_cpu_device(cpu); > > + struct acpi_device *acpi_dev = ACPI_COMPANION(cpu_dev); > > + int level = 0; > > + > > + if (!cpu_dev) > > + return -ENODEV; > > + > > + while (acpi_dev) { > > + if (!strcmp(acpi_device_hid(acpi_dev), > > + ACPI_PROCESSOR_CONTAINER_HID) && > > + !kstrtouint(acpi_device_uid(acpi_dev), 0, &acpi_uid) && > > + acpi_uid == container_uid) > > + return 0; > > + > > + acpi_dev = acpi_dev->parent; > > + level++; > > + } > > + > > + return -ENODEV; > > +} > > + > > +static int coresight_pmu_get_cpus(struct coresight_pmu > *coresight_pmu) > > +{ > > + struct acpi_apmt_node *apmt_node; > > + int affinity_flag; > > + int cpu; > > + > > + apmt_node = coresight_pmu->apmt_node; > > + affinity_flag = apmt_node->flags & ACPI_APMT_FLAGS_AFFINITY; > > + > > + if (affinity_flag == ACPI_APMT_FLAGS_AFFINITY_PROC) { > > + for_each_possible_cpu(cpu) { > > + if (apmt_node->proc_affinity == > > + get_acpi_id_for_cpu(cpu)) { > > + cpumask_set_cpu( > > + cpu, &coresight_pmu->associated_cpus); > > + break; > > + } > > + } > > + } else { > > + for_each_possible_cpu(cpu) { > > + if (coresight_pmu_find_cpu_container( > > + cpu, apmt_node->proc_affinity)) > > + continue; > > + > > + cpumask_set_cpu(cpu, &coresight_pmu->associated_cpus); > > + } > > + } > > + > > + return 0; > > +} > > + > > +static int coresight_pmu_register_pmu(struct coresight_pmu > *coresight_pmu) > > +{ > > + int ret; > > + struct attribute_group **attr_groups; > > + > > + attr_groups = coresight_pmu_alloc_attr_group(coresight_pmu); > > + if (!attr_groups) { > > + ret = -ENOMEM; > > + return ret; > > + } > > + > > + ret = cpuhp_state_add_instance(coresight_pmu_cpuhp_state, > > + &coresight_pmu->cpuhp_node); > > + if (ret) > > + return ret; > > + > > + coresight_pmu->pmu = (struct pmu){ > > + .task_ctx_nr = perf_invalid_context, > > + .module = THIS_MODULE, > > + .pmu_enable = coresight_pmu_enable, > > + .pmu_disable = coresight_pmu_disable, > > + .event_init = coresight_pmu_event_init, > > + .add = coresight_pmu_add, > > + .del = coresight_pmu_del, > > + .start = coresight_pmu_start, > > + .stop = coresight_pmu_stop, > > + .read = coresight_pmu_read, > > + .attr_groups = (const struct attribute_group **)attr_groups, > > + .capabilities = PERF_PMU_CAP_NO_EXCLUDE, > > + }; > > + > > + ret = perf_pmu_register(&coresight_pmu->pmu, coresight_pmu- > >name, -1); > > + if (ret) { > > + cpuhp_state_remove_instance(coresight_pmu_cpuhp_state, > > + &coresight_pmu->cpuhp_node); > > + } > > + > > + return ret; > > +} > > + > > +static int coresight_pmu_device_probe(struct platform_device *pdev) > > +{ > > + int ret; > > + struct coresight_pmu *coresight_pmu; > > + > > + ret = coresight_pmu_alloc(pdev, &coresight_pmu); > > + if (ret) > > + return ret; > > + > > + ret = coresight_pmu_init_mmio(coresight_pmu); > > + if (ret) > > + return ret; > > + > > + ret = coresight_pmu_request_irq(coresight_pmu); > > + if (ret) > > + return ret; > > + > > + ret = coresight_pmu_get_cpus(coresight_pmu); > > + if (ret) > > + return ret; > > + > > + ret = coresight_pmu_register_pmu(coresight_pmu); > > + if (ret) > > + return ret; > > + > > + return 0; > > +} > > + > > +static int coresight_pmu_device_remove(struct platform_device *pdev) > > +{ > > + struct coresight_pmu *coresight_pmu = platform_get_drvdata(pdev); > > + > > + perf_pmu_unregister(&coresight_pmu->pmu); > > + cpuhp_state_remove_instance(coresight_pmu_cpuhp_state, > > + &coresight_pmu->cpuhp_node); > > + > > + return 0; > > +} > > + > > +static struct platform_driver coresight_pmu_driver = { > > + .driver = { > > + .name = "arm-coresight-pmu", > > + .suppress_bind_attrs = true, > > + }, > > + .probe = coresight_pmu_device_probe, > > + .remove = coresight_pmu_device_remove, > > +}; > > + > > +static void coresight_pmu_set_active_cpu(int cpu, > > + struct coresight_pmu *coresight_pmu) > > +{ > > + cpumask_set_cpu(cpu, &coresight_pmu->active_cpu); > > + WARN_ON(irq_set_affinity(coresight_pmu->irq, > > + &coresight_pmu->active_cpu)); > > +} > > + > > +static int coresight_pmu_cpu_online(unsigned int cpu, struct hlist_node > *node) > > +{ > > + struct coresight_pmu *coresight_pmu = > > + hlist_entry_safe(node, struct coresight_pmu, cpuhp_node); > > + > > + if (!cpumask_test_cpu(cpu, &coresight_pmu->associated_cpus)) > > + return 0; > > + > > + /* If the PMU is already managed, there is nothing to do */ > > + if (!cpumask_empty(&coresight_pmu->active_cpu)) > > + return 0; > > + > > + /* Use this CPU for event counting */ > > + coresight_pmu_set_active_cpu(cpu, coresight_pmu); > > + > > + return 0; > > +} > > + > > +static int coresight_pmu_cpu_teardown(unsigned int cpu, struct > hlist_node *node) > > +{ > > + int dst; > > + struct cpumask online_supported; > > + > > + struct coresight_pmu *coresight_pmu = > > + hlist_entry_safe(node, struct coresight_pmu, cpuhp_node); > > + > > + /* Nothing to do if this CPU doesn't own the PMU */ > > + if (!cpumask_test_and_clear_cpu(cpu, &coresight_pmu->active_cpu)) > > + return 0; > > + > > + /* Choose a new CPU to migrate ownership of the PMU to */ > > + cpumask_and(&online_supported, &coresight_pmu->associated_cpus, > > + cpu_online_mask); > > + dst = cpumask_any_but(&online_supported, cpu); > > + if (dst >= nr_cpu_ids) > > + return 0; > > + > > + /* Use this CPU for event counting */ > > + perf_pmu_migrate_context(&coresight_pmu->pmu, cpu, dst); > > + coresight_pmu_set_active_cpu(dst, coresight_pmu); > > + > > + return 0; > > +} > > + > > +static int __init coresight_pmu_init(void) > > +{ > > + int ret; > > + > > + ret = cpuhp_setup_state_multi(CPUHP_AP_ONLINE_DYN, PMUNAME, > > + coresight_pmu_cpu_online, > > + coresight_pmu_cpu_teardown); > > + if (ret < 0) > > + return ret; > > + coresight_pmu_cpuhp_state = ret; > > + return platform_driver_register(&coresight_pmu_driver); > > +} > > + > > +static void __exit coresight_pmu_exit(void) > > +{ > > + platform_driver_unregister(&coresight_pmu_driver); > > + cpuhp_remove_multi_state(coresight_pmu_cpuhp_state); > > +} > > + > > +module_init(coresight_pmu_init); > > +module_exit(coresight_pmu_exit); > > diff --git a/drivers/perf/coresight_pmu/arm_coresight_pmu.h > b/drivers/perf/coresight_pmu/arm_coresight_pmu.h > > new file mode 100644 > > index 000000000000..59fb40eafe45 > > --- /dev/null > > +++ b/drivers/perf/coresight_pmu/arm_coresight_pmu.h > > @@ -0,0 +1,147 @@ > > +/* SPDX-License-Identifier: GPL-2.0 > > + * > > + * ARM CoreSight PMU driver. > > + * Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. > > + * > > + */ > > + > > +#ifndef __ARM_CORESIGHT_PMU_H__ > > +#define __ARM_CORESIGHT_PMU_H__ > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +#define to_coresight_pmu(p) (container_of(p, struct coresight_pmu, > pmu)) > > + > > +#define CORESIGHT_EXT_ATTR(_name, _func, _config) \ > > + (&((struct dev_ext_attribute[]){ \ > > + { \ > > + .attr = __ATTR(_name, 0444, _func, NULL), \ > > + .var = (void *)_config \ > > + } \ > > + })[0].attr.attr) > > + > > +#define CORESIGHT_FORMAT_ATTR(_name, _config) \ > > + CORESIGHT_EXT_ATTR(_name, coresight_pmu_sysfs_format_show, > \ > > + (char *)_config) > > + > > +#define CORESIGHT_EVENT_ATTR(_name, _config) \ > > + PMU_EVENT_ATTR_ID(_name, coresight_pmu_sysfs_event_show, > _config) > > + > > +/** > > + * This is the default event number for cycle count, if supported, since the > > + * ARM Coresight PMU specification does not define a standard event > code > > + * for cycle count. > > + */ > > +#define CORESIGHT_PMU_EVT_CYCLES_DEFAULT (0x1ULL << 31) > > And what do we do when an implementation defines 0x80000000 as one of > its own event specifiers? The standard cycle count is independent of any > other events, so it needs to be encoded in a manner which is distinct > from *any* potentially-valid PMEVTYPER value. We were thinking that in such case, the implementor would provide coresight_pmu_impl_ops. To avoid it, I guess we can use config[32] for the default cycle count event id. The filter value will need to be moved to config1[31:0]. Does it sound reasonable ? > > > + > > +/** > > + * The ARM Coresight PMU supports up to 256 event counters. > > + * If the counters are larger-than 32-bits, then the PMU includes at > > + * most 128 counters. > > + */ > > +#define CORESIGHT_PMU_MAX_HW_CNTRS 256 > > + > > +/* The cycle counter, if implemented, is located at counter[31]. */ > > +#define CORESIGHT_PMU_IDX_CCNTR 31 > > + > > +struct coresight_pmu; > > + > > +/* This tracks the events assigned to each counter in the PMU. */ > > +struct coresight_pmu_hw_events { > > + /* The events that are active on the PMU for the given index. */ > > + struct perf_event *events[CORESIGHT_PMU_MAX_HW_CNTRS]; > > This is really quite big - 2KB per PMU on 64-bit - given the likelihood > that typically only a fraction of that might be needed. As mentioned, it > should already be tickling CONFIG_FRAME_WARN in > coresight_pmu_validate_group(). We will rework it. Thanks for all your comments, Robin. Regards, Besar > > Thanks, > Robin. > > > + /* Each bit indicates a counter is being used (or not) for an event. */ > > + DECLARE_BITMAP(used_ctrs, CORESIGHT_PMU_MAX_HW_CNTRS); > > +}; > > + > > +/* Contains ops to query vendor/implementer specific attribute. */ > > +struct coresight_pmu_impl_ops { > > + /* Get event attributes */ > > + struct attribute **(*get_event_attrs)( > > + const struct coresight_pmu *coresight_pmu); > > + /* Get format attributes */ > > + struct attribute **(*get_format_attrs)( > > + const struct coresight_pmu *coresight_pmu); > > + /* Get string identifier */ > > + const char *(*get_identifier)(const struct coresight_pmu > *coresight_pmu); > > + /* Check if the event corresponds to cycle count event */ > > + bool (*is_cc_event)(const struct perf_event *event); > > + /* Decode event type/id from configs */ > > + u32 (*event_type)(const struct perf_event *event); > > + /* Decode filter value from configs */ > > + u32 (*event_filter)(const struct perf_event *event); > > +}; > > + > > +/* Vendor/implementer descriptor. */ > > +struct coresight_pmu_impl { > > + u32 pmiidr; > > + const struct coresight_pmu_impl_ops *ops; > > +}; > > + > > +/* Coresight PMU descriptor. */ > > +struct coresight_pmu { > > + struct pmu pmu; > > + struct device *dev; > > + struct acpi_apmt_node *apmt_node; > > + const char *name; > > + const char *identifier; > > + void __iomem *base0; > > + void __iomem *base1; > > + int irq; > > + cpumask_t associated_cpus; > > + cpumask_t active_cpu; > > + struct hlist_node cpuhp_node; > > + > > + u32 pmcfgr; > > + u32 num_adj_counters; > > + u32 num_set_clr_reg; > > + > > + struct coresight_pmu_hw_events hw_events; > > + > > + void (*write_reg64)(u64 val, void __iomem *base, u32 offset); > > + u64 (*read_reg64)(void __iomem *base, u32 offset); > > + > > + struct coresight_pmu_impl impl; > > +}; > > + > > +/* Default function to show event attribute in sysfs. */ > > +ssize_t coresight_pmu_sysfs_event_show(struct device *dev, > > + struct device_attribute *attr, > > + char *buf); > > + > > +/* Default function to show format attribute in sysfs. */ > > +ssize_t coresight_pmu_sysfs_format_show(struct device *dev, > > + struct device_attribute *attr, > > + char *buf); > > + > > +/* Get the default Coresight PMU event attributes. */ > > +struct attribute ** > > +coresight_pmu_get_event_attrs(const struct coresight_pmu > *coresight_pmu); > > + > > +/* Get the default Coresight PMU format attributes. */ > > +struct attribute ** > > +coresight_pmu_get_format_attrs(const struct coresight_pmu > *coresight_pmu); > > + > > +/* Get the default Coresight PMU device identifier. */ > > +const char * > > +coresight_pmu_get_identifier(const struct coresight_pmu > *coresight_pmu); > > + > > +/* Default function to query if an event is a cycle counter event. */ > > +bool coresight_pmu_is_cc_event(const struct perf_event *event); > > + > > +/* Default function to query the type/id of an event. */ > > +u32 coresight_pmu_event_type(const struct perf_event *event); > > + > > +/* Default function to query the filter value of an event. */ > > +u32 coresight_pmu_event_filter(const struct perf_event *event); > > + > > +#endif /* __ARM_CORESIGHT_PMU_H__ */ _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel