From mboxrd@z Thu Jan 1 00:00:00 1970 Received: with ECARTIS (v1.0.0; list linux-mips); Fri, 25 May 2018 11:27:54 +0200 (CEST) Received: from bombadil.infradead.org ([IPv6:2607:7c80:54:e::133]:51306 "EHLO bombadil.infradead.org" rhost-flags-OK-OK-OK-OK) by eddie.linux-mips.org with ESMTP id S23993394AbeEYJWdJgx6A (ORCPT ); Fri, 25 May 2018 11:22:33 +0200 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20170209; h=Content-Transfer-Encoding: Content-Type:MIME-Version:References:In-Reply-To:Message-Id:Date:Subject:Cc: To:From:Sender:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=pVRGt0LiPoQnKGtlJzqGAW4y/kfPC64JALY7kTXboao=; b=Zf6/PgY58AzBX6p9Z+wJRHXBc /V9SNR9885MIGvy8pdSHXM8X+TKsdHWyYp5uhNXQBCODQDJYTqxQScqLHhui5oJgF3UuMRGWTNtAP /lrqwAiLt2zNofS6TunPiY9tGFrtnzNIkcVMYBzFBMlF3SPIFGqsSlWvtdz74lDeZoGbmw7hiLSZ0 0zg+r3KVIL/4/eVTKPRKUUmmg98RPSRF6wjOglcJfh8ydf5lVSJBw2UMBONRPqvKpoSHGwKhK1AUd iT4uatWFdtBKkK09NQlzhozu3R6G/w3FRcmKDUDZiJc4eYFL4yt/v+tKn0wwlwLhb+tw2gaxifEX8 PhQz3AMqA==; Received: from 80-109-164-210.cable.dynamic.surfer.at ([80.109.164.210] helo=localhost) by bombadil.infradead.org with esmtpsa (Exim 4.90_1 #2 (Red Hat Linux)) id 1fM8vf-00020c-CS; Fri, 25 May 2018 09:22:31 +0000 From: Christoph Hellwig To: Ralf Baechle , James Hogan Cc: Kevin Cernekee , Florian Fainelli , Huacai Chen , Jiaxun Yang , David Daney , Tom Bogendoerfer , linux-mips@linux-mips.org, iommu@lists.linux-foundation.org Subject: [PATCH 24/25] MIPS: remove the old dma-default implementation Date: Fri, 25 May 2018 11:21:10 +0200 Message-Id: <20180525092111.18516-25-hch@lst.de> X-Mailer: git-send-email 2.17.0 In-Reply-To: <20180525092111.18516-1-hch@lst.de> References: <20180525092111.18516-1-hch@lst.de> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-SRS-Rewrite: SMTP reverse-path rewritten from by bombadil.infradead.org. See http://www.infradead.org/rpr.html Return-Path: X-Envelope-To: <"|/home/ecartis/ecartis -s linux-mips"> (uid 0) X-Orcpt: rfc822;linux-mips@linux-mips.org Original-Recipient: rfc822;linux-mips@linux-mips.org X-archive-position: 64037 X-ecartis-version: Ecartis v1.0.0 Sender: linux-mips-bounce@linux-mips.org Errors-to: linux-mips-bounce@linux-mips.org X-original-sender: hch@lst.de Precedence: bulk List-help: List-unsubscribe: List-software: Ecartis version 1.0.0 List-Id: linux-mips X-List-ID: linux-mips List-subscribe: List-owner: List-post: List-archive: X-list: linux-mips Now unused. Signed-off-by: Christoph Hellwig --- arch/mips/Kconfig | 5 +- arch/mips/include/asm/dma-mapping.h | 3 - .../include/asm/mach-generic/dma-coherence.h | 73 ---- arch/mips/mm/Makefile | 1 - arch/mips/mm/dma-default.c | 379 ------------------ 5 files changed, 1 insertion(+), 460 deletions(-) delete mode 100644 arch/mips/include/asm/mach-generic/dma-coherence.h delete mode 100644 arch/mips/mm/dma-default.c diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig index 9ac3c6260b68..ad5a542bf094 100644 --- a/arch/mips/Kconfig +++ b/arch/mips/Kconfig @@ -72,9 +72,6 @@ config MIPS select SYSCTL_EXCEPTION_TRACE select VIRT_TO_BUS -config MIPS_DMA_DEFAULT - bool - menu "Machine selection" choice @@ -1113,7 +1110,7 @@ config DMA_NONCOHERENT select NEED_DMA_MAP_STATE select DMA_NONCOHERENT_MMAP select DMA_NONCOHERENT_CACHE_SYNC - select DMA_NONCOHERENT_OPS if !MIPS_DMA_DEFAULT + select DMA_NONCOHERENT_OPS config SYS_HAS_EARLY_PRINTK bool diff --git a/arch/mips/include/asm/dma-mapping.h b/arch/mips/include/asm/dma-mapping.h index caf97f739897..143250986e17 100644 --- a/arch/mips/include/asm/dma-mapping.h +++ b/arch/mips/include/asm/dma-mapping.h @@ -11,7 +11,6 @@ #endif extern const struct dma_map_ops jazz_dma_ops; -extern const struct dma_map_ops mips_default_dma_map_ops; extern const struct dma_map_ops mips_swiotlb_ops; static inline const struct dma_map_ops *get_arch_dma_ops(struct bus_type *bus) @@ -20,8 +19,6 @@ static inline const struct dma_map_ops *get_arch_dma_ops(struct bus_type *bus) return &jazz_dma_ops; #elif defined(CONFIG_SWIOTLB) return &mips_swiotlb_ops; -#elif defined(CONFIG_MIPS_DMA_DEFAULT) - return &mips_default_dma_map_ops; #elif defined(CONFIG_DMA_NONCOHERENT_OPS) return &dma_noncoherent_ops; #else diff --git a/arch/mips/include/asm/mach-generic/dma-coherence.h b/arch/mips/include/asm/mach-generic/dma-coherence.h deleted file mode 100644 index 8ad7a40ca786..000000000000 --- a/arch/mips/include/asm/mach-generic/dma-coherence.h +++ /dev/null @@ -1,73 +0,0 @@ -/* - * This file is subject to the terms and conditions of the GNU General Public - * License. See the file "COPYING" in the main directory of this archive - * for more details. - * - * Copyright (C) 2006 Ralf Baechle - * - */ -#ifndef __ASM_MACH_GENERIC_DMA_COHERENCE_H -#define __ASM_MACH_GENERIC_DMA_COHERENCE_H - -struct device; - -static inline dma_addr_t plat_map_dma_mem(struct device *dev, void *addr, - size_t size) -{ - return virt_to_phys(addr); -} - -static inline dma_addr_t plat_map_dma_mem_page(struct device *dev, - struct page *page) -{ - return page_to_phys(page); -} - -static inline unsigned long plat_dma_addr_to_phys(struct device *dev, - dma_addr_t dma_addr) -{ - return dma_addr; -} - -static inline void plat_unmap_dma_mem(struct device *dev, dma_addr_t dma_addr, - size_t size, enum dma_data_direction direction) -{ -} - -static inline int plat_dma_supported(struct device *dev, u64 mask) -{ - /* - * we fall back to GFP_DMA when the mask isn't all 1s, - * so we can't guarantee allocations that must be - * within a tighter range than GFP_DMA.. - */ - if (mask < DMA_BIT_MASK(24)) - return 0; - - return 1; -} - -static inline int plat_device_is_coherent(struct device *dev) -{ -#ifdef CONFIG_DMA_PERDEV_COHERENT - return dev->archdata.dma_coherent; -#else - switch (coherentio) { - default: - case IO_COHERENCE_DEFAULT: - return hw_coherentio; - case IO_COHERENCE_ENABLED: - return 1; - case IO_COHERENCE_DISABLED: - return 0; - } -#endif -} - -#ifndef plat_post_dma_flush -static inline void plat_post_dma_flush(struct device *dev) -{ -} -#endif - -#endif /* __ASM_MACH_GENERIC_DMA_COHERENCE_H */ diff --git a/arch/mips/mm/Makefile b/arch/mips/mm/Makefile index c6146c3805dc..6922f393af19 100644 --- a/arch/mips/mm/Makefile +++ b/arch/mips/mm/Makefile @@ -17,7 +17,6 @@ obj-$(CONFIG_32BIT) += ioremap.o pgtable-32.o obj-$(CONFIG_64BIT) += pgtable-64.o obj-$(CONFIG_HIGHMEM) += highmem.o obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o -obj-$(CONFIG_MIPS_DMA_DEFAULT) += dma-default.o obj-$(CONFIG_DMA_NONCOHERENT) += dma-noncoherent.o obj-$(CONFIG_SWIOTLB) += dma-swiotlb.o diff --git a/arch/mips/mm/dma-default.c b/arch/mips/mm/dma-default.c deleted file mode 100644 index 10b56e8a2076..000000000000 --- a/arch/mips/mm/dma-default.c +++ /dev/null @@ -1,379 +0,0 @@ -/* - * This file is subject to the terms and conditions of the GNU General Public - * License. See the file "COPYING" in the main directory of this archive - * for more details. - * - * Copyright (C) 2000 Ani Joshi - * Copyright (C) 2000, 2001, 06 Ralf Baechle - * swiped from i386, and cloned for MIPS by Geert, polished by Ralf. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -#include - -static inline struct page *dma_addr_to_page(struct device *dev, - dma_addr_t dma_addr) -{ - return pfn_to_page( - plat_dma_addr_to_phys(dev, dma_addr) >> PAGE_SHIFT); -} - -/* - * The affected CPUs below in 'cpu_needs_post_dma_flush()' can - * speculatively fill random cachelines with stale data at any time, - * requiring an extra flush post-DMA. - * - * Warning on the terminology - Linux calls an uncached area coherent; - * MIPS terminology calls memory areas with hardware maintained coherency - * coherent. - * - * Note that the R14000 and R16000 should also be checked for in this - * condition. However this function is only called on non-I/O-coherent - * systems and only the R10000 and R12000 are used in such systems, the - * SGI IP28 Indigo² rsp. SGI IP32 aka O2. - */ -static inline bool cpu_needs_post_dma_flush(struct device *dev) -{ - if (plat_device_is_coherent(dev)) - return false; - - switch (boot_cpu_type()) { - case CPU_R10000: - case CPU_R12000: - case CPU_BMIPS5000: - return true; - - default: - /* - * Presence of MAARs suggests that the CPU supports - * speculatively prefetching data, and therefore requires - * the post-DMA flush/invalidate. - */ - return cpu_has_maar; - } -} - -static gfp_t massage_gfp_flags(const struct device *dev, gfp_t gfp) -{ - gfp_t dma_flag; - -#ifdef CONFIG_ISA - if (dev == NULL) - dma_flag = __GFP_DMA; - else -#endif -#if defined(CONFIG_ZONE_DMA32) && defined(CONFIG_ZONE_DMA) - if (dev == NULL || dev->coherent_dma_mask < DMA_BIT_MASK(32)) - dma_flag = __GFP_DMA; - else if (dev->coherent_dma_mask < DMA_BIT_MASK(64)) - dma_flag = __GFP_DMA32; - else -#endif -#if defined(CONFIG_ZONE_DMA32) && !defined(CONFIG_ZONE_DMA) - if (dev == NULL || dev->coherent_dma_mask < DMA_BIT_MASK(64)) - dma_flag = __GFP_DMA32; - else -#endif -#if defined(CONFIG_ZONE_DMA) && !defined(CONFIG_ZONE_DMA32) - if (dev == NULL || - dev->coherent_dma_mask < DMA_BIT_MASK(sizeof(phys_addr_t) * 8)) - dma_flag = __GFP_DMA; - else -#endif - dma_flag = 0; - - /* Don't invoke OOM killer */ - gfp |= __GFP_NORETRY; - - return gfp | dma_flag; -} - -static void *mips_dma_alloc_coherent(struct device *dev, size_t size, - dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs) -{ - void *ret; - struct page *page = NULL; - unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT; - - gfp = massage_gfp_flags(dev, gfp); - - if (IS_ENABLED(CONFIG_DMA_CMA) && gfpflags_allow_blocking(gfp)) - page = dma_alloc_from_contiguous(dev, count, get_order(size), - gfp); - if (!page) - page = alloc_pages(gfp, get_order(size)); - - if (!page) - return NULL; - - ret = page_address(page); - memset(ret, 0, size); - *dma_handle = plat_map_dma_mem(dev, ret, size); - if (!(attrs & DMA_ATTR_NON_CONSISTENT) && - !plat_device_is_coherent(dev)) { - dma_cache_wback_inv((unsigned long) ret, size); - ret = UNCAC_ADDR(ret); - } - - return ret; -} - -static void mips_dma_free_coherent(struct device *dev, size_t size, void *vaddr, - dma_addr_t dma_handle, unsigned long attrs) -{ - unsigned long addr = (unsigned long) vaddr; - unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT; - struct page *page = NULL; - - plat_unmap_dma_mem(dev, dma_handle, size, DMA_BIDIRECTIONAL); - - if (!(attrs & DMA_ATTR_NON_CONSISTENT) && !plat_device_is_coherent(dev)) - addr = CAC_ADDR(addr); - - page = virt_to_page((void *) addr); - - if (!dma_release_from_contiguous(dev, page, count)) - __free_pages(page, get_order(size)); -} - -static int mips_dma_mmap(struct device *dev, struct vm_area_struct *vma, - void *cpu_addr, dma_addr_t dma_addr, size_t size, - unsigned long attrs) -{ - unsigned long user_count = vma_pages(vma); - unsigned long count = PAGE_ALIGN(size) >> PAGE_SHIFT; - unsigned long addr = (unsigned long)cpu_addr; - unsigned long off = vma->vm_pgoff; - unsigned long pfn; - int ret = -ENXIO; - - if (!plat_device_is_coherent(dev)) - addr = CAC_ADDR(addr); - - pfn = page_to_pfn(virt_to_page((void *)addr)); - - if (attrs & DMA_ATTR_WRITE_COMBINE) - vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot); - else - vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); - - if (dma_mmap_from_dev_coherent(dev, vma, cpu_addr, size, &ret)) - return ret; - - if (off < count && user_count <= (count - off)) { - ret = remap_pfn_range(vma, vma->vm_start, - pfn + off, - user_count << PAGE_SHIFT, - vma->vm_page_prot); - } - - return ret; -} - -static inline void __dma_sync_virtual(void *addr, size_t size, - enum dma_data_direction direction) -{ - switch (direction) { - case DMA_TO_DEVICE: - dma_cache_wback((unsigned long)addr, size); - break; - - case DMA_FROM_DEVICE: - dma_cache_inv((unsigned long)addr, size); - break; - - case DMA_BIDIRECTIONAL: - dma_cache_wback_inv((unsigned long)addr, size); - break; - - default: - BUG(); - } -} - -/* - * A single sg entry may refer to multiple physically contiguous - * pages. But we still need to process highmem pages individually. - * If highmem is not configured then the bulk of this loop gets - * optimized out. - */ -static inline void __dma_sync(struct page *page, - unsigned long offset, size_t size, enum dma_data_direction direction) -{ - size_t left = size; - - do { - size_t len = left; - - if (PageHighMem(page)) { - void *addr; - - if (offset + len > PAGE_SIZE) { - if (offset >= PAGE_SIZE) { - page += offset >> PAGE_SHIFT; - offset &= ~PAGE_MASK; - } - len = PAGE_SIZE - offset; - } - - addr = kmap_atomic(page); - __dma_sync_virtual(addr + offset, len, direction); - kunmap_atomic(addr); - } else - __dma_sync_virtual(page_address(page) + offset, - size, direction); - offset = 0; - page++; - left -= len; - } while (left); -} - -static void mips_dma_unmap_page(struct device *dev, dma_addr_t dma_addr, - size_t size, enum dma_data_direction direction, unsigned long attrs) -{ - if (cpu_needs_post_dma_flush(dev) && !(attrs & DMA_ATTR_SKIP_CPU_SYNC)) - __dma_sync(dma_addr_to_page(dev, dma_addr), - dma_addr & ~PAGE_MASK, size, direction); - plat_post_dma_flush(dev); - plat_unmap_dma_mem(dev, dma_addr, size, direction); -} - -static int mips_dma_map_sg(struct device *dev, struct scatterlist *sglist, - int nents, enum dma_data_direction direction, unsigned long attrs) -{ - int i; - struct scatterlist *sg; - - for_each_sg(sglist, sg, nents, i) { - if (!plat_device_is_coherent(dev) && - !(attrs & DMA_ATTR_SKIP_CPU_SYNC)) - __dma_sync(sg_page(sg), sg->offset, sg->length, - direction); -#ifdef CONFIG_NEED_SG_DMA_LENGTH - sg->dma_length = sg->length; -#endif - sg->dma_address = plat_map_dma_mem_page(dev, sg_page(sg)) + - sg->offset; - } - - return nents; -} - -static dma_addr_t mips_dma_map_page(struct device *dev, struct page *page, - unsigned long offset, size_t size, enum dma_data_direction direction, - unsigned long attrs) -{ - if (!plat_device_is_coherent(dev) && !(attrs & DMA_ATTR_SKIP_CPU_SYNC)) - __dma_sync(page, offset, size, direction); - - return plat_map_dma_mem_page(dev, page) + offset; -} - -static void mips_dma_unmap_sg(struct device *dev, struct scatterlist *sglist, - int nhwentries, enum dma_data_direction direction, - unsigned long attrs) -{ - int i; - struct scatterlist *sg; - - for_each_sg(sglist, sg, nhwentries, i) { - if (!plat_device_is_coherent(dev) && - !(attrs & DMA_ATTR_SKIP_CPU_SYNC) && - direction != DMA_TO_DEVICE) - __dma_sync(sg_page(sg), sg->offset, sg->length, - direction); - plat_unmap_dma_mem(dev, sg->dma_address, sg->length, direction); - } -} - -static void mips_dma_sync_single_for_cpu(struct device *dev, - dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) -{ - if (cpu_needs_post_dma_flush(dev)) - __dma_sync(dma_addr_to_page(dev, dma_handle), - dma_handle & ~PAGE_MASK, size, direction); - plat_post_dma_flush(dev); -} - -static void mips_dma_sync_single_for_device(struct device *dev, - dma_addr_t dma_handle, size_t size, enum dma_data_direction direction) -{ - if (!plat_device_is_coherent(dev)) - __dma_sync(dma_addr_to_page(dev, dma_handle), - dma_handle & ~PAGE_MASK, size, direction); -} - -static void mips_dma_sync_sg_for_cpu(struct device *dev, - struct scatterlist *sglist, int nelems, - enum dma_data_direction direction) -{ - int i; - struct scatterlist *sg; - - if (cpu_needs_post_dma_flush(dev)) { - for_each_sg(sglist, sg, nelems, i) { - __dma_sync(sg_page(sg), sg->offset, sg->length, - direction); - } - } - plat_post_dma_flush(dev); -} - -static void mips_dma_sync_sg_for_device(struct device *dev, - struct scatterlist *sglist, int nelems, - enum dma_data_direction direction) -{ - int i; - struct scatterlist *sg; - - if (!plat_device_is_coherent(dev)) { - for_each_sg(sglist, sg, nelems, i) { - __dma_sync(sg_page(sg), sg->offset, sg->length, - direction); - } - } -} - -static int mips_dma_supported(struct device *dev, u64 mask) -{ - return plat_dma_supported(dev, mask); -} - -static void mips_dma_cache_sync(struct device *dev, void *vaddr, size_t size, - enum dma_data_direction direction) -{ - BUG_ON(direction == DMA_NONE); - - if (!plat_device_is_coherent(dev)) - __dma_sync_virtual(vaddr, size, direction); -} - -const struct dma_map_ops mips_default_dma_map_ops = { - .alloc = mips_dma_alloc_coherent, - .free = mips_dma_free_coherent, - .mmap = mips_dma_mmap, - .map_page = mips_dma_map_page, - .unmap_page = mips_dma_unmap_page, - .map_sg = mips_dma_map_sg, - .unmap_sg = mips_dma_unmap_sg, - .sync_single_for_cpu = mips_dma_sync_single_for_cpu, - .sync_single_for_device = mips_dma_sync_single_for_device, - .sync_sg_for_cpu = mips_dma_sync_sg_for_cpu, - .sync_sg_for_device = mips_dma_sync_sg_for_device, - .dma_supported = mips_dma_supported, - .cache_sync = mips_dma_cache_sync, -}; -EXPORT_SYMBOL(mips_default_dma_map_ops); -- 2.17.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Christoph Hellwig Subject: [PATCH 24/25] MIPS: remove the old dma-default implementation Date: Fri, 25 May 2018 11:21:10 +0200 Message-ID: <20180525092111.18516-25-hch@lst.de> References: <20180525092111.18516-1-hch@lst.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180525092111.18516-1-hch-jcswGhMUV9g@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: iommu-bounces-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org Errors-To: iommu-bounces-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org To: Ralf Baechle , James Hogan Cc: linux-mips-6z/3iImG2C8G8FEW9MqTrA@public.gmane.org, Florian Fainelli , David Daney , Kevin Cernekee , Jiaxun Yang , iommu-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org, Tom Bogendoerfer , Huacai Chen List-Id: iommu@lists.linux-foundation.org Tm93IHVudXNlZC4KClNpZ25lZC1vZmYtYnk6IENocmlzdG9waCBIZWxsd2lnIDxoY2hAbHN0LmRl PgotLS0KIGFyY2gvbWlwcy9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAg NSArLQogYXJjaC9taXBzL2luY2x1ZGUvYXNtL2RtYS1tYXBwaW5nLmggICAgICAgICAgIHwgICAz IC0KIC4uLi9pbmNsdWRlL2FzbS9tYWNoLWdlbmVyaWMvZG1hLWNvaGVyZW5jZS5oICB8ICA3MyAt LS0tCiBhcmNoL21pcHMvbW0vTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEg LQogYXJjaC9taXBzL21tL2RtYS1kZWZhdWx0LmMgICAgICAgICAgICAgICAgICAgIHwgMzc5IC0t LS0tLS0tLS0tLS0tLS0tLQogNSBmaWxlcyBjaGFuZ2VkLCAxIGluc2VydGlvbigrKSwgNDYwIGRl bGV0aW9ucygtKQogZGVsZXRlIG1vZGUgMTAwNjQ0IGFyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNo LWdlbmVyaWMvZG1hLWNvaGVyZW5jZS5oCiBkZWxldGUgbW9kZSAxMDA2NDQgYXJjaC9taXBzL21t L2RtYS1kZWZhdWx0LmMKCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvS2NvbmZpZyBiL2FyY2gvbWlw cy9LY29uZmlnCmluZGV4IDlhYzNjNjI2MGI2OC4uYWQ1YTU0MmJmMDk0IDEwMDY0NAotLS0gYS9h cmNoL21pcHMvS2NvbmZpZworKysgYi9hcmNoL21pcHMvS2NvbmZpZwpAQCAtNzIsOSArNzIsNiBA QCBjb25maWcgTUlQUwogCXNlbGVjdCBTWVNDVExfRVhDRVBUSU9OX1RSQUNFCiAJc2VsZWN0IFZJ UlRfVE9fQlVTCiAKLWNvbmZpZyBNSVBTX0RNQV9ERUZBVUxUCi0JYm9vbAotCiBtZW51ICJNYWNo aW5lIHNlbGVjdGlvbiIKIAogY2hvaWNlCkBAIC0xMTEzLDcgKzExMTAsNyBAQCBjb25maWcgRE1B X05PTkNPSEVSRU5UCiAJc2VsZWN0IE5FRURfRE1BX01BUF9TVEFURQogCXNlbGVjdCBETUFfTk9O Q09IRVJFTlRfTU1BUAogCXNlbGVjdCBETUFfTk9OQ09IRVJFTlRfQ0FDSEVfU1lOQwotCXNlbGVj dCBETUFfTk9OQ09IRVJFTlRfT1BTIGlmICFNSVBTX0RNQV9ERUZBVUxUCisJc2VsZWN0IERNQV9O T05DT0hFUkVOVF9PUFMKIAogY29uZmlnIFNZU19IQVNfRUFSTFlfUFJJTlRLCiAJYm9vbApkaWZm IC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2RtYS1tYXBwaW5nLmggYi9hcmNoL21pcHMv aW5jbHVkZS9hc20vZG1hLW1hcHBpbmcuaAppbmRleCBjYWY5N2Y3Mzk4OTcuLjE0MzI1MDk4NmUx NyAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL2RtYS1tYXBwaW5nLmgKKysrIGIv YXJjaC9taXBzL2luY2x1ZGUvYXNtL2RtYS1tYXBwaW5nLmgKQEAgLTExLDcgKzExLDYgQEAKICNl bmRpZgogCiBleHRlcm4gY29uc3Qgc3RydWN0IGRtYV9tYXBfb3BzIGphenpfZG1hX29wczsKLWV4 dGVybiBjb25zdCBzdHJ1Y3QgZG1hX21hcF9vcHMgbWlwc19kZWZhdWx0X2RtYV9tYXBfb3BzOwog ZXh0ZXJuIGNvbnN0IHN0cnVjdCBkbWFfbWFwX29wcyBtaXBzX3N3aW90bGJfb3BzOwogCiBzdGF0 aWMgaW5saW5lIGNvbnN0IHN0cnVjdCBkbWFfbWFwX29wcyAqZ2V0X2FyY2hfZG1hX29wcyhzdHJ1 Y3QgYnVzX3R5cGUgKmJ1cykKQEAgLTIwLDggKzE5LDYgQEAgc3RhdGljIGlubGluZSBjb25zdCBz dHJ1Y3QgZG1hX21hcF9vcHMgKmdldF9hcmNoX2RtYV9vcHMoc3RydWN0IGJ1c190eXBlICpidXMp CiAJcmV0dXJuICZqYXp6X2RtYV9vcHM7CiAjZWxpZiBkZWZpbmVkKENPTkZJR19TV0lPVExCKQog CXJldHVybiAmbWlwc19zd2lvdGxiX29wczsKLSNlbGlmIGRlZmluZWQoQ09ORklHX01JUFNfRE1B X0RFRkFVTFQpCi0JcmV0dXJuICZtaXBzX2RlZmF1bHRfZG1hX21hcF9vcHM7CiAjZWxpZiBkZWZp bmVkKENPTkZJR19ETUFfTk9OQ09IRVJFTlRfT1BTKQogCXJldHVybiAmZG1hX25vbmNvaGVyZW50 X29wczsKICNlbHNlCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1nZW5l cmljL2RtYS1jb2hlcmVuY2UuaCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9tYWNoLWdlbmVyaWMv ZG1hLWNvaGVyZW5jZS5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4YWQ3YTQwY2E3 ODYuLjAwMDAwMDAwMDAwMAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vbWFjaC1nZW5lcmlj L2RtYS1jb2hlcmVuY2UuaAorKysgL2Rldi9udWxsCkBAIC0xLDczICswLDAgQEAKLS8qCi0gKiBU aGlzIGZpbGUgaXMgc3ViamVjdCB0byB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdO VSBHZW5lcmFsIFB1YmxpYwotICogTGljZW5zZS4gIFNlZSB0aGUgZmlsZSAiQ09QWUlORyIgaW4g dGhlIG1haW4gZGlyZWN0b3J5IG9mIHRoaXMgYXJjaGl2ZQotICogZm9yIG1vcmUgZGV0YWlscy4K LSAqCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDYgIFJhbGYgQmFlY2hsZSA8cmFsZkBsaW51eC1taXBz Lm9yZz4KLSAqCi0gKi8KLSNpZm5kZWYgX19BU01fTUFDSF9HRU5FUklDX0RNQV9DT0hFUkVOQ0Vf SAotI2RlZmluZSBfX0FTTV9NQUNIX0dFTkVSSUNfRE1BX0NPSEVSRU5DRV9ICi0KLXN0cnVjdCBk ZXZpY2U7Ci0KLXN0YXRpYyBpbmxpbmUgZG1hX2FkZHJfdCBwbGF0X21hcF9kbWFfbWVtKHN0cnVj dCBkZXZpY2UgKmRldiwgdm9pZCAqYWRkciwKLQlzaXplX3Qgc2l6ZSkKLXsKLQlyZXR1cm4gdmly dF90b19waHlzKGFkZHIpOwotfQotCi1zdGF0aWMgaW5saW5lIGRtYV9hZGRyX3QgcGxhdF9tYXBf ZG1hX21lbV9wYWdlKHN0cnVjdCBkZXZpY2UgKmRldiwKLQlzdHJ1Y3QgcGFnZSAqcGFnZSkKLXsK LQlyZXR1cm4gcGFnZV90b19waHlzKHBhZ2UpOwotfQotCi1zdGF0aWMgaW5saW5lIHVuc2lnbmVk IGxvbmcgcGxhdF9kbWFfYWRkcl90b19waHlzKHN0cnVjdCBkZXZpY2UgKmRldiwKLQlkbWFfYWRk cl90IGRtYV9hZGRyKQotewotCXJldHVybiBkbWFfYWRkcjsKLX0KLQotc3RhdGljIGlubGluZSB2 b2lkIHBsYXRfdW5tYXBfZG1hX21lbShzdHJ1Y3QgZGV2aWNlICpkZXYsIGRtYV9hZGRyX3QgZG1h X2FkZHIsCi0Jc2l6ZV90IHNpemUsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcmVjdGlvbikK LXsKLX0KLQotc3RhdGljIGlubGluZSBpbnQgcGxhdF9kbWFfc3VwcG9ydGVkKHN0cnVjdCBkZXZp Y2UgKmRldiwgdTY0IG1hc2spCi17Ci0JLyoKLQkgKiB3ZSBmYWxsIGJhY2sgdG8gR0ZQX0RNQSB3 aGVuIHRoZSBtYXNrIGlzbid0IGFsbCAxcywKLQkgKiBzbyB3ZSBjYW4ndCBndWFyYW50ZWUgYWxs b2NhdGlvbnMgdGhhdCBtdXN0IGJlCi0JICogd2l0aGluIGEgdGlnaHRlciByYW5nZSB0aGFuIEdG UF9ETUEuLgotCSAqLwotCWlmIChtYXNrIDwgRE1BX0JJVF9NQVNLKDI0KSkKLQkJcmV0dXJuIDA7 Ci0KLQlyZXR1cm4gMTsKLX0KLQotc3RhdGljIGlubGluZSBpbnQgcGxhdF9kZXZpY2VfaXNfY29o ZXJlbnQoc3RydWN0IGRldmljZSAqZGV2KQotewotI2lmZGVmIENPTkZJR19ETUFfUEVSREVWX0NP SEVSRU5UCi0JcmV0dXJuIGRldi0+YXJjaGRhdGEuZG1hX2NvaGVyZW50OwotI2Vsc2UKLQlzd2l0 Y2ggKGNvaGVyZW50aW8pIHsKLQlkZWZhdWx0OgotCWNhc2UgSU9fQ09IRVJFTkNFX0RFRkFVTFQ6 Ci0JCXJldHVybiBod19jb2hlcmVudGlvOwotCWNhc2UgSU9fQ09IRVJFTkNFX0VOQUJMRUQ6Ci0J CXJldHVybiAxOwotCWNhc2UgSU9fQ09IRVJFTkNFX0RJU0FCTEVEOgotCQlyZXR1cm4gMDsKLQl9 Ci0jZW5kaWYKLX0KLQotI2lmbmRlZiBwbGF0X3Bvc3RfZG1hX2ZsdXNoCi1zdGF0aWMgaW5saW5l IHZvaWQgcGxhdF9wb3N0X2RtYV9mbHVzaChzdHJ1Y3QgZGV2aWNlICpkZXYpCi17Ci19Ci0jZW5k aWYKLQotI2VuZGlmIC8qIF9fQVNNX01BQ0hfR0VORVJJQ19ETUFfQ09IRVJFTkNFX0ggKi8KZGlm ZiAtLWdpdCBhL2FyY2gvbWlwcy9tbS9NYWtlZmlsZSBiL2FyY2gvbWlwcy9tbS9NYWtlZmlsZQpp bmRleCBjNjE0NmMzODA1ZGMuLjY5MjJmMzkzYWYxOSAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL21t L01ha2VmaWxlCisrKyBiL2FyY2gvbWlwcy9tbS9NYWtlZmlsZQpAQCAtMTcsNyArMTcsNiBAQCBv YmotJChDT05GSUdfMzJCSVQpCQkrPSBpb3JlbWFwLm8gcGd0YWJsZS0zMi5vCiBvYmotJChDT05G SUdfNjRCSVQpCQkrPSBwZ3RhYmxlLTY0Lm8KIG9iai0kKENPTkZJR19ISUdITUVNKQkJKz0gaGln aG1lbS5vCiBvYmotJChDT05GSUdfSFVHRVRMQl9QQUdFKQkrPSBodWdldGxicGFnZS5vCi1vYmot JChDT05GSUdfTUlQU19ETUFfREVGQVVMVCkJKz0gZG1hLWRlZmF1bHQubwogb2JqLSQoQ09ORklH X0RNQV9OT05DT0hFUkVOVCkJKz0gZG1hLW5vbmNvaGVyZW50Lm8KIG9iai0kKENPTkZJR19TV0lP VExCKQkJKz0gZG1hLXN3aW90bGIubwogCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvbW0vZG1hLWRl ZmF1bHQuYyBiL2FyY2gvbWlwcy9tbS9kbWEtZGVmYXVsdC5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAxMGI1NmU4YTIwNzYuLjAwMDAwMDAwMDAwMAotLS0gYS9hcmNoL21pcHMvbW0v ZG1hLWRlZmF1bHQuYworKysgL2Rldi9udWxsCkBAIC0xLDM3OSArMCwwIEBACi0vKgotICogVGhp cyBmaWxlIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMKLSAqIExpY2Vuc2UuICBTZWUgdGhlIGZpbGUgIkNPUFlJTkciIGluIHRo ZSBtYWluIGRpcmVjdG9yeSBvZiB0aGlzIGFyY2hpdmUKLSAqIGZvciBtb3JlIGRldGFpbHMuCi0g KgotICogQ29weXJpZ2h0IChDKSAyMDAwICBBbmkgSm9zaGkgPGFqb3NoaUB1bml4Ym94LmNvbT4K LSAqIENvcHlyaWdodCAoQykgMjAwMCwgMjAwMSwgMDYJIFJhbGYgQmFlY2hsZSA8cmFsZkBsaW51 eC1taXBzLm9yZz4KLSAqIHN3aXBlZCBmcm9tIGkzODYsIGFuZCBjbG9uZWQgZm9yIE1JUFMgYnkg R2VlcnQsIHBvbGlzaGVkIGJ5IFJhbGYuCi0gKi8KLQotI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+ Ci0jaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KLSNpbmNsdWRlIDxsaW51eC9tbS5oPgot I2luY2x1ZGUgPGxpbnV4L2V4cG9ydC5oPgotI2luY2x1ZGUgPGxpbnV4L3NjYXR0ZXJsaXN0Lmg+ Ci0jaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+Ci0jaW5jbHVkZSA8bGludXgvZ2ZwLmg+Ci0jaW5j bHVkZSA8bGludXgvaGlnaG1lbS5oPgotI2luY2x1ZGUgPGxpbnV4L2RtYS1jb250aWd1b3VzLmg+ Ci0KLSNpbmNsdWRlIDxhc20vY2FjaGUuaD4KLSNpbmNsdWRlIDxhc20vY3B1LXR5cGUuaD4KLSNp bmNsdWRlIDxhc20vaW8uaD4KLQotI2luY2x1ZGUgPGRtYS1jb2hlcmVuY2UuaD4KLQotc3RhdGlj IGlubGluZSBzdHJ1Y3QgcGFnZSAqZG1hX2FkZHJfdG9fcGFnZShzdHJ1Y3QgZGV2aWNlICpkZXYs Ci0JZG1hX2FkZHJfdCBkbWFfYWRkcikKLXsKLQlyZXR1cm4gcGZuX3RvX3BhZ2UoCi0JCXBsYXRf ZG1hX2FkZHJfdG9fcGh5cyhkZXYsIGRtYV9hZGRyKSA+PiBQQUdFX1NISUZUKTsKLX0KLQotLyoK LSAqIFRoZSBhZmZlY3RlZCBDUFVzIGJlbG93IGluICdjcHVfbmVlZHNfcG9zdF9kbWFfZmx1c2go KScgY2FuCi0gKiBzcGVjdWxhdGl2ZWx5IGZpbGwgcmFuZG9tIGNhY2hlbGluZXMgd2l0aCBzdGFs ZSBkYXRhIGF0IGFueSB0aW1lLAotICogcmVxdWlyaW5nIGFuIGV4dHJhIGZsdXNoIHBvc3QtRE1B LgotICoKLSAqIFdhcm5pbmcgb24gdGhlIHRlcm1pbm9sb2d5IC0gTGludXggY2FsbHMgYW4gdW5j YWNoZWQgYXJlYSBjb2hlcmVudDsKLSAqIE1JUFMgdGVybWlub2xvZ3kgY2FsbHMgbWVtb3J5IGFy ZWFzIHdpdGggaGFyZHdhcmUgbWFpbnRhaW5lZCBjb2hlcmVuY3kKLSAqIGNvaGVyZW50LgotICoK LSAqIE5vdGUgdGhhdCB0aGUgUjE0MDAwIGFuZCBSMTYwMDAgc2hvdWxkIGFsc28gYmUgY2hlY2tl ZCBmb3IgaW4gdGhpcwotICogY29uZGl0aW9uLiAgSG93ZXZlciB0aGlzIGZ1bmN0aW9uIGlzIG9u bHkgY2FsbGVkIG9uIG5vbi1JL08tY29oZXJlbnQKLSAqIHN5c3RlbXMgYW5kIG9ubHkgdGhlIFIx MDAwMCBhbmQgUjEyMDAwIGFyZSB1c2VkIGluIHN1Y2ggc3lzdGVtcywgdGhlCi0gKiBTR0kgSVAy OCBJbmRpZ2/CsiByc3AuIFNHSSBJUDMyIGFrYSBPMi4KLSAqLwotc3RhdGljIGlubGluZSBib29s IGNwdV9uZWVkc19wb3N0X2RtYV9mbHVzaChzdHJ1Y3QgZGV2aWNlICpkZXYpCi17Ci0JaWYgKHBs YXRfZGV2aWNlX2lzX2NvaGVyZW50KGRldikpCi0JCXJldHVybiBmYWxzZTsKLQotCXN3aXRjaCAo Ym9vdF9jcHVfdHlwZSgpKSB7Ci0JY2FzZSBDUFVfUjEwMDAwOgotCWNhc2UgQ1BVX1IxMjAwMDoK LQljYXNlIENQVV9CTUlQUzUwMDA6Ci0JCXJldHVybiB0cnVlOwotCi0JZGVmYXVsdDoKLQkJLyoK LQkJICogUHJlc2VuY2Ugb2YgTUFBUnMgc3VnZ2VzdHMgdGhhdCB0aGUgQ1BVIHN1cHBvcnRzCi0J CSAqIHNwZWN1bGF0aXZlbHkgcHJlZmV0Y2hpbmcgZGF0YSwgYW5kIHRoZXJlZm9yZSByZXF1aXJl cwotCQkgKiB0aGUgcG9zdC1ETUEgZmx1c2gvaW52YWxpZGF0ZS4KLQkJICovCi0JCXJldHVybiBj cHVfaGFzX21hYXI7Ci0JfQotfQotCi1zdGF0aWMgZ2ZwX3QgbWFzc2FnZV9nZnBfZmxhZ3MoY29u c3Qgc3RydWN0IGRldmljZSAqZGV2LCBnZnBfdCBnZnApCi17Ci0JZ2ZwX3QgZG1hX2ZsYWc7Ci0K LSNpZmRlZiBDT05GSUdfSVNBCi0JaWYgKGRldiA9PSBOVUxMKQotCQlkbWFfZmxhZyA9IF9fR0ZQ X0RNQTsKLQllbHNlCi0jZW5kaWYKLSNpZiBkZWZpbmVkKENPTkZJR19aT05FX0RNQTMyKSAmJiBk ZWZpbmVkKENPTkZJR19aT05FX0RNQSkKLQkgICAgIGlmIChkZXYgPT0gTlVMTCB8fCBkZXYtPmNv aGVyZW50X2RtYV9tYXNrIDwgRE1BX0JJVF9NQVNLKDMyKSkKLQkJCWRtYV9mbGFnID0gX19HRlBf RE1BOwotCWVsc2UgaWYgKGRldi0+Y29oZXJlbnRfZG1hX21hc2sgPCBETUFfQklUX01BU0soNjQp KQotCQkJZG1hX2ZsYWcgPSBfX0dGUF9ETUEzMjsKLQllbHNlCi0jZW5kaWYKLSNpZiBkZWZpbmVk KENPTkZJR19aT05FX0RNQTMyKSAmJiAhZGVmaW5lZChDT05GSUdfWk9ORV9ETUEpCi0JICAgICBp ZiAoZGV2ID09IE5VTEwgfHwgZGV2LT5jb2hlcmVudF9kbWFfbWFzayA8IERNQV9CSVRfTUFTSyg2 NCkpCi0JCWRtYV9mbGFnID0gX19HRlBfRE1BMzI7Ci0JZWxzZQotI2VuZGlmCi0jaWYgZGVmaW5l ZChDT05GSUdfWk9ORV9ETUEpICYmICFkZWZpbmVkKENPTkZJR19aT05FX0RNQTMyKQotCSAgICAg aWYgKGRldiA9PSBOVUxMIHx8Ci0JCSBkZXYtPmNvaGVyZW50X2RtYV9tYXNrIDwgRE1BX0JJVF9N QVNLKHNpemVvZihwaHlzX2FkZHJfdCkgKiA4KSkKLQkJZG1hX2ZsYWcgPSBfX0dGUF9ETUE7Ci0J ZWxzZQotI2VuZGlmCi0JCWRtYV9mbGFnID0gMDsKLQotCS8qIERvbid0IGludm9rZSBPT00ga2ls bGVyICovCi0JZ2ZwIHw9IF9fR0ZQX05PUkVUUlk7Ci0KLQlyZXR1cm4gZ2ZwIHwgZG1hX2ZsYWc7 Ci19Ci0KLXN0YXRpYyB2b2lkICptaXBzX2RtYV9hbGxvY19jb2hlcmVudChzdHJ1Y3QgZGV2aWNl ICpkZXYsIHNpemVfdCBzaXplLAotCWRtYV9hZGRyX3QgKmRtYV9oYW5kbGUsIGdmcF90IGdmcCwg dW5zaWduZWQgbG9uZyBhdHRycykKLXsKLQl2b2lkICpyZXQ7Ci0Jc3RydWN0IHBhZ2UgKnBhZ2Ug PSBOVUxMOwotCXVuc2lnbmVkIGludCBjb3VudCA9IFBBR0VfQUxJR04oc2l6ZSkgPj4gUEFHRV9T SElGVDsKLQotCWdmcCA9IG1hc3NhZ2VfZ2ZwX2ZsYWdzKGRldiwgZ2ZwKTsKLQotCWlmIChJU19F TkFCTEVEKENPTkZJR19ETUFfQ01BKSAmJiBnZnBmbGFnc19hbGxvd19ibG9ja2luZyhnZnApKQot CQlwYWdlID0gZG1hX2FsbG9jX2Zyb21fY29udGlndW91cyhkZXYsIGNvdW50LCBnZXRfb3JkZXIo c2l6ZSksCi0JCQkJCQkgZ2ZwKTsKLQlpZiAoIXBhZ2UpCi0JCXBhZ2UgPSBhbGxvY19wYWdlcyhn ZnAsIGdldF9vcmRlcihzaXplKSk7Ci0KLQlpZiAoIXBhZ2UpCi0JCXJldHVybiBOVUxMOwotCi0J cmV0ID0gcGFnZV9hZGRyZXNzKHBhZ2UpOwotCW1lbXNldChyZXQsIDAsIHNpemUpOwotCSpkbWFf aGFuZGxlID0gcGxhdF9tYXBfZG1hX21lbShkZXYsIHJldCwgc2l6ZSk7Ci0JaWYgKCEoYXR0cnMg JiBETUFfQVRUUl9OT05fQ09OU0lTVEVOVCkgJiYKLQkgICAgIXBsYXRfZGV2aWNlX2lzX2NvaGVy ZW50KGRldikpIHsKLQkJZG1hX2NhY2hlX3diYWNrX2ludigodW5zaWduZWQgbG9uZykgcmV0LCBz aXplKTsKLQkJcmV0ID0gVU5DQUNfQUREUihyZXQpOwotCX0KLQotCXJldHVybiByZXQ7Ci19Ci0K LXN0YXRpYyB2b2lkIG1pcHNfZG1hX2ZyZWVfY29oZXJlbnQoc3RydWN0IGRldmljZSAqZGV2LCBz aXplX3Qgc2l6ZSwgdm9pZCAqdmFkZHIsCi0JZG1hX2FkZHJfdCBkbWFfaGFuZGxlLCB1bnNpZ25l ZCBsb25nIGF0dHJzKQotewotCXVuc2lnbmVkIGxvbmcgYWRkciA9ICh1bnNpZ25lZCBsb25nKSB2 YWRkcjsKLQl1bnNpZ25lZCBpbnQgY291bnQgPSBQQUdFX0FMSUdOKHNpemUpID4+IFBBR0VfU0hJ RlQ7Ci0Jc3RydWN0IHBhZ2UgKnBhZ2UgPSBOVUxMOwotCi0JcGxhdF91bm1hcF9kbWFfbWVtKGRl diwgZG1hX2hhbmRsZSwgc2l6ZSwgRE1BX0JJRElSRUNUSU9OQUwpOwotCi0JaWYgKCEoYXR0cnMg JiBETUFfQVRUUl9OT05fQ09OU0lTVEVOVCkgJiYgIXBsYXRfZGV2aWNlX2lzX2NvaGVyZW50KGRl dikpCi0JCWFkZHIgPSBDQUNfQUREUihhZGRyKTsKLQotCXBhZ2UgPSB2aXJ0X3RvX3BhZ2UoKHZv aWQgKikgYWRkcik7Ci0KLQlpZiAoIWRtYV9yZWxlYXNlX2Zyb21fY29udGlndW91cyhkZXYsIHBh Z2UsIGNvdW50KSkKLQkJX19mcmVlX3BhZ2VzKHBhZ2UsIGdldF9vcmRlcihzaXplKSk7Ci19Ci0K LXN0YXRpYyBpbnQgbWlwc19kbWFfbW1hcChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCB2bV9h cmVhX3N0cnVjdCAqdm1hLAotCXZvaWQgKmNwdV9hZGRyLCBkbWFfYWRkcl90IGRtYV9hZGRyLCBz aXplX3Qgc2l6ZSwKLQl1bnNpZ25lZCBsb25nIGF0dHJzKQotewotCXVuc2lnbmVkIGxvbmcgdXNl cl9jb3VudCA9IHZtYV9wYWdlcyh2bWEpOwotCXVuc2lnbmVkIGxvbmcgY291bnQgPSBQQUdFX0FM SUdOKHNpemUpID4+IFBBR0VfU0hJRlQ7Ci0JdW5zaWduZWQgbG9uZyBhZGRyID0gKHVuc2lnbmVk IGxvbmcpY3B1X2FkZHI7Ci0JdW5zaWduZWQgbG9uZyBvZmYgPSB2bWEtPnZtX3Bnb2ZmOwotCXVu c2lnbmVkIGxvbmcgcGZuOwotCWludCByZXQgPSAtRU5YSU87Ci0KLQlpZiAoIXBsYXRfZGV2aWNl X2lzX2NvaGVyZW50KGRldikpCi0JCWFkZHIgPSBDQUNfQUREUihhZGRyKTsKLQotCXBmbiA9IHBh Z2VfdG9fcGZuKHZpcnRfdG9fcGFnZSgodm9pZCAqKWFkZHIpKTsKLQotCWlmIChhdHRycyAmIERN QV9BVFRSX1dSSVRFX0NPTUJJTkUpCi0JCXZtYS0+dm1fcGFnZV9wcm90ID0gcGdwcm90X3dyaXRl Y29tYmluZSh2bWEtPnZtX3BhZ2VfcHJvdCk7Ci0JZWxzZQotCQl2bWEtPnZtX3BhZ2VfcHJvdCA9 IHBncHJvdF9ub25jYWNoZWQodm1hLT52bV9wYWdlX3Byb3QpOwotCi0JaWYgKGRtYV9tbWFwX2Zy b21fZGV2X2NvaGVyZW50KGRldiwgdm1hLCBjcHVfYWRkciwgc2l6ZSwgJnJldCkpCi0JCXJldHVy biByZXQ7Ci0KLQlpZiAob2ZmIDwgY291bnQgJiYgdXNlcl9jb3VudCA8PSAoY291bnQgLSBvZmYp KSB7Ci0JCXJldCA9IHJlbWFwX3Bmbl9yYW5nZSh2bWEsIHZtYS0+dm1fc3RhcnQsCi0JCQkJICAg ICAgcGZuICsgb2ZmLAotCQkJCSAgICAgIHVzZXJfY291bnQgPDwgUEFHRV9TSElGVCwKLQkJCQkg ICAgICB2bWEtPnZtX3BhZ2VfcHJvdCk7Ci0JfQotCi0JcmV0dXJuIHJldDsKLX0KLQotc3RhdGlj IGlubGluZSB2b2lkIF9fZG1hX3N5bmNfdmlydHVhbCh2b2lkICphZGRyLCBzaXplX3Qgc2l6ZSwK LQllbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXJlY3Rpb24pCi17Ci0Jc3dpdGNoIChkaXJlY3Rp b24pIHsKLQljYXNlIERNQV9UT19ERVZJQ0U6Ci0JCWRtYV9jYWNoZV93YmFjaygodW5zaWduZWQg bG9uZylhZGRyLCBzaXplKTsKLQkJYnJlYWs7Ci0KLQljYXNlIERNQV9GUk9NX0RFVklDRToKLQkJ ZG1hX2NhY2hlX2ludigodW5zaWduZWQgbG9uZylhZGRyLCBzaXplKTsKLQkJYnJlYWs7Ci0KLQlj YXNlIERNQV9CSURJUkVDVElPTkFMOgotCQlkbWFfY2FjaGVfd2JhY2tfaW52KCh1bnNpZ25lZCBs b25nKWFkZHIsIHNpemUpOwotCQlicmVhazsKLQotCWRlZmF1bHQ6Ci0JCUJVRygpOwotCX0KLX0K LQotLyoKLSAqIEEgc2luZ2xlIHNnIGVudHJ5IG1heSByZWZlciB0byBtdWx0aXBsZSBwaHlzaWNh bGx5IGNvbnRpZ3VvdXMKLSAqIHBhZ2VzLiBCdXQgd2Ugc3RpbGwgbmVlZCB0byBwcm9jZXNzIGhp Z2htZW0gcGFnZXMgaW5kaXZpZHVhbGx5LgotICogSWYgaGlnaG1lbSBpcyBub3QgY29uZmlndXJl ZCB0aGVuIHRoZSBidWxrIG9mIHRoaXMgbG9vcCBnZXRzCi0gKiBvcHRpbWl6ZWQgb3V0LgotICov Ci1zdGF0aWMgaW5saW5lIHZvaWQgX19kbWFfc3luYyhzdHJ1Y3QgcGFnZSAqcGFnZSwKLQl1bnNp Z25lZCBsb25nIG9mZnNldCwgc2l6ZV90IHNpemUsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRp cmVjdGlvbikKLXsKLQlzaXplX3QgbGVmdCA9IHNpemU7Ci0KLQlkbyB7Ci0JCXNpemVfdCBsZW4g PSBsZWZ0OwotCi0JCWlmIChQYWdlSGlnaE1lbShwYWdlKSkgewotCQkJdm9pZCAqYWRkcjsKLQot CQkJaWYgKG9mZnNldCArIGxlbiA+IFBBR0VfU0laRSkgewotCQkJCWlmIChvZmZzZXQgPj0gUEFH RV9TSVpFKSB7Ci0JCQkJCXBhZ2UgKz0gb2Zmc2V0ID4+IFBBR0VfU0hJRlQ7Ci0JCQkJCW9mZnNl dCAmPSB+UEFHRV9NQVNLOwotCQkJCX0KLQkJCQlsZW4gPSBQQUdFX1NJWkUgLSBvZmZzZXQ7Ci0J CQl9Ci0KLQkJCWFkZHIgPSBrbWFwX2F0b21pYyhwYWdlKTsKLQkJCV9fZG1hX3N5bmNfdmlydHVh bChhZGRyICsgb2Zmc2V0LCBsZW4sIGRpcmVjdGlvbik7Ci0JCQlrdW5tYXBfYXRvbWljKGFkZHIp OwotCQl9IGVsc2UKLQkJCV9fZG1hX3N5bmNfdmlydHVhbChwYWdlX2FkZHJlc3MocGFnZSkgKyBv ZmZzZXQsCi0JCQkJCSAgIHNpemUsIGRpcmVjdGlvbik7Ci0JCW9mZnNldCA9IDA7Ci0JCXBhZ2Ur KzsKLQkJbGVmdCAtPSBsZW47Ci0JfSB3aGlsZSAobGVmdCk7Ci19Ci0KLXN0YXRpYyB2b2lkIG1p cHNfZG1hX3VubWFwX3BhZ2Uoc3RydWN0IGRldmljZSAqZGV2LCBkbWFfYWRkcl90IGRtYV9hZGRy LAotCXNpemVfdCBzaXplLCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXJlY3Rpb24sIHVuc2ln bmVkIGxvbmcgYXR0cnMpCi17Ci0JaWYgKGNwdV9uZWVkc19wb3N0X2RtYV9mbHVzaChkZXYpICYm ICEoYXR0cnMgJiBETUFfQVRUUl9TS0lQX0NQVV9TWU5DKSkKLQkJX19kbWFfc3luYyhkbWFfYWRk cl90b19wYWdlKGRldiwgZG1hX2FkZHIpLAotCQkJICAgZG1hX2FkZHIgJiB+UEFHRV9NQVNLLCBz aXplLCBkaXJlY3Rpb24pOwotCXBsYXRfcG9zdF9kbWFfZmx1c2goZGV2KTsKLQlwbGF0X3VubWFw X2RtYV9tZW0oZGV2LCBkbWFfYWRkciwgc2l6ZSwgZGlyZWN0aW9uKTsKLX0KLQotc3RhdGljIGlu dCBtaXBzX2RtYV9tYXBfc2coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qgc2NhdHRlcmxpc3Qg KnNnbGlzdCwKLQlpbnQgbmVudHMsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcmVjdGlvbiwg dW5zaWduZWQgbG9uZyBhdHRycykKLXsKLQlpbnQgaTsKLQlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNn OwotCi0JZm9yX2VhY2hfc2coc2dsaXN0LCBzZywgbmVudHMsIGkpIHsKLQkJaWYgKCFwbGF0X2Rl dmljZV9pc19jb2hlcmVudChkZXYpICYmCi0JCSAgICAhKGF0dHJzICYgRE1BX0FUVFJfU0tJUF9D UFVfU1lOQykpCi0JCQlfX2RtYV9zeW5jKHNnX3BhZ2Uoc2cpLCBzZy0+b2Zmc2V0LCBzZy0+bGVu Z3RoLAotCQkJCSAgIGRpcmVjdGlvbik7Ci0jaWZkZWYgQ09ORklHX05FRURfU0dfRE1BX0xFTkdU SAotCQlzZy0+ZG1hX2xlbmd0aCA9IHNnLT5sZW5ndGg7Ci0jZW5kaWYKLQkJc2ctPmRtYV9hZGRy ZXNzID0gcGxhdF9tYXBfZG1hX21lbV9wYWdlKGRldiwgc2dfcGFnZShzZykpICsKLQkJCQkgIHNn LT5vZmZzZXQ7Ci0JfQotCi0JcmV0dXJuIG5lbnRzOwotfQotCi1zdGF0aWMgZG1hX2FkZHJfdCBt aXBzX2RtYV9tYXBfcGFnZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBwYWdlICpwYWdlLAot CXVuc2lnbmVkIGxvbmcgb2Zmc2V0LCBzaXplX3Qgc2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rp b24gZGlyZWN0aW9uLAotCXVuc2lnbmVkIGxvbmcgYXR0cnMpCi17Ci0JaWYgKCFwbGF0X2Rldmlj ZV9pc19jb2hlcmVudChkZXYpICYmICEoYXR0cnMgJiBETUFfQVRUUl9TS0lQX0NQVV9TWU5DKSkK LQkJX19kbWFfc3luYyhwYWdlLCBvZmZzZXQsIHNpemUsIGRpcmVjdGlvbik7Ci0KLQlyZXR1cm4g cGxhdF9tYXBfZG1hX21lbV9wYWdlKGRldiwgcGFnZSkgKyBvZmZzZXQ7Ci19Ci0KLXN0YXRpYyB2 b2lkIG1pcHNfZG1hX3VubWFwX3NnKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHNjYXR0ZXJs aXN0ICpzZ2xpc3QsCi0JaW50IG5od2VudHJpZXMsIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRp cmVjdGlvbiwKLQl1bnNpZ25lZCBsb25nIGF0dHJzKQotewotCWludCBpOwotCXN0cnVjdCBzY2F0 dGVybGlzdCAqc2c7Ci0KLQlmb3JfZWFjaF9zZyhzZ2xpc3QsIHNnLCBuaHdlbnRyaWVzLCBpKSB7 Ci0JCWlmICghcGxhdF9kZXZpY2VfaXNfY29oZXJlbnQoZGV2KSAmJgotCQkgICAgIShhdHRycyAm IERNQV9BVFRSX1NLSVBfQ1BVX1NZTkMpICYmCi0JCSAgICBkaXJlY3Rpb24gIT0gRE1BX1RPX0RF VklDRSkKLQkJCV9fZG1hX3N5bmMoc2dfcGFnZShzZyksIHNnLT5vZmZzZXQsIHNnLT5sZW5ndGgs Ci0JCQkJICAgZGlyZWN0aW9uKTsKLQkJcGxhdF91bm1hcF9kbWFfbWVtKGRldiwgc2ctPmRtYV9h ZGRyZXNzLCBzZy0+bGVuZ3RoLCBkaXJlY3Rpb24pOwotCX0KLX0KLQotc3RhdGljIHZvaWQgbWlw c19kbWFfc3luY19zaW5nbGVfZm9yX2NwdShzdHJ1Y3QgZGV2aWNlICpkZXYsCi0JZG1hX2FkZHJf dCBkbWFfaGFuZGxlLCBzaXplX3Qgc2l6ZSwgZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyZWN0 aW9uKQotewotCWlmIChjcHVfbmVlZHNfcG9zdF9kbWFfZmx1c2goZGV2KSkKLQkJX19kbWFfc3lu YyhkbWFfYWRkcl90b19wYWdlKGRldiwgZG1hX2hhbmRsZSksCi0JCQkgICBkbWFfaGFuZGxlICYg flBBR0VfTUFTSywgc2l6ZSwgZGlyZWN0aW9uKTsKLQlwbGF0X3Bvc3RfZG1hX2ZsdXNoKGRldik7 Ci19Ci0KLXN0YXRpYyB2b2lkIG1pcHNfZG1hX3N5bmNfc2luZ2xlX2Zvcl9kZXZpY2Uoc3RydWN0 IGRldmljZSAqZGV2LAotCWRtYV9hZGRyX3QgZG1hX2hhbmRsZSwgc2l6ZV90IHNpemUsIGVudW0g ZG1hX2RhdGFfZGlyZWN0aW9uIGRpcmVjdGlvbikKLXsKLQlpZiAoIXBsYXRfZGV2aWNlX2lzX2Nv aGVyZW50KGRldikpCi0JCV9fZG1hX3N5bmMoZG1hX2FkZHJfdG9fcGFnZShkZXYsIGRtYV9oYW5k bGUpLAotCQkJICAgZG1hX2hhbmRsZSAmIH5QQUdFX01BU0ssIHNpemUsIGRpcmVjdGlvbik7Ci19 Ci0KLXN0YXRpYyB2b2lkIG1pcHNfZG1hX3N5bmNfc2dfZm9yX2NwdShzdHJ1Y3QgZGV2aWNlICpk ZXYsCi0Jc3RydWN0IHNjYXR0ZXJsaXN0ICpzZ2xpc3QsIGludCBuZWxlbXMsCi0JZW51bSBkbWFf ZGF0YV9kaXJlY3Rpb24gZGlyZWN0aW9uKQotewotCWludCBpOwotCXN0cnVjdCBzY2F0dGVybGlz dCAqc2c7Ci0KLQlpZiAoY3B1X25lZWRzX3Bvc3RfZG1hX2ZsdXNoKGRldikpIHsKLQkJZm9yX2Vh Y2hfc2coc2dsaXN0LCBzZywgbmVsZW1zLCBpKSB7Ci0JCQlfX2RtYV9zeW5jKHNnX3BhZ2Uoc2cp LCBzZy0+b2Zmc2V0LCBzZy0+bGVuZ3RoLAotCQkJCSAgIGRpcmVjdGlvbik7Ci0JCX0KLQl9Ci0J cGxhdF9wb3N0X2RtYV9mbHVzaChkZXYpOwotfQotCi1zdGF0aWMgdm9pZCBtaXBzX2RtYV9zeW5j X3NnX2Zvcl9kZXZpY2Uoc3RydWN0IGRldmljZSAqZGV2LAotCXN0cnVjdCBzY2F0dGVybGlzdCAq c2dsaXN0LCBpbnQgbmVsZW1zLAotCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcmVjdGlvbikK LXsKLQlpbnQgaTsKLQlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnOwotCi0JaWYgKCFwbGF0X2Rldmlj ZV9pc19jb2hlcmVudChkZXYpKSB7Ci0JCWZvcl9lYWNoX3NnKHNnbGlzdCwgc2csIG5lbGVtcywg aSkgewotCQkJX19kbWFfc3luYyhzZ19wYWdlKHNnKSwgc2ctPm9mZnNldCwgc2ctPmxlbmd0aCwK LQkJCQkgICBkaXJlY3Rpb24pOwotCQl9Ci0JfQotfQotCi1zdGF0aWMgaW50IG1pcHNfZG1hX3N1 cHBvcnRlZChzdHJ1Y3QgZGV2aWNlICpkZXYsIHU2NCBtYXNrKQotewotCXJldHVybiBwbGF0X2Rt YV9zdXBwb3J0ZWQoZGV2LCBtYXNrKTsKLX0KLQotc3RhdGljIHZvaWQgbWlwc19kbWFfY2FjaGVf c3luYyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHZvaWQgKnZhZGRyLCBzaXplX3Qgc2l6ZSwKLQkJCSBl bnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkaXJlY3Rpb24pCi17Ci0JQlVHX09OKGRpcmVjdGlvbiA9 PSBETUFfTk9ORSk7Ci0KLQlpZiAoIXBsYXRfZGV2aWNlX2lzX2NvaGVyZW50KGRldikpCi0JCV9f ZG1hX3N5bmNfdmlydHVhbCh2YWRkciwgc2l6ZSwgZGlyZWN0aW9uKTsKLX0KLQotY29uc3Qgc3Ry dWN0IGRtYV9tYXBfb3BzIG1pcHNfZGVmYXVsdF9kbWFfbWFwX29wcyA9IHsKLQkuYWxsb2MgPSBt aXBzX2RtYV9hbGxvY19jb2hlcmVudCwKLQkuZnJlZSA9IG1pcHNfZG1hX2ZyZWVfY29oZXJlbnQs Ci0JLm1tYXAgPSBtaXBzX2RtYV9tbWFwLAotCS5tYXBfcGFnZSA9IG1pcHNfZG1hX21hcF9wYWdl LAotCS51bm1hcF9wYWdlID0gbWlwc19kbWFfdW5tYXBfcGFnZSwKLQkubWFwX3NnID0gbWlwc19k bWFfbWFwX3NnLAotCS51bm1hcF9zZyA9IG1pcHNfZG1hX3VubWFwX3NnLAotCS5zeW5jX3Npbmds ZV9mb3JfY3B1ID0gbWlwc19kbWFfc3luY19zaW5nbGVfZm9yX2NwdSwKLQkuc3luY19zaW5nbGVf Zm9yX2RldmljZSA9IG1pcHNfZG1hX3N5bmNfc2luZ2xlX2Zvcl9kZXZpY2UsCi0JLnN5bmNfc2df Zm9yX2NwdSA9IG1pcHNfZG1hX3N5bmNfc2dfZm9yX2NwdSwKLQkuc3luY19zZ19mb3JfZGV2aWNl ID0gbWlwc19kbWFfc3luY19zZ19mb3JfZGV2aWNlLAotCS5kbWFfc3VwcG9ydGVkID0gbWlwc19k bWFfc3VwcG9ydGVkLAotCS5jYWNoZV9zeW5jID0gbWlwc19kbWFfY2FjaGVfc3luYywKLX07Ci1F WFBPUlRfU1lNQk9MKG1pcHNfZGVmYXVsdF9kbWFfbWFwX29wcyk7Ci0tIAoyLjE3LjAKCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmlvbW11IG1haWxpbmcg bGlzdAppb21tdUBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4 Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby9pb21tdQ==