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 mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4C1DFC433FE for ; Mon, 11 Oct 2021 03:01:03 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1FD7D6054F for ; Mon, 11 Oct 2021 03:01:03 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233646AbhJKDCz (ORCPT ); Sun, 10 Oct 2021 23:02:55 -0400 Received: from us-smtp-delivery-124.mimecast.com ([170.10.133.124]:35844 "EHLO us-smtp-delivery-124.mimecast.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230273AbhJKDCx (ORCPT ); Sun, 10 Oct 2021 23:02:53 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1633921253; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=c6AyUo0P4jqww7yBj4YHm5SI0ziK+vWCaJKXgZN+3Gc=; b=bHf2kiXjEdpfUKdu3UG5k2rHq8vQsSz8gbnAwMtvniXqEtzZf05X0bE5hfT9BRJ5THN5TK pp/gEhPuAMTe3RoSAb89hxeJht+i9ppeKK1YVIti/bNGl4din2UzCrBO2P17FCqpK1hPz+ umxyhR2x+rQwoyhe3RjcqohctMMmbiE= Received: from mail-pf1-f200.google.com (mail-pf1-f200.google.com [209.85.210.200]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-208-C4pHIf1AMGavPSOT-GFrSA-1; Sun, 10 Oct 2021 23:00:51 -0400 X-MC-Unique: C4pHIf1AMGavPSOT-GFrSA-1 Received: by mail-pf1-f200.google.com with SMTP id 2-20020aa79102000000b0044c216dd8ecso6640728pfh.18 for ; Sun, 10 Oct 2021 20:00:51 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=c6AyUo0P4jqww7yBj4YHm5SI0ziK+vWCaJKXgZN+3Gc=; b=rCfA+FqYvfyXeYOZ4S6wt+xnsC4G834Kug1vWSqssSTXlRqD1t9nE/QdSn8KPRddTp RSgX0E5hHlLkp9ExE5suE+KuXGaLxQJpYC4t7CWodKwOHpJI+8UgB4waB447GK7hfT+F 95g8s2t2sbSxxz/SUjJLw29ceGP6XOD7L6a6IPaKJMo12x6L5a0uNXenaHOWzZKQY3gY CmH/vvsZvAMcVUvT2crFN2VlXDCfkLbzGQJf0Y+Krj4mjPTBTadOCgnbtK4Zo8mYT8kz RHoh+CsaN8mqcVdfMYx+CHBz053IcZpiIY0KTLG+WOBkDZel9TWt4yIGP+b7RpAqLjhE tLMw== X-Gm-Message-State: AOAM532fs1oXoAob91UoKx5s2AQBkCpR1K5u7djbIk6EdZmwx8TNhTFx BDIQinqjscw1+YgoVgLL/UnBvM98MefxSVAO8jUsmojYaJ2xBZ6j3wx9ADvXoacwlXSkRKgtBqu SA40twjAULyjcpwTNUypWB9Ui X-Received: by 2002:a63:200a:: with SMTP id g10mr15940557pgg.242.1633921250249; Sun, 10 Oct 2021 20:00:50 -0700 (PDT) X-Google-Smtp-Source: ABdhPJy+v5J5UcW5S22Imp2npH1Lehnlm7PtWm446qlfdPovNchz+me5hq/SmmI1GWSZ2xB3kCGgLA== X-Received: by 2002:a63:200a:: with SMTP id g10mr15940516pgg.242.1633921249713; Sun, 10 Oct 2021 20:00:49 -0700 (PDT) Received: from wangxiaodeMacBook-Air.local ([209.132.188.80]) by smtp.gmail.com with ESMTPSA id z9sm5499043pji.42.2021.10.10.20.00.47 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Sun, 10 Oct 2021 20:00:49 -0700 (PDT) Subject: Re: [PATCH v4 1/7] virtio-pci: introduce legacy device module To: Wu Zongyong , virtualization@lists.linux-foundation.org, linux-kernel@vger.kernel.org, mst@redhat.com Cc: wei.yang1@linux.alibaba.com References: From: Jason Wang Message-ID: <897fb1b2-abf1-0ad5-a7de-7b214c3484d5@redhat.com> Date: Mon, 11 Oct 2021 11:00:45 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.14.0 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=gbk; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org ÔÚ 2021/9/29 ÏÂÎç2:11, Wu Zongyong дµÀ: > Split common codes from virtio-pci-legacy so vDPA driver can reuse it > later. > > Signed-off-by: Wu Zongyong Acked-by: Jason Wang > --- > drivers/virtio/Kconfig | 10 ++ > drivers/virtio/Makefile | 1 + > drivers/virtio/virtio_pci_common.c | 10 +- > drivers/virtio/virtio_pci_common.h | 9 +- > drivers/virtio/virtio_pci_legacy.c | 101 +++--------- > drivers/virtio/virtio_pci_legacy_dev.c | 220 +++++++++++++++++++++++++ > include/linux/virtio_pci_legacy.h | 44 +++++ > 7 files changed, 312 insertions(+), 83 deletions(-) > create mode 100644 drivers/virtio/virtio_pci_legacy_dev.c > create mode 100644 include/linux/virtio_pci_legacy.h > > diff --git a/drivers/virtio/Kconfig b/drivers/virtio/Kconfig > index ce1b3f6ec325..8fcf94cd2c96 100644 > --- a/drivers/virtio/Kconfig > +++ b/drivers/virtio/Kconfig > @@ -20,6 +20,15 @@ config VIRTIO_PCI_LIB > PCI device with possible vendor specific extensions. Any > module that selects this module must depend on PCI. > > +config VIRTIO_PCI_LIB_LEGACY > + tristate > + help > + Legacy PCI device (Virtio PCI Card 0.9.x Draft and older device) > + implementation. > + This module implements the basic probe and control for devices > + which are based on legacy PCI device. Any module that selects this > + module must depend on PCI. > + > menuconfig VIRTIO_MENU > bool "Virtio drivers" > default y > @@ -43,6 +52,7 @@ config VIRTIO_PCI_LEGACY > bool "Support for legacy virtio draft 0.9.X and older devices" > default y > depends on VIRTIO_PCI > + select VIRTIO_PCI_LIB_LEGACY > help > Virtio PCI Card 0.9.X Draft (circa 2014) and older device support. > > diff --git a/drivers/virtio/Makefile b/drivers/virtio/Makefile > index 699bbea0465f..0a82d0873248 100644 > --- a/drivers/virtio/Makefile > +++ b/drivers/virtio/Makefile > @@ -1,6 +1,7 @@ > # SPDX-License-Identifier: GPL-2.0 > obj-$(CONFIG_VIRTIO) += virtio.o virtio_ring.o > obj-$(CONFIG_VIRTIO_PCI_LIB) += virtio_pci_modern_dev.o > +obj-$(CONFIG_VIRTIO_PCI_LIB_LEGACY) += virtio_pci_legacy_dev.o > obj-$(CONFIG_VIRTIO_MMIO) += virtio_mmio.o > obj-$(CONFIG_VIRTIO_PCI) += virtio_pci.o > virtio_pci-y := virtio_pci_modern.o virtio_pci_common.o > diff --git a/drivers/virtio/virtio_pci_common.c b/drivers/virtio/virtio_pci_common.c > index b35bb2d57f62..d724f676608b 100644 > --- a/drivers/virtio/virtio_pci_common.c > +++ b/drivers/virtio/virtio_pci_common.c > @@ -549,6 +549,8 @@ static int virtio_pci_probe(struct pci_dev *pci_dev, > > pci_set_master(pci_dev); > > + vp_dev->is_legacy = vp_dev->ldev.ioaddr ? true : false; > + > rc = register_virtio_device(&vp_dev->vdev); > reg_dev = vp_dev; > if (rc) > @@ -557,10 +559,10 @@ static int virtio_pci_probe(struct pci_dev *pci_dev, > return 0; > > err_register: > - if (vp_dev->ioaddr) > - virtio_pci_legacy_remove(vp_dev); > + if (vp_dev->is_legacy) > + virtio_pci_legacy_remove(vp_dev); > else > - virtio_pci_modern_remove(vp_dev); > + virtio_pci_modern_remove(vp_dev); > err_probe: > pci_disable_device(pci_dev); > err_enable_device: > @@ -587,7 +589,7 @@ static void virtio_pci_remove(struct pci_dev *pci_dev) > > unregister_virtio_device(&vp_dev->vdev); > > - if (vp_dev->ioaddr) > + if (vp_dev->is_legacy) > virtio_pci_legacy_remove(vp_dev); > else > virtio_pci_modern_remove(vp_dev); > diff --git a/drivers/virtio/virtio_pci_common.h b/drivers/virtio/virtio_pci_common.h > index beec047a8f8d..eb17a29fc7ef 100644 > --- a/drivers/virtio/virtio_pci_common.h > +++ b/drivers/virtio/virtio_pci_common.h > @@ -25,6 +25,7 @@ > #include > #include > #include > +#include > #include > #include > #include > @@ -44,16 +45,14 @@ struct virtio_pci_vq_info { > struct virtio_pci_device { > struct virtio_device vdev; > struct pci_dev *pci_dev; > + struct virtio_pci_legacy_device ldev; > struct virtio_pci_modern_device mdev; > > - /* In legacy mode, these two point to within ->legacy. */ > + bool is_legacy; > + > /* Where to read and clear interrupt */ > u8 __iomem *isr; > > - /* Legacy only field */ > - /* the IO mapping for the PCI config space */ > - void __iomem *ioaddr; > - > /* a list of queues so we can dispatch IRQs */ > spinlock_t lock; > struct list_head virtqueues; > diff --git a/drivers/virtio/virtio_pci_legacy.c b/drivers/virtio/virtio_pci_legacy.c > index d62e9835aeec..82eb437ad920 100644 > --- a/drivers/virtio/virtio_pci_legacy.c > +++ b/drivers/virtio/virtio_pci_legacy.c > @@ -14,6 +14,7 @@ > * Michael S. Tsirkin > */ > > +#include "linux/virtio_pci_legacy.h" > #include "virtio_pci_common.h" > > /* virtio config->get_features() implementation */ > @@ -23,7 +24,7 @@ static u64 vp_get_features(struct virtio_device *vdev) > > /* When someone needs more than 32 feature bits, we'll need to > * steal a bit to indicate that the rest are somewhere else. */ > - return ioread32(vp_dev->ioaddr + VIRTIO_PCI_HOST_FEATURES); > + return vp_legacy_get_features(&vp_dev->ldev); > } > > /* virtio config->finalize_features() implementation */ > @@ -38,7 +39,7 @@ static int vp_finalize_features(struct virtio_device *vdev) > BUG_ON((u32)vdev->features != vdev->features); > > /* We only support 32 feature bits. */ > - iowrite32(vdev->features, vp_dev->ioaddr + VIRTIO_PCI_GUEST_FEATURES); > + vp_legacy_set_features(&vp_dev->ldev, vdev->features); > > return 0; > } > @@ -48,7 +49,7 @@ static void vp_get(struct virtio_device *vdev, unsigned offset, > void *buf, unsigned len) > { > struct virtio_pci_device *vp_dev = to_vp_device(vdev); > - void __iomem *ioaddr = vp_dev->ioaddr + > + void __iomem *ioaddr = vp_dev->ldev.ioaddr + > VIRTIO_PCI_CONFIG_OFF(vp_dev->msix_enabled) + > offset; > u8 *ptr = buf; > @@ -64,7 +65,7 @@ static void vp_set(struct virtio_device *vdev, unsigned offset, > const void *buf, unsigned len) > { > struct virtio_pci_device *vp_dev = to_vp_device(vdev); > - void __iomem *ioaddr = vp_dev->ioaddr + > + void __iomem *ioaddr = vp_dev->ldev.ioaddr + > VIRTIO_PCI_CONFIG_OFF(vp_dev->msix_enabled) + > offset; > const u8 *ptr = buf; > @@ -78,7 +79,7 @@ static void vp_set(struct virtio_device *vdev, unsigned offset, > static u8 vp_get_status(struct virtio_device *vdev) > { > struct virtio_pci_device *vp_dev = to_vp_device(vdev); > - return ioread8(vp_dev->ioaddr + VIRTIO_PCI_STATUS); > + return vp_legacy_get_status(&vp_dev->ldev); > } > > static void vp_set_status(struct virtio_device *vdev, u8 status) > @@ -86,28 +87,24 @@ static void vp_set_status(struct virtio_device *vdev, u8 status) > struct virtio_pci_device *vp_dev = to_vp_device(vdev); > /* We should never be setting status to 0. */ > BUG_ON(status == 0); > - iowrite8(status, vp_dev->ioaddr + VIRTIO_PCI_STATUS); > + vp_legacy_set_status(&vp_dev->ldev, status); > } > > static void vp_reset(struct virtio_device *vdev) > { > struct virtio_pci_device *vp_dev = to_vp_device(vdev); > /* 0 status means a reset. */ > - iowrite8(0, vp_dev->ioaddr + VIRTIO_PCI_STATUS); > + vp_legacy_set_status(&vp_dev->ldev, 0); > /* Flush out the status write, and flush in device writes, > * including MSi-X interrupts, if any. */ > - ioread8(vp_dev->ioaddr + VIRTIO_PCI_STATUS); > + vp_legacy_get_status(&vp_dev->ldev); > /* Flush pending VQ/configuration callbacks. */ > vp_synchronize_vectors(vdev); > } > > static u16 vp_config_vector(struct virtio_pci_device *vp_dev, u16 vector) > { > - /* Setup the vector used for configuration events */ > - iowrite16(vector, vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR); > - /* Verify we had enough resources to assign the vector */ > - /* Will also flush the write out to device */ > - return ioread16(vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR); > + return vp_legacy_config_vector(&vp_dev->ldev, vector); > } > > static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev, > @@ -123,12 +120,9 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev, > int err; > u64 q_pfn; > > - /* Select the queue we're interested in */ > - iowrite16(index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL); > - > /* Check if queue is either not available or already active. */ > - num = ioread16(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NUM); > - if (!num || ioread32(vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN)) > + num = vp_legacy_get_queue_size(&vp_dev->ldev, index); > + if (!num || vp_legacy_get_queue_enable(&vp_dev->ldev, index)) > return ERR_PTR(-ENOENT); > > info->msix_vector = msix_vec; > @@ -151,13 +145,12 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev, > } > > /* activate the queue */ > - iowrite32(q_pfn, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN); > + vp_legacy_set_queue_address(&vp_dev->ldev, index, q_pfn); > > - vq->priv = (void __force *)vp_dev->ioaddr + VIRTIO_PCI_QUEUE_NOTIFY; > + vq->priv = (void __force *)vp_dev->ldev.ioaddr + VIRTIO_PCI_QUEUE_NOTIFY; > > if (msix_vec != VIRTIO_MSI_NO_VECTOR) { > - iowrite16(msix_vec, vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR); > - msix_vec = ioread16(vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR); > + msix_vec = vp_legacy_queue_vector(&vp_dev->ldev, index, msix_vec); > if (msix_vec == VIRTIO_MSI_NO_VECTOR) { > err = -EBUSY; > goto out_deactivate; > @@ -167,7 +160,7 @@ static struct virtqueue *setup_vq(struct virtio_pci_device *vp_dev, > return vq; > > out_deactivate: > - iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN); > + vp_legacy_set_queue_address(&vp_dev->ldev, index, 0); > out_del_vq: > vring_del_virtqueue(vq); > return ERR_PTR(err); > @@ -178,17 +171,15 @@ static void del_vq(struct virtio_pci_vq_info *info) > struct virtqueue *vq = info->vq; > struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev); > > - iowrite16(vq->index, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_SEL); > - > if (vp_dev->msix_enabled) { > - iowrite16(VIRTIO_MSI_NO_VECTOR, > - vp_dev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR); > + vp_legacy_queue_vector(&vp_dev->ldev, vq->index, > + VIRTIO_MSI_NO_VECTOR); > /* Flush the write out to device */ > - ioread8(vp_dev->ioaddr + VIRTIO_PCI_ISR); > + ioread8(vp_dev->ldev.ioaddr + VIRTIO_PCI_ISR); > } > > /* Select and deactivate the queue */ > - iowrite32(0, vp_dev->ioaddr + VIRTIO_PCI_QUEUE_PFN); > + vp_legacy_set_queue_address(&vp_dev->ldev, vq->index, 0); > > vring_del_virtqueue(vq); > } > @@ -211,51 +202,18 @@ static const struct virtio_config_ops virtio_pci_config_ops = { > /* the PCI probing function */ > int virtio_pci_legacy_probe(struct virtio_pci_device *vp_dev) > { > + struct virtio_pci_legacy_device *ldev = &vp_dev->ldev; > struct pci_dev *pci_dev = vp_dev->pci_dev; > int rc; > > - /* We only own devices >= 0x1000 and <= 0x103f: leave the rest. */ > - if (pci_dev->device < 0x1000 || pci_dev->device > 0x103f) > - return -ENODEV; > - > - if (pci_dev->revision != VIRTIO_PCI_ABI_VERSION) { > - printk(KERN_ERR "virtio_pci: expected ABI version %d, got %d\n", > - VIRTIO_PCI_ABI_VERSION, pci_dev->revision); > - return -ENODEV; > - } > - > - rc = dma_set_mask(&pci_dev->dev, DMA_BIT_MASK(64)); > - if (rc) { > - rc = dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32)); > - } else { > - /* > - * The virtio ring base address is expressed as a 32-bit PFN, > - * with a page size of 1 << VIRTIO_PCI_QUEUE_ADDR_SHIFT. > - */ > - dma_set_coherent_mask(&pci_dev->dev, > - DMA_BIT_MASK(32 + VIRTIO_PCI_QUEUE_ADDR_SHIFT)); > - } > - > - if (rc) > - dev_warn(&pci_dev->dev, "Failed to enable 64-bit or 32-bit DMA. Trying to continue, but this might not work.\n"); > + ldev->pci_dev = pci_dev; > > - rc = pci_request_region(pci_dev, 0, "virtio-pci-legacy"); > + rc = vp_legacy_probe(ldev); > if (rc) > return rc; > > - rc = -ENOMEM; > - vp_dev->ioaddr = pci_iomap(pci_dev, 0, 0); > - if (!vp_dev->ioaddr) > - goto err_iomap; > - > - vp_dev->isr = vp_dev->ioaddr + VIRTIO_PCI_ISR; > - > - /* we use the subsystem vendor/device id as the virtio vendor/device > - * id. this allows us to use the same PCI vendor/device id for all > - * virtio devices and to identify the particular virtio driver by > - * the subsystem ids */ > - vp_dev->vdev.id.vendor = pci_dev->subsystem_vendor; > - vp_dev->vdev.id.device = pci_dev->subsystem_device; > + vp_dev->isr = ldev->isr; > + vp_dev->vdev.id = ldev->id; > > vp_dev->vdev.config = &virtio_pci_config_ops; > > @@ -264,16 +222,11 @@ int virtio_pci_legacy_probe(struct virtio_pci_device *vp_dev) > vp_dev->del_vq = del_vq; > > return 0; > - > -err_iomap: > - pci_release_region(pci_dev, 0); > - return rc; > } > > void virtio_pci_legacy_remove(struct virtio_pci_device *vp_dev) > { > - struct pci_dev *pci_dev = vp_dev->pci_dev; > + struct virtio_pci_legacy_device *ldev = &vp_dev->ldev; > > - pci_iounmap(pci_dev, vp_dev->ioaddr); > - pci_release_region(pci_dev, 0); > + vp_legacy_remove(ldev); > } > diff --git a/drivers/virtio/virtio_pci_legacy_dev.c b/drivers/virtio/virtio_pci_legacy_dev.c > new file mode 100644 > index 000000000000..9b97680dd02b > --- /dev/null > +++ b/drivers/virtio/virtio_pci_legacy_dev.c > @@ -0,0 +1,220 @@ > +// SPDX-License-Identifier: GPL-2.0-or-later > + > +#include "linux/virtio_pci.h" > +#include > +#include > +#include > + > + > +/* > + * vp_legacy_probe: probe the legacy virtio pci device, note that the > + * caller is required to enable PCI device before calling this function. > + * @ldev: the legacy virtio-pci device > + * > + * Return 0 on succeed otherwise fail > + */ > +int vp_legacy_probe(struct virtio_pci_legacy_device *ldev) > +{ > + struct pci_dev *pci_dev = ldev->pci_dev; > + int rc; > + > + /* We only own devices >= 0x1000 and <= 0x103f: leave the rest. */ > + if (pci_dev->device < 0x1000 || pci_dev->device > 0x103f) > + return -ENODEV; > + > + if (pci_dev->revision != VIRTIO_PCI_ABI_VERSION) > + return -ENODEV; > + > + rc = dma_set_mask(&pci_dev->dev, DMA_BIT_MASK(64)); > + if (rc) { > + rc = dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32)); > + } else { > + /* > + * The virtio ring base address is expressed as a 32-bit PFN, > + * with a page size of 1 << VIRTIO_PCI_QUEUE_ADDR_SHIFT. > + */ > + dma_set_coherent_mask(&pci_dev->dev, > + DMA_BIT_MASK(32 + VIRTIO_PCI_QUEUE_ADDR_SHIFT)); > + } > + > + if (rc) > + dev_warn(&pci_dev->dev, "Failed to enable 64-bit or 32-bit DMA. Trying to continue, but this might not work.\n"); > + > + rc = pci_request_region(pci_dev, 0, "virtio-pci-legacy"); > + if (rc) > + return rc; > + > + ldev->ioaddr = pci_iomap(pci_dev, 0, 0); > + if (!ldev->ioaddr) > + goto err_iomap; > + > + ldev->isr = ldev->ioaddr + VIRTIO_PCI_ISR; > + > + ldev->id.vendor = pci_dev->subsystem_vendor; > + ldev->id.device = pci_dev->subsystem_device; > + > + return 0; > +err_iomap: > + pci_release_region(pci_dev, 0); > + return rc; > +} > +EXPORT_SYMBOL_GPL(vp_legacy_probe); > + > +/* > + * vp_legacy_probe: remove and cleanup the legacy virtio pci device > + * @ldev: the legacy virtio-pci device > + */ > +void vp_legacy_remove(struct virtio_pci_legacy_device *ldev) > +{ > + struct pci_dev *pci_dev = ldev->pci_dev; > + > + pci_iounmap(pci_dev, ldev->ioaddr); > + pci_release_region(pci_dev, 0); > +} > +EXPORT_SYMBOL_GPL(vp_legacy_remove); > + > +/* > + * vp_legacy_get_features - get features from device > + * @ldev: the legacy virtio-pci device > + * > + * Returns the features read from the device > + */ > +u64 vp_legacy_get_features(struct virtio_pci_legacy_device *ldev) > +{ > + > + return ioread32(ldev->ioaddr + VIRTIO_PCI_HOST_FEATURES); > +} > +EXPORT_SYMBOL_GPL(vp_legacy_get_features); > + > +/* > + * vp_legacy_get_driver_features - get driver features from device > + * @ldev: the legacy virtio-pci device > + * > + * Returns the driver features read from the device > + */ > +u64 vp_legacy_get_driver_features(struct virtio_pci_legacy_device *ldev) > +{ > + return ioread32(ldev->ioaddr + VIRTIO_PCI_GUEST_FEATURES); > +} > +EXPORT_SYMBOL_GPL(vp_legacy_get_driver_features); > + > +/* > + * vp_legacy_set_features - set features to device > + * @ldev: the legacy virtio-pci device > + * @features: the features set to device > + */ > +void vp_legacy_set_features(struct virtio_pci_legacy_device *ldev, > + u32 features) > +{ > + iowrite32(features, ldev->ioaddr + VIRTIO_PCI_GUEST_FEATURES); > +} > +EXPORT_SYMBOL_GPL(vp_legacy_set_features); > + > +/* > + * vp_legacy_get_status - get the device status > + * @ldev: the legacy virtio-pci device > + * > + * Returns the status read from device > + */ > +u8 vp_legacy_get_status(struct virtio_pci_legacy_device *ldev) > +{ > + return ioread8(ldev->ioaddr + VIRTIO_PCI_STATUS); > +} > +EXPORT_SYMBOL_GPL(vp_legacy_get_status); > + > +/* > + * vp_legacy_set_status - set status to device > + * @ldev: the legacy virtio-pci device > + * @status: the status set to device > + */ > +void vp_legacy_set_status(struct virtio_pci_legacy_device *ldev, > + u8 status) > +{ > + iowrite8(status, ldev->ioaddr + VIRTIO_PCI_STATUS); > +} > +EXPORT_SYMBOL_GPL(vp_legacy_set_status); > + > +/* > + * vp_legacy_queue_vector - set the MSIX vector for a specific virtqueue > + * @ldev: the legacy virtio-pci device > + * @index: queue index > + * @vector: the config vector > + * > + * Returns the config vector read from the device > + */ > +u16 vp_legacy_queue_vector(struct virtio_pci_legacy_device *ldev, > + u16 index, u16 vector) > +{ > + iowrite16(index, ldev->ioaddr + VIRTIO_PCI_QUEUE_SEL); > + iowrite16(vector, ldev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR); > + /* Flush the write out to device */ > + return ioread16(ldev->ioaddr + VIRTIO_MSI_QUEUE_VECTOR); > +} > +EXPORT_SYMBOL_GPL(vp_legacy_queue_vector); > + > +/* > + * vp_legacy_config_vector - set the vector for config interrupt > + * @ldev: the legacy virtio-pci device > + * @vector: the config vector > + * > + * Returns the config vector read from the device > + */ > +u16 vp_legacy_config_vector(struct virtio_pci_legacy_device *ldev, > + u16 vector) > +{ > + /* Setup the vector used for configuration events */ > + iowrite16(vector, ldev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR); > + /* Verify we had enough resources to assign the vector */ > + /* Will also flush the write out to device */ > + return ioread16(ldev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR); > +} > +EXPORT_SYMBOL_GPL(vp_legacy_config_vector); > + > +/* > + * vp_legacy_set_queue_address - set the virtqueue address > + * @ldev: the legacy virtio-pci device > + * @index: the queue index > + * @queue_pfn: pfn of the virtqueue > + */ > +void vp_legacy_set_queue_address(struct virtio_pci_legacy_device *ldev, > + u16 index, u32 queue_pfn) > +{ > + iowrite16(index, ldev->ioaddr + VIRTIO_PCI_QUEUE_SEL); > + iowrite32(queue_pfn, ldev->ioaddr + VIRTIO_PCI_QUEUE_PFN); > +} > +EXPORT_SYMBOL_GPL(vp_legacy_set_queue_address); > + > +/* > + * vp_legacy_get_queue_enable - enable a virtqueue > + * @ldev: the legacy virtio-pci device > + * @index: the queue index > + * > + * Returns whether a virtqueue is enabled or not > + */ > +bool vp_legacy_get_queue_enable(struct virtio_pci_legacy_device *ldev, > + u16 index) > +{ > + iowrite16(index, ldev->ioaddr + VIRTIO_PCI_QUEUE_SEL); > + return ioread32(ldev->ioaddr + VIRTIO_PCI_QUEUE_PFN); > +} > +EXPORT_SYMBOL_GPL(vp_legacy_get_queue_enable); > + > +/* > + * vp_legacy_get_queue_size - get size for a virtqueue > + * @ldev: the legacy virtio-pci device > + * @index: the queue index > + * > + * Returns the size of the virtqueue > + */ > +u16 vp_legacy_get_queue_size(struct virtio_pci_legacy_device *ldev, > + u16 index) > +{ > + iowrite16(index, ldev->ioaddr + VIRTIO_PCI_QUEUE_SEL); > + return ioread16(ldev->ioaddr + VIRTIO_PCI_QUEUE_NUM); > +} > +EXPORT_SYMBOL_GPL(vp_legacy_get_queue_size); > + > +MODULE_VERSION("0.1"); > +MODULE_DESCRIPTION("Legacy Virtio PCI Device"); > +MODULE_AUTHOR("Wu Zongyong "); > +MODULE_LICENSE("GPL"); > diff --git a/include/linux/virtio_pci_legacy.h b/include/linux/virtio_pci_legacy.h > new file mode 100644 > index 000000000000..ee2c6157215f > --- /dev/null > +++ b/include/linux/virtio_pci_legacy.h > @@ -0,0 +1,44 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +#ifndef _LINUX_VIRTIO_PCI_LEGACY_H > +#define _LINUX_VIRTIO_PCI_LEGACY_H > + > +#include "linux/mod_devicetable.h" > +#include > +#include > + > +struct virtio_pci_legacy_device { > + struct pci_dev *pci_dev; > + > + /* Where to read and clear interrupt */ > + u8 __iomem *isr; > + /* The IO mapping for the PCI config space (legacy mode only) */ > + void __iomem *ioaddr; > + > + struct virtio_device_id id; > +}; > + > +u64 vp_legacy_get_features(struct virtio_pci_legacy_device *ldev); > +u64 vp_legacy_get_driver_features(struct virtio_pci_legacy_device *ldev); > +void vp_legacy_set_features(struct virtio_pci_legacy_device *ldev, > + u32 features); > +u8 vp_legacy_get_status(struct virtio_pci_legacy_device *ldev); > +void vp_legacy_set_status(struct virtio_pci_legacy_device *ldev, > + u8 status); > +u16 vp_legacy_queue_vector(struct virtio_pci_legacy_device *ldev, > + u16 idx, u16 vector); > +u16 vp_legacy_config_vector(struct virtio_pci_legacy_device *ldev, > + u16 vector); > +void vp_legacy_set_queue_address(struct virtio_pci_legacy_device *ldev, > + u16 index, u32 queue_pfn); > +void vp_legacy_set_queue_enable(struct virtio_pci_legacy_device *ldev, > + u16 idx, bool enable); > +bool vp_legacy_get_queue_enable(struct virtio_pci_legacy_device *ldev, > + u16 idx); > +void vp_legacy_set_queue_size(struct virtio_pci_legacy_device *ldev, > + u16 idx, u16 size); > +u16 vp_legacy_get_queue_size(struct virtio_pci_legacy_device *ldev, > + u16 idx); > +int vp_legacy_probe(struct virtio_pci_legacy_device *ldev); > +void vp_legacy_remove(struct virtio_pci_legacy_device *ldev); > + > +#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 mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E4742C4167E for ; Mon, 11 Oct 2021 03:01:04 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [140.211.166.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 9360760F38 for ; Mon, 11 Oct 2021 03:01:04 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 9360760F38 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id 5116F4021B; Mon, 11 Oct 2021 03:01:04 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id GI7XXMpijanA; Mon, 11 Oct 2021 03:01:02 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [IPv6:2605:bc80:3010:104::8cd3:938]) by smtp2.osuosl.org (Postfix) with ESMTPS id 8E73040231; Mon, 11 Oct 2021 03:01:01 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 3FCC8C000F; Mon, 11 Oct 2021 03:01:01 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [IPv6:2605:bc80:3010::133]) by lists.linuxfoundation.org (Postfix) with ESMTP id 1994CC000D for ; Mon, 11 Oct 2021 03:01:00 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id 057FE40231 for ; Mon, 11 Oct 2021 03:01:00 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id mn_olsROjTOj for ; Mon, 11 Oct 2021 03:00:57 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by smtp2.osuosl.org (Postfix) with ESMTPS id 912374021B for ; Mon, 11 Oct 2021 03:00:57 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1633921255; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=c6AyUo0P4jqww7yBj4YHm5SI0ziK+vWCaJKXgZN+3Gc=; b=g1IAjaCde1atjuLWmcvVng0uYYiS+r52K/ZlcnEC2/BZ462LT7sXmN8OvqdW67CKL95vjk Mu534x1gtro5qGDy1b6OJyKIsLo/qv51AQNHxsSqVknczHi9hT/LKNgmoze/dTF3CbGI+x /cTIQasHpINpuMrOGWe3DmVm7JOVVl0= Received: from mail-pl1-f197.google.com (mail-pl1-f197.google.com [209.85.214.197]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-525-bnJmwqxqOhmItX6U7ss-sQ-1; Sun, 10 Oct 2021 23:00:51 -0400 X-MC-Unique: bnJmwqxqOhmItX6U7ss-sQ-1 Received: by mail-pl1-f197.google.com with SMTP id o6-20020a170902bcc600b00138a9a5bc42so7196248pls.17 for ; Sun, 10 Oct 2021 20:00:51 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=c6AyUo0P4jqww7yBj4YHm5SI0ziK+vWCaJKXgZN+3Gc=; b=swdMbUj7RYN410rjeHD8PRrevY6YWSApxOd+Fftbt+N4gVL4oAmhOm4Bt0/1w3oNue 5Zkab6BDYExdFe+3qfm35uNSdDv1SfTEFN7NO/yVot7UKA7Z723m1Q83YAuSoT9bRm8l qtuSWd/Q5/A3AHLUdE/0+PkwHzJg6aw2t/gSLHUHrW38ThtBX+qwQy5cmoUMhDl0DEFj d8R+Qjz7kCdI7/kM7uGtyzoy047bdgI0O+uPpa6gHLzm42gdKw90QNxZN1JXfpbnw2pG 1nR9T/SQFrh2KX7ComNM2W2GQ9hNZGGqUhWChGKEs5zBy129z0AjyyT+MFvortnigprk wkFQ== X-Gm-Message-State: AOAM532onqI+WvMN/Tax9EgMCjLoalXjPa+S3p5/aEWxFawUaMCn6XI4 eca4usV30n86mEHTEme7yKuN1xrKJOSrYUOGzIB9hc0UMu96ox2vkCSXw2CAc+9YT39wUOOYK8O Bu7JQEm9ADVB31GovLTMGyE09IzZY5wxlJ45Bsa3IMw== X-Received: by 2002:a63:200a:: with SMTP id g10mr15940556pgg.242.1633921250249; Sun, 10 Oct 2021 20:00:50 -0700 (PDT) X-Google-Smtp-Source: ABdhPJy+v5J5UcW5S22Imp2npH1Lehnlm7PtWm446qlfdPovNchz+me5hq/SmmI1GWSZ2xB3kCGgLA== X-Received: by 2002:a63:200a:: with SMTP id g10mr15940516pgg.242.1633921249713; Sun, 10 Oct 2021 20:00:49 -0700 (PDT) Received: from wangxiaodeMacBook-Air.local ([209.132.188.80]) by smtp.gmail.com with ESMTPSA id z9sm5499043pji.42.2021.10.10.20.00.47 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Sun, 10 Oct 2021 20:00:49 -0700 (PDT) Subject: Re: [PATCH v4 1/7] virtio-pci: introduce legacy device module To: Wu Zongyong , virtualization@lists.linux-foundation.org, linux-kernel@vger.kernel.org, mst@redhat.com References: From: Jason Wang Message-ID: <897fb1b2-abf1-0ad5-a7de-7b214c3484d5@redhat.com> Date: Mon, 11 Oct 2021 11:00:45 +0800 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Thunderbird/78.14.0 MIME-Version: 1.0 In-Reply-To: Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=jasowang@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-US Cc: wei.yang1@linux.alibaba.com X-BeenThere: virtualization@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Linux virtualization List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="gbk"; Format="flowed" Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" CtTaIDIwMjEvOS8yOSDPws7nMjoxMSwgV3UgWm9uZ3lvbmcg0LS1wDoKPiBTcGxpdCBjb21tb24g Y29kZXMgZnJvbSB2aXJ0aW8tcGNpLWxlZ2FjeSBzbyB2RFBBIGRyaXZlciBjYW4gcmV1c2UgaXQK PiBsYXRlci4KPgo+IFNpZ25lZC1vZmYtYnk6IFd1IFpvbmd5b25nIDx3dXpvbmd5b25nQGxpbnV4 LmFsaWJhYmEuY29tPgoKCkFja2VkLWJ5OiBKYXNvbiBXYW5nIDxqYXNvd2FuZ0ByZWRoYXQuY29t PgoKCj4gLS0tCj4gICBkcml2ZXJzL3ZpcnRpby9LY29uZmlnICAgICAgICAgICAgICAgICB8ICAx MCArKwo+ICAgZHJpdmVycy92aXJ0aW8vTWFrZWZpbGUgICAgICAgICAgICAgICAgfCAgIDEgKwo+ ICAgZHJpdmVycy92aXJ0aW8vdmlydGlvX3BjaV9jb21tb24uYyAgICAgfCAgMTAgKy0KPiAgIGRy aXZlcnMvdmlydGlvL3ZpcnRpb19wY2lfY29tbW9uLmggICAgIHwgICA5ICstCj4gICBkcml2ZXJz L3ZpcnRpby92aXJ0aW9fcGNpX2xlZ2FjeS5jICAgICB8IDEwMSArKystLS0tLS0tLS0KPiAgIGRy aXZlcnMvdmlydGlvL3ZpcnRpb19wY2lfbGVnYWN5X2Rldi5jIHwgMjIwICsrKysrKysrKysrKysr KysrKysrKysrKysKPiAgIGluY2x1ZGUvbGludXgvdmlydGlvX3BjaV9sZWdhY3kuaCAgICAgIHwg IDQ0ICsrKysrCj4gICA3IGZpbGVzIGNoYW5nZWQsIDMxMiBpbnNlcnRpb25zKCspLCA4MyBkZWxl dGlvbnMoLSkKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3ZpcnRpby92aXJ0aW9fcGNp X2xlZ2FjeV9kZXYuYwo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvbGludXgvdmlydGlv X3BjaV9sZWdhY3kuaAo+Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlydGlvL0tjb25maWcgYi9k cml2ZXJzL3ZpcnRpby9LY29uZmlnCj4gaW5kZXggY2UxYjNmNmVjMzI1Li44ZmNmOTRjZDJjOTYg MTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy92aXJ0aW8vS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvdmly dGlvL0tjb25maWcKPiBAQCAtMjAsNiArMjAsMTUgQEAgY29uZmlnIFZJUlRJT19QQ0lfTElCCj4g ICAJICBQQ0kgZGV2aWNlIHdpdGggcG9zc2libGUgdmVuZG9yIHNwZWNpZmljIGV4dGVuc2lvbnMu IEFueQo+ICAgCSAgbW9kdWxlIHRoYXQgc2VsZWN0cyB0aGlzIG1vZHVsZSBtdXN0IGRlcGVuZCBv biBQQ0kuCj4gICAKPiArY29uZmlnIFZJUlRJT19QQ0lfTElCX0xFR0FDWQo+ICsJdHJpc3RhdGUK PiArCWhlbHAKPiArCSAgTGVnYWN5IFBDSSBkZXZpY2UgKFZpcnRpbyBQQ0kgQ2FyZCAwLjkueCBE cmFmdCBhbmQgb2xkZXIgZGV2aWNlKQo+ICsJICBpbXBsZW1lbnRhdGlvbi4KPiArCSAgVGhpcyBt b2R1bGUgaW1wbGVtZW50cyB0aGUgYmFzaWMgcHJvYmUgYW5kIGNvbnRyb2wgZm9yIGRldmljZXMK PiArCSAgd2hpY2ggYXJlIGJhc2VkIG9uIGxlZ2FjeSBQQ0kgZGV2aWNlLiBBbnkgbW9kdWxlIHRo YXQgc2VsZWN0cyB0aGlzCj4gKwkgIG1vZHVsZSBtdXN0IGRlcGVuZCBvbiBQQ0kuCj4gKwo+ICAg bWVudWNvbmZpZyBWSVJUSU9fTUVOVQo+ICAgCWJvb2wgIlZpcnRpbyBkcml2ZXJzIgo+ICAgCWRl ZmF1bHQgeQo+IEBAIC00Myw2ICs1Miw3IEBAIGNvbmZpZyBWSVJUSU9fUENJX0xFR0FDWQo+ICAg CWJvb2wgIlN1cHBvcnQgZm9yIGxlZ2FjeSB2aXJ0aW8gZHJhZnQgMC45LlggYW5kIG9sZGVyIGRl dmljZXMiCj4gICAJZGVmYXVsdCB5Cj4gICAJZGVwZW5kcyBvbiBWSVJUSU9fUENJCj4gKwlzZWxl Y3QgVklSVElPX1BDSV9MSUJfTEVHQUNZCj4gICAJaGVscAo+ICAgICAgICAgICAgIFZpcnRpbyBQ Q0kgQ2FyZCAwLjkuWCBEcmFmdCAoY2lyY2EgMjAxNCkgYW5kIG9sZGVyIGRldmljZSBzdXBwb3J0 Lgo+ICAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlydGlvL01ha2VmaWxlIGIvZHJpdmVycy92 aXJ0aW8vTWFrZWZpbGUKPiBpbmRleCA2OTliYmVhMDQ2NWYuLjBhODJkMDg3MzI0OCAxMDA2NDQK PiAtLS0gYS9kcml2ZXJzL3ZpcnRpby9NYWtlZmlsZQo+ICsrKyBiL2RyaXZlcnMvdmlydGlvL01h a2VmaWxlCj4gQEAgLTEsNiArMSw3IEBACj4gICAjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBH UEwtMi4wCj4gICBvYmotJChDT05GSUdfVklSVElPKSArPSB2aXJ0aW8ubyB2aXJ0aW9fcmluZy5v Cj4gICBvYmotJChDT05GSUdfVklSVElPX1BDSV9MSUIpICs9IHZpcnRpb19wY2lfbW9kZXJuX2Rl di5vCj4gK29iai0kKENPTkZJR19WSVJUSU9fUENJX0xJQl9MRUdBQ1kpICs9IHZpcnRpb19wY2lf bGVnYWN5X2Rldi5vCj4gICBvYmotJChDT05GSUdfVklSVElPX01NSU8pICs9IHZpcnRpb19tbWlv Lm8KPiAgIG9iai0kKENPTkZJR19WSVJUSU9fUENJKSArPSB2aXJ0aW9fcGNpLm8KPiAgIHZpcnRp b19wY2kteSA6PSB2aXJ0aW9fcGNpX21vZGVybi5vIHZpcnRpb19wY2lfY29tbW9uLm8KPiBkaWZm IC0tZ2l0IGEvZHJpdmVycy92aXJ0aW8vdmlydGlvX3BjaV9jb21tb24uYyBiL2RyaXZlcnMvdmly dGlvL3ZpcnRpb19wY2lfY29tbW9uLmMKPiBpbmRleCBiMzViYjJkNTdmNjIuLmQ3MjRmNjc2NjA4 YiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3ZpcnRpby92aXJ0aW9fcGNpX2NvbW1vbi5jCj4gKysr IGIvZHJpdmVycy92aXJ0aW8vdmlydGlvX3BjaV9jb21tb24uYwo+IEBAIC01NDksNiArNTQ5LDgg QEAgc3RhdGljIGludCB2aXJ0aW9fcGNpX3Byb2JlKHN0cnVjdCBwY2lfZGV2ICpwY2lfZGV2LAo+ ICAgCj4gICAJcGNpX3NldF9tYXN0ZXIocGNpX2Rldik7Cj4gICAKPiArCXZwX2Rldi0+aXNfbGVn YWN5ID0gdnBfZGV2LT5sZGV2LmlvYWRkciA/IHRydWUgOiBmYWxzZTsKPiArCj4gICAJcmMgPSBy ZWdpc3Rlcl92aXJ0aW9fZGV2aWNlKCZ2cF9kZXYtPnZkZXYpOwo+ICAgCXJlZ19kZXYgPSB2cF9k ZXY7Cj4gICAJaWYgKHJjKQo+IEBAIC01NTcsMTAgKzU1OSwxMCBAQCBzdGF0aWMgaW50IHZpcnRp b19wY2lfcHJvYmUoc3RydWN0IHBjaV9kZXYgKnBjaV9kZXYsCj4gICAJcmV0dXJuIDA7Cj4gICAK PiAgIGVycl9yZWdpc3RlcjoKPiAtCWlmICh2cF9kZXYtPmlvYWRkcikKPiAtCSAgICAgdmlydGlv X3BjaV9sZWdhY3lfcmVtb3ZlKHZwX2Rldik7Cj4gKwlpZiAodnBfZGV2LT5pc19sZWdhY3kpCj4g KwkJdmlydGlvX3BjaV9sZWdhY3lfcmVtb3ZlKHZwX2Rldik7Cj4gICAJZWxzZQo+IC0JICAgICB2 aXJ0aW9fcGNpX21vZGVybl9yZW1vdmUodnBfZGV2KTsKPiArCQl2aXJ0aW9fcGNpX21vZGVybl9y ZW1vdmUodnBfZGV2KTsKPiAgIGVycl9wcm9iZToKPiAgIAlwY2lfZGlzYWJsZV9kZXZpY2UocGNp X2Rldik7Cj4gICBlcnJfZW5hYmxlX2RldmljZToKPiBAQCAtNTg3LDcgKzU4OSw3IEBAIHN0YXRp YyB2b2lkIHZpcnRpb19wY2lfcmVtb3ZlKHN0cnVjdCBwY2lfZGV2ICpwY2lfZGV2KQo+ICAgCj4g ICAJdW5yZWdpc3Rlcl92aXJ0aW9fZGV2aWNlKCZ2cF9kZXYtPnZkZXYpOwo+ICAgCj4gLQlpZiAo dnBfZGV2LT5pb2FkZHIpCj4gKwlpZiAodnBfZGV2LT5pc19sZWdhY3kpCj4gICAJCXZpcnRpb19w Y2lfbGVnYWN5X3JlbW92ZSh2cF9kZXYpOwo+ICAgCWVsc2UKPiAgIAkJdmlydGlvX3BjaV9tb2Rl cm5fcmVtb3ZlKHZwX2Rldik7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlydGlvL3ZpcnRpb19w Y2lfY29tbW9uLmggYi9kcml2ZXJzL3ZpcnRpby92aXJ0aW9fcGNpX2NvbW1vbi5oCj4gaW5kZXgg YmVlYzA0N2E4ZjhkLi5lYjE3YTI5ZmM3ZWYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy92aXJ0aW8v dmlydGlvX3BjaV9jb21tb24uaAo+ICsrKyBiL2RyaXZlcnMvdmlydGlvL3ZpcnRpb19wY2lfY29t bW9uLmgKPiBAQCAtMjUsNiArMjUsNyBAQAo+ICAgI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19jb25m aWcuaD4KPiAgICNpbmNsdWRlIDxsaW51eC92aXJ0aW9fcmluZy5oPgo+ICAgI2luY2x1ZGUgPGxp bnV4L3ZpcnRpb19wY2kuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19wY2lfbGVnYWN5Lmg+ Cj4gICAjaW5jbHVkZSA8bGludXgvdmlydGlvX3BjaV9tb2Rlcm4uaD4KPiAgICNpbmNsdWRlIDxs aW51eC9oaWdobWVtLmg+Cj4gICAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KPiBAQCAtNDQs MTYgKzQ1LDE0IEBAIHN0cnVjdCB2aXJ0aW9fcGNpX3ZxX2luZm8gewo+ICAgc3RydWN0IHZpcnRp b19wY2lfZGV2aWNlIHsKPiAgIAlzdHJ1Y3QgdmlydGlvX2RldmljZSB2ZGV2Owo+ICAgCXN0cnVj dCBwY2lfZGV2ICpwY2lfZGV2Owo+ICsJc3RydWN0IHZpcnRpb19wY2lfbGVnYWN5X2RldmljZSBs ZGV2Owo+ICAgCXN0cnVjdCB2aXJ0aW9fcGNpX21vZGVybl9kZXZpY2UgbWRldjsKPiAgIAo+IC0J LyogSW4gbGVnYWN5IG1vZGUsIHRoZXNlIHR3byBwb2ludCB0byB3aXRoaW4gLT5sZWdhY3kuICov Cj4gKwlib29sIGlzX2xlZ2FjeTsKPiArCj4gICAJLyogV2hlcmUgdG8gcmVhZCBhbmQgY2xlYXIg aW50ZXJydXB0ICovCj4gICAJdTggX19pb21lbSAqaXNyOwo+ICAgCj4gLQkvKiBMZWdhY3kgb25s eSBmaWVsZCAqLwo+IC0JLyogdGhlIElPIG1hcHBpbmcgZm9yIHRoZSBQQ0kgY29uZmlnIHNwYWNl ICovCj4gLQl2b2lkIF9faW9tZW0gKmlvYWRkcjsKPiAtCj4gICAJLyogYSBsaXN0IG9mIHF1ZXVl cyBzbyB3ZSBjYW4gZGlzcGF0Y2ggSVJRcyAqLwo+ICAgCXNwaW5sb2NrX3QgbG9jazsKPiAgIAlz dHJ1Y3QgbGlzdF9oZWFkIHZpcnRxdWV1ZXM7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlydGlv L3ZpcnRpb19wY2lfbGVnYWN5LmMgYi9kcml2ZXJzL3ZpcnRpby92aXJ0aW9fcGNpX2xlZ2FjeS5j Cj4gaW5kZXggZDYyZTk4MzVhZWVjLi44MmViNDM3YWQ5MjAgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy92aXJ0aW8vdmlydGlvX3BjaV9sZWdhY3kuYwo+ICsrKyBiL2RyaXZlcnMvdmlydGlvL3ZpcnRp b19wY2lfbGVnYWN5LmMKPiBAQCAtMTQsNiArMTQsNyBAQAo+ICAgICogIE1pY2hhZWwgUy4gVHNp cmtpbiA8bXN0QHJlZGhhdC5jb20+Cj4gICAgKi8KPiAgIAo+ICsjaW5jbHVkZSAibGludXgvdmly dGlvX3BjaV9sZWdhY3kuaCIKPiAgICNpbmNsdWRlICJ2aXJ0aW9fcGNpX2NvbW1vbi5oIgo+ICAg Cj4gICAvKiB2aXJ0aW8gY29uZmlnLT5nZXRfZmVhdHVyZXMoKSBpbXBsZW1lbnRhdGlvbiAqLwo+ IEBAIC0yMyw3ICsyNCw3IEBAIHN0YXRpYyB1NjQgdnBfZ2V0X2ZlYXR1cmVzKHN0cnVjdCB2aXJ0 aW9fZGV2aWNlICp2ZGV2KQo+ICAgCj4gICAJLyogV2hlbiBzb21lb25lIG5lZWRzIG1vcmUgdGhh biAzMiBmZWF0dXJlIGJpdHMsIHdlJ2xsIG5lZWQgdG8KPiAgIAkgKiBzdGVhbCBhIGJpdCB0byBp bmRpY2F0ZSB0aGF0IHRoZSByZXN0IGFyZSBzb21ld2hlcmUgZWxzZS4gKi8KPiAtCXJldHVybiBp b3JlYWQzMih2cF9kZXYtPmlvYWRkciArIFZJUlRJT19QQ0lfSE9TVF9GRUFUVVJFUyk7Cj4gKwly ZXR1cm4gdnBfbGVnYWN5X2dldF9mZWF0dXJlcygmdnBfZGV2LT5sZGV2KTsKPiAgIH0KPiAgIAo+ ICAgLyogdmlydGlvIGNvbmZpZy0+ZmluYWxpemVfZmVhdHVyZXMoKSBpbXBsZW1lbnRhdGlvbiAq Lwo+IEBAIC0zOCw3ICszOSw3IEBAIHN0YXRpYyBpbnQgdnBfZmluYWxpemVfZmVhdHVyZXMoc3Ry dWN0IHZpcnRpb19kZXZpY2UgKnZkZXYpCj4gICAJQlVHX09OKCh1MzIpdmRldi0+ZmVhdHVyZXMg IT0gdmRldi0+ZmVhdHVyZXMpOwo+ICAgCj4gICAJLyogV2Ugb25seSBzdXBwb3J0IDMyIGZlYXR1 cmUgYml0cy4gKi8KPiAtCWlvd3JpdGUzMih2ZGV2LT5mZWF0dXJlcywgdnBfZGV2LT5pb2FkZHIg KyBWSVJUSU9fUENJX0dVRVNUX0ZFQVRVUkVTKTsKPiArCXZwX2xlZ2FjeV9zZXRfZmVhdHVyZXMo JnZwX2Rldi0+bGRldiwgdmRldi0+ZmVhdHVyZXMpOwo+ICAgCj4gICAJcmV0dXJuIDA7Cj4gICB9 Cj4gQEAgLTQ4LDcgKzQ5LDcgQEAgc3RhdGljIHZvaWQgdnBfZ2V0KHN0cnVjdCB2aXJ0aW9fZGV2 aWNlICp2ZGV2LCB1bnNpZ25lZCBvZmZzZXQsCj4gICAJCSAgIHZvaWQgKmJ1ZiwgdW5zaWduZWQg bGVuKQo+ICAgewo+ICAgCXN0cnVjdCB2aXJ0aW9fcGNpX2RldmljZSAqdnBfZGV2ID0gdG9fdnBf ZGV2aWNlKHZkZXYpOwo+IC0Jdm9pZCBfX2lvbWVtICppb2FkZHIgPSB2cF9kZXYtPmlvYWRkciAr Cj4gKwl2b2lkIF9faW9tZW0gKmlvYWRkciA9IHZwX2Rldi0+bGRldi5pb2FkZHIgKwo+ICAgCQkJ VklSVElPX1BDSV9DT05GSUdfT0ZGKHZwX2Rldi0+bXNpeF9lbmFibGVkKSArCj4gICAJCQlvZmZz ZXQ7Cj4gICAJdTggKnB0ciA9IGJ1ZjsKPiBAQCAtNjQsNyArNjUsNyBAQCBzdGF0aWMgdm9pZCB2 cF9zZXQoc3RydWN0IHZpcnRpb19kZXZpY2UgKnZkZXYsIHVuc2lnbmVkIG9mZnNldCwKPiAgIAkJ ICAgY29uc3Qgdm9pZCAqYnVmLCB1bnNpZ25lZCBsZW4pCj4gICB7Cj4gICAJc3RydWN0IHZpcnRp b19wY2lfZGV2aWNlICp2cF9kZXYgPSB0b192cF9kZXZpY2UodmRldik7Cj4gLQl2b2lkIF9faW9t ZW0gKmlvYWRkciA9IHZwX2Rldi0+aW9hZGRyICsKPiArCXZvaWQgX19pb21lbSAqaW9hZGRyID0g dnBfZGV2LT5sZGV2LmlvYWRkciArCj4gICAJCQlWSVJUSU9fUENJX0NPTkZJR19PRkYodnBfZGV2 LT5tc2l4X2VuYWJsZWQpICsKPiAgIAkJCW9mZnNldDsKPiAgIAljb25zdCB1OCAqcHRyID0gYnVm Owo+IEBAIC03OCw3ICs3OSw3IEBAIHN0YXRpYyB2b2lkIHZwX3NldChzdHJ1Y3QgdmlydGlvX2Rl dmljZSAqdmRldiwgdW5zaWduZWQgb2Zmc2V0LAo+ICAgc3RhdGljIHU4IHZwX2dldF9zdGF0dXMo c3RydWN0IHZpcnRpb19kZXZpY2UgKnZkZXYpCj4gICB7Cj4gICAJc3RydWN0IHZpcnRpb19wY2lf ZGV2aWNlICp2cF9kZXYgPSB0b192cF9kZXZpY2UodmRldik7Cj4gLQlyZXR1cm4gaW9yZWFkOCh2 cF9kZXYtPmlvYWRkciArIFZJUlRJT19QQ0lfU1RBVFVTKTsKPiArCXJldHVybiB2cF9sZWdhY3lf Z2V0X3N0YXR1cygmdnBfZGV2LT5sZGV2KTsKPiAgIH0KPiAgIAo+ICAgc3RhdGljIHZvaWQgdnBf c2V0X3N0YXR1cyhzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldiwgdTggc3RhdHVzKQo+IEBAIC04 NiwyOCArODcsMjQgQEAgc3RhdGljIHZvaWQgdnBfc2V0X3N0YXR1cyhzdHJ1Y3QgdmlydGlvX2Rl dmljZSAqdmRldiwgdTggc3RhdHVzKQo+ICAgCXN0cnVjdCB2aXJ0aW9fcGNpX2RldmljZSAqdnBf ZGV2ID0gdG9fdnBfZGV2aWNlKHZkZXYpOwo+ICAgCS8qIFdlIHNob3VsZCBuZXZlciBiZSBzZXR0 aW5nIHN0YXR1cyB0byAwLiAqLwo+ICAgCUJVR19PTihzdGF0dXMgPT0gMCk7Cj4gLQlpb3dyaXRl OChzdGF0dXMsIHZwX2Rldi0+aW9hZGRyICsgVklSVElPX1BDSV9TVEFUVVMpOwo+ICsJdnBfbGVn YWN5X3NldF9zdGF0dXMoJnZwX2Rldi0+bGRldiwgc3RhdHVzKTsKPiAgIH0KPiAgIAo+ICAgc3Rh dGljIHZvaWQgdnBfcmVzZXQoc3RydWN0IHZpcnRpb19kZXZpY2UgKnZkZXYpCj4gICB7Cj4gICAJ c3RydWN0IHZpcnRpb19wY2lfZGV2aWNlICp2cF9kZXYgPSB0b192cF9kZXZpY2UodmRldik7Cj4g ICAJLyogMCBzdGF0dXMgbWVhbnMgYSByZXNldC4gKi8KPiAtCWlvd3JpdGU4KDAsIHZwX2Rldi0+ aW9hZGRyICsgVklSVElPX1BDSV9TVEFUVVMpOwo+ICsJdnBfbGVnYWN5X3NldF9zdGF0dXMoJnZw X2Rldi0+bGRldiwgMCk7Cj4gICAJLyogRmx1c2ggb3V0IHRoZSBzdGF0dXMgd3JpdGUsIGFuZCBm bHVzaCBpbiBkZXZpY2Ugd3JpdGVzLAo+ICAgCSAqIGluY2x1ZGluZyBNU2ktWCBpbnRlcnJ1cHRz LCBpZiBhbnkuICovCj4gLQlpb3JlYWQ4KHZwX2Rldi0+aW9hZGRyICsgVklSVElPX1BDSV9TVEFU VVMpOwo+ICsJdnBfbGVnYWN5X2dldF9zdGF0dXMoJnZwX2Rldi0+bGRldik7Cj4gICAJLyogRmx1 c2ggcGVuZGluZyBWUS9jb25maWd1cmF0aW9uIGNhbGxiYWNrcy4gKi8KPiAgIAl2cF9zeW5jaHJv bml6ZV92ZWN0b3JzKHZkZXYpOwo+ICAgfQo+ICAgCj4gICBzdGF0aWMgdTE2IHZwX2NvbmZpZ192 ZWN0b3Ioc3RydWN0IHZpcnRpb19wY2lfZGV2aWNlICp2cF9kZXYsIHUxNiB2ZWN0b3IpCj4gICB7 Cj4gLQkvKiBTZXR1cCB0aGUgdmVjdG9yIHVzZWQgZm9yIGNvbmZpZ3VyYXRpb24gZXZlbnRzICov Cj4gLQlpb3dyaXRlMTYodmVjdG9yLCB2cF9kZXYtPmlvYWRkciArIFZJUlRJT19NU0lfQ09ORklH X1ZFQ1RPUik7Cj4gLQkvKiBWZXJpZnkgd2UgaGFkIGVub3VnaCByZXNvdXJjZXMgdG8gYXNzaWdu IHRoZSB2ZWN0b3IgKi8KPiAtCS8qIFdpbGwgYWxzbyBmbHVzaCB0aGUgd3JpdGUgb3V0IHRvIGRl dmljZSAqLwo+IC0JcmV0dXJuIGlvcmVhZDE2KHZwX2Rldi0+aW9hZGRyICsgVklSVElPX01TSV9D T05GSUdfVkVDVE9SKTsKPiArCXJldHVybiB2cF9sZWdhY3lfY29uZmlnX3ZlY3RvcigmdnBfZGV2 LT5sZGV2LCB2ZWN0b3IpOwo+ICAgfQo+ICAgCj4gICBzdGF0aWMgc3RydWN0IHZpcnRxdWV1ZSAq c2V0dXBfdnEoc3RydWN0IHZpcnRpb19wY2lfZGV2aWNlICp2cF9kZXYsCj4gQEAgLTEyMywxMiAr MTIwLDkgQEAgc3RhdGljIHN0cnVjdCB2aXJ0cXVldWUgKnNldHVwX3ZxKHN0cnVjdCB2aXJ0aW9f cGNpX2RldmljZSAqdnBfZGV2LAo+ICAgCWludCBlcnI7Cj4gICAJdTY0IHFfcGZuOwo+ICAgCj4g LQkvKiBTZWxlY3QgdGhlIHF1ZXVlIHdlJ3JlIGludGVyZXN0ZWQgaW4gKi8KPiAtCWlvd3JpdGUx NihpbmRleCwgdnBfZGV2LT5pb2FkZHIgKyBWSVJUSU9fUENJX1FVRVVFX1NFTCk7Cj4gLQo+ICAg CS8qIENoZWNrIGlmIHF1ZXVlIGlzIGVpdGhlciBub3QgYXZhaWxhYmxlIG9yIGFscmVhZHkgYWN0 aXZlLiAqLwo+IC0JbnVtID0gaW9yZWFkMTYodnBfZGV2LT5pb2FkZHIgKyBWSVJUSU9fUENJX1FV RVVFX05VTSk7Cj4gLQlpZiAoIW51bSB8fCBpb3JlYWQzMih2cF9kZXYtPmlvYWRkciArIFZJUlRJ T19QQ0lfUVVFVUVfUEZOKSkKPiArCW51bSA9IHZwX2xlZ2FjeV9nZXRfcXVldWVfc2l6ZSgmdnBf ZGV2LT5sZGV2LCBpbmRleCk7Cj4gKwlpZiAoIW51bSB8fCB2cF9sZWdhY3lfZ2V0X3F1ZXVlX2Vu YWJsZSgmdnBfZGV2LT5sZGV2LCBpbmRleCkpCj4gICAJCXJldHVybiBFUlJfUFRSKC1FTk9FTlQp Owo+ICAgCj4gICAJaW5mby0+bXNpeF92ZWN0b3IgPSBtc2l4X3ZlYzsKPiBAQCAtMTUxLDEzICsx NDUsMTIgQEAgc3RhdGljIHN0cnVjdCB2aXJ0cXVldWUgKnNldHVwX3ZxKHN0cnVjdCB2aXJ0aW9f cGNpX2RldmljZSAqdnBfZGV2LAo+ICAgCX0KPiAgIAo+ICAgCS8qIGFjdGl2YXRlIHRoZSBxdWV1 ZSAqLwo+IC0JaW93cml0ZTMyKHFfcGZuLCB2cF9kZXYtPmlvYWRkciArIFZJUlRJT19QQ0lfUVVF VUVfUEZOKTsKPiArCXZwX2xlZ2FjeV9zZXRfcXVldWVfYWRkcmVzcygmdnBfZGV2LT5sZGV2LCBp bmRleCwgcV9wZm4pOwo+ICAgCj4gLQl2cS0+cHJpdiA9ICh2b2lkIF9fZm9yY2UgKil2cF9kZXYt PmlvYWRkciArIFZJUlRJT19QQ0lfUVVFVUVfTk9USUZZOwo+ICsJdnEtPnByaXYgPSAodm9pZCBf X2ZvcmNlICopdnBfZGV2LT5sZGV2LmlvYWRkciArIFZJUlRJT19QQ0lfUVVFVUVfTk9USUZZOwo+ ICAgCj4gICAJaWYgKG1zaXhfdmVjICE9IFZJUlRJT19NU0lfTk9fVkVDVE9SKSB7Cj4gLQkJaW93 cml0ZTE2KG1zaXhfdmVjLCB2cF9kZXYtPmlvYWRkciArIFZJUlRJT19NU0lfUVVFVUVfVkVDVE9S KTsKPiAtCQltc2l4X3ZlYyA9IGlvcmVhZDE2KHZwX2Rldi0+aW9hZGRyICsgVklSVElPX01TSV9R VUVVRV9WRUNUT1IpOwo+ICsJCW1zaXhfdmVjID0gdnBfbGVnYWN5X3F1ZXVlX3ZlY3RvcigmdnBf ZGV2LT5sZGV2LCBpbmRleCwgbXNpeF92ZWMpOwo+ICAgCQlpZiAobXNpeF92ZWMgPT0gVklSVElP X01TSV9OT19WRUNUT1IpIHsKPiAgIAkJCWVyciA9IC1FQlVTWTsKPiAgIAkJCWdvdG8gb3V0X2Rl YWN0aXZhdGU7Cj4gQEAgLTE2Nyw3ICsxNjAsNyBAQCBzdGF0aWMgc3RydWN0IHZpcnRxdWV1ZSAq c2V0dXBfdnEoc3RydWN0IHZpcnRpb19wY2lfZGV2aWNlICp2cF9kZXYsCj4gICAJcmV0dXJuIHZx Owo+ICAgCj4gICBvdXRfZGVhY3RpdmF0ZToKPiAtCWlvd3JpdGUzMigwLCB2cF9kZXYtPmlvYWRk ciArIFZJUlRJT19QQ0lfUVVFVUVfUEZOKTsKPiArCXZwX2xlZ2FjeV9zZXRfcXVldWVfYWRkcmVz cygmdnBfZGV2LT5sZGV2LCBpbmRleCwgMCk7Cj4gICBvdXRfZGVsX3ZxOgo+ICAgCXZyaW5nX2Rl bF92aXJ0cXVldWUodnEpOwo+ICAgCXJldHVybiBFUlJfUFRSKGVycik7Cj4gQEAgLTE3OCwxNyAr MTcxLDE1IEBAIHN0YXRpYyB2b2lkIGRlbF92cShzdHJ1Y3QgdmlydGlvX3BjaV92cV9pbmZvICpp bmZvKQo+ICAgCXN0cnVjdCB2aXJ0cXVldWUgKnZxID0gaW5mby0+dnE7Cj4gICAJc3RydWN0IHZp cnRpb19wY2lfZGV2aWNlICp2cF9kZXYgPSB0b192cF9kZXZpY2UodnEtPnZkZXYpOwo+ICAgCj4g LQlpb3dyaXRlMTYodnEtPmluZGV4LCB2cF9kZXYtPmlvYWRkciArIFZJUlRJT19QQ0lfUVVFVUVf U0VMKTsKPiAtCj4gICAJaWYgKHZwX2Rldi0+bXNpeF9lbmFibGVkKSB7Cj4gLQkJaW93cml0ZTE2 KFZJUlRJT19NU0lfTk9fVkVDVE9SLAo+IC0JCQkgIHZwX2Rldi0+aW9hZGRyICsgVklSVElPX01T SV9RVUVVRV9WRUNUT1IpOwo+ICsJCXZwX2xlZ2FjeV9xdWV1ZV92ZWN0b3IoJnZwX2Rldi0+bGRl diwgdnEtPmluZGV4LAo+ICsJCQkJVklSVElPX01TSV9OT19WRUNUT1IpOwo+ICAgCQkvKiBGbHVz aCB0aGUgd3JpdGUgb3V0IHRvIGRldmljZSAqLwo+IC0JCWlvcmVhZDgodnBfZGV2LT5pb2FkZHIg KyBWSVJUSU9fUENJX0lTUik7Cj4gKwkJaW9yZWFkOCh2cF9kZXYtPmxkZXYuaW9hZGRyICsgVklS VElPX1BDSV9JU1IpOwo+ICAgCX0KPiAgIAo+ICAgCS8qIFNlbGVjdCBhbmQgZGVhY3RpdmF0ZSB0 aGUgcXVldWUgKi8KPiAtCWlvd3JpdGUzMigwLCB2cF9kZXYtPmlvYWRkciArIFZJUlRJT19QQ0lf UVVFVUVfUEZOKTsKPiArCXZwX2xlZ2FjeV9zZXRfcXVldWVfYWRkcmVzcygmdnBfZGV2LT5sZGV2 LCB2cS0+aW5kZXgsIDApOwo+ICAgCj4gICAJdnJpbmdfZGVsX3ZpcnRxdWV1ZSh2cSk7Cj4gICB9 Cj4gQEAgLTIxMSw1MSArMjAyLDE4IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdmlydGlvX2NvbmZp Z19vcHMgdmlydGlvX3BjaV9jb25maWdfb3BzID0gewo+ICAgLyogdGhlIFBDSSBwcm9iaW5nIGZ1 bmN0aW9uICovCj4gICBpbnQgdmlydGlvX3BjaV9sZWdhY3lfcHJvYmUoc3RydWN0IHZpcnRpb19w Y2lfZGV2aWNlICp2cF9kZXYpCj4gICB7Cj4gKwlzdHJ1Y3QgdmlydGlvX3BjaV9sZWdhY3lfZGV2 aWNlICpsZGV2ID0gJnZwX2Rldi0+bGRldjsKPiAgIAlzdHJ1Y3QgcGNpX2RldiAqcGNpX2RldiA9 IHZwX2Rldi0+cGNpX2RldjsKPiAgIAlpbnQgcmM7Cj4gICAKPiAtCS8qIFdlIG9ubHkgb3duIGRl dmljZXMgPj0gMHgxMDAwIGFuZCA8PSAweDEwM2Y6IGxlYXZlIHRoZSByZXN0LiAqLwo+IC0JaWYg KHBjaV9kZXYtPmRldmljZSA8IDB4MTAwMCB8fCBwY2lfZGV2LT5kZXZpY2UgPiAweDEwM2YpCj4g LQkJcmV0dXJuIC1FTk9ERVY7Cj4gLQo+IC0JaWYgKHBjaV9kZXYtPnJldmlzaW9uICE9IFZJUlRJ T19QQ0lfQUJJX1ZFUlNJT04pIHsKPiAtCQlwcmludGsoS0VSTl9FUlIgInZpcnRpb19wY2k6IGV4 cGVjdGVkIEFCSSB2ZXJzaW9uICVkLCBnb3QgJWRcbiIsCj4gLQkJICAgICAgIFZJUlRJT19QQ0lf QUJJX1ZFUlNJT04sIHBjaV9kZXYtPnJldmlzaW9uKTsKPiAtCQlyZXR1cm4gLUVOT0RFVjsKPiAt CX0KPiAtCj4gLQlyYyA9IGRtYV9zZXRfbWFzaygmcGNpX2Rldi0+ZGV2LCBETUFfQklUX01BU0so NjQpKTsKPiAtCWlmIChyYykgewo+IC0JCXJjID0gZG1hX3NldF9tYXNrX2FuZF9jb2hlcmVudCgm cGNpX2Rldi0+ZGV2LCBETUFfQklUX01BU0soMzIpKTsKPiAtCX0gZWxzZSB7Cj4gLQkJLyoKPiAt CQkgKiBUaGUgdmlydGlvIHJpbmcgYmFzZSBhZGRyZXNzIGlzIGV4cHJlc3NlZCBhcyBhIDMyLWJp dCBQRk4sCj4gLQkJICogd2l0aCBhIHBhZ2Ugc2l6ZSBvZiAxIDw8IFZJUlRJT19QQ0lfUVVFVUVf QUREUl9TSElGVC4KPiAtCQkgKi8KPiAtCQlkbWFfc2V0X2NvaGVyZW50X21hc2soJnBjaV9kZXYt PmRldiwKPiAtCQkJCURNQV9CSVRfTUFTSygzMiArIFZJUlRJT19QQ0lfUVVFVUVfQUREUl9TSElG VCkpOwo+IC0JfQo+IC0KPiAtCWlmIChyYykKPiAtCQlkZXZfd2FybigmcGNpX2Rldi0+ZGV2LCAi RmFpbGVkIHRvIGVuYWJsZSA2NC1iaXQgb3IgMzItYml0IERNQS4gIFRyeWluZyB0byBjb250aW51 ZSwgYnV0IHRoaXMgbWlnaHQgbm90IHdvcmsuXG4iKTsKPiArCWxkZXYtPnBjaV9kZXYgPSBwY2lf ZGV2Owo+ICAgCj4gLQlyYyA9IHBjaV9yZXF1ZXN0X3JlZ2lvbihwY2lfZGV2LCAwLCAidmlydGlv LXBjaS1sZWdhY3kiKTsKPiArCXJjID0gdnBfbGVnYWN5X3Byb2JlKGxkZXYpOwo+ICAgCWlmIChy YykKPiAgIAkJcmV0dXJuIHJjOwo+ICAgCj4gLQlyYyA9IC1FTk9NRU07Cj4gLQl2cF9kZXYtPmlv YWRkciA9IHBjaV9pb21hcChwY2lfZGV2LCAwLCAwKTsKPiAtCWlmICghdnBfZGV2LT5pb2FkZHIp Cj4gLQkJZ290byBlcnJfaW9tYXA7Cj4gLQo+IC0JdnBfZGV2LT5pc3IgPSB2cF9kZXYtPmlvYWRk ciArIFZJUlRJT19QQ0lfSVNSOwo+IC0KPiAtCS8qIHdlIHVzZSB0aGUgc3Vic3lzdGVtIHZlbmRv ci9kZXZpY2UgaWQgYXMgdGhlIHZpcnRpbyB2ZW5kb3IvZGV2aWNlCj4gLQkgKiBpZC4gIHRoaXMg YWxsb3dzIHVzIHRvIHVzZSB0aGUgc2FtZSBQQ0kgdmVuZG9yL2RldmljZSBpZCBmb3IgYWxsCj4g LQkgKiB2aXJ0aW8gZGV2aWNlcyBhbmQgdG8gaWRlbnRpZnkgdGhlIHBhcnRpY3VsYXIgdmlydGlv IGRyaXZlciBieQo+IC0JICogdGhlIHN1YnN5c3RlbSBpZHMgKi8KPiAtCXZwX2Rldi0+dmRldi5p ZC52ZW5kb3IgPSBwY2lfZGV2LT5zdWJzeXN0ZW1fdmVuZG9yOwo+IC0JdnBfZGV2LT52ZGV2Lmlk LmRldmljZSA9IHBjaV9kZXYtPnN1YnN5c3RlbV9kZXZpY2U7Cj4gKwl2cF9kZXYtPmlzciA9IGxk ZXYtPmlzcjsKPiArCXZwX2Rldi0+dmRldi5pZCA9IGxkZXYtPmlkOwo+ICAgCj4gICAJdnBfZGV2 LT52ZGV2LmNvbmZpZyA9ICZ2aXJ0aW9fcGNpX2NvbmZpZ19vcHM7Cj4gICAKPiBAQCAtMjY0LDE2 ICsyMjIsMTEgQEAgaW50IHZpcnRpb19wY2lfbGVnYWN5X3Byb2JlKHN0cnVjdCB2aXJ0aW9fcGNp X2RldmljZSAqdnBfZGV2KQo+ICAgCXZwX2Rldi0+ZGVsX3ZxID0gZGVsX3ZxOwo+ICAgCj4gICAJ cmV0dXJuIDA7Cj4gLQo+IC1lcnJfaW9tYXA6Cj4gLQlwY2lfcmVsZWFzZV9yZWdpb24ocGNpX2Rl diwgMCk7Cj4gLQlyZXR1cm4gcmM7Cj4gICB9Cj4gICAKPiAgIHZvaWQgdmlydGlvX3BjaV9sZWdh Y3lfcmVtb3ZlKHN0cnVjdCB2aXJ0aW9fcGNpX2RldmljZSAqdnBfZGV2KQo+ICAgewo+IC0Jc3Ry dWN0IHBjaV9kZXYgKnBjaV9kZXYgPSB2cF9kZXYtPnBjaV9kZXY7Cj4gKwlzdHJ1Y3QgdmlydGlv X3BjaV9sZWdhY3lfZGV2aWNlICpsZGV2ID0gJnZwX2Rldi0+bGRldjsKPiAgIAo+IC0JcGNpX2lv dW5tYXAocGNpX2RldiwgdnBfZGV2LT5pb2FkZHIpOwo+IC0JcGNpX3JlbGVhc2VfcmVnaW9uKHBj aV9kZXYsIDApOwo+ICsJdnBfbGVnYWN5X3JlbW92ZShsZGV2KTsKPiAgIH0KPiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy92aXJ0aW8vdmlydGlvX3BjaV9sZWdhY3lfZGV2LmMgYi9kcml2ZXJzL3ZpcnRp by92aXJ0aW9fcGNpX2xlZ2FjeV9kZXYuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXgg MDAwMDAwMDAwMDAwLi45Yjk3NjgwZGQwMmIKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVy cy92aXJ0aW8vdmlydGlvX3BjaV9sZWdhY3lfZGV2LmMKPiBAQCAtMCwwICsxLDIyMCBAQAo+ICsv LyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vci1sYXRlcgo+ICsKPiArI2luY2x1 ZGUgImxpbnV4L3ZpcnRpb19wY2kuaCIKPiArI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19wY2lfbGVn YWN5Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3Bj aS5oPgo+ICsKPiArCj4gKy8qCj4gKyAqIHZwX2xlZ2FjeV9wcm9iZTogcHJvYmUgdGhlIGxlZ2Fj eSB2aXJ0aW8gcGNpIGRldmljZSwgbm90ZSB0aGF0IHRoZQo+ICsgKiBjYWxsZXIgaXMgcmVxdWly ZWQgdG8gZW5hYmxlIFBDSSBkZXZpY2UgYmVmb3JlIGNhbGxpbmcgdGhpcyBmdW5jdGlvbi4KPiAr ICogQGxkZXY6IHRoZSBsZWdhY3kgdmlydGlvLXBjaSBkZXZpY2UKPiArICoKPiArICogUmV0dXJu IDAgb24gc3VjY2VlZCBvdGhlcndpc2UgZmFpbAo+ICsgKi8KPiAraW50IHZwX2xlZ2FjeV9wcm9i ZShzdHJ1Y3QgdmlydGlvX3BjaV9sZWdhY3lfZGV2aWNlICpsZGV2KQo+ICt7Cj4gKwlzdHJ1Y3Qg cGNpX2RldiAqcGNpX2RldiA9IGxkZXYtPnBjaV9kZXY7Cj4gKwlpbnQgcmM7Cj4gKwo+ICsJLyog V2Ugb25seSBvd24gZGV2aWNlcyA+PSAweDEwMDAgYW5kIDw9IDB4MTAzZjogbGVhdmUgdGhlIHJl c3QuICovCj4gKwlpZiAocGNpX2Rldi0+ZGV2aWNlIDwgMHgxMDAwIHx8IHBjaV9kZXYtPmRldmlj ZSA+IDB4MTAzZikKPiArCQlyZXR1cm4gLUVOT0RFVjsKPiArCj4gKwlpZiAocGNpX2Rldi0+cmV2 aXNpb24gIT0gVklSVElPX1BDSV9BQklfVkVSU0lPTikKPiArCQlyZXR1cm4gLUVOT0RFVjsKPiAr Cj4gKwlyYyA9IGRtYV9zZXRfbWFzaygmcGNpX2Rldi0+ZGV2LCBETUFfQklUX01BU0soNjQpKTsK PiArCWlmIChyYykgewo+ICsJCXJjID0gZG1hX3NldF9tYXNrX2FuZF9jb2hlcmVudCgmcGNpX2Rl di0+ZGV2LCBETUFfQklUX01BU0soMzIpKTsKPiArCX0gZWxzZSB7Cj4gKwkJLyoKPiArCQkgKiBU aGUgdmlydGlvIHJpbmcgYmFzZSBhZGRyZXNzIGlzIGV4cHJlc3NlZCBhcyBhIDMyLWJpdCBQRk4s Cj4gKwkJICogd2l0aCBhIHBhZ2Ugc2l6ZSBvZiAxIDw8IFZJUlRJT19QQ0lfUVVFVUVfQUREUl9T SElGVC4KPiArCQkgKi8KPiArCQlkbWFfc2V0X2NvaGVyZW50X21hc2soJnBjaV9kZXYtPmRldiwK PiArCQkJCURNQV9CSVRfTUFTSygzMiArIFZJUlRJT19QQ0lfUVVFVUVfQUREUl9TSElGVCkpOwo+ ICsJfQo+ICsKPiArCWlmIChyYykKPiArCQlkZXZfd2FybigmcGNpX2Rldi0+ZGV2LCAiRmFpbGVk IHRvIGVuYWJsZSA2NC1iaXQgb3IgMzItYml0IERNQS4gIFRyeWluZyB0byBjb250aW51ZSwgYnV0 IHRoaXMgbWlnaHQgbm90IHdvcmsuXG4iKTsKPiArCj4gKwlyYyA9IHBjaV9yZXF1ZXN0X3JlZ2lv bihwY2lfZGV2LCAwLCAidmlydGlvLXBjaS1sZWdhY3kiKTsKPiArCWlmIChyYykKPiArCQlyZXR1 cm4gcmM7Cj4gKwo+ICsJbGRldi0+aW9hZGRyID0gcGNpX2lvbWFwKHBjaV9kZXYsIDAsIDApOwo+ ICsJaWYgKCFsZGV2LT5pb2FkZHIpCj4gKwkJZ290byBlcnJfaW9tYXA7Cj4gKwo+ICsJbGRldi0+ aXNyID0gbGRldi0+aW9hZGRyICsgVklSVElPX1BDSV9JU1I7Cj4gKwo+ICsJbGRldi0+aWQudmVu ZG9yID0gcGNpX2Rldi0+c3Vic3lzdGVtX3ZlbmRvcjsKPiArCWxkZXYtPmlkLmRldmljZSA9IHBj aV9kZXYtPnN1YnN5c3RlbV9kZXZpY2U7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK2Vycl9pb21hcDoK PiArCXBjaV9yZWxlYXNlX3JlZ2lvbihwY2lfZGV2LCAwKTsKPiArCXJldHVybiByYzsKPiArfQo+ ICtFWFBPUlRfU1lNQk9MX0dQTCh2cF9sZWdhY3lfcHJvYmUpOwo+ICsKPiArLyoKPiArICogdnBf bGVnYWN5X3Byb2JlOiByZW1vdmUgYW5kIGNsZWFudXAgdGhlIGxlZ2FjeSB2aXJ0aW8gcGNpIGRl dmljZQo+ICsgKiBAbGRldjogdGhlIGxlZ2FjeSB2aXJ0aW8tcGNpIGRldmljZQo+ICsgKi8KPiAr dm9pZCB2cF9sZWdhY3lfcmVtb3ZlKHN0cnVjdCB2aXJ0aW9fcGNpX2xlZ2FjeV9kZXZpY2UgKmxk ZXYpCj4gK3sKPiArCXN0cnVjdCBwY2lfZGV2ICpwY2lfZGV2ID0gbGRldi0+cGNpX2RldjsKPiAr Cj4gKwlwY2lfaW91bm1hcChwY2lfZGV2LCBsZGV2LT5pb2FkZHIpOwo+ICsJcGNpX3JlbGVhc2Vf cmVnaW9uKHBjaV9kZXYsIDApOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0xfR1BMKHZwX2xlZ2FjeV9y ZW1vdmUpOwo+ICsKPiArLyoKPiArICogdnBfbGVnYWN5X2dldF9mZWF0dXJlcyAtIGdldCBmZWF0 dXJlcyBmcm9tIGRldmljZQo+ICsgKiBAbGRldjogdGhlIGxlZ2FjeSB2aXJ0aW8tcGNpIGRldmlj ZQo+ICsgKgo+ICsgKiBSZXR1cm5zIHRoZSBmZWF0dXJlcyByZWFkIGZyb20gdGhlIGRldmljZQo+ ICsgKi8KPiArdTY0IHZwX2xlZ2FjeV9nZXRfZmVhdHVyZXMoc3RydWN0IHZpcnRpb19wY2lfbGVn YWN5X2RldmljZSAqbGRldikKPiArewo+ICsKPiArCXJldHVybiBpb3JlYWQzMihsZGV2LT5pb2Fk ZHIgKyBWSVJUSU9fUENJX0hPU1RfRkVBVFVSRVMpOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0xfR1BM KHZwX2xlZ2FjeV9nZXRfZmVhdHVyZXMpOwo+ICsKPiArLyoKPiArICogdnBfbGVnYWN5X2dldF9k cml2ZXJfZmVhdHVyZXMgLSBnZXQgZHJpdmVyIGZlYXR1cmVzIGZyb20gZGV2aWNlCj4gKyAqIEBs ZGV2OiB0aGUgbGVnYWN5IHZpcnRpby1wY2kgZGV2aWNlCj4gKyAqCj4gKyAqIFJldHVybnMgdGhl IGRyaXZlciBmZWF0dXJlcyByZWFkIGZyb20gdGhlIGRldmljZQo+ICsgKi8KPiArdTY0IHZwX2xl Z2FjeV9nZXRfZHJpdmVyX2ZlYXR1cmVzKHN0cnVjdCB2aXJ0aW9fcGNpX2xlZ2FjeV9kZXZpY2Ug KmxkZXYpCj4gK3sKPiArCXJldHVybiBpb3JlYWQzMihsZGV2LT5pb2FkZHIgKyBWSVJUSU9fUENJ X0dVRVNUX0ZFQVRVUkVTKTsKPiArfQo+ICtFWFBPUlRfU1lNQk9MX0dQTCh2cF9sZWdhY3lfZ2V0 X2RyaXZlcl9mZWF0dXJlcyk7Cj4gKwo+ICsvKgo+ICsgKiB2cF9sZWdhY3lfc2V0X2ZlYXR1cmVz IC0gc2V0IGZlYXR1cmVzIHRvIGRldmljZQo+ICsgKiBAbGRldjogdGhlIGxlZ2FjeSB2aXJ0aW8t cGNpIGRldmljZQo+ICsgKiBAZmVhdHVyZXM6IHRoZSBmZWF0dXJlcyBzZXQgdG8gZGV2aWNlCj4g KyAqLwo+ICt2b2lkIHZwX2xlZ2FjeV9zZXRfZmVhdHVyZXMoc3RydWN0IHZpcnRpb19wY2lfbGVn YWN5X2RldmljZSAqbGRldiwKPiArCQkJICAgIHUzMiBmZWF0dXJlcykKPiArewo+ICsJaW93cml0 ZTMyKGZlYXR1cmVzLCBsZGV2LT5pb2FkZHIgKyBWSVJUSU9fUENJX0dVRVNUX0ZFQVRVUkVTKTsK PiArfQo+ICtFWFBPUlRfU1lNQk9MX0dQTCh2cF9sZWdhY3lfc2V0X2ZlYXR1cmVzKTsKPiArCj4g Ky8qCj4gKyAqIHZwX2xlZ2FjeV9nZXRfc3RhdHVzIC0gZ2V0IHRoZSBkZXZpY2Ugc3RhdHVzCj4g KyAqIEBsZGV2OiB0aGUgbGVnYWN5IHZpcnRpby1wY2kgZGV2aWNlCj4gKyAqCj4gKyAqIFJldHVy bnMgdGhlIHN0YXR1cyByZWFkIGZyb20gZGV2aWNlCj4gKyAqLwo+ICt1OCB2cF9sZWdhY3lfZ2V0 X3N0YXR1cyhzdHJ1Y3QgdmlydGlvX3BjaV9sZWdhY3lfZGV2aWNlICpsZGV2KQo+ICt7Cj4gKwly ZXR1cm4gaW9yZWFkOChsZGV2LT5pb2FkZHIgKyBWSVJUSU9fUENJX1NUQVRVUyk7Cj4gK30KPiAr RVhQT1JUX1NZTUJPTF9HUEwodnBfbGVnYWN5X2dldF9zdGF0dXMpOwo+ICsKPiArLyoKPiArICog dnBfbGVnYWN5X3NldF9zdGF0dXMgLSBzZXQgc3RhdHVzIHRvIGRldmljZQo+ICsgKiBAbGRldjog dGhlIGxlZ2FjeSB2aXJ0aW8tcGNpIGRldmljZQo+ICsgKiBAc3RhdHVzOiB0aGUgc3RhdHVzIHNl dCB0byBkZXZpY2UKPiArICovCj4gK3ZvaWQgdnBfbGVnYWN5X3NldF9zdGF0dXMoc3RydWN0IHZp cnRpb19wY2lfbGVnYWN5X2RldmljZSAqbGRldiwKPiArCQkJCSB1OCBzdGF0dXMpCj4gK3sKPiAr CWlvd3JpdGU4KHN0YXR1cywgbGRldi0+aW9hZGRyICsgVklSVElPX1BDSV9TVEFUVVMpOwo+ICt9 Cj4gK0VYUE9SVF9TWU1CT0xfR1BMKHZwX2xlZ2FjeV9zZXRfc3RhdHVzKTsKPiArCj4gKy8qCj4g KyAqIHZwX2xlZ2FjeV9xdWV1ZV92ZWN0b3IgLSBzZXQgdGhlIE1TSVggdmVjdG9yIGZvciBhIHNw ZWNpZmljIHZpcnRxdWV1ZQo+ICsgKiBAbGRldjogdGhlIGxlZ2FjeSB2aXJ0aW8tcGNpIGRldmlj ZQo+ICsgKiBAaW5kZXg6IHF1ZXVlIGluZGV4Cj4gKyAqIEB2ZWN0b3I6IHRoZSBjb25maWcgdmVj dG9yCj4gKyAqCj4gKyAqIFJldHVybnMgdGhlIGNvbmZpZyB2ZWN0b3IgcmVhZCBmcm9tIHRoZSBk ZXZpY2UKPiArICovCj4gK3UxNiB2cF9sZWdhY3lfcXVldWVfdmVjdG9yKHN0cnVjdCB2aXJ0aW9f cGNpX2xlZ2FjeV9kZXZpY2UgKmxkZXYsCj4gKwkJCSAgIHUxNiBpbmRleCwgdTE2IHZlY3RvcikK PiArewo+ICsJaW93cml0ZTE2KGluZGV4LCBsZGV2LT5pb2FkZHIgKyBWSVJUSU9fUENJX1FVRVVF X1NFTCk7Cj4gKwlpb3dyaXRlMTYodmVjdG9yLCBsZGV2LT5pb2FkZHIgKyBWSVJUSU9fTVNJX1FV RVVFX1ZFQ1RPUik7Cj4gKwkvKiBGbHVzaCB0aGUgd3JpdGUgb3V0IHRvIGRldmljZSAqLwo+ICsJ cmV0dXJuIGlvcmVhZDE2KGxkZXYtPmlvYWRkciArIFZJUlRJT19NU0lfUVVFVUVfVkVDVE9SKTsK PiArfQo+ICtFWFBPUlRfU1lNQk9MX0dQTCh2cF9sZWdhY3lfcXVldWVfdmVjdG9yKTsKPiArCj4g Ky8qCj4gKyAqIHZwX2xlZ2FjeV9jb25maWdfdmVjdG9yIC0gc2V0IHRoZSB2ZWN0b3IgZm9yIGNv bmZpZyBpbnRlcnJ1cHQKPiArICogQGxkZXY6IHRoZSBsZWdhY3kgdmlydGlvLXBjaSBkZXZpY2UK PiArICogQHZlY3RvcjogdGhlIGNvbmZpZyB2ZWN0b3IKPiArICoKPiArICogUmV0dXJucyB0aGUg Y29uZmlnIHZlY3RvciByZWFkIGZyb20gdGhlIGRldmljZQo+ICsgKi8KPiArdTE2IHZwX2xlZ2Fj eV9jb25maWdfdmVjdG9yKHN0cnVjdCB2aXJ0aW9fcGNpX2xlZ2FjeV9kZXZpY2UgKmxkZXYsCj4g KwkJCSAgICB1MTYgdmVjdG9yKQo+ICt7Cj4gKwkvKiBTZXR1cCB0aGUgdmVjdG9yIHVzZWQgZm9y IGNvbmZpZ3VyYXRpb24gZXZlbnRzICovCj4gKwlpb3dyaXRlMTYodmVjdG9yLCBsZGV2LT5pb2Fk ZHIgKyBWSVJUSU9fTVNJX0NPTkZJR19WRUNUT1IpOwo+ICsJLyogVmVyaWZ5IHdlIGhhZCBlbm91 Z2ggcmVzb3VyY2VzIHRvIGFzc2lnbiB0aGUgdmVjdG9yICovCj4gKwkvKiBXaWxsIGFsc28gZmx1 c2ggdGhlIHdyaXRlIG91dCB0byBkZXZpY2UgKi8KPiArCXJldHVybiBpb3JlYWQxNihsZGV2LT5p b2FkZHIgKyBWSVJUSU9fTVNJX0NPTkZJR19WRUNUT1IpOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0xf R1BMKHZwX2xlZ2FjeV9jb25maWdfdmVjdG9yKTsKPiArCj4gKy8qCj4gKyAqIHZwX2xlZ2FjeV9z ZXRfcXVldWVfYWRkcmVzcyAtIHNldCB0aGUgdmlydHF1ZXVlIGFkZHJlc3MKPiArICogQGxkZXY6 IHRoZSBsZWdhY3kgdmlydGlvLXBjaSBkZXZpY2UKPiArICogQGluZGV4OiB0aGUgcXVldWUgaW5k ZXgKPiArICogQHF1ZXVlX3BmbjogcGZuIG9mIHRoZSB2aXJ0cXVldWUKPiArICovCj4gK3ZvaWQg dnBfbGVnYWN5X3NldF9xdWV1ZV9hZGRyZXNzKHN0cnVjdCB2aXJ0aW9fcGNpX2xlZ2FjeV9kZXZp Y2UgKmxkZXYsCj4gKwkJCSAgICAgdTE2IGluZGV4LCB1MzIgcXVldWVfcGZuKQo+ICt7Cj4gKwlp b3dyaXRlMTYoaW5kZXgsIGxkZXYtPmlvYWRkciArIFZJUlRJT19QQ0lfUVVFVUVfU0VMKTsKPiAr CWlvd3JpdGUzMihxdWV1ZV9wZm4sIGxkZXYtPmlvYWRkciArIFZJUlRJT19QQ0lfUVVFVUVfUEZO KTsKPiArfQo+ICtFWFBPUlRfU1lNQk9MX0dQTCh2cF9sZWdhY3lfc2V0X3F1ZXVlX2FkZHJlc3Mp Owo+ICsKPiArLyoKPiArICogdnBfbGVnYWN5X2dldF9xdWV1ZV9lbmFibGUgLSBlbmFibGUgYSB2 aXJ0cXVldWUKPiArICogQGxkZXY6IHRoZSBsZWdhY3kgdmlydGlvLXBjaSBkZXZpY2UKPiArICog QGluZGV4OiB0aGUgcXVldWUgaW5kZXgKPiArICoKPiArICogUmV0dXJucyB3aGV0aGVyIGEgdmly dHF1ZXVlIGlzIGVuYWJsZWQgb3Igbm90Cj4gKyAqLwo+ICtib29sIHZwX2xlZ2FjeV9nZXRfcXVl dWVfZW5hYmxlKHN0cnVjdCB2aXJ0aW9fcGNpX2xlZ2FjeV9kZXZpY2UgKmxkZXYsCj4gKwkJCQl1 MTYgaW5kZXgpCj4gK3sKPiArCWlvd3JpdGUxNihpbmRleCwgbGRldi0+aW9hZGRyICsgVklSVElP X1BDSV9RVUVVRV9TRUwpOwo+ICsJcmV0dXJuIGlvcmVhZDMyKGxkZXYtPmlvYWRkciArIFZJUlRJ T19QQ0lfUVVFVUVfUEZOKTsKPiArfQo+ICtFWFBPUlRfU1lNQk9MX0dQTCh2cF9sZWdhY3lfZ2V0 X3F1ZXVlX2VuYWJsZSk7Cj4gKwo+ICsvKgo+ICsgKiB2cF9sZWdhY3lfZ2V0X3F1ZXVlX3NpemUg LSBnZXQgc2l6ZSBmb3IgYSB2aXJ0cXVldWUKPiArICogQGxkZXY6IHRoZSBsZWdhY3kgdmlydGlv LXBjaSBkZXZpY2UKPiArICogQGluZGV4OiB0aGUgcXVldWUgaW5kZXgKPiArICoKPiArICogUmV0 dXJucyB0aGUgc2l6ZSBvZiB0aGUgdmlydHF1ZXVlCj4gKyAqLwo+ICt1MTYgdnBfbGVnYWN5X2dl dF9xdWV1ZV9zaXplKHN0cnVjdCB2aXJ0aW9fcGNpX2xlZ2FjeV9kZXZpY2UgKmxkZXYsCj4gKwkJ CSAgICAgdTE2IGluZGV4KQo+ICt7Cj4gKwlpb3dyaXRlMTYoaW5kZXgsIGxkZXYtPmlvYWRkciAr IFZJUlRJT19QQ0lfUVVFVUVfU0VMKTsKPiArCXJldHVybiBpb3JlYWQxNihsZGV2LT5pb2FkZHIg KyBWSVJUSU9fUENJX1FVRVVFX05VTSk7Cj4gK30KPiArRVhQT1JUX1NZTUJPTF9HUEwodnBfbGVn YWN5X2dldF9xdWV1ZV9zaXplKTsKPiArCj4gK01PRFVMRV9WRVJTSU9OKCIwLjEiKTsKPiArTU9E VUxFX0RFU0NSSVBUSU9OKCJMZWdhY3kgVmlydGlvIFBDSSBEZXZpY2UiKTsKPiArTU9EVUxFX0FV VEhPUigiV3UgWm9uZ3lvbmcgPHd1em9uZ3lvbmdAbGludXguYWxpYmFiYS5jb20+Iik7Cj4gK01P RFVMRV9MSUNFTlNFKCJHUEwiKTsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC92aXJ0aW9f cGNpX2xlZ2FjeS5oIGIvaW5jbHVkZS9saW51eC92aXJ0aW9fcGNpX2xlZ2FjeS5oCj4gbmV3IGZp bGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmVlMmM2MTU3MjE1Zgo+IC0tLSAv ZGV2L251bGwKPiArKysgYi9pbmNsdWRlL2xpbnV4L3ZpcnRpb19wY2lfbGVnYWN5LmgKPiBAQCAt MCwwICsxLDQ0IEBACj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wICovCj4g KyNpZm5kZWYgX0xJTlVYX1ZJUlRJT19QQ0lfTEVHQUNZX0gKPiArI2RlZmluZSBfTElOVVhfVklS VElPX1BDSV9MRUdBQ1lfSAo+ICsKPiArI2luY2x1ZGUgImxpbnV4L21vZF9kZXZpY2V0YWJsZS5o Igo+ICsjaW5jbHVkZSA8bGludXgvcGNpLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC92aXJ0aW9fcGNp Lmg+Cj4gKwo+ICtzdHJ1Y3QgdmlydGlvX3BjaV9sZWdhY3lfZGV2aWNlIHsKPiArCXN0cnVjdCBw Y2lfZGV2ICpwY2lfZGV2Owo+ICsKPiArCS8qIFdoZXJlIHRvIHJlYWQgYW5kIGNsZWFyIGludGVy cnVwdCAqLwo+ICsJdTggX19pb21lbSAqaXNyOwo+ICsJLyogVGhlIElPIG1hcHBpbmcgZm9yIHRo ZSBQQ0kgY29uZmlnIHNwYWNlIChsZWdhY3kgbW9kZSBvbmx5KSAqLwo+ICsJdm9pZCBfX2lvbWVt ICppb2FkZHI7Cj4gKwo+ICsJc3RydWN0IHZpcnRpb19kZXZpY2VfaWQgaWQ7Cj4gK307Cj4gKwo+ ICt1NjQgdnBfbGVnYWN5X2dldF9mZWF0dXJlcyhzdHJ1Y3QgdmlydGlvX3BjaV9sZWdhY3lfZGV2 aWNlICpsZGV2KTsKPiArdTY0IHZwX2xlZ2FjeV9nZXRfZHJpdmVyX2ZlYXR1cmVzKHN0cnVjdCB2 aXJ0aW9fcGNpX2xlZ2FjeV9kZXZpY2UgKmxkZXYpOwo+ICt2b2lkIHZwX2xlZ2FjeV9zZXRfZmVh dHVyZXMoc3RydWN0IHZpcnRpb19wY2lfbGVnYWN5X2RldmljZSAqbGRldiwKPiArCQkJdTMyIGZl YXR1cmVzKTsKPiArdTggdnBfbGVnYWN5X2dldF9zdGF0dXMoc3RydWN0IHZpcnRpb19wY2lfbGVn YWN5X2RldmljZSAqbGRldik7Cj4gK3ZvaWQgdnBfbGVnYWN5X3NldF9zdGF0dXMoc3RydWN0IHZp cnRpb19wY2lfbGVnYWN5X2RldmljZSAqbGRldiwKPiArCQkJdTggc3RhdHVzKTsKPiArdTE2IHZw X2xlZ2FjeV9xdWV1ZV92ZWN0b3Ioc3RydWN0IHZpcnRpb19wY2lfbGVnYWN5X2RldmljZSAqbGRl diwKPiArCQkJICAgdTE2IGlkeCwgdTE2IHZlY3Rvcik7Cj4gK3UxNiB2cF9sZWdhY3lfY29uZmln X3ZlY3RvcihzdHJ1Y3QgdmlydGlvX3BjaV9sZWdhY3lfZGV2aWNlICpsZGV2LAo+ICsJCSAgICAg dTE2IHZlY3Rvcik7Cj4gK3ZvaWQgdnBfbGVnYWN5X3NldF9xdWV1ZV9hZGRyZXNzKHN0cnVjdCB2 aXJ0aW9fcGNpX2xlZ2FjeV9kZXZpY2UgKmxkZXYsCj4gKwkJCSAgICAgdTE2IGluZGV4LCB1MzIg cXVldWVfcGZuKTsKPiArdm9pZCB2cF9sZWdhY3lfc2V0X3F1ZXVlX2VuYWJsZShzdHJ1Y3Qgdmly dGlvX3BjaV9sZWdhY3lfZGV2aWNlICpsZGV2LAo+ICsJCQkJdTE2IGlkeCwgYm9vbCBlbmFibGUp Owo+ICtib29sIHZwX2xlZ2FjeV9nZXRfcXVldWVfZW5hYmxlKHN0cnVjdCB2aXJ0aW9fcGNpX2xl Z2FjeV9kZXZpY2UgKmxkZXYsCj4gKwkJCQl1MTYgaWR4KTsKPiArdm9pZCB2cF9sZWdhY3lfc2V0 X3F1ZXVlX3NpemUoc3RydWN0IHZpcnRpb19wY2lfbGVnYWN5X2RldmljZSAqbGRldiwKPiArCQkJ ICAgICAgdTE2IGlkeCwgdTE2IHNpemUpOwo+ICt1MTYgdnBfbGVnYWN5X2dldF9xdWV1ZV9zaXpl KHN0cnVjdCB2aXJ0aW9fcGNpX2xlZ2FjeV9kZXZpY2UgKmxkZXYsCj4gKwkJCSAgICAgdTE2IGlk eCk7Cj4gK2ludCB2cF9sZWdhY3lfcHJvYmUoc3RydWN0IHZpcnRpb19wY2lfbGVnYWN5X2Rldmlj ZSAqbGRldik7Cj4gK3ZvaWQgdnBfbGVnYWN5X3JlbW92ZShzdHJ1Y3QgdmlydGlvX3BjaV9sZWdh Y3lfZGV2aWNlICpsZGV2KTsKPiArCj4gKyNlbmRpZgoKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KVmlydHVhbGl6YXRpb24gbWFpbGluZyBsaXN0ClZpcnR1 YWxpemF0aW9uQGxpc3RzLmxpbnV4LWZvdW5kYXRpb24ub3JnCmh0dHBzOi8vbGlzdHMubGludXhm b3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZvL3ZpcnR1YWxpemF0aW9u