From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by smtp.subspace.kernel.org (Postfix) with ESMTP id 8867C2F30; Thu, 18 Apr 2024 21:22:27 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.140.110.172 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1713475351; cv=none; b=fj2jVjKZqnP2qksvv4nhHKLqbPZx1tN3URJBE5j6XzqhdVm2bpkUkI5FU98O+M11ghh99x+jb8iZMoMbjss2LKhpBj0KAvSeJWEzNuFc+eupGeGNfTe86wbZ2APz8UCT3Ionve5GR+t41K8o+86MLdJdeRUoepExCHz2d2S1NLE= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1713475351; c=relaxed/simple; bh=KYflgGO+afdYp22Iw67D60rcfeNCkVH2dcJRCsgKTWo=; h=Message-ID:Date:MIME-Version:Subject:To:Cc:References:From: In-Reply-To:Content-Type; b=BFls4/xkm9UroIuTXmiQr5hNi+FKj8PKAJKKG/E+vvzo8nY7M/SITcIx0logT4UI/f+4NH4zbKXRvsqALztgR9zScBAo1w3qtDLcsQEbn7RxclC/UnTgjE3mOQ7lHS4IcXUrPvt+P1QNm+4SjsMhahoT4vifROOjU2MQXgHpoUQ= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=arm.com; spf=pass smtp.mailfrom=arm.com; arc=none smtp.client-ip=217.140.110.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=arm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=arm.com Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id D44142F; Thu, 18 Apr 2024 14:22:53 -0700 (PDT) Received: from [10.57.20.187] (unknown [10.57.20.187]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 6258B3F738; Thu, 18 Apr 2024 14:22:22 -0700 (PDT) Message-ID: <7f9a82ea-c4c8-40a5-8f26-7cb135e91c5d@arm.com> Date: Thu, 18 Apr 2024 22:22:13 +0100 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v2 2/7] iommu/riscv: Add RISC-V IOMMU platform device driver To: Tomasz Jeznach , Joerg Roedel , Will Deacon , Paul Walmsley Cc: Palmer Dabbelt , Albert Ou , Anup Patel , Sunil V L , Nick Kossifidis , Sebastien Boeuf , Rob Herring , Krzysztof Kozlowski , Conor Dooley , devicetree@vger.kernel.org, iommu@lists.linux.dev, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux@rivosinc.com References: <741996169fef074b5d9f4f218c2a98bf5dd38386.1713456598.git.tjeznach@rivosinc.com> From: Robin Murphy Content-Language: en-GB In-Reply-To: <741996169fef074b5d9f4f218c2a98bf5dd38386.1713456598.git.tjeznach@rivosinc.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit On 2024-04-18 5:32 pm, Tomasz Jeznach wrote: > Introduce platform device driver for implementation of RISC-V IOMMU > architected hardware. > > Hardware interface definition located in file iommu-bits.h is based on > ratified RISC-V IOMMU Architecture Specification version 1.0.0. > > This patch implements platform device initialization, early check and > configuration of the IOMMU interfaces and enables global pass-through > address translation mode (iommu_mode == BARE), without registering > hardware instance in the IOMMU subsystem. > > Link: https://github.com/riscv-non-isa/riscv-iommu > Co-developed-by: Nick Kossifidis > Signed-off-by: Nick Kossifidis > Co-developed-by: Sebastien Boeuf > Signed-off-by: Sebastien Boeuf > Signed-off-by: Tomasz Jeznach > --- > MAINTAINERS | 6 + > drivers/iommu/Kconfig | 1 + > drivers/iommu/Makefile | 2 +- > drivers/iommu/riscv/Kconfig | 16 + > drivers/iommu/riscv/Makefile | 2 + > drivers/iommu/riscv/iommu-bits.h | 707 +++++++++++++++++++++++++++ > drivers/iommu/riscv/iommu-platform.c | 94 ++++ > drivers/iommu/riscv/iommu.c | 89 ++++ > drivers/iommu/riscv/iommu.h | 62 +++ > 9 files changed, 978 insertions(+), 1 deletion(-) > create mode 100644 drivers/iommu/riscv/Kconfig > create mode 100644 drivers/iommu/riscv/Makefile > create mode 100644 drivers/iommu/riscv/iommu-bits.h > create mode 100644 drivers/iommu/riscv/iommu-platform.c > create mode 100644 drivers/iommu/riscv/iommu.c > create mode 100644 drivers/iommu/riscv/iommu.h > > diff --git a/MAINTAINERS b/MAINTAINERS > index 2657f9eae84c..051599c76585 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -18972,6 +18972,12 @@ L: iommu@lists.linux.dev > L: linux-riscv@lists.infradead.org > S: Maintained > F: Documentation/devicetree/bindings/iommu/riscv,iommu.yaml > +F: drivers/iommu/riscv/Kconfig > +F: drivers/iommu/riscv/Makefile > +F: drivers/iommu/riscv/iommu-bits.h > +F: drivers/iommu/riscv/iommu-platform.c > +F: drivers/iommu/riscv/iommu.c > +F: drivers/iommu/riscv/iommu.h I'm pretty sure a single "F: drivers/iommu/riscv/" pattern will suffice. > RISC-V MICROCHIP FPGA SUPPORT > M: Conor Dooley > diff --git a/drivers/iommu/Kconfig b/drivers/iommu/Kconfig > index 0af39bbbe3a3..ae762db0365e 100644 > --- a/drivers/iommu/Kconfig > +++ b/drivers/iommu/Kconfig > @@ -195,6 +195,7 @@ config MSM_IOMMU > source "drivers/iommu/amd/Kconfig" > source "drivers/iommu/intel/Kconfig" > source "drivers/iommu/iommufd/Kconfig" > +source "drivers/iommu/riscv/Kconfig" > > config IRQ_REMAP > bool "Support for Interrupt Remapping" > diff --git a/drivers/iommu/Makefile b/drivers/iommu/Makefile > index 542760d963ec..5e5a83c6c2aa 100644 > --- a/drivers/iommu/Makefile > +++ b/drivers/iommu/Makefile > @@ -1,5 +1,5 @@ > # SPDX-License-Identifier: GPL-2.0 > -obj-y += amd/ intel/ arm/ iommufd/ > +obj-y += amd/ intel/ arm/ iommufd/ riscv/ > obj-$(CONFIG_IOMMU_API) += iommu.o > obj-$(CONFIG_IOMMU_API) += iommu-traces.o > obj-$(CONFIG_IOMMU_API) += iommu-sysfs.o > diff --git a/drivers/iommu/riscv/Kconfig b/drivers/iommu/riscv/Kconfig > new file mode 100644 > index 000000000000..d02326bddb4c > --- /dev/null > +++ b/drivers/iommu/riscv/Kconfig > @@ -0,0 +1,16 @@ > +# SPDX-License-Identifier: GPL-2.0-only > +# RISC-V IOMMU support > + > +config RISCV_IOMMU > + def_bool y if RISCV && 64BIT && MMU Drop the dependencies here, they're already dependencies. However, also consider allowing users to configure this out without disabling IOMMU_SUPPORT entirely - I imagine other IOMMU implementations are going to end up paired wiothg RISC-V CPUs sooner or later. Furthermore, if it's a regular driver model driver, consider allowing it to build as a module. Not to mention that the help text below is rather pointless if there's no prompt offered in the first place. > + depends on RISCV && 64BIT && MMU > + select DMA_OPS Drop this, you're not (and shouldn't be) architecture code implementing DMA ops. > + select IOMMU_API > + select IOMMU_IOVA Drop this, you're not using the IOVA library either. > + help > + Support for implementations of the RISC-V IOMMU architecture that > + complements the RISC-V MMU capabilities, providing similar address > + translation and protection functions for accesses from I/O devices. > + > + Say Y here if your SoC includes an IOMMU device implementing > + the RISC-V IOMMU architecture. > diff --git a/drivers/iommu/riscv/Makefile b/drivers/iommu/riscv/Makefile > new file mode 100644 > index 000000000000..e4c189de58d3 > --- /dev/null > +++ b/drivers/iommu/riscv/Makefile > @@ -0,0 +1,2 @@ > +# SPDX-License-Identifier: GPL-2.0-only > +obj-$(CONFIG_RISCV_IOMMU) += iommu.o iommu-platform.o > diff --git a/drivers/iommu/riscv/iommu-bits.h b/drivers/iommu/riscv/iommu-bits.h > new file mode 100644 > index 000000000000..ba093c29de9f > --- /dev/null > +++ b/drivers/iommu/riscv/iommu-bits.h > @@ -0,0 +1,707 @@ > +/* SPDX-License-Identifier: GPL-2.0-only */ > +/* > + * Copyright © 2022-2024 Rivos Inc. > + * Copyright © 2023 FORTH-ICS/CARV > + * Copyright © 2023 RISC-V IOMMU Task Group > + * > + * RISC-V IOMMU - Register Layout and Data Structures. > + * > + * Based on the 'RISC-V IOMMU Architecture Specification', Version 1.0 > + * Published at https://github.com/riscv-non-isa/riscv-iommu > + * > + */ > + > +#ifndef _RISCV_IOMMU_BITS_H_ > +#define _RISCV_IOMMU_BITS_H_ > + > +#include > +#include > +#include > + > +/* > + * Chapter 5: Memory Mapped register interface > + */ > + > +/* Common field positions */ > +#define RISCV_IOMMU_PPN_FIELD GENMASK_ULL(53, 10) > +#define RISCV_IOMMU_QUEUE_LOGSZ_FIELD GENMASK_ULL(4, 0) > +#define RISCV_IOMMU_QUEUE_INDEX_FIELD GENMASK_ULL(31, 0) > +#define RISCV_IOMMU_QUEUE_ENABLE BIT(0) > +#define RISCV_IOMMU_QUEUE_INTR_ENABLE BIT(1) > +#define RISCV_IOMMU_QUEUE_MEM_FAULT BIT(8) > +#define RISCV_IOMMU_QUEUE_OVERFLOW BIT(9) > +#define RISCV_IOMMU_QUEUE_ACTIVE BIT(16) > +#define RISCV_IOMMU_QUEUE_BUSY BIT(17) > + > +#define RISCV_IOMMU_ATP_PPN_FIELD GENMASK_ULL(43, 0) > +#define RISCV_IOMMU_ATP_MODE_FIELD GENMASK_ULL(63, 60) > + > +/* 5.3 IOMMU Capabilities (64bits) */ > +#define RISCV_IOMMU_REG_CAP 0x0000 > +#define RISCV_IOMMU_CAP_VERSION GENMASK_ULL(7, 0) > +#define RISCV_IOMMU_CAP_S_SV32 BIT_ULL(8) > +#define RISCV_IOMMU_CAP_S_SV39 BIT_ULL(9) > +#define RISCV_IOMMU_CAP_S_SV48 BIT_ULL(10) > +#define RISCV_IOMMU_CAP_S_SV57 BIT_ULL(11) > +#define RISCV_IOMMU_CAP_SVPBMT BIT_ULL(15) > +#define RISCV_IOMMU_CAP_G_SV32 BIT_ULL(16) > +#define RISCV_IOMMU_CAP_G_SV39 BIT_ULL(17) > +#define RISCV_IOMMU_CAP_G_SV48 BIT_ULL(18) > +#define RISCV_IOMMU_CAP_G_SV57 BIT_ULL(19) > +#define RISCV_IOMMU_CAP_AMO_MRIF BIT_ULL(21) > +#define RISCV_IOMMU_CAP_MSI_FLAT BIT_ULL(22) > +#define RISCV_IOMMU_CAP_MSI_MRIF BIT_ULL(23) > +#define RISCV_IOMMU_CAP_AMO_HWAD BIT_ULL(24) > +#define RISCV_IOMMU_CAP_ATS BIT_ULL(25) > +#define RISCV_IOMMU_CAP_T2GPA BIT_ULL(26) > +#define RISCV_IOMMU_CAP_END BIT_ULL(27) > +#define RISCV_IOMMU_CAP_IGS GENMASK_ULL(29, 28) > +#define RISCV_IOMMU_CAP_HPM BIT_ULL(30) > +#define RISCV_IOMMU_CAP_DBG BIT_ULL(31) > +#define RISCV_IOMMU_CAP_PAS GENMASK_ULL(37, 32) > +#define RISCV_IOMMU_CAP_PD8 BIT_ULL(38) > +#define RISCV_IOMMU_CAP_PD17 BIT_ULL(39) > +#define RISCV_IOMMU_CAP_PD20 BIT_ULL(40) > + > +#define RISCV_IOMMU_CAP_VERSION_VER_MASK 0xF0 > +#define RISCV_IOMMU_CAP_VERSION_REV_MASK 0x0F > + > +/** > + * enum riscv_iommu_igs_settings - Interrupt Generation Support Settings > + * @RISCV_IOMMU_CAP_IGS_MSI: I/O MMU supports only MSI generation > + * @RISCV_IOMMU_CAP_IGS_WSI: I/O MMU supports only Wired-Signaled interrupt > + * @RISCV_IOMMU_CAP_IGS_BOTH: I/O MMU supports both MSI and WSI generation > + * @RISCV_IOMMU_CAP_IGS_RSRV: Reserved for standard use > + */ > +enum riscv_iommu_igs_settings { > + RISCV_IOMMU_CAP_IGS_MSI = 0, > + RISCV_IOMMU_CAP_IGS_WSI = 1, > + RISCV_IOMMU_CAP_IGS_BOTH = 2, > + RISCV_IOMMU_CAP_IGS_RSRV = 3 > +}; > + > +/* 5.4 Features control register (32bits) */ > +#define RISCV_IOMMU_REG_FCTL 0x0008 > +#define RISCV_IOMMU_FCTL_BE BIT(0) > +#define RISCV_IOMMU_FCTL_WSI BIT(1) > +#define RISCV_IOMMU_FCTL_GXL BIT(2) > + > +/* 5.5 Device-directory-table pointer (64bits) */ > +#define RISCV_IOMMU_REG_DDTP 0x0010 > +#define RISCV_IOMMU_DDTP_MODE GENMASK_ULL(3, 0) > +#define RISCV_IOMMU_DDTP_BUSY BIT_ULL(4) > +#define RISCV_IOMMU_DDTP_PPN RISCV_IOMMU_PPN_FIELD > + > +/** > + * enum riscv_iommu_ddtp_modes - I/O MMU translation modes > + * @RISCV_IOMMU_DDTP_MODE_OFF: No inbound transactions allowed > + * @RISCV_IOMMU_DDTP_MODE_BARE: Pass-through mode > + * @RISCV_IOMMU_DDTP_MODE_1LVL: One-level DDT > + * @RISCV_IOMMU_DDTP_MODE_2LVL: Two-level DDT > + * @RISCV_IOMMU_DDTP_MODE_3LVL: Three-level DDT > + * @RISCV_IOMMU_DDTP_MODE_MAX: Max value allowed by specification > + */ > +enum riscv_iommu_ddtp_modes { > + RISCV_IOMMU_DDTP_MODE_OFF = 0, > + RISCV_IOMMU_DDTP_MODE_BARE = 1, > + RISCV_IOMMU_DDTP_MODE_1LVL = 2, > + RISCV_IOMMU_DDTP_MODE_2LVL = 3, > + RISCV_IOMMU_DDTP_MODE_3LVL = 4, > + RISCV_IOMMU_DDTP_MODE_MAX = 4 > +}; > + > +/* 5.6 Command Queue Base (64bits) */ > +#define RISCV_IOMMU_REG_CQB 0x0018 > +#define RISCV_IOMMU_CQB_ENTRIES RISCV_IOMMU_QUEUE_LOGSZ_FIELD > +#define RISCV_IOMMU_CQB_PPN RISCV_IOMMU_PPN_FIELD > + > +/* 5.7 Command Queue head (32bits) */ > +#define RISCV_IOMMU_REG_CQH 0x0020 > +#define RISCV_IOMMU_CQH_INDEX RISCV_IOMMU_QUEUE_INDEX_FIELD > + > +/* 5.8 Command Queue tail (32bits) */ > +#define RISCV_IOMMU_REG_CQT 0x0024 > +#define RISCV_IOMMU_CQT_INDEX RISCV_IOMMU_QUEUE_INDEX_FIELD > + > +/* 5.9 Fault Queue Base (64bits) */ > +#define RISCV_IOMMU_REG_FQB 0x0028 > +#define RISCV_IOMMU_FQB_ENTRIES RISCV_IOMMU_QUEUE_LOGSZ_FIELD > +#define RISCV_IOMMU_FQB_PPN RISCV_IOMMU_PPN_FIELD > + > +/* 5.10 Fault Queue Head (32bits) */ > +#define RISCV_IOMMU_REG_FQH 0x0030 > +#define RISCV_IOMMU_FQH_INDEX RISCV_IOMMU_QUEUE_INDEX_FIELD > + > +/* 5.11 Fault Queue tail (32bits) */ > +#define RISCV_IOMMU_REG_FQT 0x0034 > +#define RISCV_IOMMU_FQT_INDEX RISCV_IOMMU_QUEUE_INDEX_FIELD > + > +/* 5.12 Page Request Queue base (64bits) */ > +#define RISCV_IOMMU_REG_PQB 0x0038 > +#define RISCV_IOMMU_PQB_ENTRIES RISCV_IOMMU_QUEUE_LOGSZ_FIELD > +#define RISCV_IOMMU_PQB_PPN RISCV_IOMMU_PPN_FIELD > + > +/* 5.13 Page Request Queue head (32bits) */ > +#define RISCV_IOMMU_REG_PQH 0x0040 > +#define RISCV_IOMMU_PQH_INDEX RISCV_IOMMU_QUEUE_INDEX_FIELD > + > +/* 5.14 Page Request Queue tail (32bits) */ > +#define RISCV_IOMMU_REG_PQT 0x0044 > +#define RISCV_IOMMU_PQT_INDEX_MASK RISCV_IOMMU_QUEUE_INDEX_FIELD > + > +/* 5.15 Command Queue CSR (32bits) */ > +#define RISCV_IOMMU_REG_CQCSR 0x0048 > +#define RISCV_IOMMU_CQCSR_CQEN RISCV_IOMMU_QUEUE_ENABLE > +#define RISCV_IOMMU_CQCSR_CIE RISCV_IOMMU_QUEUE_INTR_ENABLE > +#define RISCV_IOMMU_CQCSR_CQMF RISCV_IOMMU_QUEUE_MEM_FAULT > +#define RISCV_IOMMU_CQCSR_CMD_TO BIT(9) > +#define RISCV_IOMMU_CQCSR_CMD_ILL BIT(10) > +#define RISCV_IOMMU_CQCSR_FENCE_W_IP BIT(11) > +#define RISCV_IOMMU_CQCSR_CQON RISCV_IOMMU_QUEUE_ACTIVE > +#define RISCV_IOMMU_CQCSR_BUSY RISCV_IOMMU_QUEUE_BUSY > + > +/* 5.16 Fault Queue CSR (32bits) */ > +#define RISCV_IOMMU_REG_FQCSR 0x004C > +#define RISCV_IOMMU_FQCSR_FQEN RISCV_IOMMU_QUEUE_ENABLE > +#define RISCV_IOMMU_FQCSR_FIE RISCV_IOMMU_QUEUE_INTR_ENABLE > +#define RISCV_IOMMU_FQCSR_FQMF RISCV_IOMMU_QUEUE_MEM_FAULT > +#define RISCV_IOMMU_FQCSR_FQOF RISCV_IOMMU_QUEUE_OVERFLOW > +#define RISCV_IOMMU_FQCSR_FQON RISCV_IOMMU_QUEUE_ACTIVE > +#define RISCV_IOMMU_FQCSR_BUSY RISCV_IOMMU_QUEUE_BUSY > + > +/* 5.17 Page Request Queue CSR (32bits) */ > +#define RISCV_IOMMU_REG_PQCSR 0x0050 > +#define RISCV_IOMMU_PQCSR_PQEN RISCV_IOMMU_QUEUE_ENABLE > +#define RISCV_IOMMU_PQCSR_PIE RISCV_IOMMU_QUEUE_INTR_ENABLE > +#define RISCV_IOMMU_PQCSR_PQMF RISCV_IOMMU_QUEUE_MEM_FAULT > +#define RISCV_IOMMU_PQCSR_PQOF RISCV_IOMMU_QUEUE_OVERFLOW > +#define RISCV_IOMMU_PQCSR_PQON RISCV_IOMMU_QUEUE_ACTIVE > +#define RISCV_IOMMU_PQCSR_BUSY RISCV_IOMMU_QUEUE_BUSY > + > +/* 5.18 Interrupt Pending Status (32bits) */ > +#define RISCV_IOMMU_REG_IPSR 0x0054 > + > +#define RISCV_IOMMU_INTR_CQ 0 > +#define RISCV_IOMMU_INTR_FQ 1 > +#define RISCV_IOMMU_INTR_PM 2 > +#define RISCV_IOMMU_INTR_PQ 3 > +#define RISCV_IOMMU_INTR_COUNT 4 > + > +#define RISCV_IOMMU_IPSR_CIP BIT(RISCV_IOMMU_INTR_CQ) > +#define RISCV_IOMMU_IPSR_FIP BIT(RISCV_IOMMU_INTR_FQ) > +#define RISCV_IOMMU_IPSR_PMIP BIT(RISCV_IOMMU_INTR_PM) > +#define RISCV_IOMMU_IPSR_PIP BIT(RISCV_IOMMU_INTR_PQ) > + > +/* 5.19 Performance monitoring counter overflow status (32bits) */ > +#define RISCV_IOMMU_REG_IOCOUNTOVF 0x0058 > +#define RISCV_IOMMU_IOCOUNTOVF_CY BIT(0) > +#define RISCV_IOMMU_IOCOUNTOVF_HPM GENMASK_ULL(31, 1) > + > +/* 5.20 Performance monitoring counter inhibits (32bits) */ > +#define RISCV_IOMMU_REG_IOCOUNTINH 0x005C > +#define RISCV_IOMMU_IOCOUNTINH_CY BIT(0) > +#define RISCV_IOMMU_IOCOUNTINH_HPM GENMASK(31, 1) > + > +/* 5.21 Performance monitoring cycles counter (64bits) */ > +#define RISCV_IOMMU_REG_IOHPMCYCLES 0x0060 > +#define RISCV_IOMMU_IOHPMCYCLES_COUNTER GENMASK_ULL(62, 0) > +#define RISCV_IOMMU_IOHPMCYCLES_OVF BIT_ULL(63) > + > +/* 5.22 Performance monitoring event counters (31 * 64bits) */ > +#define RISCV_IOMMU_REG_IOHPMCTR_BASE 0x0068 > +#define RISCV_IOMMU_REG_IOHPMCTR(_n) (RISCV_IOMMU_REG_IOHPMCTR_BASE + ((_n) * 0x8)) > + > +/* 5.23 Performance monitoring event selectors (31 * 64bits) */ > +#define RISCV_IOMMU_REG_IOHPMEVT_BASE 0x0160 > +#define RISCV_IOMMU_REG_IOHPMEVT(_n) (RISCV_IOMMU_REG_IOHPMEVT_BASE + ((_n) * 0x8)) > +#define RISCV_IOMMU_IOHPMEVT_CNT 31 > +#define RISCV_IOMMU_IOHPMEVT_EVENT_ID GENMASK_ULL(14, 0) > +#define RISCV_IOMMU_IOHPMEVT_DMASK BIT_ULL(15) > +#define RISCV_IOMMU_IOHPMEVT_PID_PSCID GENMASK_ULL(35, 16) > +#define RISCV_IOMMU_IOHPMEVT_DID_GSCID GENMASK_ULL(59, 36) > +#define RISCV_IOMMU_IOHPMEVT_PV_PSCV BIT_ULL(60) > +#define RISCV_IOMMU_IOHPMEVT_DV_GSCV BIT_ULL(61) > +#define RISCV_IOMMU_IOHPMEVT_IDT BIT_ULL(62) > +#define RISCV_IOMMU_IOHPMEVT_OF BIT_ULL(63) > + > +/** > + * enum riscv_iommu_hpmevent_id - Performance-monitoring event identifier > + * > + * @RISCV_IOMMU_HPMEVENT_INVALID: Invalid event, do not count > + * @RISCV_IOMMU_HPMEVENT_URQ: Untranslated requests > + * @RISCV_IOMMU_HPMEVENT_TRQ: Translated requests > + * @RISCV_IOMMU_HPMEVENT_ATS_RQ: ATS translation requests > + * @RISCV_IOMMU_HPMEVENT_TLB_MISS: TLB misses > + * @RISCV_IOMMU_HPMEVENT_DD_WALK: Device directory walks > + * @RISCV_IOMMU_HPMEVENT_PD_WALK: Process directory walks > + * @RISCV_IOMMU_HPMEVENT_S_VS_WALKS: S/VS-Stage page table walks > + * @RISCV_IOMMU_HPMEVENT_G_WALKS: G-Stage page table walks > + * @RISCV_IOMMU_HPMEVENT_MAX: Value to denote maximum Event IDs > + */ > +enum riscv_iommu_hpmevent_id { > + RISCV_IOMMU_HPMEVENT_INVALID = 0, > + RISCV_IOMMU_HPMEVENT_URQ = 1, > + RISCV_IOMMU_HPMEVENT_TRQ = 2, > + RISCV_IOMMU_HPMEVENT_ATS_RQ = 3, > + RISCV_IOMMU_HPMEVENT_TLB_MISS = 4, > + RISCV_IOMMU_HPMEVENT_DD_WALK = 5, > + RISCV_IOMMU_HPMEVENT_PD_WALK = 6, > + RISCV_IOMMU_HPMEVENT_S_VS_WALKS = 7, > + RISCV_IOMMU_HPMEVENT_G_WALKS = 8, > + RISCV_IOMMU_HPMEVENT_MAX = 9 > +}; > + > +/* 5.24 Translation request IOVA (64bits) */ > +#define RISCV_IOMMU_REG_TR_REQ_IOVA 0x0258 > +#define RISCV_IOMMU_TR_REQ_IOVA_VPN GENMASK_ULL(63, 12) > + > +/* 5.25 Translation request control (64bits) */ > +#define RISCV_IOMMU_REG_TR_REQ_CTL 0x0260 > +#define RISCV_IOMMU_TR_REQ_CTL_GO_BUSY BIT_ULL(0) > +#define RISCV_IOMMU_TR_REQ_CTL_PRIV BIT_ULL(1) > +#define RISCV_IOMMU_TR_REQ_CTL_EXE BIT_ULL(2) > +#define RISCV_IOMMU_TR_REQ_CTL_NW BIT_ULL(3) > +#define RISCV_IOMMU_TR_REQ_CTL_PID GENMASK_ULL(31, 12) > +#define RISCV_IOMMU_TR_REQ_CTL_PV BIT_ULL(32) > +#define RISCV_IOMMU_TR_REQ_CTL_DID GENMASK_ULL(63, 40) > + > +/* 5.26 Translation request response (64bits) */ > +#define RISCV_IOMMU_REG_TR_RESPONSE 0x0268 > +#define RISCV_IOMMU_TR_RESPONSE_FAULT BIT_ULL(0) > +#define RISCV_IOMMU_TR_RESPONSE_PBMT GENMASK_ULL(8, 7) > +#define RISCV_IOMMU_TR_RESPONSE_SZ BIT_ULL(9) > +#define RISCV_IOMMU_TR_RESPONSE_PPN RISCV_IOMMU_PPN_FIELD > + > +/* 5.27 Interrupt cause to vector (64bits) */ > +#define RISCV_IOMMU_REG_IVEC 0x02F8 > +#define RISCV_IOMMU_IVEC_CIV GENMASK_ULL(3, 0) > +#define RISCV_IOMMU_IVEC_FIV GENMASK_ULL(7, 4) > +#define RISCV_IOMMU_IVEC_PMIV GENMASK_ULL(11, 8) > +#define RISCV_IOMMU_IVEC_PIV GENMASK_ULL(15, 12) > + > +/* 5.28 MSI Configuration table (32 * 64bits) */ > +#define RISCV_IOMMU_REG_MSI_CONFIG 0x0300 > +#define RISCV_IOMMU_REG_MSI_ADDR(_n) (RISCV_IOMMU_REG_MSI_CONFIG + ((_n) * 0x10)) > +#define RISCV_IOMMU_MSI_ADDR GENMASK_ULL(55, 2) > +#define RISCV_IOMMU_REG_MSI_DATA(_n) (RISCV_IOMMU_REG_MSI_CONFIG + ((_n) * 0x10) + 0x08) > +#define RISCV_IOMMU_MSI_DATA GENMASK_ULL(31, 0) > +#define RISCV_IOMMU_REG_MSI_VEC_CTL(_n) (RISCV_IOMMU_REG_MSI_CONFIG + ((_n) * 0x10) + 0x0C) > +#define RISCV_IOMMU_MSI_VEC_CTL_M BIT_ULL(0) > + > +#define RISCV_IOMMU_REG_SIZE 0x1000 > + > +/* > + * Chapter 2: Data structures > + */ > + > +/* > + * Device Directory Table macros for non-leaf nodes > + */ > +#define RISCV_IOMMU_DDTE_VALID BIT_ULL(0) > +#define RISCV_IOMMU_DDTE_PPN RISCV_IOMMU_PPN_FIELD > + > +/** > + * struct riscv_iommu_dc - Device Context > + * @tc: Translation Control > + * @iohgatp: I/O Hypervisor guest address translation and protection > + * (Second stage context) > + * @ta: Translation Attributes > + * @fsc: First stage context > + * @msiptp: MSI page table pointer > + * @msi_addr_mask: MSI address mask > + * @msi_addr_pattern: MSI address pattern > + * @_reserved: Reserved for future use, padding > + * > + * This structure is used for leaf nodes on the Device Directory Table, > + * in case RISCV_IOMMU_CAP_MSI_FLAT is not set, the bottom 4 fields are > + * not present and are skipped with pointer arithmetic to avoid > + * casting, check out riscv_iommu_get_dc(). > + * See section 2.1 for more details > + */ > +struct riscv_iommu_dc { > + u64 tc; > + u64 iohgatp; > + u64 ta; > + u64 fsc; > + u64 msiptp; > + u64 msi_addr_mask; > + u64 msi_addr_pattern; > + u64 _reserved; > +}; > + > +/* Translation control fields */ > +#define RISCV_IOMMU_DC_TC_V BIT_ULL(0) > +#define RISCV_IOMMU_DC_TC_EN_ATS BIT_ULL(1) > +#define RISCV_IOMMU_DC_TC_EN_PRI BIT_ULL(2) > +#define RISCV_IOMMU_DC_TC_T2GPA BIT_ULL(3) > +#define RISCV_IOMMU_DC_TC_DTF BIT_ULL(4) > +#define RISCV_IOMMU_DC_TC_PDTV BIT_ULL(5) > +#define RISCV_IOMMU_DC_TC_PRPR BIT_ULL(6) > +#define RISCV_IOMMU_DC_TC_GADE BIT_ULL(7) > +#define RISCV_IOMMU_DC_TC_SADE BIT_ULL(8) > +#define RISCV_IOMMU_DC_TC_DPE BIT_ULL(9) > +#define RISCV_IOMMU_DC_TC_SBE BIT_ULL(10) > +#define RISCV_IOMMU_DC_TC_SXL BIT_ULL(11) > + > +/* Second-stage (aka G-stage) context fields */ > +#define RISCV_IOMMU_DC_IOHGATP_PPN RISCV_IOMMU_ATP_PPN_FIELD > +#define RISCV_IOMMU_DC_IOHGATP_GSCID GENMASK_ULL(59, 44) > +#define RISCV_IOMMU_DC_IOHGATP_MODE RISCV_IOMMU_ATP_MODE_FIELD > + > +/** > + * enum riscv_iommu_dc_iohgatp_modes - Guest address translation/protection modes > + * @RISCV_IOMMU_DC_IOHGATP_MODE_BARE: No translation/protection > + * @RISCV_IOMMU_DC_IOHGATP_MODE_SV32X4: Sv32x4 (2-bit extension of Sv32), when fctl.GXL == 1 > + * @RISCV_IOMMU_DC_IOHGATP_MODE_SV39X4: Sv39x4 (2-bit extension of Sv39), when fctl.GXL == 0 > + * @RISCV_IOMMU_DC_IOHGATP_MODE_SV48X4: Sv48x4 (2-bit extension of Sv48), when fctl.GXL == 0 > + * @RISCV_IOMMU_DC_IOHGATP_MODE_SV57X4: Sv57x4 (2-bit extension of Sv57), when fctl.GXL == 0 > + */ > +enum riscv_iommu_dc_iohgatp_modes { > + RISCV_IOMMU_DC_IOHGATP_MODE_BARE = 0, > + RISCV_IOMMU_DC_IOHGATP_MODE_SV32X4 = 8, > + RISCV_IOMMU_DC_IOHGATP_MODE_SV39X4 = 8, > + RISCV_IOMMU_DC_IOHGATP_MODE_SV48X4 = 9, > + RISCV_IOMMU_DC_IOHGATP_MODE_SV57X4 = 10 > +}; > + > +/* Translation attributes fields */ > +#define RISCV_IOMMU_DC_TA_PSCID GENMASK_ULL(31, 12) > + > +/* First-stage context fields */ > +#define RISCV_IOMMU_DC_FSC_PPN RISCV_IOMMU_ATP_PPN_FIELD > +#define RISCV_IOMMU_DC_FSC_MODE RISCV_IOMMU_ATP_MODE_FIELD > + > +/** > + * enum riscv_iommu_dc_fsc_atp_modes - First stage address translation/protection modes > + * @RISCV_IOMMU_DC_FSC_MODE_BARE: No translation/protection > + * @RISCV_IOMMU_DC_FSC_IOSATP_MODE_SV32: Sv32, when dc.tc.SXL == 1 > + * @RISCV_IOMMU_DC_FSC_IOSATP_MODE_SV39: Sv39, when dc.tc.SXL == 0 > + * @RISCV_IOMMU_DC_FSC_IOSATP_MODE_SV48: Sv48, when dc.tc.SXL == 0 > + * @RISCV_IOMMU_DC_FSC_IOSATP_MODE_SV57: Sv57, when dc.tc.SXL == 0 > + * @RISCV_IOMMU_DC_FSC_PDTP_MODE_PD8: 1lvl PDT, 8bit process ids > + * @RISCV_IOMMU_DC_FSC_PDTP_MODE_PD17: 2lvl PDT, 17bit process ids > + * @RISCV_IOMMU_DC_FSC_PDTP_MODE_PD20: 3lvl PDT, 20bit process ids > + * > + * FSC holds IOSATP when RISCV_IOMMU_DC_TC_PDTV is 0 and PDTP otherwise. > + * IOSATP controls the first stage address translation (same as the satp register on > + * the RISC-V MMU), and PDTP holds the process directory table, used to select a > + * first stage page table based on a process id (for devices that support multiple > + * process ids). > + */ > +enum riscv_iommu_dc_fsc_atp_modes { > + RISCV_IOMMU_DC_FSC_MODE_BARE = 0, > + RISCV_IOMMU_DC_FSC_IOSATP_MODE_SV32 = 8, > + RISCV_IOMMU_DC_FSC_IOSATP_MODE_SV39 = 8, > + RISCV_IOMMU_DC_FSC_IOSATP_MODE_SV48 = 9, > + RISCV_IOMMU_DC_FSC_IOSATP_MODE_SV57 = 10, > + RISCV_IOMMU_DC_FSC_PDTP_MODE_PD8 = 1, > + RISCV_IOMMU_DC_FSC_PDTP_MODE_PD17 = 2, > + RISCV_IOMMU_DC_FSC_PDTP_MODE_PD20 = 3 > +}; > + > +/* MSI page table pointer */ > +#define RISCV_IOMMU_DC_MSIPTP_PPN RISCV_IOMMU_ATP_PPN_FIELD > +#define RISCV_IOMMU_DC_MSIPTP_MODE RISCV_IOMMU_ATP_MODE_FIELD > +#define RISCV_IOMMU_DC_MSIPTP_MODE_OFF 0 > +#define RISCV_IOMMU_DC_MSIPTP_MODE_FLAT 1 > + > +/* MSI address mask */ > +#define RISCV_IOMMU_DC_MSI_ADDR_MASK GENMASK_ULL(51, 0) > + > +/* MSI address pattern */ > +#define RISCV_IOMMU_DC_MSI_PATTERN GENMASK_ULL(51, 0) > + > +/** > + * struct riscv_iommu_pc - Process Context > + * @ta: Translation Attributes > + * @fsc: First stage context > + * > + * This structure is used for leaf nodes on the Process Directory Table > + * See section 2.3 for more details > + */ > +struct riscv_iommu_pc { > + u64 ta; > + u64 fsc; > +}; > + > +/* Translation attributes fields */ > +#define RISCV_IOMMU_PC_TA_V BIT_ULL(0) > +#define RISCV_IOMMU_PC_TA_ENS BIT_ULL(1) > +#define RISCV_IOMMU_PC_TA_SUM BIT_ULL(2) > +#define RISCV_IOMMU_PC_TA_PSCID GENMASK_ULL(31, 12) > + > +/* First stage context fields */ > +#define RISCV_IOMMU_PC_FSC_PPN RISCV_IOMMU_ATP_PPN_FIELD > +#define RISCV_IOMMU_PC_FSC_MODE RISCV_IOMMU_ATP_MODE_FIELD > + > +/* > + * Chapter 3: In-memory queue interface > + */ > + > +/** > + * struct riscv_iommu_command - Generic I/O MMU command structure > + * @dword0: Includes the opcode and the function identifier > + * @dword1: Opcode specific data > + * > + * The commands are interpreted as two 64bit fields, where the first > + * 7bits of the first field are the opcode which also defines the > + * command's format, followed by a 3bit field that specifies the > + * function invoked by that command, and the rest is opcode-specific. > + * This is a generic struct which will be populated differently > + * according to each command. For more infos on the commands and > + * the command queue check section 3.1. > + */ > +struct riscv_iommu_command { > + u64 dword0; > + u64 dword1; > +}; > + > +/* Fields on dword0, common for all commands */ > +#define RISCV_IOMMU_CMD_OPCODE GENMASK_ULL(6, 0) > +#define RISCV_IOMMU_CMD_FUNC GENMASK_ULL(9, 7) > + > +/* 3.1.1 I/O MMU Page-table cache invalidation */ > +/* Fields on dword0 */ > +#define RISCV_IOMMU_CMD_IOTINVAL_OPCODE 1 > +#define RISCV_IOMMU_CMD_IOTINVAL_FUNC_VMA 0 > +#define RISCV_IOMMU_CMD_IOTINVAL_FUNC_GVMA 1 > +#define RISCV_IOMMU_CMD_IOTINVAL_AV BIT_ULL(10) > +#define RISCV_IOMMU_CMD_IOTINVAL_PSCID GENMASK_ULL(31, 12) > +#define RISCV_IOMMU_CMD_IOTINVAL_PSCV BIT_ULL(32) > +#define RISCV_IOMMU_CMD_IOTINVAL_GV BIT_ULL(33) > +#define RISCV_IOMMU_CMD_IOTINVAL_GSCID GENMASK_ULL(59, 44) > +/* dword1[61:10] is the 4K-aligned page address */ > +#define RISCV_IOMMU_CMD_IOTINVAL_ADDR GENMASK_ULL(61, 10) > + > +/* 3.1.2 I/O MMU Command Queue Fences */ > +/* Fields on dword0 */ > +#define RISCV_IOMMU_CMD_IOFENCE_OPCODE 2 > +#define RISCV_IOMMU_CMD_IOFENCE_FUNC_C 0 > +#define RISCV_IOMMU_CMD_IOFENCE_AV BIT_ULL(10) > +#define RISCV_IOMMU_CMD_IOFENCE_WSI BIT_ULL(11) > +#define RISCV_IOMMU_CMD_IOFENCE_PR BIT_ULL(12) > +#define RISCV_IOMMU_CMD_IOFENCE_PW BIT_ULL(13) > +#define RISCV_IOMMU_CMD_IOFENCE_DATA GENMASK_ULL(63, 32) > +/* dword1 is the address, word-size aligned and shifted to the right by two bits. */ > + > +/* 3.1.3 I/O MMU Directory cache invalidation */ > +/* Fields on dword0 */ > +#define RISCV_IOMMU_CMD_IODIR_OPCODE 3 > +#define RISCV_IOMMU_CMD_IODIR_FUNC_INVAL_DDT 0 > +#define RISCV_IOMMU_CMD_IODIR_FUNC_INVAL_PDT 1 > +#define RISCV_IOMMU_CMD_IODIR_PID GENMASK_ULL(31, 12) > +#define RISCV_IOMMU_CMD_IODIR_DV BIT_ULL(33) > +#define RISCV_IOMMU_CMD_IODIR_DID GENMASK_ULL(63, 40) > +/* dword1 is reserved for standard use */ > + > +/* 3.1.4 I/O MMU PCIe ATS */ > +/* Fields on dword0 */ > +#define RISCV_IOMMU_CMD_ATS_OPCODE 4 > +#define RISCV_IOMMU_CMD_ATS_FUNC_INVAL 0 > +#define RISCV_IOMMU_CMD_ATS_FUNC_PRGR 1 > +#define RISCV_IOMMU_CMD_ATS_PID GENMASK_ULL(31, 12) > +#define RISCV_IOMMU_CMD_ATS_PV BIT_ULL(32) > +#define RISCV_IOMMU_CMD_ATS_DSV BIT_ULL(33) > +#define RISCV_IOMMU_CMD_ATS_RID GENMASK_ULL(55, 40) > +#define RISCV_IOMMU_CMD_ATS_DSEG GENMASK_ULL(63, 56) > +/* dword1 is the ATS payload, two different payload types for INVAL and PRGR */ > + > +/* ATS.INVAL payload*/ > +#define RISCV_IOMMU_CMD_ATS_INVAL_G BIT_ULL(0) > +/* Bits 1 - 10 are zeroed */ > +#define RISCV_IOMMU_CMD_ATS_INVAL_S BIT_ULL(11) > +#define RISCV_IOMMU_CMD_ATS_INVAL_UADDR GENMASK_ULL(63, 12) > + > +/* ATS.PRGR payload */ > +/* Bits 0 - 31 are zeroed */ > +#define RISCV_IOMMU_CMD_ATS_PRGR_PRG_INDEX GENMASK_ULL(40, 32) > +/* Bits 41 - 43 are zeroed */ > +#define RISCV_IOMMU_CMD_ATS_PRGR_RESP_CODE GENMASK_ULL(47, 44) > +#define RISCV_IOMMU_CMD_ATS_PRGR_DST_ID GENMASK_ULL(63, 48) > + > +/** > + * struct riscv_iommu_fq_record - Fault/Event Queue Record > + * @hdr: Header, includes fault/event cause, PID/DID, transaction type etc > + * @_reserved: Low 32bits for custom use, high 32bits for standard use > + * @iotval: Transaction-type/cause specific format > + * @iotval2: Cause specific format > + * > + * The fault/event queue reports events and failures raised when > + * processing transactions. Each record is a 32byte structure where > + * the first dword has a fixed format for providing generic infos > + * regarding the fault/event, and two more dwords are there for > + * fault/event-specific information. For more details see section > + * 3.2. > + */ > +struct riscv_iommu_fq_record { > + u64 hdr; > + u64 _reserved; > + u64 iotval; > + u64 iotval2; > +}; > + > +/* Fields on header */ > +#define RISCV_IOMMU_FQ_HDR_CAUSE GENMASK_ULL(11, 0) > +#define RISCV_IOMMU_FQ_HDR_PID GENMASK_ULL(31, 12) > +#define RISCV_IOMMU_FQ_HDR_PV BIT_ULL(32) > +#define RISCV_IOMMU_FQ_HDR_PRIV BIT_ULL(33) > +#define RISCV_IOMMU_FQ_HDR_TTYPE GENMASK_ULL(39, 34) > +#define RISCV_IOMMU_FQ_HDR_DID GENMASK_ULL(63, 40) > + > +/** > + * enum riscv_iommu_fq_causes - Fault/event cause values > + * @RISCV_IOMMU_FQ_CAUSE_INST_FAULT: Instruction access fault > + * @RISCV_IOMMU_FQ_CAUSE_RD_ADDR_MISALIGNED: Read address misaligned > + * @RISCV_IOMMU_FQ_CAUSE_RD_FAULT: Read load fault > + * @RISCV_IOMMU_FQ_CAUSE_WR_ADDR_MISALIGNED: Write/AMO address misaligned > + * @RISCV_IOMMU_FQ_CAUSE_WR_FAULT: Write/AMO access fault > + * @RISCV_IOMMU_FQ_CAUSE_INST_FAULT_S: Instruction page fault > + * @RISCV_IOMMU_FQ_CAUSE_RD_FAULT_S: Read page fault > + * @RISCV_IOMMU_FQ_CAUSE_WR_FAULT_S: Write/AMO page fault > + * @RISCV_IOMMU_FQ_CAUSE_INST_FAULT_VS: Instruction guest page fault > + * @RISCV_IOMMU_FQ_CAUSE_RD_FAULT_VS: Read guest page fault > + * @RISCV_IOMMU_FQ_CAUSE_WR_FAULT_VS: Write/AMO guest page fault > + * @RISCV_IOMMU_FQ_CAUSE_DMA_DISABLED: All inbound transactions disallowed > + * @RISCV_IOMMU_FQ_CAUSE_DDT_LOAD_FAULT: DDT entry load access fault > + * @RISCV_IOMMU_FQ_CAUSE_DDT_INVALID: DDT entry invalid > + * @RISCV_IOMMU_FQ_CAUSE_DDT_MISCONFIGURED: DDT entry misconfigured > + * @RISCV_IOMMU_FQ_CAUSE_TTYPE_BLOCKED: Transaction type disallowed > + * @RISCV_IOMMU_FQ_CAUSE_MSI_LOAD_FAULT: MSI PTE load access fault > + * @RISCV_IOMMU_FQ_CAUSE_MSI_INVALID: MSI PTE invalid > + * @RISCV_IOMMU_FQ_CAUSE_MSI_MISCONFIGURED: MSI PTE misconfigured > + * @RISCV_IOMMU_FQ_CAUSE_MRIF_FAULT: MRIF access fault > + * @RISCV_IOMMU_FQ_CAUSE_PDT_LOAD_FAULT: PDT entry load access fault > + * @RISCV_IOMMU_FQ_CAUSE_PDT_INVALID: PDT entry invalid > + * @RISCV_IOMMU_FQ_CAUSE_PDT_MISCONFIGURED: PDT entry misconfigured > + * @RISCV_IOMMU_FQ_CAUSE_DDT_CORRUPTED: DDT data corruption > + * @RISCV_IOMMU_FQ_CAUSE_PDT_CORRUPTED: PDT data corruption > + * @RISCV_IOMMU_FQ_CAUSE_MSI_PT_CORRUPTED: MSI page table data corruption > + * @RISCV_IOMMU_FQ_CAUSE_MRIF_CORRUIPTED: MRIF data corruption > + * @RISCV_IOMMU_FQ_CAUSE_INTERNAL_DP_ERROR: Internal data path error > + * @RISCV_IOMMU_FQ_CAUSE_MSI_WR_FAULT: IOMMU MSI write access fault > + * @RISCV_IOMMU_FQ_CAUSE_PT_CORRUPTED: First/second stage page table data corruption > + * > + * Values are on table 11 of the spec, encodings 275 - 2047 are reserved for standard > + * use, and 2048 - 4095 for custom use. > + */ > +enum riscv_iommu_fq_causes { > + RISCV_IOMMU_FQ_CAUSE_INST_FAULT = 1, > + RISCV_IOMMU_FQ_CAUSE_RD_ADDR_MISALIGNED = 4, > + RISCV_IOMMU_FQ_CAUSE_RD_FAULT = 5, > + RISCV_IOMMU_FQ_CAUSE_WR_ADDR_MISALIGNED = 6, > + RISCV_IOMMU_FQ_CAUSE_WR_FAULT = 7, > + RISCV_IOMMU_FQ_CAUSE_INST_FAULT_S = 12, > + RISCV_IOMMU_FQ_CAUSE_RD_FAULT_S = 13, > + RISCV_IOMMU_FQ_CAUSE_WR_FAULT_S = 15, > + RISCV_IOMMU_FQ_CAUSE_INST_FAULT_VS = 20, > + RISCV_IOMMU_FQ_CAUSE_RD_FAULT_VS = 21, > + RISCV_IOMMU_FQ_CAUSE_WR_FAULT_VS = 23, > + RISCV_IOMMU_FQ_CAUSE_DMA_DISABLED = 256, > + RISCV_IOMMU_FQ_CAUSE_DDT_LOAD_FAULT = 257, > + RISCV_IOMMU_FQ_CAUSE_DDT_INVALID = 258, > + RISCV_IOMMU_FQ_CAUSE_DDT_MISCONFIGURED = 259, > + RISCV_IOMMU_FQ_CAUSE_TTYPE_BLOCKED = 260, > + RISCV_IOMMU_FQ_CAUSE_MSI_LOAD_FAULT = 261, > + RISCV_IOMMU_FQ_CAUSE_MSI_INVALID = 262, > + RISCV_IOMMU_FQ_CAUSE_MSI_MISCONFIGURED = 263, > + RISCV_IOMMU_FQ_CAUSE_MRIF_FAULT = 264, > + RISCV_IOMMU_FQ_CAUSE_PDT_LOAD_FAULT = 265, > + RISCV_IOMMU_FQ_CAUSE_PDT_INVALID = 266, > + RISCV_IOMMU_FQ_CAUSE_PDT_MISCONFIGURED = 267, > + RISCV_IOMMU_FQ_CAUSE_DDT_CORRUPTED = 268, > + RISCV_IOMMU_FQ_CAUSE_PDT_CORRUPTED = 269, > + RISCV_IOMMU_FQ_CAUSE_MSI_PT_CORRUPTED = 270, > + RISCV_IOMMU_FQ_CAUSE_MRIF_CORRUIPTED = 271, > + RISCV_IOMMU_FQ_CAUSE_INTERNAL_DP_ERROR = 272, > + RISCV_IOMMU_FQ_CAUSE_MSI_WR_FAULT = 273, > + RISCV_IOMMU_FQ_CAUSE_PT_CORRUPTED = 274 > +}; > + > +/** > + * enum riscv_iommu_fq_ttypes: Fault/event transaction types > + * @RISCV_IOMMU_FQ_TTYPE_NONE: None. Fault not caused by an inbound transaction. > + * @RISCV_IOMMU_FQ_TTYPE_UADDR_INST_FETCH: Instruction fetch from untranslated address > + * @RISCV_IOMMU_FQ_TTYPE_UADDR_RD: Read from untranslated address > + * @RISCV_IOMMU_FQ_TTYPE_UADDR_WR: Write/AMO to untranslated address > + * @RISCV_IOMMU_FQ_TTYPE_TADDR_INST_FETCH: Instruction fetch from translated address > + * @RISCV_IOMMU_FQ_TTYPE_TADDR_RD: Read from translated address > + * @RISCV_IOMMU_FQ_TTYPE_TADDR_WR: Write/AMO to translated address > + * @RISCV_IOMMU_FQ_TTYPE_PCIE_ATS_REQ: PCIe ATS translation request > + * @RISCV_IOMMU_FW_TTYPE_PCIE_MSG_REQ: PCIe message request > + * > + * Values are on table 12 of the spec, type 4 and 10 - 31 are reserved for standard use > + * and 31 - 63 for custom use. > + */ > +enum riscv_iommu_fq_ttypes { > + RISCV_IOMMU_FQ_TTYPE_NONE = 0, > + RISCV_IOMMU_FQ_TTYPE_UADDR_INST_FETCH = 1, > + RISCV_IOMMU_FQ_TTYPE_UADDR_RD = 2, > + RISCV_IOMMU_FQ_TTYPE_UADDR_WR = 3, > + RISCV_IOMMU_FQ_TTYPE_TADDR_INST_FETCH = 5, > + RISCV_IOMMU_FQ_TTYPE_TADDR_RD = 6, > + RISCV_IOMMU_FQ_TTYPE_TADDR_WR = 7, > + RISCV_IOMMU_FQ_TTYPE_PCIE_ATS_REQ = 8, > + RISCV_IOMMU_FW_TTYPE_PCIE_MSG_REQ = 9, > +}; > + > +/** > + * struct riscv_iommu_pq_record - PCIe Page Request record > + * @hdr: Header, includes PID, DID etc > + * @payload: Holds the page address, request group and permission bits > + * > + * For more infos on the PCIe Page Request queue see chapter 3.3. > + */ > +struct riscv_iommu_pq_record { > + u64 hdr; > + u64 payload; > +}; > + > +/* Header fields */ > +#define RISCV_IOMMU_PREQ_HDR_PID GENMASK_ULL(31, 12) > +#define RISCV_IOMMU_PREQ_HDR_PV BIT_ULL(32) > +#define RISCV_IOMMU_PREQ_HDR_PRIV BIT_ULL(33) > +#define RISCV_IOMMU_PREQ_HDR_EXEC BIT_ULL(34) > +#define RISCV_IOMMU_PREQ_HDR_DID GENMASK_ULL(63, 40) > + > +/* Payload fields */ > +#define RISCV_IOMMU_PREQ_PAYLOAD_R BIT_ULL(0) > +#define RISCV_IOMMU_PREQ_PAYLOAD_W BIT_ULL(1) > +#define RISCV_IOMMU_PREQ_PAYLOAD_L BIT_ULL(2) > +#define RISCV_IOMMU_PREQ_PAYLOAD_M GENMASK_ULL(2, 0) /* Mask of RWL for convenience */ > +#define RISCV_IOMMU_PREQ_PRG_INDEX GENMASK_ULL(11, 3) > +#define RISCV_IOMMU_PREQ_UADDR GENMASK_ULL(63, 12) > + > +/** > + * struct riscv_iommu_msi_pte - MSI Page Table Entry > + * @pte: MSI PTE > + * @mrif_info: Memory-resident interrupt file info > + * > + * The MSI Page Table is used for virtualizing MSIs, so that when > + * a device sends an MSI to a guest, the IOMMU can reroute it > + * by translating the MSI address, either to a guest interrupt file > + * or a memory resident interrupt file (MRIF). Note that this page table > + * is an array of MSI PTEs, not a multi-level pt, each entry > + * is a leaf entry. For more infos check out the AIA spec, chapter 9.5. > + * > + * Also in basic mode the mrif_info field is ignored by the IOMMU and can > + * be used by software, any other reserved fields on pte must be zeroed-out > + * by software. > + */ > +struct riscv_iommu_msi_pte { > + u64 pte; > + u64 mrif_info; > +}; > + > +/* Fields on pte */ > +#define RISCV_IOMMU_MSI_PTE_V BIT_ULL(0) > +#define RISCV_IOMMU_MSI_PTE_M GENMASK_ULL(2, 1) > +#define RISCV_IOMMU_MSI_PTE_MRIF_ADDR GENMASK_ULL(53, 7) /* When M == 1 (MRIF mode) */ > +#define RISCV_IOMMU_MSI_PTE_PPN RISCV_IOMMU_PPN_FIELD /* When M == 3 (basic mode) */ > +#define RISCV_IOMMU_MSI_PTE_C BIT_ULL(63) > + > +/* Fields on mrif_info */ > +#define RISCV_IOMMU_MSI_MRIF_NID GENMASK_ULL(9, 0) > +#define RISCV_IOMMU_MSI_MRIF_NPPN RISCV_IOMMU_PPN_FIELD > +#define RISCV_IOMMU_MSI_MRIF_NID_MSB BIT_ULL(60) > + > +#endif /* _RISCV_IOMMU_BITS_H_ */ > diff --git a/drivers/iommu/riscv/iommu-platform.c b/drivers/iommu/riscv/iommu-platform.c > new file mode 100644 > index 000000000000..770086ae2ab3 > --- /dev/null > +++ b/drivers/iommu/riscv/iommu-platform.c > @@ -0,0 +1,94 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * RISC-V IOMMU as a platform device > + * > + * Copyright © 2023 FORTH-ICS/CARV > + * Copyright © 2023-2024 Rivos Inc. > + * > + * Authors > + * Nick Kossifidis > + * Tomasz Jeznach > + */ > + > +#include > +#include > +#include > +#include > + > +#include "iommu-bits.h" > +#include "iommu.h" > + > +static int riscv_iommu_platform_probe(struct platform_device *pdev) > +{ > + struct device *dev = &pdev->dev; > + struct riscv_iommu_device *iommu = NULL; > + struct resource *res = NULL; > + int vec; > + > + iommu = devm_kzalloc(dev, sizeof(*iommu), GFP_KERNEL); > + if (!iommu) > + return -ENOMEM; > + > + iommu->dev = dev; > + iommu->reg = devm_platform_get_and_ioremap_resource(pdev, 0, &res); > + if (IS_ERR(iommu->reg)) > + return dev_err_probe(dev, PTR_ERR(iommu->reg), > + "could not map register region\n"); > + > + dev_set_drvdata(dev, iommu); > + > + /* Check device reported capabilities / features. */ > + iommu->caps = riscv_iommu_readq(iommu, RISCV_IOMMU_REG_CAP); > + iommu->fctl = riscv_iommu_readl(iommu, RISCV_IOMMU_REG_FCTL); > + > + /* For now we only support WSI */ > + switch (FIELD_GET(RISCV_IOMMU_CAP_IGS, iommu->caps)) { > + case RISCV_IOMMU_CAP_IGS_WSI: > + case RISCV_IOMMU_CAP_IGS_BOTH: > + break; > + default: > + return dev_err_probe(dev, -ENODEV, > + "unable to use wire-signaled interrupts\n"); > + } > + > + iommu->irqs_count = platform_irq_count(pdev); > + if (iommu->irqs_count <= 0) > + return dev_err_probe(dev, -ENODEV, > + "no IRQ resources provided\n"); > + > + for (vec = 0; vec < iommu->irqs_count; vec++) > + iommu->irqs[vec] = platform_get_irq(pdev, vec); And if I've specified 97 interrupts in my DT because I won't let schema be the boss of me? > + /* Enable wire-signaled interrupts, fctl.WSI */ > + if (!(iommu->fctl & RISCV_IOMMU_FCTL_WSI)) { > + iommu->fctl ^= RISCV_IOMMU_FCTL_WSI; Using XOR to only ever set a 0 bit to 1 seems a bit obtuse. > + riscv_iommu_writel(iommu, RISCV_IOMMU_REG_FCTL, iommu->fctl); > + } > + > + return riscv_iommu_init(iommu); > +}; > + > +static void riscv_iommu_platform_remove(struct platform_device *pdev) > +{ > + riscv_iommu_remove(dev_get_drvdata(&pdev->dev)); > +}; > + > +static const struct of_device_id riscv_iommu_of_match[] = { > + {.compatible = "riscv,iommu",}, > + {}, > +}; > + > +MODULE_DEVICE_TABLE(of, riscv_iommu_of_match); And yet it cannot be a module? > +static struct platform_driver riscv_iommu_platform_driver = { > + .probe = riscv_iommu_platform_probe, > + .remove_new = riscv_iommu_platform_remove, > + .driver = { > + .name = "riscv,iommu", > + .of_match_table = riscv_iommu_of_match, > + .suppress_bind_attrs = true, > + }, > +}; > + > +module_driver(riscv_iommu_platform_driver, platform_driver_register, > + platform_driver_unregister); module_platform_driver() is a thing. Or builtin_platform_driver(), as things currently stand. > diff --git a/drivers/iommu/riscv/iommu.c b/drivers/iommu/riscv/iommu.c > new file mode 100644 > index 000000000000..af68c89200a9 > --- /dev/null > +++ b/drivers/iommu/riscv/iommu.c > @@ -0,0 +1,89 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * IOMMU API for RISC-V IOMMU implementations. > + * > + * Copyright © 2022-2024 Rivos Inc. > + * Copyright © 2023 FORTH-ICS/CARV > + * > + * Authors > + * Tomasz Jeznach > + * Nick Kossifidis > + */ > + > +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt I guess that ends up as "iommu:"? Given that that prefix already belongs to the core code, please pick something more specific. > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "iommu-bits.h" > +#include "iommu.h" > + > +MODULE_DESCRIPTION("Driver for RISC-V IOMMU"); > +MODULE_AUTHOR("Tomasz Jeznach "); > +MODULE_AUTHOR("Nick Kossifidis "); > +MODULE_LICENSE("GPL"); > + > +/* Timeouts in [us] */ > +#define RISCV_IOMMU_DDTP_TIMEOUT 50000 > + > +static int riscv_iommu_init_check(struct riscv_iommu_device *iommu) > +{ > + u64 ddtp; > + > + /* Hardware must be configured in OFF | BARE mode at system initialization. */ > + riscv_iommu_readq_timeout(iommu, RISCV_IOMMU_REG_DDTP, > + ddtp, !(ddtp & RISCV_IOMMU_DDTP_BUSY), > + 10, RISCV_IOMMU_DDTP_TIMEOUT); > + if (FIELD_GET(RISCV_IOMMU_DDTP_MODE, ddtp) > RISCV_IOMMU_DDTP_MODE_BARE) > + return -EBUSY; It looks like RISC-V already supports kdump, so you probably want to be prepared to find the IOMMU with its pants down and deal with it from day one. > + > + /* Configure accesses to in-memory data structures for CPU-native byte order. */ > + if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) != !!(iommu->fctl & RISCV_IOMMU_FCTL_BE)) { > + if (!(iommu->caps & RISCV_IOMMU_CAP_END)) > + return -EINVAL; > + riscv_iommu_writel(iommu, RISCV_IOMMU_REG_FCTL, > + iommu->fctl ^ RISCV_IOMMU_FCTL_BE); > + iommu->fctl = riscv_iommu_readl(iommu, RISCV_IOMMU_REG_FCTL); > + if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) != !!(iommu->fctl & RISCV_IOMMU_FCTL_BE)) > + return -EINVAL; > + } That's fun. It could be reorganised to avoid the duplicate check, but it is rather majestic as-is :) > + > + dma_set_mask_and_coherent(iommu->dev, > + DMA_BIT_MASK(FIELD_GET(RISCV_IOMMU_CAP_PAS, iommu->caps))); This isn't a check, so I would think it belongs to "_init" rather than "_init_check". Thanks, Robin. > + > + return 0; > +} > + > +void riscv_iommu_remove(struct riscv_iommu_device *iommu) > +{ > + iommu_device_sysfs_remove(&iommu->iommu); > +} > + > +int riscv_iommu_init(struct riscv_iommu_device *iommu) > +{ > + int rc; > + > + rc = riscv_iommu_init_check(iommu); > + if (rc) > + return dev_err_probe(iommu->dev, rc, "unexpected device state\n"); > + /* > + * Placeholder for a complete IOMMU device initialization. > + * For now, only bare minimum: enable global identity mapping mode and register sysfs. > + */ > + riscv_iommu_writeq(iommu, RISCV_IOMMU_REG_DDTP, > + FIELD_PREP(RISCV_IOMMU_DDTP_MODE, RISCV_IOMMU_DDTP_MODE_BARE)); > + > + rc = iommu_device_sysfs_add(&iommu->iommu, NULL, NULL, "riscv-iommu@%s", > + dev_name(iommu->dev)); > + if (WARN(rc, "cannot register sysfs interface\n")) > + goto err_sysfs; > + > + return 0; > + > +err_sysfs: > + return rc; > +} > diff --git a/drivers/iommu/riscv/iommu.h b/drivers/iommu/riscv/iommu.h > new file mode 100644 > index 000000000000..700e33dc2446 > --- /dev/null > +++ b/drivers/iommu/riscv/iommu.h > @@ -0,0 +1,62 @@ > +/* SPDX-License-Identifier: GPL-2.0-only */ > +/* > + * Copyright © 2022-2024 Rivos Inc. > + * Copyright © 2023 FORTH-ICS/CARV > + * > + * Authors > + * Tomasz Jeznach > + * Nick Kossifidis > + */ > + > +#ifndef _RISCV_IOMMU_H_ > +#define _RISCV_IOMMU_H_ > + > +#include > +#include > +#include > + > +#include "iommu-bits.h" > + > +struct riscv_iommu_device { > + /* iommu core interface */ > + struct iommu_device iommu; > + > + /* iommu hardware */ > + struct device *dev; > + > + /* hardware control register space */ > + void __iomem *reg; > + > + /* supported and enabled hardware capabilities */ > + u64 caps; > + u32 fctl; > + > + /* available interrupt numbers, MSI or WSI */ > + unsigned int irqs[RISCV_IOMMU_INTR_COUNT]; > + unsigned int irqs_count; > +}; > + > +int riscv_iommu_init(struct riscv_iommu_device *iommu); > +void riscv_iommu_remove(struct riscv_iommu_device *iommu); > + > +#define riscv_iommu_readl(iommu, addr) \ > + readl_relaxed((iommu)->reg + (addr)) > + > +#define riscv_iommu_readq(iommu, addr) \ > + readq_relaxed((iommu)->reg + (addr)) > + > +#define riscv_iommu_writel(iommu, addr, val) \ > + writel_relaxed((val), (iommu)->reg + (addr)) > + > +#define riscv_iommu_writeq(iommu, addr, val) \ > + writeq_relaxed((val), (iommu)->reg + (addr)) > + > +#define riscv_iommu_readq_timeout(iommu, addr, val, cond, delay_us, timeout_us) \ > + readx_poll_timeout(readq_relaxed, (iommu)->reg + (addr), val, cond, \ > + delay_us, timeout_us) > + > +#define riscv_iommu_readl_timeout(iommu, addr, val, cond, delay_us, timeout_us) \ > + readx_poll_timeout(readl_relaxed, (iommu)->reg + (addr), val, cond, \ > + delay_us, timeout_us) > + > +#endif 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 7C568C4345F for ; Thu, 18 Apr 2024 21:22:41 +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-Type: Content-Transfer-Encoding:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:From:References:To:Subject:MIME-Version: Date:Message-ID:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=QDeD0VvnjPcklo1eiGqjqgbCCS7ZhqXNfZtoYZnNQtk=; b=4l8froQo/U4Xs3n4w8f+6bvo7X Gxmc21o3A2jK0hrrqY/AsuBM3v78Czw/NnhUcdC1lecex8wbUY6CxtTW6VhJ2m2F+oKqFFuP9HMG1 yDZoxXrsq2KYPRXgLfUhXMWapUYOEiIZFsG8tQkIW6wlR/fjoobzo5NlvmYoddDL80Wj93tJdck8x pjg6QEE9BmAP4aYWVVRQqmHlEM4QTduSyzq1LLuCCYs6EUGLTlclN98sTzwStm0DtDZdkwSKqdUke eklCQK7QQtMduoUQSOuhslc6dpSHrw1QJcnz5Vp1Wyd0YOYE6hN3f8J7MkueNvdTB7m0Ul5qBHiZI DlfjlxJQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1rxZDH-00000003kL7-0Zj7; Thu, 18 Apr 2024 21:22:35 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1rxZDB-00000003kI8-2gWM for linux-riscv@lists.infradead.org; Thu, 18 Apr 2024 21:22:33 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id D44142F; Thu, 18 Apr 2024 14:22:53 -0700 (PDT) Received: from [10.57.20.187] (unknown [10.57.20.187]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 6258B3F738; Thu, 18 Apr 2024 14:22:22 -0700 (PDT) Message-ID: <7f9a82ea-c4c8-40a5-8f26-7cb135e91c5d@arm.com> Date: Thu, 18 Apr 2024 22:22:13 +0100 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v2 2/7] iommu/riscv: Add RISC-V IOMMU platform device driver To: Tomasz Jeznach , Joerg Roedel , Will Deacon , Paul Walmsley References: <741996169fef074b5d9f4f218c2a98bf5dd38386.1713456598.git.tjeznach@rivosinc.com> From: Robin Murphy Content-Language: en-GB In-Reply-To: <741996169fef074b5d9f4f218c2a98bf5dd38386.1713456598.git.tjeznach@rivosinc.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240418_142229_891620_3ADFAAAC X-CRM114-Status: GOOD ( 26.73 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Anup Patel , devicetree@vger.kernel.org, Conor Dooley , Albert Ou , linux@rivosinc.com, linux-kernel@vger.kernel.org, Rob Herring , Sebastien Boeuf , iommu@lists.linux.dev, Palmer Dabbelt , Nick Kossifidis , Krzysztof Kozlowski , linux-riscv@lists.infradead.org Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org T24gMjAyNC0wNC0xOCA1OjMyIHBtLCBUb21hc3ogSmV6bmFjaCB3cm90ZToKPiBJbnRyb2R1Y2Ug cGxhdGZvcm0gZGV2aWNlIGRyaXZlciBmb3IgaW1wbGVtZW50YXRpb24gb2YgUklTQy1WIElPTU1V Cj4gYXJjaGl0ZWN0ZWQgaGFyZHdhcmUuCj4gCj4gSGFyZHdhcmUgaW50ZXJmYWNlIGRlZmluaXRp b24gbG9jYXRlZCBpbiBmaWxlIGlvbW11LWJpdHMuaCBpcyBiYXNlZCBvbgo+IHJhdGlmaWVkIFJJ U0MtViBJT01NVSBBcmNoaXRlY3R1cmUgU3BlY2lmaWNhdGlvbiB2ZXJzaW9uIDEuMC4wLgo+IAo+ IFRoaXMgcGF0Y2ggaW1wbGVtZW50cyBwbGF0Zm9ybSBkZXZpY2UgaW5pdGlhbGl6YXRpb24sIGVh cmx5IGNoZWNrIGFuZAo+IGNvbmZpZ3VyYXRpb24gb2YgdGhlIElPTU1VIGludGVyZmFjZXMgYW5k IGVuYWJsZXMgZ2xvYmFsIHBhc3MtdGhyb3VnaAo+IGFkZHJlc3MgdHJhbnNsYXRpb24gbW9kZSAo aW9tbXVfbW9kZSA9PSBCQVJFKSwgd2l0aG91dCByZWdpc3RlcmluZwo+IGhhcmR3YXJlIGluc3Rh bmNlIGluIHRoZSBJT01NVSBzdWJzeXN0ZW0uCj4gCj4gTGluazogaHR0cHM6Ly9naXRodWIuY29t L3Jpc2N2LW5vbi1pc2EvcmlzY3YtaW9tbXUKPiBDby1kZXZlbG9wZWQtYnk6IE5pY2sgS29zc2lm aWRpcyA8bWlja0BpY3MuZm9ydGguZ3I+Cj4gU2lnbmVkLW9mZi1ieTogTmljayBLb3NzaWZpZGlz IDxtaWNrQGljcy5mb3J0aC5ncj4KPiBDby1kZXZlbG9wZWQtYnk6IFNlYmFzdGllbiBCb2V1ZiA8 c2ViQHJpdm9zaW5jLmNvbT4KPiBTaWduZWQtb2ZmLWJ5OiBTZWJhc3RpZW4gQm9ldWYgPHNlYkBy aXZvc2luYy5jb20+Cj4gU2lnbmVkLW9mZi1ieTogVG9tYXN6IEplem5hY2ggPHRqZXpuYWNoQHJp dm9zaW5jLmNvbT4KPiAtLS0KPiAgIE1BSU5UQUlORVJTICAgICAgICAgICAgICAgICAgICAgICAg ICB8ICAgNiArCj4gICBkcml2ZXJzL2lvbW11L0tjb25maWcgICAgICAgICAgICAgICAgfCAgIDEg Kwo+ICAgZHJpdmVycy9pb21tdS9NYWtlZmlsZSAgICAgICAgICAgICAgIHwgICAyICstCj4gICBk cml2ZXJzL2lvbW11L3Jpc2N2L0tjb25maWcgICAgICAgICAgfCAgMTYgKwo+ICAgZHJpdmVycy9p b21tdS9yaXNjdi9NYWtlZmlsZSAgICAgICAgIHwgICAyICsKPiAgIGRyaXZlcnMvaW9tbXUvcmlz Y3YvaW9tbXUtYml0cy5oICAgICB8IDcwNyArKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAg IGRyaXZlcnMvaW9tbXUvcmlzY3YvaW9tbXUtcGxhdGZvcm0uYyB8ICA5NCArKysrCj4gICBkcml2 ZXJzL2lvbW11L3Jpc2N2L2lvbW11LmMgICAgICAgICAgfCAgODkgKysrKwo+ICAgZHJpdmVycy9p b21tdS9yaXNjdi9pb21tdS5oICAgICAgICAgIHwgIDYyICsrKwo+ICAgOSBmaWxlcyBjaGFuZ2Vk LCA5NzggaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0 IGRyaXZlcnMvaW9tbXUvcmlzY3YvS2NvbmZpZwo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZl cnMvaW9tbXUvcmlzY3YvTWFrZWZpbGUKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2lv bW11L3Jpc2N2L2lvbW11LWJpdHMuaAo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaW9t bXUvcmlzY3YvaW9tbXUtcGxhdGZvcm0uYwo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMv aW9tbXUvcmlzY3YvaW9tbXUuYwo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvaW9tbXUv cmlzY3YvaW9tbXUuaAo+IAo+IGRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJT Cj4gaW5kZXggMjY1N2Y5ZWFlODRjLi4wNTE1OTljNzY1ODUgMTAwNjQ0Cj4gLS0tIGEvTUFJTlRB SU5FUlMKPiArKysgYi9NQUlOVEFJTkVSUwo+IEBAIC0xODk3Miw2ICsxODk3MiwxMiBAQCBMOglp b21tdUBsaXN0cy5saW51eC5kZXYKPiAgIEw6CWxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5v cmcKPiAgIFM6CU1haW50YWluZWQKPiAgIEY6CURvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5k aW5ncy9pb21tdS9yaXNjdixpb21tdS55YW1sCj4gK0Y6CWRyaXZlcnMvaW9tbXUvcmlzY3YvS2Nv bmZpZwo+ICtGOglkcml2ZXJzL2lvbW11L3Jpc2N2L01ha2VmaWxlCj4gK0Y6CWRyaXZlcnMvaW9t bXUvcmlzY3YvaW9tbXUtYml0cy5oCj4gK0Y6CWRyaXZlcnMvaW9tbXUvcmlzY3YvaW9tbXUtcGxh dGZvcm0uYwo+ICtGOglkcml2ZXJzL2lvbW11L3Jpc2N2L2lvbW11LmMKPiArRjoJZHJpdmVycy9p b21tdS9yaXNjdi9pb21tdS5oCgpJJ20gcHJldHR5IHN1cmUgYSBzaW5nbGUgIkY6IGRyaXZlcnMv aW9tbXUvcmlzY3YvIiBwYXR0ZXJuIHdpbGwgc3VmZmljZS4KCj4gICBSSVNDLVYgTUlDUk9DSElQ IEZQR0EgU1VQUE9SVAo+ICAgTToJQ29ub3IgRG9vbGV5IDxjb25vci5kb29sZXlAbWljcm9jaGlw LmNvbT4KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9pb21tdS9LY29uZmlnIGIvZHJpdmVycy9pb21t dS9LY29uZmlnCj4gaW5kZXggMGFmMzliYmJlM2EzLi5hZTc2MmRiMDM2NWUgMTAwNjQ0Cj4gLS0t IGEvZHJpdmVycy9pb21tdS9LY29uZmlnCj4gKysrIGIvZHJpdmVycy9pb21tdS9LY29uZmlnCj4g QEAgLTE5NSw2ICsxOTUsNyBAQCBjb25maWcgTVNNX0lPTU1VCj4gICBzb3VyY2UgImRyaXZlcnMv aW9tbXUvYW1kL0tjb25maWciCj4gICBzb3VyY2UgImRyaXZlcnMvaW9tbXUvaW50ZWwvS2NvbmZp ZyIKPiAgIHNvdXJjZSAiZHJpdmVycy9pb21tdS9pb21tdWZkL0tjb25maWciCj4gK3NvdXJjZSAi ZHJpdmVycy9pb21tdS9yaXNjdi9LY29uZmlnIgo+ICAgCj4gICBjb25maWcgSVJRX1JFTUFQCj4g ICAJYm9vbCAiU3VwcG9ydCBmb3IgSW50ZXJydXB0IFJlbWFwcGluZyIKPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9pb21tdS9NYWtlZmlsZSBiL2RyaXZlcnMvaW9tbXUvTWFrZWZpbGUKPiBpbmRleCA1 NDI3NjBkOTYzZWMuLjVlNWE4M2M2YzJhYSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2lvbW11L01h a2VmaWxlCj4gKysrIGIvZHJpdmVycy9pb21tdS9NYWtlZmlsZQo+IEBAIC0xLDUgKzEsNSBAQAo+ ICAgIyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAo+IC1vYmoteSArPSBhbWQvIGlu dGVsLyBhcm0vIGlvbW11ZmQvCj4gK29iai15ICs9IGFtZC8gaW50ZWwvIGFybS8gaW9tbXVmZC8g cmlzY3YvCj4gICBvYmotJChDT05GSUdfSU9NTVVfQVBJKSArPSBpb21tdS5vCj4gICBvYmotJChD T05GSUdfSU9NTVVfQVBJKSArPSBpb21tdS10cmFjZXMubwo+ICAgb2JqLSQoQ09ORklHX0lPTU1V X0FQSSkgKz0gaW9tbXUtc3lzZnMubwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2lvbW11L3Jpc2N2 L0tjb25maWcgYi9kcml2ZXJzL2lvbW11L3Jpc2N2L0tjb25maWcKPiBuZXcgZmlsZSBtb2RlIDEw MDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uZDAyMzI2YmRkYjRjCj4gLS0tIC9kZXYvbnVsbAo+ ICsrKyBiL2RyaXZlcnMvaW9tbXUvcmlzY3YvS2NvbmZpZwo+IEBAIC0wLDAgKzEsMTYgQEAKPiAr IyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5Cj4gKyMgUklTQy1WIElPTU1V IHN1cHBvcnQKPiArCj4gK2NvbmZpZyBSSVNDVl9JT01NVQo+ICsJZGVmX2Jvb2wgeSBpZiBSSVND ViAmJiA2NEJJVCAmJiBNTVUKCkRyb3AgdGhlIGRlcGVuZGVuY2llcyBoZXJlLCB0aGV5J3JlIGFs cmVhZHkgZGVwZW5kZW5jaWVzLiBIb3dldmVyLCBhbHNvIApjb25zaWRlciBhbGxvd2luZyB1c2Vy cyB0byBjb25maWd1cmUgdGhpcyBvdXQgd2l0aG91dCBkaXNhYmxpbmcgCklPTU1VX1NVUFBPUlQg ZW50aXJlbHkgLSBJIGltYWdpbmUgb3RoZXIgSU9NTVUgaW1wbGVtZW50YXRpb25zIGFyZSBnb2lu ZyAKdG8gZW5kIHVwIHBhaXJlZCB3aW90aGcgUklTQy1WIENQVXMgc29vbmVyIG9yIGxhdGVyLiBG dXJ0aGVybW9yZSwgaWYgCml0J3MgYSByZWd1bGFyIGRyaXZlciBtb2RlbCBkcml2ZXIsIGNvbnNp ZGVyIGFsbG93aW5nIGl0IHRvIGJ1aWxkIGFzIGEgCm1vZHVsZS4gTm90IHRvIG1lbnRpb24gdGhh dCB0aGUgaGVscCB0ZXh0IGJlbG93IGlzIHJhdGhlciBwb2ludGxlc3MgaWYgCnRoZXJlJ3Mgbm8g cHJvbXB0IG9mZmVyZWQgaW4gdGhlIGZpcnN0IHBsYWNlLgoKPiArCWRlcGVuZHMgb24gUklTQ1Yg JiYgNjRCSVQgJiYgTU1VCj4gKwlzZWxlY3QgRE1BX09QUwoKRHJvcCB0aGlzLCB5b3UncmUgbm90 IChhbmQgc2hvdWxkbid0IGJlKSBhcmNoaXRlY3R1cmUgY29kZSBpbXBsZW1lbnRpbmcgCkRNQSBv cHMuCgo+ICsJc2VsZWN0IElPTU1VX0FQSQo+ICsJc2VsZWN0IElPTU1VX0lPVkEKCkRyb3AgdGhp cywgeW91J3JlIG5vdCB1c2luZyB0aGUgSU9WQSBsaWJyYXJ5IGVpdGhlci4KCj4gKwloZWxwCj4g KwkgIFN1cHBvcnQgZm9yIGltcGxlbWVudGF0aW9ucyBvZiB0aGUgUklTQy1WIElPTU1VIGFyY2hp dGVjdHVyZSB0aGF0Cj4gKwkgIGNvbXBsZW1lbnRzIHRoZSBSSVNDLVYgTU1VIGNhcGFiaWxpdGll cywgcHJvdmlkaW5nIHNpbWlsYXIgYWRkcmVzcwo+ICsJICB0cmFuc2xhdGlvbiBhbmQgcHJvdGVj dGlvbiBmdW5jdGlvbnMgZm9yIGFjY2Vzc2VzIGZyb20gSS9PIGRldmljZXMuCj4gKwo+ICsJICBT YXkgWSBoZXJlIGlmIHlvdXIgU29DIGluY2x1ZGVzIGFuIElPTU1VIGRldmljZSBpbXBsZW1lbnRp bmcKPiArCSAgdGhlIFJJU0MtViBJT01NVSBhcmNoaXRlY3R1cmUuCj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvaW9tbXUvcmlzY3YvTWFrZWZpbGUgYi9kcml2ZXJzL2lvbW11L3Jpc2N2L01ha2VmaWxl Cj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmU0YzE4OWRlNThk Mwo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2lvbW11L3Jpc2N2L01ha2VmaWxlCj4g QEAgLTAsMCArMSwyIEBACj4gKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb25s eQo+ICtvYmotJChDT05GSUdfUklTQ1ZfSU9NTVUpICs9IGlvbW11Lm8gaW9tbXUtcGxhdGZvcm0u bwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2lvbW11L3Jpc2N2L2lvbW11LWJpdHMuaCBiL2RyaXZl cnMvaW9tbXUvcmlzY3YvaW9tbXUtYml0cy5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRl eCAwMDAwMDAwMDAwMDAuLmJhMDkzYzI5ZGU5Zgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2 ZXJzL2lvbW11L3Jpc2N2L2lvbW11LWJpdHMuaAo+IEBAIC0wLDAgKzEsNzA3IEBACj4gKy8qIFNQ RFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkgKi8KPiArLyoKPiArICogQ29weXJp Z2h0IMKpIDIwMjItMjAyNCBSaXZvcyBJbmMuCj4gKyAqIENvcHlyaWdodCDCqSAyMDIzIEZPUlRI LUlDUy9DQVJWCj4gKyAqIENvcHlyaWdodCDCqSAyMDIzIFJJU0MtViBJT01NVSBUYXNrIEdyb3Vw Cj4gKyAqCj4gKyAqIFJJU0MtViBJT01NVSAtIFJlZ2lzdGVyIExheW91dCBhbmQgRGF0YSBTdHJ1 Y3R1cmVzLgo+ICsgKgo+ICsgKiBCYXNlZCBvbiB0aGUgJ1JJU0MtViBJT01NVSBBcmNoaXRlY3R1 cmUgU3BlY2lmaWNhdGlvbicsIFZlcnNpb24gMS4wCj4gKyAqIFB1Ymxpc2hlZCBhdCAgaHR0cHM6 Ly9naXRodWIuY29tL3Jpc2N2LW5vbi1pc2EvcmlzY3YtaW9tbXUKPiArICoKPiArICovCj4gKwo+ ICsjaWZuZGVmIF9SSVNDVl9JT01NVV9CSVRTX0hfCj4gKyNkZWZpbmUgX1JJU0NWX0lPTU1VX0JJ VFNfSF8KPiArCj4gKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgo+ICsjaW5jbHVkZSA8bGludXgv Yml0ZmllbGQuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2JpdHMuaD4KPiArCj4gKy8qCj4gKyAqIENo YXB0ZXIgNTogTWVtb3J5IE1hcHBlZCByZWdpc3RlciBpbnRlcmZhY2UKPiArICovCj4gKwo+ICsv KiBDb21tb24gZmllbGQgcG9zaXRpb25zICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUFBOX0ZJ RUxECQlHRU5NQVNLX1VMTCg1MywgMTApCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUVVFVUVfTE9H U1pfRklFTEQJR0VOTUFTS19VTEwoNCwgMCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9RVUVVRV9J TkRFWF9GSUVMRAlHRU5NQVNLX1VMTCgzMSwgMCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9RVUVV RV9FTkFCTEUJQklUKDApCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUVVFVUVfSU5UUl9FTkFCTEUJ QklUKDEpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUVVFVUVfTUVNX0ZBVUxUCUJJVCg4KQo+ICsj ZGVmaW5lIFJJU0NWX0lPTU1VX1FVRVVFX09WRVJGTE9XCUJJVCg5KQo+ICsjZGVmaW5lIFJJU0NW X0lPTU1VX1FVRVVFX0FDVElWRQlCSVQoMTYpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUVVFVUVf QlVTWQkJQklUKDE3KQo+ICsKPiArI2RlZmluZSBSSVNDVl9JT01NVV9BVFBfUFBOX0ZJRUxECUdF Tk1BU0tfVUxMKDQzLCAwKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0FUUF9NT0RFX0ZJRUxECUdF Tk1BU0tfVUxMKDYzLCA2MCkKPiArCj4gKy8qIDUuMyBJT01NVSBDYXBhYmlsaXRpZXMgKDY0Yml0 cykgKi8KPiArI2RlZmluZSBSSVNDVl9JT01NVV9SRUdfQ0FQCQkweDAwMDAKPiArI2RlZmluZSBS SVNDVl9JT01NVV9DQVBfVkVSU0lPTgkJR0VOTUFTS19VTEwoNywgMCkKPiArI2RlZmluZSBSSVND Vl9JT01NVV9DQVBfU19TVjMyCQlCSVRfVUxMKDgpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ0FQ X1NfU1YzOQkJQklUX1VMTCg5KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NBUF9TX1NWNDgJCUJJ VF9VTEwoMTApCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ0FQX1NfU1Y1NwkJQklUX1VMTCgxMSkK PiArI2RlZmluZSBSSVNDVl9JT01NVV9DQVBfU1ZQQk1UCQlCSVRfVUxMKDE1KQo+ICsjZGVmaW5l IFJJU0NWX0lPTU1VX0NBUF9HX1NWMzIJCUJJVF9VTEwoMTYpCj4gKyNkZWZpbmUgUklTQ1ZfSU9N TVVfQ0FQX0dfU1YzOQkJQklUX1VMTCgxNykKPiArI2RlZmluZSBSSVNDVl9JT01NVV9DQVBfR19T VjQ4CQlCSVRfVUxMKDE4KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NBUF9HX1NWNTcJCUJJVF9V TEwoMTkpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ0FQX0FNT19NUklGCUJJVF9VTEwoMjEpCj4g KyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ0FQX01TSV9GTEFUCUJJVF9VTEwoMjIpCj4gKyNkZWZpbmUg UklTQ1ZfSU9NTVVfQ0FQX01TSV9NUklGCUJJVF9VTEwoMjMpCj4gKyNkZWZpbmUgUklTQ1ZfSU9N TVVfQ0FQX0FNT19IV0FECUJJVF9VTEwoMjQpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ0FQX0FU UwkJQklUX1VMTCgyNSkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9DQVBfVDJHUEEJCUJJVF9VTEwo MjYpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ0FQX0VORAkJQklUX1VMTCgyNykKPiArI2RlZmlu ZSBSSVNDVl9JT01NVV9DQVBfSUdTCQlHRU5NQVNLX1VMTCgyOSwgMjgpCj4gKyNkZWZpbmUgUklT Q1ZfSU9NTVVfQ0FQX0hQTQkJQklUX1VMTCgzMCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9DQVBf REJHCQlCSVRfVUxMKDMxKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NBUF9QQVMJCUdFTk1BU0tf VUxMKDM3LCAzMikKPiArI2RlZmluZSBSSVNDVl9JT01NVV9DQVBfUEQ4CQlCSVRfVUxMKDM4KQo+ ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NBUF9QRDE3CQlCSVRfVUxMKDM5KQo+ICsjZGVmaW5lIFJJ U0NWX0lPTU1VX0NBUF9QRDIwCQlCSVRfVUxMKDQwKQo+ICsKPiArI2RlZmluZSBSSVNDVl9JT01N VV9DQVBfVkVSU0lPTl9WRVJfTUFTSwkweEYwCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ0FQX1ZF UlNJT05fUkVWX01BU0sJMHgwRgo+ICsKPiArLyoqCj4gKyAqIGVudW0gcmlzY3ZfaW9tbXVfaWdz X3NldHRpbmdzIC0gSW50ZXJydXB0IEdlbmVyYXRpb24gU3VwcG9ydCBTZXR0aW5ncwo+ICsgKiBA UklTQ1ZfSU9NTVVfQ0FQX0lHU19NU0k6IEkvTyBNTVUgc3VwcG9ydHMgb25seSBNU0kgZ2VuZXJh dGlvbgo+ICsgKiBAUklTQ1ZfSU9NTVVfQ0FQX0lHU19XU0k6IEkvTyBNTVUgc3VwcG9ydHMgb25s eSBXaXJlZC1TaWduYWxlZCBpbnRlcnJ1cHQKPiArICogQFJJU0NWX0lPTU1VX0NBUF9JR1NfQk9U SDogSS9PIE1NVSBzdXBwb3J0cyBib3RoIE1TSSBhbmQgV1NJIGdlbmVyYXRpb24KPiArICogQFJJ U0NWX0lPTU1VX0NBUF9JR1NfUlNSVjogUmVzZXJ2ZWQgZm9yIHN0YW5kYXJkIHVzZQo+ICsgKi8K PiArZW51bSByaXNjdl9pb21tdV9pZ3Nfc2V0dGluZ3Mgewo+ICsJUklTQ1ZfSU9NTVVfQ0FQX0lH U19NU0kgPSAwLAo+ICsJUklTQ1ZfSU9NTVVfQ0FQX0lHU19XU0kgPSAxLAo+ICsJUklTQ1ZfSU9N TVVfQ0FQX0lHU19CT1RIID0gMiwKPiArCVJJU0NWX0lPTU1VX0NBUF9JR1NfUlNSViA9IDMKPiAr fTsKPiArCj4gKy8qIDUuNCBGZWF0dXJlcyBjb250cm9sIHJlZ2lzdGVyICgzMmJpdHMpICovCj4g KyNkZWZpbmUgUklTQ1ZfSU9NTVVfUkVHX0ZDVEwJCTB4MDAwOAo+ICsjZGVmaW5lIFJJU0NWX0lP TU1VX0ZDVExfQkUJCUJJVCgwKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0ZDVExfV1NJCQlCSVQo MSkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9GQ1RMX0dYTAkJQklUKDIpCj4gKwo+ICsvKiA1LjUg RGV2aWNlLWRpcmVjdG9yeS10YWJsZSBwb2ludGVyICg2NGJpdHMpICovCj4gKyNkZWZpbmUgUklT Q1ZfSU9NTVVfUkVHX0REVFAJCTB4MDAxMAo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0REVFBfTU9E RQkJR0VOTUFTS19VTEwoMywgMCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9ERFRQX0JVU1kJCUJJ VF9VTEwoNCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9ERFRQX1BQTgkJUklTQ1ZfSU9NTVVfUFBO X0ZJRUxECj4gKwo+ICsvKioKPiArICogZW51bSByaXNjdl9pb21tdV9kZHRwX21vZGVzIC0gSS9P IE1NVSB0cmFuc2xhdGlvbiBtb2Rlcwo+ICsgKiBAUklTQ1ZfSU9NTVVfRERUUF9NT0RFX09GRjog Tm8gaW5ib3VuZCB0cmFuc2FjdGlvbnMgYWxsb3dlZAo+ICsgKiBAUklTQ1ZfSU9NTVVfRERUUF9N T0RFX0JBUkU6IFBhc3MtdGhyb3VnaCBtb2RlCj4gKyAqIEBSSVNDVl9JT01NVV9ERFRQX01PREVf MUxWTDogT25lLWxldmVsIEREVAo+ICsgKiBAUklTQ1ZfSU9NTVVfRERUUF9NT0RFXzJMVkw6IFR3 by1sZXZlbCBERFQKPiArICogQFJJU0NWX0lPTU1VX0REVFBfTU9ERV8zTFZMOiBUaHJlZS1sZXZl bCBERFQKPiArICogQFJJU0NWX0lPTU1VX0REVFBfTU9ERV9NQVg6IE1heCB2YWx1ZSBhbGxvd2Vk IGJ5IHNwZWNpZmljYXRpb24KPiArICovCj4gK2VudW0gcmlzY3ZfaW9tbXVfZGR0cF9tb2RlcyB7 Cj4gKwlSSVNDVl9JT01NVV9ERFRQX01PREVfT0ZGID0gMCwKPiArCVJJU0NWX0lPTU1VX0REVFBf TU9ERV9CQVJFID0gMSwKPiArCVJJU0NWX0lPTU1VX0REVFBfTU9ERV8xTFZMID0gMiwKPiArCVJJ U0NWX0lPTU1VX0REVFBfTU9ERV8yTFZMID0gMywKPiArCVJJU0NWX0lPTU1VX0REVFBfTU9ERV8z TFZMID0gNCwKPiArCVJJU0NWX0lPTU1VX0REVFBfTU9ERV9NQVggPSA0Cj4gK307Cj4gKwo+ICsv KiA1LjYgQ29tbWFuZCBRdWV1ZSBCYXNlICg2NGJpdHMpICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9N TVVfUkVHX0NRQgkJMHgwMDE4Cj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ1FCX0VOVFJJRVMJCVJJ U0NWX0lPTU1VX1FVRVVFX0xPR1NaX0ZJRUxECj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ1FCX1BQ TgkJUklTQ1ZfSU9NTVVfUFBOX0ZJRUxECj4gKwo+ICsvKiA1LjcgQ29tbWFuZCBRdWV1ZSBoZWFk ICgzMmJpdHMpICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUkVHX0NRSAkJMHgwMDIwCj4gKyNk ZWZpbmUgUklTQ1ZfSU9NTVVfQ1FIX0lOREVYCQlSSVNDVl9JT01NVV9RVUVVRV9JTkRFWF9GSUVM RAo+ICsKPiArLyogNS44IENvbW1hbmQgUXVldWUgdGFpbCAoMzJiaXRzKSAqLwo+ICsjZGVmaW5l IFJJU0NWX0lPTU1VX1JFR19DUVQJCTB4MDAyNAo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NRVF9J TkRFWAkJUklTQ1ZfSU9NTVVfUVVFVUVfSU5ERVhfRklFTEQKPiArCj4gKy8qIDUuOSBGYXVsdCBR dWV1ZSBCYXNlICg2NGJpdHMpICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUkVHX0ZRQgkJMHgw MDI4Cj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfRlFCX0VOVFJJRVMJCVJJU0NWX0lPTU1VX1FVRVVF X0xPR1NaX0ZJRUxECj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfRlFCX1BQTgkJUklTQ1ZfSU9NTVVf UFBOX0ZJRUxECj4gKwo+ICsvKiA1LjEwIEZhdWx0IFF1ZXVlIEhlYWQgKDMyYml0cykgKi8KPiAr I2RlZmluZSBSSVNDVl9JT01NVV9SRUdfRlFICQkweDAwMzAKPiArI2RlZmluZSBSSVNDVl9JT01N VV9GUUhfSU5ERVgJCVJJU0NWX0lPTU1VX1FVRVVFX0lOREVYX0ZJRUxECj4gKwo+ICsvKiA1LjEx IEZhdWx0IFF1ZXVlIHRhaWwgKDMyYml0cykgKi8KPiArI2RlZmluZSBSSVNDVl9JT01NVV9SRUdf RlFUCQkweDAwMzQKPiArI2RlZmluZSBSSVNDVl9JT01NVV9GUVRfSU5ERVgJCVJJU0NWX0lPTU1V X1FVRVVFX0lOREVYX0ZJRUxECj4gKwo+ICsvKiA1LjEyIFBhZ2UgUmVxdWVzdCBRdWV1ZSBiYXNl ICg2NGJpdHMpICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUkVHX1BRQgkJMHgwMDM4Cj4gKyNk ZWZpbmUgUklTQ1ZfSU9NTVVfUFFCX0VOVFJJRVMJCVJJU0NWX0lPTU1VX1FVRVVFX0xPR1NaX0ZJ RUxECj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUFFCX1BQTgkJUklTQ1ZfSU9NTVVfUFBOX0ZJRUxE Cj4gKwo+ICsvKiA1LjEzIFBhZ2UgUmVxdWVzdCBRdWV1ZSBoZWFkICgzMmJpdHMpICovCj4gKyNk ZWZpbmUgUklTQ1ZfSU9NTVVfUkVHX1BRSAkJMHgwMDQwCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVf UFFIX0lOREVYCQlSSVNDVl9JT01NVV9RVUVVRV9JTkRFWF9GSUVMRAo+ICsKPiArLyogNS4xNCBQ YWdlIFJlcXVlc3QgUXVldWUgdGFpbCAoMzJiaXRzKSAqLwo+ICsjZGVmaW5lIFJJU0NWX0lPTU1V X1JFR19QUVQJCTB4MDA0NAo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1BRVF9JTkRFWF9NQVNLCVJJ U0NWX0lPTU1VX1FVRVVFX0lOREVYX0ZJRUxECj4gKwo+ICsvKiA1LjE1IENvbW1hbmQgUXVldWUg Q1NSICgzMmJpdHMpICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUkVHX0NRQ1NSCQkweDAwNDgK PiArI2RlZmluZSBSSVNDVl9JT01NVV9DUUNTUl9DUUVOCQlSSVNDVl9JT01NVV9RVUVVRV9FTkFC TEUKPiArI2RlZmluZSBSSVNDVl9JT01NVV9DUUNTUl9DSUUJCVJJU0NWX0lPTU1VX1FVRVVFX0lO VFJfRU5BQkxFCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ1FDU1JfQ1FNRgkJUklTQ1ZfSU9NTVVf UVVFVUVfTUVNX0ZBVUxUCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ1FDU1JfQ01EX1RPCUJJVCg5 KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NRQ1NSX0NNRF9JTEwJQklUKDEwKQo+ICsjZGVmaW5l IFJJU0NWX0lPTU1VX0NRQ1NSX0ZFTkNFX1dfSVAJQklUKDExKQo+ICsjZGVmaW5lIFJJU0NWX0lP TU1VX0NRQ1NSX0NRT04JCVJJU0NWX0lPTU1VX1FVRVVFX0FDVElWRQo+ICsjZGVmaW5lIFJJU0NW X0lPTU1VX0NRQ1NSX0JVU1kJCVJJU0NWX0lPTU1VX1FVRVVFX0JVU1kKPiArCj4gKy8qIDUuMTYg RmF1bHQgUXVldWUgQ1NSICgzMmJpdHMpICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUkVHX0ZR Q1NSCQkweDAwNEMKPiArI2RlZmluZSBSSVNDVl9JT01NVV9GUUNTUl9GUUVOCQlSSVNDVl9JT01N VV9RVUVVRV9FTkFCTEUKPiArI2RlZmluZSBSSVNDVl9JT01NVV9GUUNTUl9GSUUJCVJJU0NWX0lP TU1VX1FVRVVFX0lOVFJfRU5BQkxFCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfRlFDU1JfRlFNRgkJ UklTQ1ZfSU9NTVVfUVVFVUVfTUVNX0ZBVUxUCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfRlFDU1Jf RlFPRgkJUklTQ1ZfSU9NTVVfUVVFVUVfT1ZFUkZMT1cKPiArI2RlZmluZSBSSVNDVl9JT01NVV9G UUNTUl9GUU9OCQlSSVNDVl9JT01NVV9RVUVVRV9BQ1RJVkUKPiArI2RlZmluZSBSSVNDVl9JT01N VV9GUUNTUl9CVVNZCQlSSVNDVl9JT01NVV9RVUVVRV9CVVNZCj4gKwo+ICsvKiA1LjE3IFBhZ2Ug UmVxdWVzdCBRdWV1ZSBDU1IgKDMyYml0cykgKi8KPiArI2RlZmluZSBSSVNDVl9JT01NVV9SRUdf UFFDU1IJCTB4MDA1MAo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1BRQ1NSX1BRRU4JCVJJU0NWX0lP TU1VX1FVRVVFX0VOQUJMRQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1BRQ1NSX1BJRQkJUklTQ1Zf SU9NTVVfUVVFVUVfSU5UUl9FTkFCTEUKPiArI2RlZmluZSBSSVNDVl9JT01NVV9QUUNTUl9QUU1G CQlSSVNDVl9JT01NVV9RVUVVRV9NRU1fRkFVTFQKPiArI2RlZmluZSBSSVNDVl9JT01NVV9QUUNT Ul9QUU9GCQlSSVNDVl9JT01NVV9RVUVVRV9PVkVSRkxPVwo+ICsjZGVmaW5lIFJJU0NWX0lPTU1V X1BRQ1NSX1BRT04JCVJJU0NWX0lPTU1VX1FVRVVFX0FDVElWRQo+ICsjZGVmaW5lIFJJU0NWX0lP TU1VX1BRQ1NSX0JVU1kJCVJJU0NWX0lPTU1VX1FVRVVFX0JVU1kKPiArCj4gKy8qIDUuMTggSW50 ZXJydXB0IFBlbmRpbmcgU3RhdHVzICgzMmJpdHMpICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVf UkVHX0lQU1IJCTB4MDA1NAo+ICsKPiArI2RlZmluZSBSSVNDVl9JT01NVV9JTlRSX0NRCQkwCj4g KyNkZWZpbmUgUklTQ1ZfSU9NTVVfSU5UUl9GUQkJMQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0lO VFJfUE0JCTIKPiArI2RlZmluZSBSSVNDVl9JT01NVV9JTlRSX1BRCQkzCj4gKyNkZWZpbmUgUklT Q1ZfSU9NTVVfSU5UUl9DT1VOVAkJNAo+ICsKPiArI2RlZmluZSBSSVNDVl9JT01NVV9JUFNSX0NJ UAkJQklUKFJJU0NWX0lPTU1VX0lOVFJfQ1EpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfSVBTUl9G SVAJCUJJVChSSVNDVl9JT01NVV9JTlRSX0ZRKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0lQU1Jf UE1JUAkJQklUKFJJU0NWX0lPTU1VX0lOVFJfUE0pCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfSVBT Ul9QSVAJCUJJVChSSVNDVl9JT01NVV9JTlRSX1BRKQo+ICsKPiArLyogNS4xOSBQZXJmb3JtYW5j ZSBtb25pdG9yaW5nIGNvdW50ZXIgb3ZlcmZsb3cgc3RhdHVzICgzMmJpdHMpICovCj4gKyNkZWZp bmUgUklTQ1ZfSU9NTVVfUkVHX0lPQ09VTlRPVkYJMHgwMDU4Cj4gKyNkZWZpbmUgUklTQ1ZfSU9N TVVfSU9DT1VOVE9WRl9DWQlCSVQoMCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9JT0NPVU5UT1ZG X0hQTQlHRU5NQVNLX1VMTCgzMSwgMSkKPiArCj4gKy8qIDUuMjAgUGVyZm9ybWFuY2UgbW9uaXRv cmluZyBjb3VudGVyIGluaGliaXRzICgzMmJpdHMpICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVf UkVHX0lPQ09VTlRJTkgJMHgwMDVDCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfSU9DT1VOVElOSF9D WQlCSVQoMCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9JT0NPVU5USU5IX0hQTQlHRU5NQVNLKDMx LCAxKQo+ICsKPiArLyogNS4yMSBQZXJmb3JtYW5jZSBtb25pdG9yaW5nIGN5Y2xlcyBjb3VudGVy ICg2NGJpdHMpICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUkVHX0lPSFBNQ1lDTEVTICAgICAw eDAwNjAKPiArI2RlZmluZSBSSVNDVl9JT01NVV9JT0hQTUNZQ0xFU19DT1VOVEVSCUdFTk1BU0tf VUxMKDYyLCAwKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0lPSFBNQ1lDTEVTX09WRglCSVRfVUxM KDYzKQo+ICsKPiArLyogNS4yMiBQZXJmb3JtYW5jZSBtb25pdG9yaW5nIGV2ZW50IGNvdW50ZXJz ICgzMSAqIDY0Yml0cykgKi8KPiArI2RlZmluZSBSSVNDVl9JT01NVV9SRUdfSU9IUE1DVFJfQkFT RQkweDAwNjgKPiArI2RlZmluZSBSSVNDVl9JT01NVV9SRUdfSU9IUE1DVFIoX24pCShSSVNDVl9J T01NVV9SRUdfSU9IUE1DVFJfQkFTRSArICgoX24pICogMHg4KSkKPiArCj4gKy8qIDUuMjMgUGVy Zm9ybWFuY2UgbW9uaXRvcmluZyBldmVudCBzZWxlY3RvcnMgKDMxICogNjRiaXRzKSAqLwo+ICsj ZGVmaW5lIFJJU0NWX0lPTU1VX1JFR19JT0hQTUVWVF9CQVNFCTB4MDE2MAo+ICsjZGVmaW5lIFJJ U0NWX0lPTU1VX1JFR19JT0hQTUVWVChfbikJKFJJU0NWX0lPTU1VX1JFR19JT0hQTUVWVF9CQVNF ICsgKChfbikgKiAweDgpKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0lPSFBNRVZUX0NOVAkzMQo+ ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0lPSFBNRVZUX0VWRU5UX0lECUdFTk1BU0tfVUxMKDE0LCAw KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0lPSFBNRVZUX0RNQVNLCUJJVF9VTEwoMTUpCj4gKyNk ZWZpbmUgUklTQ1ZfSU9NTVVfSU9IUE1FVlRfUElEX1BTQ0lECUdFTk1BU0tfVUxMKDM1LCAxNikK PiArI2RlZmluZSBSSVNDVl9JT01NVV9JT0hQTUVWVF9ESURfR1NDSUQJR0VOTUFTS19VTEwoNTks IDM2KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0lPSFBNRVZUX1BWX1BTQ1YJQklUX1VMTCg2MCkK PiArI2RlZmluZSBSSVNDVl9JT01NVV9JT0hQTUVWVF9EVl9HU0NWCUJJVF9VTEwoNjEpCj4gKyNk ZWZpbmUgUklTQ1ZfSU9NTVVfSU9IUE1FVlRfSURUCUJJVF9VTEwoNjIpCj4gKyNkZWZpbmUgUklT Q1ZfSU9NTVVfSU9IUE1FVlRfT0YJCUJJVF9VTEwoNjMpCj4gKwo+ICsvKioKPiArICogZW51bSBy aXNjdl9pb21tdV9ocG1ldmVudF9pZCAtIFBlcmZvcm1hbmNlLW1vbml0b3JpbmcgZXZlbnQgaWRl bnRpZmllcgo+ICsgKgo+ICsgKiBAUklTQ1ZfSU9NTVVfSFBNRVZFTlRfSU5WQUxJRDogSW52YWxp ZCBldmVudCwgZG8gbm90IGNvdW50Cj4gKyAqIEBSSVNDVl9JT01NVV9IUE1FVkVOVF9VUlE6IFVu dHJhbnNsYXRlZCByZXF1ZXN0cwo+ICsgKiBAUklTQ1ZfSU9NTVVfSFBNRVZFTlRfVFJROiBUcmFu c2xhdGVkIHJlcXVlc3RzCj4gKyAqIEBSSVNDVl9JT01NVV9IUE1FVkVOVF9BVFNfUlE6IEFUUyB0 cmFuc2xhdGlvbiByZXF1ZXN0cwo+ICsgKiBAUklTQ1ZfSU9NTVVfSFBNRVZFTlRfVExCX01JU1M6 IFRMQiBtaXNzZXMKPiArICogQFJJU0NWX0lPTU1VX0hQTUVWRU5UX0REX1dBTEs6IERldmljZSBk aXJlY3Rvcnkgd2Fsa3MKPiArICogQFJJU0NWX0lPTU1VX0hQTUVWRU5UX1BEX1dBTEs6IFByb2Nl c3MgZGlyZWN0b3J5IHdhbGtzCj4gKyAqIEBSSVNDVl9JT01NVV9IUE1FVkVOVF9TX1ZTX1dBTEtT OiBTL1ZTLVN0YWdlIHBhZ2UgdGFibGUgd2Fsa3MKPiArICogQFJJU0NWX0lPTU1VX0hQTUVWRU5U X0dfV0FMS1M6IEctU3RhZ2UgcGFnZSB0YWJsZSB3YWxrcwo+ICsgKiBAUklTQ1ZfSU9NTVVfSFBN RVZFTlRfTUFYOiBWYWx1ZSB0byBkZW5vdGUgbWF4aW11bSBFdmVudCBJRHMKPiArICovCj4gK2Vu dW0gcmlzY3ZfaW9tbXVfaHBtZXZlbnRfaWQgewo+ICsJUklTQ1ZfSU9NTVVfSFBNRVZFTlRfSU5W QUxJRCAgICA9IDAsCj4gKwlSSVNDVl9JT01NVV9IUE1FVkVOVF9VUlEgICAgICAgID0gMSwKPiAr CVJJU0NWX0lPTU1VX0hQTUVWRU5UX1RSUSAgICAgICAgPSAyLAo+ICsJUklTQ1ZfSU9NTVVfSFBN RVZFTlRfQVRTX1JRICAgICA9IDMsCj4gKwlSSVNDVl9JT01NVV9IUE1FVkVOVF9UTEJfTUlTUyAg ID0gNCwKPiArCVJJU0NWX0lPTU1VX0hQTUVWRU5UX0REX1dBTEsgICAgPSA1LAo+ICsJUklTQ1Zf SU9NTVVfSFBNRVZFTlRfUERfV0FMSyAgICA9IDYsCj4gKwlSSVNDVl9JT01NVV9IUE1FVkVOVF9T X1ZTX1dBTEtTID0gNywKPiArCVJJU0NWX0lPTU1VX0hQTUVWRU5UX0dfV0FMS1MgICAgPSA4LAo+ ICsJUklTQ1ZfSU9NTVVfSFBNRVZFTlRfTUFYICAgICAgICA9IDkKPiArfTsKPiArCj4gKy8qIDUu MjQgVHJhbnNsYXRpb24gcmVxdWVzdCBJT1ZBICg2NGJpdHMpICovCj4gKyNkZWZpbmUgUklTQ1Zf SU9NTVVfUkVHX1RSX1JFUV9JT1ZBICAgICAweDAyNTgKPiArI2RlZmluZSBSSVNDVl9JT01NVV9U Ul9SRVFfSU9WQV9WUE4JR0VOTUFTS19VTEwoNjMsIDEyKQo+ICsKPiArLyogNS4yNSBUcmFuc2xh dGlvbiByZXF1ZXN0IGNvbnRyb2wgKDY0Yml0cykgKi8KPiArI2RlZmluZSBSSVNDVl9JT01NVV9S RUdfVFJfUkVRX0NUTAkweDAyNjAKPiArI2RlZmluZSBSSVNDVl9JT01NVV9UUl9SRVFfQ1RMX0dP X0JVU1kJQklUX1VMTCgwKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1RSX1JFUV9DVExfUFJJVglC SVRfVUxMKDEpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfVFJfUkVRX0NUTF9FWEUJQklUX1VMTCgy KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1RSX1JFUV9DVExfTlcJQklUX1VMTCgzKQo+ICsjZGVm aW5lIFJJU0NWX0lPTU1VX1RSX1JFUV9DVExfUElECUdFTk1BU0tfVUxMKDMxLCAxMikKPiArI2Rl ZmluZSBSSVNDVl9JT01NVV9UUl9SRVFfQ1RMX1BWCUJJVF9VTEwoMzIpCj4gKyNkZWZpbmUgUklT Q1ZfSU9NTVVfVFJfUkVRX0NUTF9ESUQJR0VOTUFTS19VTEwoNjMsIDQwKQo+ICsKPiArLyogNS4y NiBUcmFuc2xhdGlvbiByZXF1ZXN0IHJlc3BvbnNlICg2NGJpdHMpICovCj4gKyNkZWZpbmUgUklT Q1ZfSU9NTVVfUkVHX1RSX1JFU1BPTlNFCTB4MDI2OAo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1RS X1JFU1BPTlNFX0ZBVUxUCUJJVF9VTEwoMCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9UUl9SRVNQ T05TRV9QQk1UCUdFTk1BU0tfVUxMKDgsIDcpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfVFJfUkVT UE9OU0VfU1oJQklUX1VMTCg5KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1RSX1JFU1BPTlNFX1BQ TglSSVNDVl9JT01NVV9QUE5fRklFTEQKPiArCj4gKy8qIDUuMjcgSW50ZXJydXB0IGNhdXNlIHRv IHZlY3RvciAoNjRiaXRzKSAqLwo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1JFR19JVkVDCQkweDAy RjgKPiArI2RlZmluZSBSSVNDVl9JT01NVV9JVkVDX0NJVgkJR0VOTUFTS19VTEwoMywgMCkKPiAr I2RlZmluZSBSSVNDVl9JT01NVV9JVkVDX0ZJVgkJR0VOTUFTS19VTEwoNywgNCkKPiArI2RlZmlu ZSBSSVNDVl9JT01NVV9JVkVDX1BNSVYJCUdFTk1BU0tfVUxMKDExLCA4KQo+ICsjZGVmaW5lIFJJ U0NWX0lPTU1VX0lWRUNfUElWCQlHRU5NQVNLX1VMTCgxNSwgMTIpCj4gKwo+ICsvKiA1LjI4IE1T SSBDb25maWd1cmF0aW9uIHRhYmxlICgzMiAqIDY0Yml0cykgKi8KPiArI2RlZmluZSBSSVNDVl9J T01NVV9SRUdfTVNJX0NPTkZJRwkweDAzMDAKPiArI2RlZmluZSBSSVNDVl9JT01NVV9SRUdfTVNJ X0FERFIoX24pCShSSVNDVl9JT01NVV9SRUdfTVNJX0NPTkZJRyArICgoX24pICogMHgxMCkpCj4g KyNkZWZpbmUgUklTQ1ZfSU9NTVVfTVNJX0FERFIJCUdFTk1BU0tfVUxMKDU1LCAyKQo+ICsjZGVm aW5lIFJJU0NWX0lPTU1VX1JFR19NU0lfREFUQShfbikJKFJJU0NWX0lPTU1VX1JFR19NU0lfQ09O RklHICsgKChfbikgKiAweDEwKSArIDB4MDgpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfTVNJX0RB VEEJCUdFTk1BU0tfVUxMKDMxLCAwKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1JFR19NU0lfVkVD X0NUTChfbikJKFJJU0NWX0lPTU1VX1JFR19NU0lfQ09ORklHICsgKChfbikgKiAweDEwKSArIDB4 MEMpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfTVNJX1ZFQ19DVExfTQlCSVRfVUxMKDApCj4gKwo+ ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1JFR19TSVpFCTB4MTAwMAo+ICsKPiArLyoKPiArICogQ2hh cHRlciAyOiBEYXRhIHN0cnVjdHVyZXMKPiArICovCj4gKwo+ICsvKgo+ICsgKiBEZXZpY2UgRGly ZWN0b3J5IFRhYmxlIG1hY3JvcyBmb3Igbm9uLWxlYWYgbm9kZXMKPiArICovCj4gKyNkZWZpbmUg UklTQ1ZfSU9NTVVfRERURV9WQUxJRAlCSVRfVUxMKDApCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVf RERURV9QUE4JUklTQ1ZfSU9NTVVfUFBOX0ZJRUxECj4gKwo+ICsvKioKPiArICogc3RydWN0IHJp c2N2X2lvbW11X2RjIC0gRGV2aWNlIENvbnRleHQKPiArICogQHRjOiBUcmFuc2xhdGlvbiBDb250 cm9sCj4gKyAqIEBpb2hnYXRwOiBJL08gSHlwZXJ2aXNvciBndWVzdCBhZGRyZXNzIHRyYW5zbGF0 aW9uIGFuZCBwcm90ZWN0aW9uCj4gKyAqCSAgICAgKFNlY29uZCBzdGFnZSBjb250ZXh0KQo+ICsg KiBAdGE6IFRyYW5zbGF0aW9uIEF0dHJpYnV0ZXMKPiArICogQGZzYzogRmlyc3Qgc3RhZ2UgY29u dGV4dAo+ICsgKiBAbXNpcHRwOiBNU0kgcGFnZSB0YWJsZSBwb2ludGVyCj4gKyAqIEBtc2lfYWRk cl9tYXNrOiBNU0kgYWRkcmVzcyBtYXNrCj4gKyAqIEBtc2lfYWRkcl9wYXR0ZXJuOiBNU0kgYWRk cmVzcyBwYXR0ZXJuCj4gKyAqIEBfcmVzZXJ2ZWQ6IFJlc2VydmVkIGZvciBmdXR1cmUgdXNlLCBw YWRkaW5nCj4gKyAqCj4gKyAqIFRoaXMgc3RydWN0dXJlIGlzIHVzZWQgZm9yIGxlYWYgbm9kZXMg b24gdGhlIERldmljZSBEaXJlY3RvcnkgVGFibGUsCj4gKyAqIGluIGNhc2UgUklTQ1ZfSU9NTVVf Q0FQX01TSV9GTEFUIGlzIG5vdCBzZXQsIHRoZSBib3R0b20gNCBmaWVsZHMgYXJlCj4gKyAqIG5v dCBwcmVzZW50IGFuZCBhcmUgc2tpcHBlZCB3aXRoIHBvaW50ZXIgYXJpdGhtZXRpYyB0byBhdm9p ZAo+ICsgKiBjYXN0aW5nLCBjaGVjayBvdXQgcmlzY3ZfaW9tbXVfZ2V0X2RjKCkuCj4gKyAqIFNl ZSBzZWN0aW9uIDIuMSBmb3IgbW9yZSBkZXRhaWxzCj4gKyAqLwo+ICtzdHJ1Y3QgcmlzY3ZfaW9t bXVfZGMgewo+ICsJdTY0IHRjOwo+ICsJdTY0IGlvaGdhdHA7Cj4gKwl1NjQgdGE7Cj4gKwl1NjQg ZnNjOwo+ICsJdTY0IG1zaXB0cDsKPiArCXU2NCBtc2lfYWRkcl9tYXNrOwo+ICsJdTY0IG1zaV9h ZGRyX3BhdHRlcm47Cj4gKwl1NjQgX3Jlc2VydmVkOwo+ICt9Owo+ICsKPiArLyogVHJhbnNsYXRp b24gY29udHJvbCBmaWVsZHMgKi8KPiArI2RlZmluZSBSSVNDVl9JT01NVV9EQ19UQ19WCQlCSVRf VUxMKDApCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfRENfVENfRU5fQVRTCUJJVF9VTEwoMSkKPiAr I2RlZmluZSBSSVNDVl9JT01NVV9EQ19UQ19FTl9QUkkJQklUX1VMTCgyKQo+ICsjZGVmaW5lIFJJ U0NWX0lPTU1VX0RDX1RDX1QyR1BBCQlCSVRfVUxMKDMpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVf RENfVENfRFRGCQlCSVRfVUxMKDQpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfRENfVENfUERUVgkJ QklUX1VMTCg1KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0RDX1RDX1BSUFIJCUJJVF9VTEwoNikK PiArI2RlZmluZSBSSVNDVl9JT01NVV9EQ19UQ19HQURFCQlCSVRfVUxMKDcpCj4gKyNkZWZpbmUg UklTQ1ZfSU9NTVVfRENfVENfU0FERQkJQklUX1VMTCg4KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1V X0RDX1RDX0RQRQkJQklUX1VMTCg5KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0RDX1RDX1NCRQkJ QklUX1VMTCgxMCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9EQ19UQ19TWEwJCUJJVF9VTEwoMTEp Cj4gKwo+ICsvKiBTZWNvbmQtc3RhZ2UgKGFrYSBHLXN0YWdlKSBjb250ZXh0IGZpZWxkcyAqLwo+ ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0RDX0lPSEdBVFBfUFBOCVJJU0NWX0lPTU1VX0FUUF9QUE5f RklFTEQKPiArI2RlZmluZSBSSVNDVl9JT01NVV9EQ19JT0hHQVRQX0dTQ0lECUdFTk1BU0tfVUxM KDU5LCA0NCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9EQ19JT0hHQVRQX01PREUJUklTQ1ZfSU9N TVVfQVRQX01PREVfRklFTEQKPiArCj4gKy8qKgo+ICsgKiBlbnVtIHJpc2N2X2lvbW11X2RjX2lv aGdhdHBfbW9kZXMgLSBHdWVzdCBhZGRyZXNzIHRyYW5zbGF0aW9uL3Byb3RlY3Rpb24gbW9kZXMK PiArICogQFJJU0NWX0lPTU1VX0RDX0lPSEdBVFBfTU9ERV9CQVJFOiBObyB0cmFuc2xhdGlvbi9w cm90ZWN0aW9uCj4gKyAqIEBSSVNDVl9JT01NVV9EQ19JT0hHQVRQX01PREVfU1YzMlg0OiBTdjMy eDQgKDItYml0IGV4dGVuc2lvbiBvZiBTdjMyKSwgd2hlbiBmY3RsLkdYTCA9PSAxCj4gKyAqIEBS SVNDVl9JT01NVV9EQ19JT0hHQVRQX01PREVfU1YzOVg0OiBTdjM5eDQgKDItYml0IGV4dGVuc2lv biBvZiBTdjM5KSwgd2hlbiBmY3RsLkdYTCA9PSAwCj4gKyAqIEBSSVNDVl9JT01NVV9EQ19JT0hH QVRQX01PREVfU1Y0OFg0OiBTdjQ4eDQgKDItYml0IGV4dGVuc2lvbiBvZiBTdjQ4KSwgd2hlbiBm Y3RsLkdYTCA9PSAwCj4gKyAqIEBSSVNDVl9JT01NVV9EQ19JT0hHQVRQX01PREVfU1Y1N1g0OiBT djU3eDQgKDItYml0IGV4dGVuc2lvbiBvZiBTdjU3KSwgd2hlbiBmY3RsLkdYTCA9PSAwCj4gKyAq Lwo+ICtlbnVtIHJpc2N2X2lvbW11X2RjX2lvaGdhdHBfbW9kZXMgewo+ICsJUklTQ1ZfSU9NTVVf RENfSU9IR0FUUF9NT0RFX0JBUkUgPSAwLAo+ICsJUklTQ1ZfSU9NTVVfRENfSU9IR0FUUF9NT0RF X1NWMzJYNCA9IDgsCj4gKwlSSVNDVl9JT01NVV9EQ19JT0hHQVRQX01PREVfU1YzOVg0ID0gOCwK PiArCVJJU0NWX0lPTU1VX0RDX0lPSEdBVFBfTU9ERV9TVjQ4WDQgPSA5LAo+ICsJUklTQ1ZfSU9N TVVfRENfSU9IR0FUUF9NT0RFX1NWNTdYNCA9IDEwCj4gK307Cj4gKwo+ICsvKiBUcmFuc2xhdGlv biBhdHRyaWJ1dGVzIGZpZWxkcyAqLwo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0RDX1RBX1BTQ0lE CQlHRU5NQVNLX1VMTCgzMSwgMTIpCj4gKwo+ICsvKiBGaXJzdC1zdGFnZSBjb250ZXh0IGZpZWxk cyAqLwo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0RDX0ZTQ19QUE4JCVJJU0NWX0lPTU1VX0FUUF9Q UE5fRklFTEQKPiArI2RlZmluZSBSSVNDVl9JT01NVV9EQ19GU0NfTU9ERQkJUklTQ1ZfSU9NTVVf QVRQX01PREVfRklFTEQKPiArCj4gKy8qKgo+ICsgKiBlbnVtIHJpc2N2X2lvbW11X2RjX2ZzY19h dHBfbW9kZXMgLSBGaXJzdCBzdGFnZSBhZGRyZXNzIHRyYW5zbGF0aW9uL3Byb3RlY3Rpb24gbW9k ZXMKPiArICogQFJJU0NWX0lPTU1VX0RDX0ZTQ19NT0RFX0JBUkU6IE5vIHRyYW5zbGF0aW9uL3By b3RlY3Rpb24KPiArICogQFJJU0NWX0lPTU1VX0RDX0ZTQ19JT1NBVFBfTU9ERV9TVjMyOiBTdjMy LCB3aGVuIGRjLnRjLlNYTCA9PSAxCj4gKyAqIEBSSVNDVl9JT01NVV9EQ19GU0NfSU9TQVRQX01P REVfU1YzOTogU3YzOSwgd2hlbiBkYy50Yy5TWEwgPT0gMAo+ICsgKiBAUklTQ1ZfSU9NTVVfRENf RlNDX0lPU0FUUF9NT0RFX1NWNDg6IFN2NDgsIHdoZW4gZGMudGMuU1hMID09IDAKPiArICogQFJJ U0NWX0lPTU1VX0RDX0ZTQ19JT1NBVFBfTU9ERV9TVjU3OiBTdjU3LCB3aGVuIGRjLnRjLlNYTCA9 PSAwCj4gKyAqIEBSSVNDVl9JT01NVV9EQ19GU0NfUERUUF9NT0RFX1BEODogMWx2bCBQRFQsIDhi aXQgcHJvY2VzcyBpZHMKPiArICogQFJJU0NWX0lPTU1VX0RDX0ZTQ19QRFRQX01PREVfUEQxNzog Mmx2bCBQRFQsIDE3Yml0IHByb2Nlc3MgaWRzCj4gKyAqIEBSSVNDVl9JT01NVV9EQ19GU0NfUERU UF9NT0RFX1BEMjA6IDNsdmwgUERULCAyMGJpdCBwcm9jZXNzIGlkcwo+ICsgKgo+ICsgKiBGU0Mg aG9sZHMgSU9TQVRQIHdoZW4gUklTQ1ZfSU9NTVVfRENfVENfUERUViBpcyAwIGFuZCBQRFRQIG90 aGVyd2lzZS4KPiArICogSU9TQVRQIGNvbnRyb2xzIHRoZSBmaXJzdCBzdGFnZSBhZGRyZXNzIHRy YW5zbGF0aW9uIChzYW1lIGFzIHRoZSBzYXRwIHJlZ2lzdGVyIG9uCj4gKyAqIHRoZSBSSVNDLVYg TU1VKSwgYW5kIFBEVFAgaG9sZHMgdGhlIHByb2Nlc3MgZGlyZWN0b3J5IHRhYmxlLCB1c2VkIHRv IHNlbGVjdCBhCj4gKyAqIGZpcnN0IHN0YWdlIHBhZ2UgdGFibGUgYmFzZWQgb24gYSBwcm9jZXNz IGlkIChmb3IgZGV2aWNlcyB0aGF0IHN1cHBvcnQgbXVsdGlwbGUKPiArICogcHJvY2VzcyBpZHMp Lgo+ICsgKi8KPiArZW51bSByaXNjdl9pb21tdV9kY19mc2NfYXRwX21vZGVzIHsKPiArCVJJU0NW X0lPTU1VX0RDX0ZTQ19NT0RFX0JBUkUgPSAwLAo+ICsJUklTQ1ZfSU9NTVVfRENfRlNDX0lPU0FU UF9NT0RFX1NWMzIgPSA4LAo+ICsJUklTQ1ZfSU9NTVVfRENfRlNDX0lPU0FUUF9NT0RFX1NWMzkg PSA4LAo+ICsJUklTQ1ZfSU9NTVVfRENfRlNDX0lPU0FUUF9NT0RFX1NWNDggPSA5LAo+ICsJUklT Q1ZfSU9NTVVfRENfRlNDX0lPU0FUUF9NT0RFX1NWNTcgPSAxMCwKPiArCVJJU0NWX0lPTU1VX0RD X0ZTQ19QRFRQX01PREVfUEQ4ID0gMSwKPiArCVJJU0NWX0lPTU1VX0RDX0ZTQ19QRFRQX01PREVf UEQxNyA9IDIsCj4gKwlSSVNDVl9JT01NVV9EQ19GU0NfUERUUF9NT0RFX1BEMjAgPSAzCj4gK307 Cj4gKwo+ICsvKiBNU0kgcGFnZSB0YWJsZSBwb2ludGVyICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9N TVVfRENfTVNJUFRQX1BQTglSSVNDVl9JT01NVV9BVFBfUFBOX0ZJRUxECj4gKyNkZWZpbmUgUklT Q1ZfSU9NTVVfRENfTVNJUFRQX01PREUJUklTQ1ZfSU9NTVVfQVRQX01PREVfRklFTEQKPiArI2Rl ZmluZSBSSVNDVl9JT01NVV9EQ19NU0lQVFBfTU9ERV9PRkYJMAo+ICsjZGVmaW5lIFJJU0NWX0lP TU1VX0RDX01TSVBUUF9NT0RFX0ZMQVQJMQo+ICsKPiArLyogTVNJIGFkZHJlc3MgbWFzayAqLwo+ ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0RDX01TSV9BRERSX01BU0sJR0VOTUFTS19VTEwoNTEsIDAp Cj4gKwo+ICsvKiBNU0kgYWRkcmVzcyBwYXR0ZXJuICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVf RENfTVNJX1BBVFRFUk4JR0VOTUFTS19VTEwoNTEsIDApCj4gKwo+ICsvKioKPiArICogc3RydWN0 IHJpc2N2X2lvbW11X3BjIC0gUHJvY2VzcyBDb250ZXh0Cj4gKyAqIEB0YTogVHJhbnNsYXRpb24g QXR0cmlidXRlcwo+ICsgKiBAZnNjOiBGaXJzdCBzdGFnZSBjb250ZXh0Cj4gKyAqCj4gKyAqIFRo aXMgc3RydWN0dXJlIGlzIHVzZWQgZm9yIGxlYWYgbm9kZXMgb24gdGhlIFByb2Nlc3MgRGlyZWN0 b3J5IFRhYmxlCj4gKyAqIFNlZSBzZWN0aW9uIDIuMyBmb3IgbW9yZSBkZXRhaWxzCj4gKyAqLwo+ ICtzdHJ1Y3QgcmlzY3ZfaW9tbXVfcGMgewo+ICsJdTY0IHRhOwo+ICsJdTY0IGZzYzsKPiArfTsK PiArCj4gKy8qIFRyYW5zbGF0aW9uIGF0dHJpYnV0ZXMgZmllbGRzICovCj4gKyNkZWZpbmUgUklT Q1ZfSU9NTVVfUENfVEFfVglCSVRfVUxMKDApCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUENfVEFf RU5TCUJJVF9VTEwoMSkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9QQ19UQV9TVU0JQklUX1VMTCgy KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1BDX1RBX1BTQ0lECUdFTk1BU0tfVUxMKDMxLCAxMikK PiArCj4gKy8qIEZpcnN0IHN0YWdlIGNvbnRleHQgZmllbGRzICovCj4gKyNkZWZpbmUgUklTQ1Zf SU9NTVVfUENfRlNDX1BQTglSSVNDVl9JT01NVV9BVFBfUFBOX0ZJRUxECj4gKyNkZWZpbmUgUklT Q1ZfSU9NTVVfUENfRlNDX01PREUJUklTQ1ZfSU9NTVVfQVRQX01PREVfRklFTEQKPiArCj4gKy8q Cj4gKyAqIENoYXB0ZXIgMzogSW4tbWVtb3J5IHF1ZXVlIGludGVyZmFjZQo+ICsgKi8KPiArCj4g Ky8qKgo+ICsgKiBzdHJ1Y3QgcmlzY3ZfaW9tbXVfY29tbWFuZCAtIEdlbmVyaWMgSS9PIE1NVSBj b21tYW5kIHN0cnVjdHVyZQo+ICsgKiBAZHdvcmQwOiBJbmNsdWRlcyB0aGUgb3Bjb2RlIGFuZCB0 aGUgZnVuY3Rpb24gaWRlbnRpZmllcgo+ICsgKiBAZHdvcmQxOiBPcGNvZGUgc3BlY2lmaWMgZGF0 YQo+ICsgKgo+ICsgKiBUaGUgY29tbWFuZHMgYXJlIGludGVycHJldGVkIGFzIHR3byA2NGJpdCBm aWVsZHMsIHdoZXJlIHRoZSBmaXJzdAo+ICsgKiA3Yml0cyBvZiB0aGUgZmlyc3QgZmllbGQgYXJl IHRoZSBvcGNvZGUgd2hpY2ggYWxzbyBkZWZpbmVzIHRoZQo+ICsgKiBjb21tYW5kJ3MgZm9ybWF0 LCBmb2xsb3dlZCBieSBhIDNiaXQgZmllbGQgdGhhdCBzcGVjaWZpZXMgdGhlCj4gKyAqIGZ1bmN0 aW9uIGludm9rZWQgYnkgdGhhdCBjb21tYW5kLCBhbmQgdGhlIHJlc3QgaXMgb3Bjb2RlLXNwZWNp ZmljLgo+ICsgKiBUaGlzIGlzIGEgZ2VuZXJpYyBzdHJ1Y3Qgd2hpY2ggd2lsbCBiZSBwb3B1bGF0 ZWQgZGlmZmVyZW50bHkKPiArICogYWNjb3JkaW5nIHRvIGVhY2ggY29tbWFuZC4gRm9yIG1vcmUg aW5mb3Mgb24gdGhlIGNvbW1hbmRzIGFuZAo+ICsgKiB0aGUgY29tbWFuZCBxdWV1ZSBjaGVjayBz ZWN0aW9uIDMuMS4KPiArICovCj4gK3N0cnVjdCByaXNjdl9pb21tdV9jb21tYW5kIHsKPiArCXU2 NCBkd29yZDA7Cj4gKwl1NjQgZHdvcmQxOwo+ICt9Owo+ICsKPiArLyogRmllbGRzIG9uIGR3b3Jk MCwgY29tbW9uIGZvciBhbGwgY29tbWFuZHMgKi8KPiArI2RlZmluZSBSSVNDVl9JT01NVV9DTURf T1BDT0RFCUdFTk1BU0tfVUxMKDYsIDApCj4gKyNkZWZpbmUJUklTQ1ZfSU9NTVVfQ01EX0ZVTkMJ R0VOTUFTS19VTEwoOSwgNykKPiArCj4gKy8qIDMuMS4xIEkvTyBNTVUgUGFnZS10YWJsZSBjYWNo ZSBpbnZhbGlkYXRpb24gKi8KPiArLyogRmllbGRzIG9uIGR3b3JkMCAqLwo+ICsjZGVmaW5lIFJJ U0NWX0lPTU1VX0NNRF9JT1RJTlZBTF9PUENPREUJCTEKPiArI2RlZmluZSBSSVNDVl9JT01NVV9D TURfSU9USU5WQUxfRlVOQ19WTUEJMAo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9JT1RJTlZB TF9GVU5DX0dWTUEJMQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9JT1RJTlZBTF9BVgkJQklU X1VMTCgxMCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9DTURfSU9USU5WQUxfUFNDSUQJCUdFTk1B U0tfVUxMKDMxLCAxMikKPiArI2RlZmluZSBSSVNDVl9JT01NVV9DTURfSU9USU5WQUxfUFNDVgkJ QklUX1VMTCgzMikKPiArI2RlZmluZSBSSVNDVl9JT01NVV9DTURfSU9USU5WQUxfR1YJCUJJVF9V TEwoMzMpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ01EX0lPVElOVkFMX0dTQ0lECQlHRU5NQVNL X1VMTCg1OSwgNDQpCj4gKy8qIGR3b3JkMVs2MToxMF0gaXMgdGhlIDRLLWFsaWduZWQgcGFnZSBh ZGRyZXNzICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ01EX0lPVElOVkFMX0FERFIJCUdFTk1B U0tfVUxMKDYxLCAxMCkKPiArCj4gKy8qIDMuMS4yIEkvTyBNTVUgQ29tbWFuZCBRdWV1ZSBGZW5j ZXMgKi8KPiArLyogRmllbGRzIG9uIGR3b3JkMCAqLwo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NN RF9JT0ZFTkNFX09QQ09ERQkJMgo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9JT0ZFTkNFX0ZV TkNfQwkJMAo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9JT0ZFTkNFX0FWCQlCSVRfVUxMKDEw KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9JT0ZFTkNFX1dTSQkJQklUX1VMTCgxMSkKPiAr I2RlZmluZSBSSVNDVl9JT01NVV9DTURfSU9GRU5DRV9QUgkJQklUX1VMTCgxMikKPiArI2RlZmlu ZSBSSVNDVl9JT01NVV9DTURfSU9GRU5DRV9QVwkJQklUX1VMTCgxMykKPiArI2RlZmluZSBSSVND Vl9JT01NVV9DTURfSU9GRU5DRV9EQVRBCQlHRU5NQVNLX1VMTCg2MywgMzIpCj4gKy8qIGR3b3Jk MSBpcyB0aGUgYWRkcmVzcywgd29yZC1zaXplIGFsaWduZWQgYW5kIHNoaWZ0ZWQgdG8gdGhlIHJp Z2h0IGJ5IHR3byBiaXRzLiAqLwo+ICsKPiArLyogMy4xLjMgSS9PIE1NVSBEaXJlY3RvcnkgY2Fj aGUgaW52YWxpZGF0aW9uICovCj4gKy8qIEZpZWxkcyBvbiBkd29yZDAgKi8KPiArI2RlZmluZSBS SVNDVl9JT01NVV9DTURfSU9ESVJfT1BDT0RFCQkzCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ01E X0lPRElSX0ZVTkNfSU5WQUxfRERUCTAKPiArI2RlZmluZSBSSVNDVl9JT01NVV9DTURfSU9ESVJf RlVOQ19JTlZBTF9QRFQJMQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9JT0RJUl9QSUQJCUdF Tk1BU0tfVUxMKDMxLCAxMikKPiArI2RlZmluZSBSSVNDVl9JT01NVV9DTURfSU9ESVJfRFYJCUJJ VF9VTEwoMzMpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ01EX0lPRElSX0RJRAkJR0VOTUFTS19V TEwoNjMsIDQwKQo+ICsvKiBkd29yZDEgaXMgcmVzZXJ2ZWQgZm9yIHN0YW5kYXJkIHVzZSAqLwo+ ICsKPiArLyogMy4xLjQgSS9PIE1NVSBQQ0llIEFUUyAqLwo+ICsvKiBGaWVsZHMgb24gZHdvcmQw ICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ01EX0FUU19PUENPREUJCTQKPiArI2RlZmluZSBS SVNDVl9JT01NVV9DTURfQVRTX0ZVTkNfSU5WQUwJCTAKPiArI2RlZmluZSBSSVNDVl9JT01NVV9D TURfQVRTX0ZVTkNfUFJHUgkJMQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9BVFNfUElECQkJ R0VOTUFTS19VTEwoMzEsIDEyKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9BVFNfUFYJCQlC SVRfVUxMKDMyKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9BVFNfRFNWCQkJQklUX1VMTCgz MykKPiArI2RlZmluZSBSSVNDVl9JT01NVV9DTURfQVRTX1JJRAkJCUdFTk1BU0tfVUxMKDU1LCA0 MCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9DTURfQVRTX0RTRUcJCUdFTk1BU0tfVUxMKDYzLCA1 NikKPiArLyogZHdvcmQxIGlzIHRoZSBBVFMgcGF5bG9hZCwgdHdvIGRpZmZlcmVudCBwYXlsb2Fk IHR5cGVzIGZvciBJTlZBTCBhbmQgUFJHUiAqLwo+ICsKPiArLyogQVRTLklOVkFMIHBheWxvYWQq Lwo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9BVFNfSU5WQUxfRwkJQklUX1VMTCgwKQo+ICsv KiBCaXRzIDEgLSAxMCBhcmUgemVyb2VkICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfQ01EX0FU U19JTlZBTF9TCQlCSVRfVUxMKDExKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9BVFNfSU5W QUxfVUFERFIJCUdFTk1BU0tfVUxMKDYzLCAxMikKPiArCj4gKy8qIEFUUy5QUkdSIHBheWxvYWQg Ki8KPiArLyogQml0cyAwIC0gMzEgYXJlIHplcm9lZCAqLwo+ICsjZGVmaW5lIFJJU0NWX0lPTU1V X0NNRF9BVFNfUFJHUl9QUkdfSU5ERVgJR0VOTUFTS19VTEwoNDAsIDMyKQo+ICsvKiBCaXRzIDQx IC0gNDMgYXJlIHplcm9lZCAqLwo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9BVFNfUFJHUl9S RVNQX0NPREUJR0VOTUFTS19VTEwoNDcsIDQ0KQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0NNRF9B VFNfUFJHUl9EU1RfSUQJCUdFTk1BU0tfVUxMKDYzLCA0OCkKPiArCj4gKy8qKgo+ICsgKiBzdHJ1 Y3QgcmlzY3ZfaW9tbXVfZnFfcmVjb3JkIC0gRmF1bHQvRXZlbnQgUXVldWUgUmVjb3JkCj4gKyAq IEBoZHI6IEhlYWRlciwgaW5jbHVkZXMgZmF1bHQvZXZlbnQgY2F1c2UsIFBJRC9ESUQsIHRyYW5z YWN0aW9uIHR5cGUgZXRjCj4gKyAqIEBfcmVzZXJ2ZWQ6IExvdyAzMmJpdHMgZm9yIGN1c3RvbSB1 c2UsIGhpZ2ggMzJiaXRzIGZvciBzdGFuZGFyZCB1c2UKPiArICogQGlvdHZhbDogVHJhbnNhY3Rp b24tdHlwZS9jYXVzZSBzcGVjaWZpYyBmb3JtYXQKPiArICogQGlvdHZhbDI6IENhdXNlIHNwZWNp ZmljIGZvcm1hdAo+ICsgKgo+ICsgKiBUaGUgZmF1bHQvZXZlbnQgcXVldWUgcmVwb3J0cyBldmVu dHMgYW5kIGZhaWx1cmVzIHJhaXNlZCB3aGVuCj4gKyAqIHByb2Nlc3NpbmcgdHJhbnNhY3Rpb25z LiBFYWNoIHJlY29yZCBpcyBhIDMyYnl0ZSBzdHJ1Y3R1cmUgd2hlcmUKPiArICogdGhlIGZpcnN0 IGR3b3JkIGhhcyBhIGZpeGVkIGZvcm1hdCBmb3IgcHJvdmlkaW5nIGdlbmVyaWMgaW5mb3MKPiAr ICogcmVnYXJkaW5nIHRoZSBmYXVsdC9ldmVudCwgYW5kIHR3byBtb3JlIGR3b3JkcyBhcmUgdGhl cmUgZm9yCj4gKyAqIGZhdWx0L2V2ZW50LXNwZWNpZmljIGluZm9ybWF0aW9uLiBGb3IgbW9yZSBk ZXRhaWxzIHNlZSBzZWN0aW9uCj4gKyAqIDMuMi4KPiArICovCj4gK3N0cnVjdCByaXNjdl9pb21t dV9mcV9yZWNvcmQgewo+ICsJdTY0IGhkcjsKPiArCXU2NCBfcmVzZXJ2ZWQ7Cj4gKwl1NjQgaW90 dmFsOwo+ICsJdTY0IGlvdHZhbDI7Cj4gK307Cj4gKwo+ICsvKiBGaWVsZHMgb24gaGVhZGVyICov Cj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfRlFfSERSX0NBVVNFCUdFTk1BU0tfVUxMKDExLCAwKQo+ ICsjZGVmaW5lIFJJU0NWX0lPTU1VX0ZRX0hEUl9QSUQJCUdFTk1BU0tfVUxMKDMxLCAxMikKPiAr I2RlZmluZSBSSVNDVl9JT01NVV9GUV9IRFJfUFYJCUJJVF9VTEwoMzIpCj4gKyNkZWZpbmUgUklT Q1ZfSU9NTVVfRlFfSERSX1BSSVYJCUJJVF9VTEwoMzMpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVf RlFfSERSX1RUWVBFCUdFTk1BU0tfVUxMKDM5LCAzNCkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9G UV9IRFJfRElECQlHRU5NQVNLX1VMTCg2MywgNDApCj4gKwo+ICsvKioKPiArICogZW51bSByaXNj dl9pb21tdV9mcV9jYXVzZXMgLSBGYXVsdC9ldmVudCBjYXVzZSB2YWx1ZXMKPiArICogQFJJU0NW X0lPTU1VX0ZRX0NBVVNFX0lOU1RfRkFVTFQ6IEluc3RydWN0aW9uIGFjY2VzcyBmYXVsdAo+ICsg KiBAUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfUkRfQUREUl9NSVNBTElHTkVEOiBSZWFkIGFkZHJlc3Mg bWlzYWxpZ25lZAo+ICsgKiBAUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfUkRfRkFVTFQ6IFJlYWQgbG9h ZCBmYXVsdAo+ICsgKiBAUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfV1JfQUREUl9NSVNBTElHTkVEOiBX cml0ZS9BTU8gYWRkcmVzcyBtaXNhbGlnbmVkCj4gKyAqIEBSSVNDVl9JT01NVV9GUV9DQVVTRV9X Ul9GQVVMVDogV3JpdGUvQU1PIGFjY2VzcyBmYXVsdAo+ICsgKiBAUklTQ1ZfSU9NTVVfRlFfQ0FV U0VfSU5TVF9GQVVMVF9TOiBJbnN0cnVjdGlvbiBwYWdlIGZhdWx0Cj4gKyAqIEBSSVNDVl9JT01N VV9GUV9DQVVTRV9SRF9GQVVMVF9TOiBSZWFkIHBhZ2UgZmF1bHQKPiArICogQFJJU0NWX0lPTU1V X0ZRX0NBVVNFX1dSX0ZBVUxUX1M6IFdyaXRlL0FNTyBwYWdlIGZhdWx0Cj4gKyAqIEBSSVNDVl9J T01NVV9GUV9DQVVTRV9JTlNUX0ZBVUxUX1ZTOiBJbnN0cnVjdGlvbiBndWVzdCBwYWdlIGZhdWx0 Cj4gKyAqIEBSSVNDVl9JT01NVV9GUV9DQVVTRV9SRF9GQVVMVF9WUzogUmVhZCBndWVzdCBwYWdl IGZhdWx0Cj4gKyAqIEBSSVNDVl9JT01NVV9GUV9DQVVTRV9XUl9GQVVMVF9WUzogV3JpdGUvQU1P IGd1ZXN0IHBhZ2UgZmF1bHQKPiArICogQFJJU0NWX0lPTU1VX0ZRX0NBVVNFX0RNQV9ESVNBQkxF RDogQWxsIGluYm91bmQgdHJhbnNhY3Rpb25zIGRpc2FsbG93ZWQKPiArICogQFJJU0NWX0lPTU1V X0ZRX0NBVVNFX0REVF9MT0FEX0ZBVUxUOiBERFQgZW50cnkgbG9hZCBhY2Nlc3MgZmF1bHQKPiAr ICogQFJJU0NWX0lPTU1VX0ZRX0NBVVNFX0REVF9JTlZBTElEOiBERFQgZW50cnkgaW52YWxpZAo+ ICsgKiBAUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfRERUX01JU0NPTkZJR1VSRUQ6IEREVCBlbnRyeSBt aXNjb25maWd1cmVkCj4gKyAqIEBSSVNDVl9JT01NVV9GUV9DQVVTRV9UVFlQRV9CTE9DS0VEOiBU cmFuc2FjdGlvbiB0eXBlIGRpc2FsbG93ZWQKPiArICogQFJJU0NWX0lPTU1VX0ZRX0NBVVNFX01T SV9MT0FEX0ZBVUxUOiBNU0kgUFRFIGxvYWQgYWNjZXNzIGZhdWx0Cj4gKyAqIEBSSVNDVl9JT01N VV9GUV9DQVVTRV9NU0lfSU5WQUxJRDogTVNJIFBURSBpbnZhbGlkCj4gKyAqIEBSSVNDVl9JT01N VV9GUV9DQVVTRV9NU0lfTUlTQ09ORklHVVJFRDogTVNJIFBURSBtaXNjb25maWd1cmVkCj4gKyAq IEBSSVNDVl9JT01NVV9GUV9DQVVTRV9NUklGX0ZBVUxUOiBNUklGIGFjY2VzcyBmYXVsdAo+ICsg KiBAUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfUERUX0xPQURfRkFVTFQ6IFBEVCBlbnRyeSBsb2FkIGFj Y2VzcyBmYXVsdAo+ICsgKiBAUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfUERUX0lOVkFMSUQ6IFBEVCBl bnRyeSBpbnZhbGlkCj4gKyAqIEBSSVNDVl9JT01NVV9GUV9DQVVTRV9QRFRfTUlTQ09ORklHVVJF RDogUERUIGVudHJ5IG1pc2NvbmZpZ3VyZWQKPiArICogQFJJU0NWX0lPTU1VX0ZRX0NBVVNFX0RE VF9DT1JSVVBURUQ6IEREVCBkYXRhIGNvcnJ1cHRpb24KPiArICogQFJJU0NWX0lPTU1VX0ZRX0NB VVNFX1BEVF9DT1JSVVBURUQ6IFBEVCBkYXRhIGNvcnJ1cHRpb24KPiArICogQFJJU0NWX0lPTU1V X0ZRX0NBVVNFX01TSV9QVF9DT1JSVVBURUQ6IE1TSSBwYWdlIHRhYmxlIGRhdGEgY29ycnVwdGlv bgo+ICsgKiBAUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfTVJJRl9DT1JSVUlQVEVEOiBNUklGIGRhdGEg Y29ycnVwdGlvbgo+ICsgKiBAUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfSU5URVJOQUxfRFBfRVJST1I6 IEludGVybmFsIGRhdGEgcGF0aCBlcnJvcgo+ICsgKiBAUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfTVNJ X1dSX0ZBVUxUOiBJT01NVSBNU0kgd3JpdGUgYWNjZXNzIGZhdWx0Cj4gKyAqIEBSSVNDVl9JT01N VV9GUV9DQVVTRV9QVF9DT1JSVVBURUQ6IEZpcnN0L3NlY29uZCBzdGFnZSBwYWdlIHRhYmxlIGRh dGEgY29ycnVwdGlvbgo+ICsgKgo+ICsgKiBWYWx1ZXMgYXJlIG9uIHRhYmxlIDExIG9mIHRoZSBz cGVjLCBlbmNvZGluZ3MgMjc1IC0gMjA0NyBhcmUgcmVzZXJ2ZWQgZm9yIHN0YW5kYXJkCj4gKyAq IHVzZSwgYW5kIDIwNDggLSA0MDk1IGZvciBjdXN0b20gdXNlLgo+ICsgKi8KPiArZW51bSByaXNj dl9pb21tdV9mcV9jYXVzZXMgewo+ICsJUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfSU5TVF9GQVVMVCA9 IDEsCj4gKwlSSVNDVl9JT01NVV9GUV9DQVVTRV9SRF9BRERSX01JU0FMSUdORUQgPSA0LAo+ICsJ UklTQ1ZfSU9NTVVfRlFfQ0FVU0VfUkRfRkFVTFQgPSA1LAo+ICsJUklTQ1ZfSU9NTVVfRlFfQ0FV U0VfV1JfQUREUl9NSVNBTElHTkVEID0gNiwKPiArCVJJU0NWX0lPTU1VX0ZRX0NBVVNFX1dSX0ZB VUxUID0gNywKPiArCVJJU0NWX0lPTU1VX0ZRX0NBVVNFX0lOU1RfRkFVTFRfUyA9IDEyLAo+ICsJ UklTQ1ZfSU9NTVVfRlFfQ0FVU0VfUkRfRkFVTFRfUyA9IDEzLAo+ICsJUklTQ1ZfSU9NTVVfRlFf Q0FVU0VfV1JfRkFVTFRfUyA9IDE1LAo+ICsJUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfSU5TVF9GQVVM VF9WUyA9IDIwLAo+ICsJUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfUkRfRkFVTFRfVlMgPSAyMSwKPiAr CVJJU0NWX0lPTU1VX0ZRX0NBVVNFX1dSX0ZBVUxUX1ZTID0gMjMsCj4gKwlSSVNDVl9JT01NVV9G UV9DQVVTRV9ETUFfRElTQUJMRUQgPSAyNTYsCj4gKwlSSVNDVl9JT01NVV9GUV9DQVVTRV9ERFRf TE9BRF9GQVVMVCA9IDI1NywKPiArCVJJU0NWX0lPTU1VX0ZRX0NBVVNFX0REVF9JTlZBTElEID0g MjU4LAo+ICsJUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfRERUX01JU0NPTkZJR1VSRUQgPSAyNTksCj4g KwlSSVNDVl9JT01NVV9GUV9DQVVTRV9UVFlQRV9CTE9DS0VEID0gMjYwLAo+ICsJUklTQ1ZfSU9N TVVfRlFfQ0FVU0VfTVNJX0xPQURfRkFVTFQgPSAyNjEsCj4gKwlSSVNDVl9JT01NVV9GUV9DQVVT RV9NU0lfSU5WQUxJRCA9IDI2MiwKPiArCVJJU0NWX0lPTU1VX0ZRX0NBVVNFX01TSV9NSVNDT05G SUdVUkVEID0gMjYzLAo+ICsJUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfTVJJRl9GQVVMVCA9IDI2NCwK PiArCVJJU0NWX0lPTU1VX0ZRX0NBVVNFX1BEVF9MT0FEX0ZBVUxUID0gMjY1LAo+ICsJUklTQ1Zf SU9NTVVfRlFfQ0FVU0VfUERUX0lOVkFMSUQgPSAyNjYsCj4gKwlSSVNDVl9JT01NVV9GUV9DQVVT RV9QRFRfTUlTQ09ORklHVVJFRCA9IDI2NywKPiArCVJJU0NWX0lPTU1VX0ZRX0NBVVNFX0REVF9D T1JSVVBURUQgPSAyNjgsCj4gKwlSSVNDVl9JT01NVV9GUV9DQVVTRV9QRFRfQ09SUlVQVEVEID0g MjY5LAo+ICsJUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfTVNJX1BUX0NPUlJVUFRFRCA9IDI3MCwKPiAr CVJJU0NWX0lPTU1VX0ZRX0NBVVNFX01SSUZfQ09SUlVJUFRFRCA9IDI3MSwKPiArCVJJU0NWX0lP TU1VX0ZRX0NBVVNFX0lOVEVSTkFMX0RQX0VSUk9SID0gMjcyLAo+ICsJUklTQ1ZfSU9NTVVfRlFf Q0FVU0VfTVNJX1dSX0ZBVUxUID0gMjczLAo+ICsJUklTQ1ZfSU9NTVVfRlFfQ0FVU0VfUFRfQ09S UlVQVEVEID0gMjc0Cj4gK307Cj4gKwo+ICsvKioKPiArICogZW51bSByaXNjdl9pb21tdV9mcV90 dHlwZXM6IEZhdWx0L2V2ZW50IHRyYW5zYWN0aW9uIHR5cGVzCj4gKyAqIEBSSVNDVl9JT01NVV9G UV9UVFlQRV9OT05FOiBOb25lLiBGYXVsdCBub3QgY2F1c2VkIGJ5IGFuIGluYm91bmQgdHJhbnNh Y3Rpb24uCj4gKyAqIEBSSVNDVl9JT01NVV9GUV9UVFlQRV9VQUREUl9JTlNUX0ZFVENIOiBJbnN0 cnVjdGlvbiBmZXRjaCBmcm9tIHVudHJhbnNsYXRlZCBhZGRyZXNzCj4gKyAqIEBSSVNDVl9JT01N VV9GUV9UVFlQRV9VQUREUl9SRDogUmVhZCBmcm9tIHVudHJhbnNsYXRlZCBhZGRyZXNzCj4gKyAq IEBSSVNDVl9JT01NVV9GUV9UVFlQRV9VQUREUl9XUjogV3JpdGUvQU1PIHRvIHVudHJhbnNsYXRl ZCBhZGRyZXNzCj4gKyAqIEBSSVNDVl9JT01NVV9GUV9UVFlQRV9UQUREUl9JTlNUX0ZFVENIOiBJ bnN0cnVjdGlvbiBmZXRjaCBmcm9tIHRyYW5zbGF0ZWQgYWRkcmVzcwo+ICsgKiBAUklTQ1ZfSU9N TVVfRlFfVFRZUEVfVEFERFJfUkQ6IFJlYWQgZnJvbSB0cmFuc2xhdGVkIGFkZHJlc3MKPiArICog QFJJU0NWX0lPTU1VX0ZRX1RUWVBFX1RBRERSX1dSOiBXcml0ZS9BTU8gdG8gdHJhbnNsYXRlZCBh ZGRyZXNzCj4gKyAqIEBSSVNDVl9JT01NVV9GUV9UVFlQRV9QQ0lFX0FUU19SRVE6IFBDSWUgQVRT IHRyYW5zbGF0aW9uIHJlcXVlc3QKPiArICogQFJJU0NWX0lPTU1VX0ZXX1RUWVBFX1BDSUVfTVNH X1JFUTogUENJZSBtZXNzYWdlIHJlcXVlc3QKPiArICoKPiArICogVmFsdWVzIGFyZSBvbiB0YWJs ZSAxMiBvZiB0aGUgc3BlYywgdHlwZSA0IGFuZCAxMCAtIDMxIGFyZSByZXNlcnZlZCBmb3Igc3Rh bmRhcmQgdXNlCj4gKyAqIGFuZCAzMSAtIDYzIGZvciBjdXN0b20gdXNlLgo+ICsgKi8KPiArZW51 bSByaXNjdl9pb21tdV9mcV90dHlwZXMgewo+ICsJUklTQ1ZfSU9NTVVfRlFfVFRZUEVfTk9ORSA9 IDAsCj4gKwlSSVNDVl9JT01NVV9GUV9UVFlQRV9VQUREUl9JTlNUX0ZFVENIID0gMSwKPiArCVJJ U0NWX0lPTU1VX0ZRX1RUWVBFX1VBRERSX1JEID0gMiwKPiArCVJJU0NWX0lPTU1VX0ZRX1RUWVBF X1VBRERSX1dSID0gMywKPiArCVJJU0NWX0lPTU1VX0ZRX1RUWVBFX1RBRERSX0lOU1RfRkVUQ0gg PSA1LAo+ICsJUklTQ1ZfSU9NTVVfRlFfVFRZUEVfVEFERFJfUkQgPSA2LAo+ICsJUklTQ1ZfSU9N TVVfRlFfVFRZUEVfVEFERFJfV1IgPSA3LAo+ICsJUklTQ1ZfSU9NTVVfRlFfVFRZUEVfUENJRV9B VFNfUkVRID0gOCwKPiArCVJJU0NWX0lPTU1VX0ZXX1RUWVBFX1BDSUVfTVNHX1JFUSA9IDksCj4g K307Cj4gKwo+ICsvKioKPiArICogc3RydWN0IHJpc2N2X2lvbW11X3BxX3JlY29yZCAtIFBDSWUg UGFnZSBSZXF1ZXN0IHJlY29yZAo+ICsgKiBAaGRyOiBIZWFkZXIsIGluY2x1ZGVzIFBJRCwgRElE IGV0Ywo+ICsgKiBAcGF5bG9hZDogSG9sZHMgdGhlIHBhZ2UgYWRkcmVzcywgcmVxdWVzdCBncm91 cCBhbmQgcGVybWlzc2lvbiBiaXRzCj4gKyAqCj4gKyAqIEZvciBtb3JlIGluZm9zIG9uIHRoZSBQ Q0llIFBhZ2UgUmVxdWVzdCBxdWV1ZSBzZWUgY2hhcHRlciAzLjMuCj4gKyAqLwo+ICtzdHJ1Y3Qg cmlzY3ZfaW9tbXVfcHFfcmVjb3JkIHsKPiArCXU2NCBoZHI7Cj4gKwl1NjQgcGF5bG9hZDsKPiAr fTsKPiArCj4gKy8qIEhlYWRlciBmaWVsZHMgKi8KPiArI2RlZmluZSBSSVNDVl9JT01NVV9QUkVR X0hEUl9QSUQJR0VOTUFTS19VTEwoMzEsIDEyKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1BSRVFf SERSX1BWCQlCSVRfVUxMKDMyKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1BSRVFfSERSX1BSSVYJ QklUX1VMTCgzMykKPiArI2RlZmluZSBSSVNDVl9JT01NVV9QUkVRX0hEUl9FWEVDCUJJVF9VTEwo MzQpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUFJFUV9IRFJfRElECUdFTk1BU0tfVUxMKDYzLCA0 MCkKPiArCj4gKy8qIFBheWxvYWQgZmllbGRzICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUFJF UV9QQVlMT0FEX1IJQklUX1VMTCgwKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX1BSRVFfUEFZTE9B RF9XCUJJVF9VTEwoMSkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9QUkVRX1BBWUxPQURfTAlCSVRf VUxMKDIpCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfUFJFUV9QQVlMT0FEX00JR0VOTUFTS19VTEwo MiwgMCkJLyogTWFzayBvZiBSV0wgZm9yIGNvbnZlbmllbmNlICovCj4gKyNkZWZpbmUgUklTQ1Zf SU9NTVVfUFJFUV9QUkdfSU5ERVgJR0VOTUFTS19VTEwoMTEsIDMpCj4gKyNkZWZpbmUgUklTQ1Zf SU9NTVVfUFJFUV9VQUREUgkJR0VOTUFTS19VTEwoNjMsIDEyKQo+ICsKPiArLyoqCj4gKyAqIHN0 cnVjdCByaXNjdl9pb21tdV9tc2lfcHRlIC0gTVNJIFBhZ2UgVGFibGUgRW50cnkKPiArICogQHB0 ZTogTVNJIFBURQo+ICsgKiBAbXJpZl9pbmZvOiBNZW1vcnktcmVzaWRlbnQgaW50ZXJydXB0IGZp bGUgaW5mbwo+ICsgKgo+ICsgKiBUaGUgTVNJIFBhZ2UgVGFibGUgaXMgdXNlZCBmb3IgdmlydHVh bGl6aW5nIE1TSXMsIHNvIHRoYXQgd2hlbgo+ICsgKiBhIGRldmljZSBzZW5kcyBhbiBNU0kgdG8g YSBndWVzdCwgdGhlIElPTU1VIGNhbiByZXJvdXRlIGl0Cj4gKyAqIGJ5IHRyYW5zbGF0aW5nIHRo ZSBNU0kgYWRkcmVzcywgZWl0aGVyIHRvIGEgZ3Vlc3QgaW50ZXJydXB0IGZpbGUKPiArICogb3Ig YSBtZW1vcnkgcmVzaWRlbnQgaW50ZXJydXB0IGZpbGUgKE1SSUYpLiBOb3RlIHRoYXQgdGhpcyBw YWdlIHRhYmxlCj4gKyAqIGlzIGFuIGFycmF5IG9mIE1TSSBQVEVzLCBub3QgYSBtdWx0aS1sZXZl bCBwdCwgZWFjaCBlbnRyeQo+ICsgKiBpcyBhIGxlYWYgZW50cnkuIEZvciBtb3JlIGluZm9zIGNo ZWNrIG91dCB0aGUgQUlBIHNwZWMsIGNoYXB0ZXIgOS41Lgo+ICsgKgo+ICsgKiBBbHNvIGluIGJh c2ljIG1vZGUgdGhlIG1yaWZfaW5mbyBmaWVsZCBpcyBpZ25vcmVkIGJ5IHRoZSBJT01NVSBhbmQg Y2FuCj4gKyAqIGJlIHVzZWQgYnkgc29mdHdhcmUsIGFueSBvdGhlciByZXNlcnZlZCBmaWVsZHMg b24gcHRlIG11c3QgYmUgemVyb2VkLW91dAo+ICsgKiBieSBzb2Z0d2FyZS4KPiArICovCj4gK3N0 cnVjdCByaXNjdl9pb21tdV9tc2lfcHRlIHsKPiArCXU2NCBwdGU7Cj4gKwl1NjQgbXJpZl9pbmZv Owo+ICt9Owo+ICsKPiArLyogRmllbGRzIG9uIHB0ZSAqLwo+ICsjZGVmaW5lIFJJU0NWX0lPTU1V X01TSV9QVEVfVgkJQklUX1VMTCgwKQo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX01TSV9QVEVfTQkJ R0VOTUFTS19VTEwoMiwgMSkKPiArI2RlZmluZSBSSVNDVl9JT01NVV9NU0lfUFRFX01SSUZfQURE UglHRU5NQVNLX1VMTCg1MywgNykJLyogV2hlbiBNID09IDEgKE1SSUYgbW9kZSkgKi8KPiArI2Rl ZmluZSBSSVNDVl9JT01NVV9NU0lfUFRFX1BQTgkJUklTQ1ZfSU9NTVVfUFBOX0ZJRUxECS8qIFdo ZW4gTSA9PSAzIChiYXNpYyBtb2RlKSAqLwo+ICsjZGVmaW5lIFJJU0NWX0lPTU1VX01TSV9QVEVf QwkJQklUX1VMTCg2MykKPiArCj4gKy8qIEZpZWxkcyBvbiBtcmlmX2luZm8gKi8KPiArI2RlZmlu ZSBSSVNDVl9JT01NVV9NU0lfTVJJRl9OSUQJR0VOTUFTS19VTEwoOSwgMCkKPiArI2RlZmluZSBS SVNDVl9JT01NVV9NU0lfTVJJRl9OUFBOCVJJU0NWX0lPTU1VX1BQTl9GSUVMRAo+ICsjZGVmaW5l IFJJU0NWX0lPTU1VX01TSV9NUklGX05JRF9NU0IJQklUX1VMTCg2MCkKPiArCj4gKyNlbmRpZiAv KiBfUklTQ1ZfSU9NTVVfQklUU19IXyAqLwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2lvbW11L3Jp c2N2L2lvbW11LXBsYXRmb3JtLmMgYi9kcml2ZXJzL2lvbW11L3Jpc2N2L2lvbW11LXBsYXRmb3Jt LmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uNzcwMDg2YWUy YWIzCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvaW9tbXUvcmlzY3YvaW9tbXUtcGxh dGZvcm0uYwo+IEBAIC0wLDAgKzEsOTQgQEAKPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IEdQTC0yLjAtb25seQo+ICsvKgo+ICsgKiBSSVNDLVYgSU9NTVUgYXMgYSBwbGF0Zm9ybSBkZXZp Y2UKPiArICoKPiArICogQ29weXJpZ2h0IMKpIDIwMjMgRk9SVEgtSUNTL0NBUlYKPiArICogQ29w eXJpZ2h0IMKpIDIwMjMtMjAyNCBSaXZvcyBJbmMuCj4gKyAqCj4gKyAqIEF1dGhvcnMKPiArICoJ TmljayBLb3NzaWZpZGlzIDxtaWNrQGljcy5mb3J0aC5ncj4KPiArICoJVG9tYXN6IEplem5hY2gg PHRqZXpuYWNoQHJpdm9zaW5jLmNvbT4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgva2Vy bmVsLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L29m X3BsYXRmb3JtLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KPiArCj4g KyNpbmNsdWRlICJpb21tdS1iaXRzLmgiCj4gKyNpbmNsdWRlICJpb21tdS5oIgo+ICsKPiArc3Rh dGljIGludCByaXNjdl9pb21tdV9wbGF0Zm9ybV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICpwZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2Owo+ICsJc3Ry dWN0IHJpc2N2X2lvbW11X2RldmljZSAqaW9tbXUgPSBOVUxMOwo+ICsJc3RydWN0IHJlc291cmNl ICpyZXMgPSBOVUxMOwo+ICsJaW50IHZlYzsKPiArCj4gKwlpb21tdSA9IGRldm1fa3phbGxvYyhk ZXYsIHNpemVvZigqaW9tbXUpLCBHRlBfS0VSTkVMKTsKPiArCWlmICghaW9tbXUpCj4gKwkJcmV0 dXJuIC1FTk9NRU07Cj4gKwo+ICsJaW9tbXUtPmRldiA9IGRldjsKPiArCWlvbW11LT5yZWcgPSBk ZXZtX3BsYXRmb3JtX2dldF9hbmRfaW9yZW1hcF9yZXNvdXJjZShwZGV2LCAwLCAmcmVzKTsKPiAr CWlmIChJU19FUlIoaW9tbXUtPnJlZykpCj4gKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoZGV2LCBQ VFJfRVJSKGlvbW11LT5yZWcpLAo+ICsJCQkJICAgICAiY291bGQgbm90IG1hcCByZWdpc3RlciBy ZWdpb25cbiIpOwo+ICsKPiArCWRldl9zZXRfZHJ2ZGF0YShkZXYsIGlvbW11KTsKPiArCj4gKwkv KiBDaGVjayBkZXZpY2UgcmVwb3J0ZWQgY2FwYWJpbGl0aWVzIC8gZmVhdHVyZXMuICovCj4gKwlp b21tdS0+Y2FwcyA9IHJpc2N2X2lvbW11X3JlYWRxKGlvbW11LCBSSVNDVl9JT01NVV9SRUdfQ0FQ KTsKPiArCWlvbW11LT5mY3RsID0gcmlzY3ZfaW9tbXVfcmVhZGwoaW9tbXUsIFJJU0NWX0lPTU1V X1JFR19GQ1RMKTsKPiArCj4gKwkvKiBGb3Igbm93IHdlIG9ubHkgc3VwcG9ydCBXU0kgKi8KPiAr CXN3aXRjaCAoRklFTERfR0VUKFJJU0NWX0lPTU1VX0NBUF9JR1MsIGlvbW11LT5jYXBzKSkgewo+ ICsJY2FzZSBSSVNDVl9JT01NVV9DQVBfSUdTX1dTSToKPiArCWNhc2UgUklTQ1ZfSU9NTVVfQ0FQ X0lHU19CT1RIOgo+ICsJCWJyZWFrOwo+ICsJZGVmYXVsdDoKPiArCQlyZXR1cm4gZGV2X2Vycl9w cm9iZShkZXYsIC1FTk9ERVYsCj4gKwkJCQkgICAgICJ1bmFibGUgdG8gdXNlIHdpcmUtc2lnbmFs ZWQgaW50ZXJydXB0c1xuIik7Cj4gKwl9Cj4gKwo+ICsJaW9tbXUtPmlycXNfY291bnQgPSBwbGF0 Zm9ybV9pcnFfY291bnQocGRldik7Cj4gKwlpZiAoaW9tbXUtPmlycXNfY291bnQgPD0gMCkKPiAr CQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIC1FTk9ERVYsCj4gKwkJCQkgICAgICJubyBJUlEg cmVzb3VyY2VzIHByb3ZpZGVkXG4iKTsKPiArCj4gKwlmb3IgKHZlYyA9IDA7IHZlYyA8IGlvbW11 LT5pcnFzX2NvdW50OyB2ZWMrKykKPiArCQlpb21tdS0+aXJxc1t2ZWNdID0gcGxhdGZvcm1fZ2V0 X2lycShwZGV2LCB2ZWMpOwoKQW5kIGlmIEkndmUgc3BlY2lmaWVkIDk3IGludGVycnVwdHMgaW4g bXkgRFQgYmVjYXVzZSBJIHdvbid0IGxldCBzY2hlbWEgCmJlIHRoZSBib3NzIG9mIG1lPwoKPiAr CS8qIEVuYWJsZSB3aXJlLXNpZ25hbGVkIGludGVycnVwdHMsIGZjdGwuV1NJICovCj4gKwlpZiAo IShpb21tdS0+ZmN0bCAmIFJJU0NWX0lPTU1VX0ZDVExfV1NJKSkgewo+ICsJCWlvbW11LT5mY3Rs IF49IFJJU0NWX0lPTU1VX0ZDVExfV1NJOwoKVXNpbmcgWE9SIHRvIG9ubHkgZXZlciBzZXQgYSAw IGJpdCB0byAxIHNlZW1zIGEgYml0IG9idHVzZS4KCj4gKwkJcmlzY3ZfaW9tbXVfd3JpdGVsKGlv bW11LCBSSVNDVl9JT01NVV9SRUdfRkNUTCwgaW9tbXUtPmZjdGwpOwo+ICsJfQo+ICsKPiArCXJl dHVybiByaXNjdl9pb21tdV9pbml0KGlvbW11KTsKPiArfTsKPiArCj4gK3N0YXRpYyB2b2lkIHJp c2N2X2lvbW11X3BsYXRmb3JtX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ ICt7Cj4gKwlyaXNjdl9pb21tdV9yZW1vdmUoZGV2X2dldF9kcnZkYXRhKCZwZGV2LT5kZXYpKTsK PiArfTsKPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIHJpc2N2X2lvbW11 X29mX21hdGNoW10gPSB7Cj4gKwl7LmNvbXBhdGlibGUgPSAicmlzY3YsaW9tbXUiLH0sCj4gKwl7 fSwKPiArfTsKPiArCj4gK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIHJpc2N2X2lvbW11X29mX21h dGNoKTsKCkFuZCB5ZXQgaXQgY2Fubm90IGJlIGEgbW9kdWxlPwoKPiArc3RhdGljIHN0cnVjdCBw bGF0Zm9ybV9kcml2ZXIgcmlzY3ZfaW9tbXVfcGxhdGZvcm1fZHJpdmVyID0gewo+ICsJLnByb2Jl ID0gcmlzY3ZfaW9tbXVfcGxhdGZvcm1fcHJvYmUsCj4gKwkucmVtb3ZlX25ldyA9IHJpc2N2X2lv bW11X3BsYXRmb3JtX3JlbW92ZSwKPiArCS5kcml2ZXIgPSB7Cj4gKwkJLm5hbWUgPSAicmlzY3Ys aW9tbXUiLAo+ICsJCS5vZl9tYXRjaF90YWJsZSA9IHJpc2N2X2lvbW11X29mX21hdGNoLAo+ICsJ CS5zdXBwcmVzc19iaW5kX2F0dHJzID0gdHJ1ZSwKPiArCX0sCj4gK307Cj4gKwo+ICttb2R1bGVf ZHJpdmVyKHJpc2N2X2lvbW11X3BsYXRmb3JtX2RyaXZlciwgcGxhdGZvcm1fZHJpdmVyX3JlZ2lz dGVyLAo+ICsJICAgICAgcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIpOwoKbW9kdWxlX3BsYXRm b3JtX2RyaXZlcigpIGlzIGEgdGhpbmcuIE9yIGJ1aWx0aW5fcGxhdGZvcm1fZHJpdmVyKCksIGFz IAp0aGluZ3MgY3VycmVudGx5IHN0YW5kLgoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9pb21tdS9y aXNjdi9pb21tdS5jIGIvZHJpdmVycy9pb21tdS9yaXNjdi9pb21tdS5jCj4gbmV3IGZpbGUgbW9k ZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmFmNjhjODkyMDBhOQo+IC0tLSAvZGV2L251 bGwKPiArKysgYi9kcml2ZXJzL2lvbW11L3Jpc2N2L2lvbW11LmMKPiBAQCAtMCwwICsxLDg5IEBA Cj4gKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkKPiArLyoKPiArICog SU9NTVUgQVBJIGZvciBSSVNDLVYgSU9NTVUgaW1wbGVtZW50YXRpb25zLgo+ICsgKgo+ICsgKiBD b3B5cmlnaHQgwqkgMjAyMi0yMDI0IFJpdm9zIEluYy4KPiArICogQ29weXJpZ2h0IMKpIDIwMjMg Rk9SVEgtSUNTL0NBUlYKPiArICoKPiArICogQXV0aG9ycwo+ICsgKglUb21hc3ogSmV6bmFjaCA8 dGplem5hY2hAcml2b3NpbmMuY29tPgo+ICsgKglOaWNrIEtvc3NpZmlkaXMgPG1pY2tAaWNzLmZv cnRoLmdyPgo+ICsgKi8KPiArCj4gKyNkZWZpbmUgcHJfZm10KGZtdCkgS0JVSUxEX01PRE5BTUUg IjogIiBmbXQKCkkgZ3Vlc3MgdGhhdCBlbmRzIHVwIGFzICJpb21tdToiPyBHaXZlbiB0aGF0IHRo YXQgcHJlZml4IGFscmVhZHkgYmVsb25ncyAKdG8gdGhlIGNvcmUgY29kZSwgcGxlYXNlIHBpY2sg c29tZXRoaW5nIG1vcmUgc3BlY2lmaWMuCgo+ICsjaW5jbHVkZSA8bGludXgvY29tcGlsZXIuaD4K PiArI2luY2x1ZGUgPGxpbnV4L2RtYS1tYXBwaW5nLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9pbml0 Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9pb21tdS5oPgo+ICsjaW5jbHVkZSA8bGludXgva2VybmVs Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KPiArCj4gKyNpbmNsdWRlICJpb21tdS1i aXRzLmgiCj4gKyNpbmNsdWRlICJpb21tdS5oIgo+ICsKPiArTU9EVUxFX0RFU0NSSVBUSU9OKCJE cml2ZXIgZm9yIFJJU0MtViBJT01NVSIpOwo+ICtNT0RVTEVfQVVUSE9SKCJUb21hc3ogSmV6bmFj aCA8dGplem5hY2hAcml2b3NpbmMuY29tPiIpOwo+ICtNT0RVTEVfQVVUSE9SKCJOaWNrIEtvc3Np ZmlkaXMgPG1pY2tAaWNzLmZvcnRoLmdyPiIpOwo+ICtNT0RVTEVfTElDRU5TRSgiR1BMIik7Cj4g Kwo+ICsvKiBUaW1lb3V0cyBpbiBbdXNdICovCj4gKyNkZWZpbmUgUklTQ1ZfSU9NTVVfRERUUF9U SU1FT1VUCTUwMDAwCj4gKwo+ICtzdGF0aWMgaW50IHJpc2N2X2lvbW11X2luaXRfY2hlY2soc3Ry dWN0IHJpc2N2X2lvbW11X2RldmljZSAqaW9tbXUpCj4gK3sKPiArCXU2NCBkZHRwOwo+ICsKPiAr CS8qIEhhcmR3YXJlIG11c3QgYmUgY29uZmlndXJlZCBpbiBPRkYgfCBCQVJFIG1vZGUgYXQgc3lz dGVtIGluaXRpYWxpemF0aW9uLiAqLwo+ICsJcmlzY3ZfaW9tbXVfcmVhZHFfdGltZW91dChpb21t dSwgUklTQ1ZfSU9NTVVfUkVHX0REVFAsCj4gKwkJCQkgIGRkdHAsICEoZGR0cCAmIFJJU0NWX0lP TU1VX0REVFBfQlVTWSksCj4gKwkJCQkgIDEwLCBSSVNDVl9JT01NVV9ERFRQX1RJTUVPVVQpOwo+ ICsJaWYgKEZJRUxEX0dFVChSSVNDVl9JT01NVV9ERFRQX01PREUsIGRkdHApID4gUklTQ1ZfSU9N TVVfRERUUF9NT0RFX0JBUkUpCj4gKwkJcmV0dXJuIC1FQlVTWTsKCkl0IGxvb2tzIGxpa2UgUklT Qy1WIGFscmVhZHkgc3VwcG9ydHMga2R1bXAsIHNvIHlvdSBwcm9iYWJseSB3YW50IHRvIGJlIApw cmVwYXJlZCB0byBmaW5kIHRoZSBJT01NVSB3aXRoIGl0cyBwYW50cyBkb3duIGFuZCBkZWFsIHdp dGggaXQgZnJvbSBkYXkgCm9uZS4KCj4gKwo+ICsJLyogQ29uZmlndXJlIGFjY2Vzc2VzIHRvIGlu LW1lbW9yeSBkYXRhIHN0cnVjdHVyZXMgZm9yIENQVS1uYXRpdmUgYnl0ZSBvcmRlci4gKi8KPiAr CWlmIChJU19FTkFCTEVEKENPTkZJR19DUFVfQklHX0VORElBTikgIT0gISEoaW9tbXUtPmZjdGwg JiBSSVNDVl9JT01NVV9GQ1RMX0JFKSkgewo+ICsJCWlmICghKGlvbW11LT5jYXBzICYgUklTQ1Zf SU9NTVVfQ0FQX0VORCkpCj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ICsJCXJpc2N2X2lvbW11X3dy aXRlbChpb21tdSwgUklTQ1ZfSU9NTVVfUkVHX0ZDVEwsCj4gKwkJCQkgICBpb21tdS0+ZmN0bCBe IFJJU0NWX0lPTU1VX0ZDVExfQkUpOwo+ICsJCWlvbW11LT5mY3RsID0gcmlzY3ZfaW9tbXVfcmVh ZGwoaW9tbXUsIFJJU0NWX0lPTU1VX1JFR19GQ1RMKTsKPiArCQlpZiAoSVNfRU5BQkxFRChDT05G SUdfQ1BVX0JJR19FTkRJQU4pICE9ICEhKGlvbW11LT5mY3RsICYgUklTQ1ZfSU9NTVVfRkNUTF9C RSkpCj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ICsJfQoKVGhhdCdzIGZ1bi4gSXQgY291bGQgYmUg cmVvcmdhbmlzZWQgdG8gYXZvaWQgdGhlIGR1cGxpY2F0ZSBjaGVjaywgYnV0IGl0IAppcyByYXRo ZXIgbWFqZXN0aWMgYXMtaXMgOikKCj4gKwo+ICsJZG1hX3NldF9tYXNrX2FuZF9jb2hlcmVudChp b21tdS0+ZGV2LAo+ICsJCQkJICBETUFfQklUX01BU0soRklFTERfR0VUKFJJU0NWX0lPTU1VX0NB UF9QQVMsIGlvbW11LT5jYXBzKSkpOwoKVGhpcyBpc24ndCBhIGNoZWNrLCBzbyBJIHdvdWxkIHRo aW5rIGl0IGJlbG9uZ3MgdG8gIl9pbml0IiByYXRoZXIgdGhhbiAKIl9pbml0X2NoZWNrIi4KClRo YW5rcywKUm9iaW4uCgo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICt2b2lkIHJpc2N2X2lv bW11X3JlbW92ZShzdHJ1Y3QgcmlzY3ZfaW9tbXVfZGV2aWNlICppb21tdSkKPiArewo+ICsJaW9t bXVfZGV2aWNlX3N5c2ZzX3JlbW92ZSgmaW9tbXUtPmlvbW11KTsKPiArfQo+ICsKPiAraW50IHJp c2N2X2lvbW11X2luaXQoc3RydWN0IHJpc2N2X2lvbW11X2RldmljZSAqaW9tbXUpCj4gK3sKPiAr CWludCByYzsKPiArCj4gKwlyYyA9IHJpc2N2X2lvbW11X2luaXRfY2hlY2soaW9tbXUpOwo+ICsJ aWYgKHJjKQo+ICsJCXJldHVybiBkZXZfZXJyX3Byb2JlKGlvbW11LT5kZXYsIHJjLCAidW5leHBl Y3RlZCBkZXZpY2Ugc3RhdGVcbiIpOwo+ICsJLyoKPiArCSAqIFBsYWNlaG9sZGVyIGZvciBhIGNv bXBsZXRlIElPTU1VIGRldmljZSBpbml0aWFsaXphdGlvbi4KPiArCSAqIEZvciBub3csIG9ubHkg YmFyZSBtaW5pbXVtOiBlbmFibGUgZ2xvYmFsIGlkZW50aXR5IG1hcHBpbmcgbW9kZSBhbmQgcmVn aXN0ZXIgc3lzZnMuCj4gKwkgKi8KPiArCXJpc2N2X2lvbW11X3dyaXRlcShpb21tdSwgUklTQ1Zf SU9NTVVfUkVHX0REVFAsCj4gKwkJCSAgIEZJRUxEX1BSRVAoUklTQ1ZfSU9NTVVfRERUUF9NT0RF LCBSSVNDVl9JT01NVV9ERFRQX01PREVfQkFSRSkpOwo+ICsKPiArCXJjID0gaW9tbXVfZGV2aWNl X3N5c2ZzX2FkZCgmaW9tbXUtPmlvbW11LCBOVUxMLCBOVUxMLCAicmlzY3YtaW9tbXVAJXMiLAo+ ICsJCQkJICAgIGRldl9uYW1lKGlvbW11LT5kZXYpKTsKPiArCWlmIChXQVJOKHJjLCAiY2Fubm90 IHJlZ2lzdGVyIHN5c2ZzIGludGVyZmFjZVxuIikpCj4gKwkJZ290byBlcnJfc3lzZnM7Cj4gKwo+ ICsJcmV0dXJuIDA7Cj4gKwo+ICtlcnJfc3lzZnM6Cj4gKwlyZXR1cm4gcmM7Cj4gK30KPiBkaWZm IC0tZ2l0IGEvZHJpdmVycy9pb21tdS9yaXNjdi9pb21tdS5oIGIvZHJpdmVycy9pb21tdS9yaXNj di9pb21tdS5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLjcw MGUzM2RjMjQ0Ngo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2lvbW11L3Jpc2N2L2lv bW11LmgKPiBAQCAtMCwwICsxLDYyIEBACj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBH UEwtMi4wLW9ubHkgKi8KPiArLyoKPiArICogQ29weXJpZ2h0IMKpIDIwMjItMjAyNCBSaXZvcyBJ bmMuCj4gKyAqIENvcHlyaWdodCDCqSAyMDIzIEZPUlRILUlDUy9DQVJWCj4gKyAqCj4gKyAqIEF1 dGhvcnMKPiArICoJVG9tYXN6IEplem5hY2ggPHRqZXpuYWNoQHJpdm9zaW5jLmNvbT4KPiArICoJ TmljayBLb3NzaWZpZGlzIDxtaWNrQGljcy5mb3J0aC5ncj4KPiArICovCj4gKwo+ICsjaWZuZGVm IF9SSVNDVl9JT01NVV9IXwo+ICsjZGVmaW5lIF9SSVNDVl9JT01NVV9IXwo+ICsKPiArI2luY2x1 ZGUgPGxpbnV4L2lvbW11Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgo+ICsjaW5jbHVk ZSA8bGludXgvaW9wb2xsLmg+Cj4gKwo+ICsjaW5jbHVkZSAiaW9tbXUtYml0cy5oIgo+ICsKPiAr c3RydWN0IHJpc2N2X2lvbW11X2RldmljZSB7Cj4gKwkvKiBpb21tdSBjb3JlIGludGVyZmFjZSAq Lwo+ICsJc3RydWN0IGlvbW11X2RldmljZSBpb21tdTsKPiArCj4gKwkvKiBpb21tdSBoYXJkd2Fy ZSAqLwo+ICsJc3RydWN0IGRldmljZSAqZGV2Owo+ICsKPiArCS8qIGhhcmR3YXJlIGNvbnRyb2wg cmVnaXN0ZXIgc3BhY2UgKi8KPiArCXZvaWQgX19pb21lbSAqcmVnOwo+ICsKPiArCS8qIHN1cHBv cnRlZCBhbmQgZW5hYmxlZCBoYXJkd2FyZSBjYXBhYmlsaXRpZXMgKi8KPiArCXU2NCBjYXBzOwo+ ICsJdTMyIGZjdGw7Cj4gKwo+ICsJLyogYXZhaWxhYmxlIGludGVycnVwdCBudW1iZXJzLCBNU0kg b3IgV1NJICovCj4gKwl1bnNpZ25lZCBpbnQgaXJxc1tSSVNDVl9JT01NVV9JTlRSX0NPVU5UXTsK PiArCXVuc2lnbmVkIGludCBpcnFzX2NvdW50Owo+ICt9Owo+ICsKPiAraW50IHJpc2N2X2lvbW11 X2luaXQoc3RydWN0IHJpc2N2X2lvbW11X2RldmljZSAqaW9tbXUpOwo+ICt2b2lkIHJpc2N2X2lv bW11X3JlbW92ZShzdHJ1Y3QgcmlzY3ZfaW9tbXVfZGV2aWNlICppb21tdSk7Cj4gKwo+ICsjZGVm aW5lIHJpc2N2X2lvbW11X3JlYWRsKGlvbW11LCBhZGRyKSBcCj4gKwlyZWFkbF9yZWxheGVkKChp b21tdSktPnJlZyArIChhZGRyKSkKPiArCj4gKyNkZWZpbmUgcmlzY3ZfaW9tbXVfcmVhZHEoaW9t bXUsIGFkZHIpIFwKPiArCXJlYWRxX3JlbGF4ZWQoKGlvbW11KS0+cmVnICsgKGFkZHIpKQo+ICsK PiArI2RlZmluZSByaXNjdl9pb21tdV93cml0ZWwoaW9tbXUsIGFkZHIsIHZhbCkgXAo+ICsJd3Jp dGVsX3JlbGF4ZWQoKHZhbCksIChpb21tdSktPnJlZyArIChhZGRyKSkKPiArCj4gKyNkZWZpbmUg cmlzY3ZfaW9tbXVfd3JpdGVxKGlvbW11LCBhZGRyLCB2YWwpIFwKPiArCXdyaXRlcV9yZWxheGVk KCh2YWwpLCAoaW9tbXUpLT5yZWcgKyAoYWRkcikpCj4gKwo+ICsjZGVmaW5lIHJpc2N2X2lvbW11 X3JlYWRxX3RpbWVvdXQoaW9tbXUsIGFkZHIsIHZhbCwgY29uZCwgZGVsYXlfdXMsIHRpbWVvdXRf dXMpIFwKPiArCXJlYWR4X3BvbGxfdGltZW91dChyZWFkcV9yZWxheGVkLCAoaW9tbXUpLT5yZWcg KyAoYWRkciksIHZhbCwgY29uZCwgXAo+ICsJCQkgICBkZWxheV91cywgdGltZW91dF91cykKPiAr Cj4gKyNkZWZpbmUgcmlzY3ZfaW9tbXVfcmVhZGxfdGltZW91dChpb21tdSwgYWRkciwgdmFsLCBj b25kLCBkZWxheV91cywgdGltZW91dF91cykgXAo+ICsJcmVhZHhfcG9sbF90aW1lb3V0KHJlYWRs X3JlbGF4ZWQsIChpb21tdSktPnJlZyArIChhZGRyKSwgdmFsLCBjb25kLCBcCj4gKwkJCSAgIGRl bGF5X3VzLCB0aW1lb3V0X3VzKQo+ICsKPiArI2VuZGlmCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1yaXNjdiBtYWlsaW5nIGxpc3QKbGludXgt cmlzY3ZAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWls bWFuL2xpc3RpbmZvL2xpbnV4LXJpc2N2Cg==