From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Liu, Yi L" Subject: [RFC v3 3/3] smaples: add vfio-mdev-pci driver Date: Tue, 23 Apr 2019 20:14:40 +0800 Message-ID: <1556021680-2911-4-git-send-email-yi.l.liu@intel.com> References: <1556021680-2911-1-git-send-email-yi.l.liu@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Return-path: In-Reply-To: <1556021680-2911-1-git-send-email-yi.l.liu@intel.com> Sender: linux-kernel-owner@vger.kernel.org To: alex.williamson@redhat.com, kwankhede@nvidia.com Cc: kevin.tian@intel.com, baolu.lu@linux.intel.com, yi.l.liu@intel.com, yi.y.sun@intel.com, joro@8bytes.org, jean-philippe.brucker@arm.com, peterx@redhat.com, linux-kernel@vger.kernel.org, kvm@vger.kernel.org, yamada.masahiro@socionext.com, iommu@lists.linux-foundation.org, Liu@vger.kernel.org List-Id: iommu@lists.linux-foundation.org This patch adds sample driver named vfio-mdev-pci. It is to wrap a PCI device as a mediated device. For a pci device, once bound to vfio-mdev-pci driver, user space access of this device will go through vfio mdev framework. The usage of the device follows mdev management method. e.g. user should create a mdev before exposing the device to user-space. Benefit of this new driver would be acting as a sample driver for recent changes from "vfio/mdev: IOMMU aware mediated device" patchset. Also it could be a good experiment driver for future device specific mdev migration support. To use this driver: a) build and load vfio-mdev-pci.ko module execute "make menuconfig" and config CONFIG_SAMPLE_VFIO_MDEV_PCI then load it with following command > sudo modprobe vfio > sudo modprobe vfio-pci > sudo insmod drivers/vfio/pci/vfio-mdev-pci.ko b) unbind original device driver e.g. use following command to unbind its original driver > echo $dev_bdf > /sys/bus/pci/devices/$dev_bdf/driver/unbind c) bind vfio-mdev-pci driver to the physical device > echo $vend_id $dev_id > /sys/bus/pci/drivers/vfio-mdev-pci/new_id d) check the supported mdev instances > ls /sys/bus/pci/devices/$dev_bdf/mdev_supported_types/ vfio-mdev-pci-type1 > ls /sys/bus/pci/devices/$dev_bdf/mdev_supported_types/\ vfio-mdev-pci-type1/ available_instances create device_api devices name e) create mdev on this physical device (only 1 instance) > echo "83b8f4f2-509f-382f-3c1e-e6bfe0fa1003" > \ /sys/bus/pci/devices/$dev_bdf/mdev_supported_types/\ vfio-mdev-pci-type1/create f) passthru the mdev to guest add the following line in Qemu boot command -device vfio-pci,\ sysfsdev=/sys/bus/mdev/devices/83b8f4f2-509f-382f-3c1e-e6bfe0fa1003 g) destroy mdev > echo 1 > /sys/bus/mdev/devices/83b8f4f2-509f-382f-3c1e-e6bfe0fa1003/\ remove Cc: Kevin Tian Cc: Lu Baolu Cc: Masahiro Yamada Suggested-by: Alex Williamson Signed-off-by: Liu, Yi L --- drivers/vfio/pci/Makefile | 5 + drivers/vfio/pci/vfio_mdev_pci.c | 386 +++++++++++++++++++++++++++++++++++++++ samples/Kconfig | 11 ++ 3 files changed, 402 insertions(+) create mode 100644 drivers/vfio/pci/vfio_mdev_pci.c diff --git a/drivers/vfio/pci/Makefile b/drivers/vfio/pci/Makefile index 813f6b3..6a05393 100644 --- a/drivers/vfio/pci/Makefile +++ b/drivers/vfio/pci/Makefile @@ -3,4 +3,9 @@ vfio-pci-y := vfio_pci.o common.o vfio_pci_intrs.o vfio_pci_rdwr.o vfio_pci_conf vfio-pci-$(CONFIG_VFIO_PCI_IGD) += vfio_pci_igd.o vfio-pci-$(CONFIG_VFIO_PCI_NVLINK2) += vfio_pci_nvlink2.o +vfio-mdev-pci-y := vfio_mdev_pci.o common.o vfio_pci_intrs.o vfio_pci_rdwr.o vfio_pci_config.o +vfio-mdev-pci-$(CONFIG_VFIO_PCI_IGD) += vfio_pci_igd.o +vfio-mdev-pci-$(CONFIG_VFIO_PCI_NVLINK2) += vfio_pci_nvlink2.o + obj-$(CONFIG_VFIO_PCI) += vfio-pci.o +obj-$(CONFIG_SAMPLE_VFIO_MDEV_PCI) += vfio-mdev-pci.o diff --git a/drivers/vfio/pci/vfio_mdev_pci.c b/drivers/vfio/pci/vfio_mdev_pci.c new file mode 100644 index 0000000..aec7a5b --- /dev/null +++ b/drivers/vfio/pci/vfio_mdev_pci.c @@ -0,0 +1,386 @@ +/* + * Copyright © 2019 Intel Corporation. + * Author: Liu, Yi L + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * Derived from original vfio_pci.c: + * Copyright (C) 2012 Red Hat, Inc. All rights reserved. + * Author: Alex Williamson + * + * Derived from original vfio: + * Copyright 2010 Cisco Systems, Inc. All rights reserved. + * Author: Tom Lyon, pugs@cisco.com + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vfio_pci_private.h" + +#define DRIVER_VERSION "0.1" +#define DRIVER_AUTHOR "Liu, Yi L " +#define DRIVER_DESC "VFIO Mdev PCI - Sample driver for PCI device as a mdev" + +#define VFIO_MDEV_PCI_NAME "vfio-mdev-pci" + +static char ids[1024] __initdata; +module_param_string(ids, ids, sizeof(ids), 0); +MODULE_PARM_DESC(ids, "Initial PCI IDs to add to the vfio-mdev-pci driver, format is \"vendor:device[:subvendor[:subdevice[:class[:class_mask]]]]\" and multiple comma separated entries can be specified"); + +static bool nointxmask; +module_param_named(nointxmask, nointxmask, bool, S_IRUGO | S_IWUSR); +MODULE_PARM_DESC(nointxmask, + "Disable support for PCI 2.3 style INTx masking. If this resolves problems for specific devices, report lspci -vvvxxx to linux-pci@vger.kernel.org so the device can be fixed automatically via the broken_intx_masking flag."); + +#ifdef CONFIG_VFIO_PCI_VGA +static bool disable_vga; +module_param(disable_vga, bool, S_IRUGO); +MODULE_PARM_DESC(disable_vga, "Disable VGA resource access through vfio-mdev-pci"); +#endif + +static bool disable_idle_d3; +module_param(disable_idle_d3, bool, S_IRUGO | S_IWUSR); +MODULE_PARM_DESC(disable_idle_d3, + "Disable using the PCI D3 low power state for idle, unused devices"); + +static struct pci_driver vfio_mdev_pci_driver; + +static ssize_t +name_show(struct kobject *kobj, struct device *dev, char *buf) +{ + return sprintf(buf, "%s-type1\n", dev_name(dev)); +} + +MDEV_TYPE_ATTR_RO(name); + +static ssize_t +available_instances_show(struct kobject *kobj, struct device *dev, char *buf) +{ + return sprintf(buf, "%d\n", 1); +} + +MDEV_TYPE_ATTR_RO(available_instances); + +static ssize_t device_api_show(struct kobject *kobj, struct device *dev, + char *buf) +{ + return sprintf(buf, "%s\n", VFIO_DEVICE_API_PCI_STRING); +} + +MDEV_TYPE_ATTR_RO(device_api); + +static struct attribute *vfio_mdev_pci_types_attrs[] = { + &mdev_type_attr_name.attr, + &mdev_type_attr_device_api.attr, + &mdev_type_attr_available_instances.attr, + NULL, +}; + +static struct attribute_group vfio_mdev_pci_type_group1 = { + .name = "type1", + .attrs = vfio_mdev_pci_types_attrs, +}; + +struct attribute_group *vfio_mdev_pci_type_groups[] = { + &vfio_mdev_pci_type_group1, + NULL, +}; + +struct vfio_mdev_pci { + struct vfio_pci_device *vdev; + struct mdev_device *mdev; + unsigned long handle; +}; + +static int vfio_mdev_pci_create(struct kobject *kobj, struct mdev_device *mdev) +{ + struct device *pdev; + struct vfio_pci_device *vdev; + struct vfio_mdev_pci *pmdev; + int ret; + + pdev = mdev_parent_dev(mdev); + vdev = dev_get_drvdata(pdev); + pmdev = kzalloc(sizeof(struct vfio_mdev_pci), GFP_KERNEL); + if (pmdev == NULL) { + ret = -EBUSY; + goto out; + } + + pmdev->mdev = mdev; + pmdev->vdev = vdev; + mdev_set_drvdata(mdev, pmdev); + ret = mdev_set_iommu_device(mdev_dev(mdev), pdev); + if (ret) { + pr_info("%s, failed to config iommu isolation for mdev: %s on pf: %s\n", + __func__, dev_name(mdev_dev(mdev)), dev_name(pdev)); + goto out; + } + +out: + return ret; +} + +static int vfio_mdev_pci_remove(struct mdev_device *mdev) +{ + struct vfio_mdev_pci *pmdev = mdev_get_drvdata(mdev); + + kfree(pmdev); + pr_info("%s, succeeded for mdev: %s\n", __func__, + dev_name(mdev_dev(mdev))); + + return 0; +} + +static int vfio_mdev_pci_open(struct mdev_device *mdev) +{ + struct vfio_mdev_pci *pmdev = mdev_get_drvdata(mdev); + struct vfio_pci_device *vdev = pmdev->vdev; + int ret = 0; + + if (!try_module_get(THIS_MODULE)) + return -ENODEV; + + mutex_lock(&vdev->reflck->lock); + + if (!vdev->refcnt) { + ret = vfio_pci_enable(vdev); + if (ret) + goto error; + + vfio_spapr_pci_eeh_open(vdev->pdev); + } + vdev->refcnt++; +error: + mutex_unlock(&vdev->reflck->lock); + if (!ret) + pr_info("Succeeded to open mdev: %s on pf: %s\n", + dev_name(mdev_dev(mdev)), dev_name(&pmdev->vdev->pdev->dev)); + else { + pr_info("Failed to open mdev: %s on pf: %s\n", + dev_name(mdev_dev(mdev)), dev_name(&pmdev->vdev->pdev->dev)); + module_put(THIS_MODULE); + } + return ret; +} + +static void vfio_mdev_pci_release(struct mdev_device *mdev) +{ + struct vfio_mdev_pci *pmdev = mdev_get_drvdata(mdev); + struct vfio_pci_device *vdev = pmdev->vdev; + + pr_info("Release mdev: %s on pf: %s\n", + dev_name(mdev_dev(mdev)), dev_name(&pmdev->vdev->pdev->dev)); + + mutex_lock(&vdev->reflck->lock); + + if (!(--vdev->refcnt)) { + vfio_spapr_pci_eeh_release(vdev->pdev); + vfio_pci_disable(vdev); + } + + mutex_unlock(&vdev->reflck->lock); + + module_put(THIS_MODULE); +} + +static long vfio_mdev_pci_ioctl(struct mdev_device *mdev, unsigned int cmd, + unsigned long arg) +{ + struct vfio_mdev_pci *pmdev = mdev_get_drvdata(mdev); + + return vfio_pci_ioctl(pmdev->vdev, cmd, arg); +} + +static int vfio_mdev_pci_mmap(struct mdev_device *mdev, + struct vm_area_struct *vma) +{ + struct vfio_mdev_pci *pmdev = mdev_get_drvdata(mdev); + + return vfio_pci_mmap(pmdev->vdev, vma); +} + +static ssize_t vfio_mdev_pci_read(struct mdev_device *mdev, char __user *buf, + size_t count, loff_t *ppos) +{ + struct vfio_mdev_pci *pmdev = mdev_get_drvdata(mdev); + + return vfio_pci_read(pmdev->vdev, buf, count, ppos); +} + +static ssize_t vfio_mdev_pci_write(struct mdev_device *mdev, + const char __user *buf, + size_t count, loff_t *ppos) +{ + struct vfio_mdev_pci *pmdev = mdev_get_drvdata(mdev); + + return vfio_pci_write(pmdev->vdev, (char __user *)buf, count, ppos); +} + +static const struct mdev_parent_ops vfio_mdev_pci_ops = { + .supported_type_groups = vfio_mdev_pci_type_groups, + .create = vfio_mdev_pci_create, + .remove = vfio_mdev_pci_remove, + + .open = vfio_mdev_pci_open, + .release = vfio_mdev_pci_release, + + .read = vfio_mdev_pci_read, + .write = vfio_mdev_pci_write, + .mmap = vfio_mdev_pci_mmap, + .ioctl = vfio_mdev_pci_ioctl, +}; + +static int vfio_mdev_pci_driver_probe(struct pci_dev *pdev, + const struct pci_device_id *id) +{ + struct vfio_pci_device *vdev; + int ret; + + if (pdev->hdr_type != PCI_HEADER_TYPE_NORMAL) + return -EINVAL; + + /* + * Prevent binding to PFs with VFs enabled, this too easily allows + * userspace instance with VFs and PFs from the same device, which + * cannot work. Disabling SR-IOV here would initiate removing the + * VFs, which would unbind the driver, which is prone to blocking + * if that VF is also in use by vfio-pci or vfio-mdev-pci. Just + * reject these PFs and let the user sort it out. + */ + if (pci_num_vf(pdev)) { + pci_warn(pdev, "Cannot bind to PF with SR-IOV enabled\n"); + return -EBUSY; + } + + vdev = kzalloc(sizeof(*vdev), GFP_KERNEL); + if (!vdev) + return -ENOMEM; + + vdev->pdev = pdev; + vdev->irq_type = VFIO_PCI_NUM_IRQS; + mutex_init(&vdev->igate); + spin_lock_init(&vdev->irqlock); + mutex_init(&vdev->ioeventfds_lock); + INIT_LIST_HEAD(&vdev->ioeventfds_list); + vdev->nointxmask = nointxmask; +#ifdef CONFIG_VFIO_PCI_VGA + vdev->disable_vga = disable_vga; +#endif + vdev->disable_idle_d3 = disable_idle_d3; + + pci_set_drvdata(pdev, vdev); + + ret = vfio_pci_reflck_attach(vdev); + if (ret) { + pci_set_drvdata(pdev, NULL); + kfree(vdev); + return ret; + } + + if (vfio_pci_is_vga(pdev)) + vfio_pci_vga_probe(vdev); + + vfio_pci_probe_power_state(vdev); + + if (!disable_idle_d3) + vfio_pci_probe_idle_d3(vdev); + + ret = mdev_register_device(&pdev->dev, &vfio_mdev_pci_ops); + if (ret) + pr_err("Cannot register mdev for device %s\n", + dev_name(&pdev->dev)); + else + pr_info("Wrap device %s as a mdev\n", dev_name(&pdev->dev)); + + return ret; +} + +static void vfio_mdev_pci_driver_remove(struct pci_dev *pdev) +{ + struct vfio_pci_device *vdev; + + vdev = pci_get_drvdata(pdev); + if (!vdev) + return; + + vfio_pci_reflck_put(vdev->reflck); + + kfree(vdev->region); + mutex_destroy(&vdev->ioeventfds_lock); + + if (!disable_idle_d3) + vfio_pci_set_power_state(vdev, PCI_D0); + + kfree(vdev->pm_save); + + if (vfio_pci_is_vga(pdev)) { + vfio_pci_vga_remove(vdev); + } + + kfree(vdev); +} + +static struct pci_driver vfio_mdev_pci_driver = { + .name = VFIO_MDEV_PCI_NAME, + .id_table = NULL, /* only dynamic ids */ + .probe = vfio_mdev_pci_driver_probe, + .remove = vfio_mdev_pci_driver_remove, + .err_handler = &vfio_err_handlers, +}; + +static void __exit vfio_mdev_pci_cleanup(void) +{ + pci_unregister_driver(&vfio_mdev_pci_driver); + vfio_pci_uninit_perm_bits(); +} + +static int __init vfio_mdev_pci_init(void) +{ + int ret; + + /* Allocate shared config space permision data used by all devices */ + ret = vfio_pci_init_perm_bits(); + if (ret) + return ret; + + /* Register and scan for devices */ + ret = pci_register_driver(&vfio_mdev_pci_driver); + if (ret) + goto out_driver; + + vfio_pci_fill_ids(ids, &vfio_mdev_pci_driver); + + return 0; +out_driver: + vfio_pci_uninit_perm_bits(); + return ret; +} + +module_init(vfio_mdev_pci_init); +module_exit(vfio_mdev_pci_cleanup); + +MODULE_VERSION(DRIVER_VERSION); +MODULE_LICENSE("GPL v2"); +MODULE_AUTHOR(DRIVER_AUTHOR); +MODULE_DESCRIPTION(DRIVER_DESC); diff --git a/samples/Kconfig b/samples/Kconfig index d19754c..8829739 100644 --- a/samples/Kconfig +++ b/samples/Kconfig @@ -160,4 +160,15 @@ config SAMPLE_STATX help Build example userspace program to use the new extended-stat syscall. +config SAMPLE_VFIO_MDEV_PCI + tristate "Sample driver for wrapping PCI device as mdev" + depends on PCI && EVENTFD && VFIO_MDEV_DEVICE + select VFIO_VIRQFD + select IRQ_BYPASS_MANAGER + help + Sample driver for wrapping a PCI device as a mdev. Once bound to + this driver, device passthru should through mdev path. + + If you don't know what to do here, say N. + endif # SAMPLES -- 2.7.4 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 X-Spam-Level: X-Spam-Status: No, score=-8.5 required=3.0 tests=DATE_IN_PAST_24_48, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B53D8C10F11 for ; Wed, 24 Apr 2019 12:31:16 +0000 (UTC) Received: from mail.linuxfoundation.org (mail.linuxfoundation.org [140.211.169.12]) (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 8E4F220811 for ; Wed, 24 Apr 2019 12:31:16 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8E4F220811 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=iommu-bounces@lists.linux-foundation.org Received: from mail.linux-foundation.org (localhost [127.0.0.1]) by mail.linuxfoundation.org (Postfix) with ESMTP id 0864BFDC; Wed, 24 Apr 2019 12:31:08 +0000 (UTC) Received: from smtp1.linuxfoundation.org (smtp1.linux-foundation.org [172.17.192.35]) by mail.linuxfoundation.org (Postfix) with ESMTPS id D3BDEFD3 for ; Wed, 24 Apr 2019 12:31:06 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from mga06.intel.com (mga06.intel.com [134.134.136.31]) by smtp1.linuxfoundation.org (Postfix) with ESMTPS id 86551786 for ; Wed, 24 Apr 2019 12:31:05 +0000 (UTC) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga104.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 24 Apr 2019 05:31:05 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.60,389,1549958400"; d="scan'208";a="167475688" Received: from yiliu-dev.bj.intel.com ([10.238.156.125]) by fmsmga001.fm.intel.com with ESMTP; 24 Apr 2019 05:31:02 -0700 From: "Liu, Yi L" To: alex.williamson@redhat.com, kwankhede@nvidia.com Subject: [RFC v3 3/3] smaples: add vfio-mdev-pci driver Date: Tue, 23 Apr 2019 20:14:40 +0800 Message-Id: <1556021680-2911-4-git-send-email-yi.l.liu@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1556021680-2911-1-git-send-email-yi.l.liu@intel.com> References: <1556021680-2911-1-git-send-email-yi.l.liu@intel.com> MIME-Version: 1.0 Cc: kevin.tian@intel.com, kvm@vger.kernel.org, Liu@mail.linuxfoundation.org, jean-philippe.brucker@arm.com, linux-kernel@vger.kernel.org, yamada.masahiro@socionext.com, yi.y.sun@intel.com, iommu@lists.linux-foundation.org X-BeenThere: iommu@lists.linux-foundation.org X-Mailman-Version: 2.1.12 Precedence: list List-Id: Development issues for Linux IOMMU support List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: base64 Sender: iommu-bounces@lists.linux-foundation.org Errors-To: iommu-bounces@lists.linux-foundation.org Message-ID: <20190423121440.cOH7OnFqnCfcqdg9we5v1vMHWoBdKff5yklZMcy4VcI@z> VGhpcyBwYXRjaCBhZGRzIHNhbXBsZSBkcml2ZXIgbmFtZWQgdmZpby1tZGV2LXBjaS4gSXQgaXMg dG8gd3JhcAphIFBDSSBkZXZpY2UgYXMgYSBtZWRpYXRlZCBkZXZpY2UuIEZvciBhIHBjaSBkZXZp Y2UsIG9uY2UgYm91bmQKdG8gdmZpby1tZGV2LXBjaSBkcml2ZXIsIHVzZXIgc3BhY2UgYWNjZXNz IG9mIHRoaXMgZGV2aWNlIHdpbGwKZ28gdGhyb3VnaCB2ZmlvIG1kZXYgZnJhbWV3b3JrLiBUaGUg dXNhZ2Ugb2YgdGhlIGRldmljZSBmb2xsb3dzCm1kZXYgbWFuYWdlbWVudCBtZXRob2QuIGUuZy4g dXNlciBzaG91bGQgY3JlYXRlIGEgbWRldiBiZWZvcmUKZXhwb3NpbmcgdGhlIGRldmljZSB0byB1 c2VyLXNwYWNlLgoKQmVuZWZpdCBvZiB0aGlzIG5ldyBkcml2ZXIgd291bGQgYmUgYWN0aW5nIGFz IGEgc2FtcGxlIGRyaXZlcgpmb3IgcmVjZW50IGNoYW5nZXMgZnJvbSAidmZpby9tZGV2OiBJT01N VSBhd2FyZSBtZWRpYXRlZCBkZXZpY2UiCnBhdGNoc2V0LiBBbHNvIGl0IGNvdWxkIGJlIGEgZ29v ZCBleHBlcmltZW50IGRyaXZlciBmb3IgZnV0dXJlCmRldmljZSBzcGVjaWZpYyBtZGV2IG1pZ3Jh dGlvbiBzdXBwb3J0LgoKVG8gdXNlIHRoaXMgZHJpdmVyOgphKSBidWlsZCBhbmQgbG9hZCB2Zmlv LW1kZXYtcGNpLmtvIG1vZHVsZQogICBleGVjdXRlICJtYWtlIG1lbnVjb25maWciIGFuZCBjb25m aWcgQ09ORklHX1NBTVBMRV9WRklPX01ERVZfUENJCiAgIHRoZW4gbG9hZCBpdCB3aXRoIGZvbGxv d2luZyBjb21tYW5kCiAgID4gc3VkbyBtb2Rwcm9iZSB2ZmlvCiAgID4gc3VkbyBtb2Rwcm9iZSB2 ZmlvLXBjaQogICA+IHN1ZG8gaW5zbW9kIGRyaXZlcnMvdmZpby9wY2kvdmZpby1tZGV2LXBjaS5r bwoKYikgdW5iaW5kIG9yaWdpbmFsIGRldmljZSBkcml2ZXIKICAgZS5nLiB1c2UgZm9sbG93aW5n IGNvbW1hbmQgdG8gdW5iaW5kIGl0cyBvcmlnaW5hbCBkcml2ZXIKICAgPiBlY2hvICRkZXZfYmRm ID4gL3N5cy9idXMvcGNpL2RldmljZXMvJGRldl9iZGYvZHJpdmVyL3VuYmluZAoKYykgYmluZCB2 ZmlvLW1kZXYtcGNpIGRyaXZlciB0byB0aGUgcGh5c2ljYWwgZGV2aWNlCiAgID4gZWNobyAkdmVu ZF9pZCAkZGV2X2lkID4gL3N5cy9idXMvcGNpL2RyaXZlcnMvdmZpby1tZGV2LXBjaS9uZXdfaWQK CmQpIGNoZWNrIHRoZSBzdXBwb3J0ZWQgbWRldiBpbnN0YW5jZXMKICAgPiBscyAvc3lzL2J1cy9w Y2kvZGV2aWNlcy8kZGV2X2JkZi9tZGV2X3N1cHBvcnRlZF90eXBlcy8KICAgICB2ZmlvLW1kZXYt cGNpLXR5cGUxCiAgID4gbHMgL3N5cy9idXMvcGNpL2RldmljZXMvJGRldl9iZGYvbWRldl9zdXBw b3J0ZWRfdHlwZXMvXAogICAgIHZmaW8tbWRldi1wY2ktdHlwZTEvCiAgICAgYXZhaWxhYmxlX2lu c3RhbmNlcyAgY3JlYXRlICBkZXZpY2VfYXBpICBkZXZpY2VzICBuYW1lCgplKSAgY3JlYXRlIG1k ZXYgb24gdGhpcyBwaHlzaWNhbCBkZXZpY2UgKG9ubHkgMSBpbnN0YW5jZSkKICAgPiBlY2hvICI4 M2I4ZjRmMi01MDlmLTM4MmYtM2MxZS1lNmJmZTBmYTEwMDMiID4gXAogICAgIC9zeXMvYnVzL3Bj aS9kZXZpY2VzLyRkZXZfYmRmL21kZXZfc3VwcG9ydGVkX3R5cGVzL1wKICAgICB2ZmlvLW1kZXYt cGNpLXR5cGUxL2NyZWF0ZQoKZikgcGFzc3RocnUgdGhlIG1kZXYgdG8gZ3Vlc3QKICAgYWRkIHRo ZSBmb2xsb3dpbmcgbGluZSBpbiBRZW11IGJvb3QgY29tbWFuZAogICAtZGV2aWNlIHZmaW8tcGNp LFwKICAgIHN5c2ZzZGV2PS9zeXMvYnVzL21kZXYvZGV2aWNlcy84M2I4ZjRmMi01MDlmLTM4MmYt M2MxZS1lNmJmZTBmYTEwMDMKCmcpIGRlc3Ryb3kgbWRldgogICA+IGVjaG8gMSA+IC9zeXMvYnVz L21kZXYvZGV2aWNlcy84M2I4ZjRmMi01MDlmLTM4MmYtM2MxZS1lNmJmZTBmYTEwMDMvXAogICAg IHJlbW92ZQoKQ2M6IEtldmluIFRpYW4gPGtldmluLnRpYW5AaW50ZWwuY29tPgpDYzogTHUgQmFv bHUgPGJhb2x1Lmx1QGxpbnV4LmludGVsLmNvbT4KQ2M6IE1hc2FoaXJvIFlhbWFkYSA8eWFtYWRh Lm1hc2FoaXJvQHNvY2lvbmV4dC5jb20+ClN1Z2dlc3RlZC1ieTogQWxleCBXaWxsaWFtc29uIDxh bGV4LndpbGxpYW1zb25AcmVkaGF0LmNvbT4KU2lnbmVkLW9mZi1ieTogTGl1LCBZaSBMIDx5aS5s LmxpdUBpbnRlbC5jb20+Ci0tLQogZHJpdmVycy92ZmlvL3BjaS9NYWtlZmlsZSAgICAgICAgfCAg IDUgKwogZHJpdmVycy92ZmlvL3BjaS92ZmlvX21kZXZfcGNpLmMgfCAzODYgKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrCiBzYW1wbGVzL0tjb25maWcgICAgICAgICAgICAg ICAgICB8ICAxMSArKwogMyBmaWxlcyBjaGFuZ2VkLCA0MDIgaW5zZXJ0aW9ucygrKQogY3JlYXRl IG1vZGUgMTAwNjQ0IGRyaXZlcnMvdmZpby9wY2kvdmZpb19tZGV2X3BjaS5jCgpkaWZmIC0tZ2l0 IGEvZHJpdmVycy92ZmlvL3BjaS9NYWtlZmlsZSBiL2RyaXZlcnMvdmZpby9wY2kvTWFrZWZpbGUK aW5kZXggODEzZjZiMy4uNmEwNTM5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy92ZmlvL3BjaS9NYWtl ZmlsZQorKysgYi9kcml2ZXJzL3ZmaW8vcGNpL01ha2VmaWxlCkBAIC0zLDQgKzMsOSBAQCB2Zmlv LXBjaS15IDo9IHZmaW9fcGNpLm8gY29tbW9uLm8gdmZpb19wY2lfaW50cnMubyB2ZmlvX3BjaV9y ZHdyLm8gdmZpb19wY2lfY29uZgogdmZpby1wY2ktJChDT05GSUdfVkZJT19QQ0lfSUdEKSArPSB2 ZmlvX3BjaV9pZ2QubwogdmZpby1wY2ktJChDT05GSUdfVkZJT19QQ0lfTlZMSU5LMikgKz0gdmZp b19wY2lfbnZsaW5rMi5vCiAKK3ZmaW8tbWRldi1wY2kteSA6PSB2ZmlvX21kZXZfcGNpLm8gY29t bW9uLm8gdmZpb19wY2lfaW50cnMubyB2ZmlvX3BjaV9yZHdyLm8gdmZpb19wY2lfY29uZmlnLm8K K3ZmaW8tbWRldi1wY2ktJChDT05GSUdfVkZJT19QQ0lfSUdEKSArPSB2ZmlvX3BjaV9pZ2Qubwor dmZpby1tZGV2LXBjaS0kKENPTkZJR19WRklPX1BDSV9OVkxJTksyKSArPSB2ZmlvX3BjaV9udmxp bmsyLm8KKwogb2JqLSQoQ09ORklHX1ZGSU9fUENJKSArPSB2ZmlvLXBjaS5vCitvYmotJChDT05G SUdfU0FNUExFX1ZGSU9fTURFVl9QQ0kpICs9IHZmaW8tbWRldi1wY2kubwpkaWZmIC0tZ2l0IGEv ZHJpdmVycy92ZmlvL3BjaS92ZmlvX21kZXZfcGNpLmMgYi9kcml2ZXJzL3ZmaW8vcGNpL3ZmaW9f bWRldl9wY2kuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hZWM3YTViCi0t LSAvZGV2L251bGwKKysrIGIvZHJpdmVycy92ZmlvL3BjaS92ZmlvX21kZXZfcGNpLmMKQEAgLTAs MCArMSwzODYgQEAKKy8qCisgKiBDb3B5cmlnaHQgwqkgMjAxOSBJbnRlbCBDb3Jwb3JhdGlvbi4K KyAqICAgICBBdXRob3I6IExpdSwgWWkgTCA8eWkubC5saXVAaW50ZWwuY29tPgorICoKKyAqIFRo aXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQv b3IgbW9kaWZ5CisgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIHZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24uCisgKgorICogRGVyaXZlZCBmcm9tIG9yaWdpbmFsIHZmaW9fcGNpLmM6Cisg KiBDb3B5cmlnaHQgKEMpIDIwMTIgUmVkIEhhdCwgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqICAgICBBdXRob3I6IEFsZXggV2lsbGlhbXNvbiA8YWxleC53aWxsaWFtc29uQHJlZGhhdC5j b20+CisgKgorICogRGVyaXZlZCBmcm9tIG9yaWdpbmFsIHZmaW86CisgKiBDb3B5cmlnaHQgMjAx MCBDaXNjbyBTeXN0ZW1zLCBJbmMuICBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogQXV0aG9yOiBU b20gTHlvbiwgcHVnc0BjaXNjby5jb20KKyAqLworCisjZGVmaW5lIHByX2ZtdChmbXQpIEtCVUlM RF9NT0ROQU1FICI6ICIgZm10CisKKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKyNpbmNsdWRl IDxsaW51eC9ldmVudGZkLmg+CisjaW5jbHVkZSA8bGludXgvZmlsZS5oPgorI2luY2x1ZGUgPGxp bnV4L2ludGVycnVwdC5oPgorI2luY2x1ZGUgPGxpbnV4L2lvbW11Lmg+CisjaW5jbHVkZSA8bGlu dXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KKyNpbmNsdWRlIDxsaW51eC9u b3RpZmllci5oPgorI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgorI2luY2x1ZGUgPGxpbnV4L3BtX3J1 bnRpbWUuaD4KKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvdHlwZXMu aD4KKyNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CisjaW5jbHVkZSA8bGludXgvdmZpby5oPgor I2luY2x1ZGUgPGxpbnV4L3ZnYWFyYi5oPgorI2luY2x1ZGUgPGxpbnV4L25vc3BlYy5oPgorI2lu Y2x1ZGUgPGxpbnV4L21kZXYuaD4KKworI2luY2x1ZGUgInZmaW9fcGNpX3ByaXZhdGUuaCIKKwor I2RlZmluZSBEUklWRVJfVkVSU0lPTiAgIjAuMSIKKyNkZWZpbmUgRFJJVkVSX0FVVEhPUiAgICJM aXUsIFlpIEwgPHlpLmwubGl1QGludGVsLmNvbT4iCisjZGVmaW5lIERSSVZFUl9ERVNDICAgICAi VkZJTyBNZGV2IFBDSSAtIFNhbXBsZSBkcml2ZXIgZm9yIFBDSSBkZXZpY2UgYXMgYSBtZGV2Igor CisjZGVmaW5lIFZGSU9fTURFVl9QQ0lfTkFNRSAgInZmaW8tbWRldi1wY2kiCisKK3N0YXRpYyBj aGFyIGlkc1sxMDI0XSBfX2luaXRkYXRhOworbW9kdWxlX3BhcmFtX3N0cmluZyhpZHMsIGlkcywg c2l6ZW9mKGlkcyksIDApOworTU9EVUxFX1BBUk1fREVTQyhpZHMsICJJbml0aWFsIFBDSSBJRHMg dG8gYWRkIHRvIHRoZSB2ZmlvLW1kZXYtcGNpIGRyaXZlciwgZm9ybWF0IGlzIFwidmVuZG9yOmRl dmljZVs6c3VidmVuZG9yWzpzdWJkZXZpY2VbOmNsYXNzWzpjbGFzc19tYXNrXV1dXVwiIGFuZCBt dWx0aXBsZSBjb21tYSBzZXBhcmF0ZWQgZW50cmllcyBjYW4gYmUgc3BlY2lmaWVkIik7CisKK3N0 YXRpYyBib29sIG5vaW50eG1hc2s7Cittb2R1bGVfcGFyYW1fbmFtZWQobm9pbnR4bWFzaywgbm9p bnR4bWFzaywgYm9vbCwgU19JUlVHTyB8IFNfSVdVU1IpOworTU9EVUxFX1BBUk1fREVTQyhub2lu dHhtYXNrLAorCQkgICJEaXNhYmxlIHN1cHBvcnQgZm9yIFBDSSAyLjMgc3R5bGUgSU5UeCBtYXNr aW5nLiAgSWYgdGhpcyByZXNvbHZlcyBwcm9ibGVtcyBmb3Igc3BlY2lmaWMgZGV2aWNlcywgcmVw b3J0IGxzcGNpIC12dnZ4eHggdG8gbGludXgtcGNpQHZnZXIua2VybmVsLm9yZyBzbyB0aGUgZGV2 aWNlIGNhbiBiZSBmaXhlZCBhdXRvbWF0aWNhbGx5IHZpYSB0aGUgYnJva2VuX2ludHhfbWFza2lu ZyBmbGFnLiIpOworCisjaWZkZWYgQ09ORklHX1ZGSU9fUENJX1ZHQQorc3RhdGljIGJvb2wgZGlz YWJsZV92Z2E7Cittb2R1bGVfcGFyYW0oZGlzYWJsZV92Z2EsIGJvb2wsIFNfSVJVR08pOworTU9E VUxFX1BBUk1fREVTQyhkaXNhYmxlX3ZnYSwgIkRpc2FibGUgVkdBIHJlc291cmNlIGFjY2VzcyB0 aHJvdWdoIHZmaW8tbWRldi1wY2kiKTsKKyNlbmRpZgorCitzdGF0aWMgYm9vbCBkaXNhYmxlX2lk bGVfZDM7Cittb2R1bGVfcGFyYW0oZGlzYWJsZV9pZGxlX2QzLCBib29sLCBTX0lSVUdPIHwgU19J V1VTUik7CitNT0RVTEVfUEFSTV9ERVNDKGRpc2FibGVfaWRsZV9kMywKKwkJICJEaXNhYmxlIHVz aW5nIHRoZSBQQ0kgRDMgbG93IHBvd2VyIHN0YXRlIGZvciBpZGxlLCB1bnVzZWQgZGV2aWNlcyIp OworCitzdGF0aWMgc3RydWN0IHBjaV9kcml2ZXIgdmZpb19tZGV2X3BjaV9kcml2ZXI7CisKK3N0 YXRpYyBzc2l6ZV90CituYW1lX3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmosIHN0cnVjdCBkZXZp Y2UgKmRldiwgY2hhciAqYnVmKQoreworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVzLXR5cGUxXG4i LCBkZXZfbmFtZShkZXYpKTsKK30KKworTURFVl9UWVBFX0FUVFJfUk8obmFtZSk7CisKK3N0YXRp YyBzc2l6ZV90CithdmFpbGFibGVfaW5zdGFuY2VzX3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmos IHN0cnVjdCBkZXZpY2UgKmRldiwgY2hhciAqYnVmKQoreworCXJldHVybiBzcHJpbnRmKGJ1Ziwg IiVkXG4iLCAxKTsKK30KKworTURFVl9UWVBFX0FUVFJfUk8oYXZhaWxhYmxlX2luc3RhbmNlcyk7 CisKK3N0YXRpYyBzc2l6ZV90IGRldmljZV9hcGlfc2hvdyhzdHJ1Y3Qga29iamVjdCAqa29iaiwg c3RydWN0IGRldmljZSAqZGV2LAorCQljaGFyICpidWYpCit7CisJcmV0dXJuIHNwcmludGYoYnVm LCAiJXNcbiIsIFZGSU9fREVWSUNFX0FQSV9QQ0lfU1RSSU5HKTsKK30KKworTURFVl9UWVBFX0FU VFJfUk8oZGV2aWNlX2FwaSk7CisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICp2ZmlvX21kZXZf cGNpX3R5cGVzX2F0dHJzW10gPSB7CisJJm1kZXZfdHlwZV9hdHRyX25hbWUuYXR0ciwKKwkmbWRl dl90eXBlX2F0dHJfZGV2aWNlX2FwaS5hdHRyLAorCSZtZGV2X3R5cGVfYXR0cl9hdmFpbGFibGVf aW5zdGFuY2VzLmF0dHIsCisJTlVMTCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlX2dy b3VwIHZmaW9fbWRldl9wY2lfdHlwZV9ncm91cDEgPSB7CisJLm5hbWUgID0gInR5cGUxIiwKKwku YXR0cnMgPSB2ZmlvX21kZXZfcGNpX3R5cGVzX2F0dHJzLAorfTsKKworc3RydWN0IGF0dHJpYnV0 ZV9ncm91cCAqdmZpb19tZGV2X3BjaV90eXBlX2dyb3Vwc1tdID0geworCSZ2ZmlvX21kZXZfcGNp X3R5cGVfZ3JvdXAxLAorCU5VTEwsCit9OworCitzdHJ1Y3QgdmZpb19tZGV2X3BjaSB7CisJc3Ry dWN0IHZmaW9fcGNpX2RldmljZSAqdmRldjsKKwlzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXY7CisJ dW5zaWduZWQgbG9uZyBoYW5kbGU7Cit9OworCitzdGF0aWMgaW50IHZmaW9fbWRldl9wY2lfY3Jl YXRlKHN0cnVjdCBrb2JqZWN0ICprb2JqLCBzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYpCit7CisJ c3RydWN0IGRldmljZSAqcGRldjsKKwlzdHJ1Y3QgdmZpb19wY2lfZGV2aWNlICp2ZGV2OworCXN0 cnVjdCB2ZmlvX21kZXZfcGNpICpwbWRldjsKKwlpbnQgcmV0OworCisJcGRldiA9IG1kZXZfcGFy ZW50X2RldihtZGV2KTsKKwl2ZGV2ID0gZGV2X2dldF9kcnZkYXRhKHBkZXYpOworCXBtZGV2ID0g a3phbGxvYyhzaXplb2Yoc3RydWN0IHZmaW9fbWRldl9wY2kpLCBHRlBfS0VSTkVMKTsKKwlpZiAo cG1kZXYgPT0gTlVMTCkgeworCQlyZXQgPSAtRUJVU1k7CisJCWdvdG8gb3V0OworCX0KKworCXBt ZGV2LT5tZGV2ID0gbWRldjsKKwlwbWRldi0+dmRldiA9IHZkZXY7CisJbWRldl9zZXRfZHJ2ZGF0 YShtZGV2LCBwbWRldik7CisJcmV0ID0gbWRldl9zZXRfaW9tbXVfZGV2aWNlKG1kZXZfZGV2KG1k ZXYpLCBwZGV2KTsKKwlpZiAocmV0KSB7CisJCXByX2luZm8oIiVzLCBmYWlsZWQgdG8gY29uZmln IGlvbW11IGlzb2xhdGlvbiBmb3IgbWRldjogJXMgb24gcGY6ICVzXG4iLAorCQkJX19mdW5jX18s IGRldl9uYW1lKG1kZXZfZGV2KG1kZXYpKSwgZGV2X25hbWUocGRldikpOworCQlnb3RvIG91dDsK Kwl9CisKK291dDoKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IHZmaW9fbWRldl9wY2lf cmVtb3ZlKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlzdHJ1Y3QgdmZpb19tZGV2X3Bj aSAqcG1kZXYgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCisJa2ZyZWUocG1kZXYpOworCXBy X2luZm8oIiVzLCBzdWNjZWVkZWQgZm9yIG1kZXY6ICVzXG4iLCBfX2Z1bmNfXywKKwkJICAgICBk ZXZfbmFtZShtZGV2X2RldihtZGV2KSkpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQg dmZpb19tZGV2X3BjaV9vcGVuKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlzdHJ1Y3Qg dmZpb19tZGV2X3BjaSAqcG1kZXYgPSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCXN0cnVjdCB2 ZmlvX3BjaV9kZXZpY2UgKnZkZXYgPSBwbWRldi0+dmRldjsKKwlpbnQgcmV0ID0gMDsKKworCWlm ICghdHJ5X21vZHVsZV9nZXQoVEhJU19NT0RVTEUpKQorCQlyZXR1cm4gLUVOT0RFVjsKKworCW11 dGV4X2xvY2soJnZkZXYtPnJlZmxjay0+bG9jayk7CisKKwlpZiAoIXZkZXYtPnJlZmNudCkgewor CQlyZXQgPSB2ZmlvX3BjaV9lbmFibGUodmRldik7CisJCWlmIChyZXQpCisJCQlnb3RvIGVycm9y OworCisJCXZmaW9fc3BhcHJfcGNpX2VlaF9vcGVuKHZkZXYtPnBkZXYpOworCX0KKwl2ZGV2LT5y ZWZjbnQrKzsKK2Vycm9yOgorCW11dGV4X3VubG9jaygmdmRldi0+cmVmbGNrLT5sb2NrKTsKKwlp ZiAoIXJldCkKKwkJcHJfaW5mbygiU3VjY2VlZGVkIHRvIG9wZW4gbWRldjogJXMgb24gcGY6ICVz XG4iLAorCQlkZXZfbmFtZShtZGV2X2RldihtZGV2KSksIGRldl9uYW1lKCZwbWRldi0+dmRldi0+ cGRldi0+ZGV2KSk7CisJZWxzZSB7CisJCXByX2luZm8oIkZhaWxlZCB0byBvcGVuIG1kZXY6ICVz IG9uIHBmOiAlc1xuIiwKKwkJZGV2X25hbWUobWRldl9kZXYobWRldikpLCBkZXZfbmFtZSgmcG1k ZXYtPnZkZXYtPnBkZXYtPmRldikpOworCQltb2R1bGVfcHV0KFRISVNfTU9EVUxFKTsKKwl9CisJ cmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgdmZpb19tZGV2X3BjaV9yZWxlYXNlKHN0cnVj dCBtZGV2X2RldmljZSAqbWRldikKK3sKKwlzdHJ1Y3QgdmZpb19tZGV2X3BjaSAqcG1kZXYgPSBt ZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCXN0cnVjdCB2ZmlvX3BjaV9kZXZpY2UgKnZkZXYgPSBw bWRldi0+dmRldjsKKworCXByX2luZm8oIlJlbGVhc2UgbWRldjogJXMgb24gcGY6ICVzXG4iLAor CQlkZXZfbmFtZShtZGV2X2RldihtZGV2KSksIGRldl9uYW1lKCZwbWRldi0+dmRldi0+cGRldi0+ ZGV2KSk7CisKKwltdXRleF9sb2NrKCZ2ZGV2LT5yZWZsY2stPmxvY2spOworCisJaWYgKCEoLS12 ZGV2LT5yZWZjbnQpKSB7CisJCXZmaW9fc3BhcHJfcGNpX2VlaF9yZWxlYXNlKHZkZXYtPnBkZXYp OworCQl2ZmlvX3BjaV9kaXNhYmxlKHZkZXYpOworCX0KKworCW11dGV4X3VubG9jaygmdmRldi0+ cmVmbGNrLT5sb2NrKTsKKworCW1vZHVsZV9wdXQoVEhJU19NT0RVTEUpOworfQorCitzdGF0aWMg bG9uZyB2ZmlvX21kZXZfcGNpX2lvY3RsKHN0cnVjdCBtZGV2X2RldmljZSAqbWRldiwgdW5zaWdu ZWQgaW50IGNtZCwKKwkJCSAgICAgdW5zaWduZWQgbG9uZyBhcmcpCit7CisJc3RydWN0IHZmaW9f bWRldl9wY2kgKnBtZGV2ID0gbWRldl9nZXRfZHJ2ZGF0YShtZGV2KTsKKworCXJldHVybiB2Zmlv X3BjaV9pb2N0bChwbWRldi0+dmRldiwgY21kLCBhcmcpOworfQorCitzdGF0aWMgaW50IHZmaW9f bWRldl9wY2lfbW1hcChzdHJ1Y3QgbWRldl9kZXZpY2UgKm1kZXYsCisJCQkJc3RydWN0IHZtX2Fy ZWFfc3RydWN0ICp2bWEpCit7CisJc3RydWN0IHZmaW9fbWRldl9wY2kgKnBtZGV2ID0gbWRldl9n ZXRfZHJ2ZGF0YShtZGV2KTsKKworCXJldHVybiB2ZmlvX3BjaV9tbWFwKHBtZGV2LT52ZGV2LCB2 bWEpOworfQorCitzdGF0aWMgc3NpemVfdCB2ZmlvX21kZXZfcGNpX3JlYWQoc3RydWN0IG1kZXZf ZGV2aWNlICptZGV2LCBjaGFyIF9fdXNlciAqYnVmLAorCQkJc2l6ZV90IGNvdW50LCBsb2ZmX3Qg KnBwb3MpCit7CisJc3RydWN0IHZmaW9fbWRldl9wY2kgKnBtZGV2ID0gbWRldl9nZXRfZHJ2ZGF0 YShtZGV2KTsKKworCXJldHVybiB2ZmlvX3BjaV9yZWFkKHBtZGV2LT52ZGV2LCBidWYsIGNvdW50 LCBwcG9zKTsKK30KKworc3RhdGljIHNzaXplX3QgdmZpb19tZGV2X3BjaV93cml0ZShzdHJ1Y3Qg bWRldl9kZXZpY2UgKm1kZXYsCisJCQkJY29uc3QgY2hhciBfX3VzZXIgKmJ1ZiwKKwkJCQlzaXpl X3QgY291bnQsIGxvZmZfdCAqcHBvcykKK3sKKwlzdHJ1Y3QgdmZpb19tZGV2X3BjaSAqcG1kZXYg PSBtZGV2X2dldF9kcnZkYXRhKG1kZXYpOworCisJcmV0dXJuIHZmaW9fcGNpX3dyaXRlKHBtZGV2 LT52ZGV2LCAoY2hhciBfX3VzZXIgKilidWYsIGNvdW50LCBwcG9zKTsKK30KKworc3RhdGljIGNv bnN0IHN0cnVjdCBtZGV2X3BhcmVudF9vcHMgdmZpb19tZGV2X3BjaV9vcHMgPSB7CisJLnN1cHBv cnRlZF90eXBlX2dyb3Vwcwk9IHZmaW9fbWRldl9wY2lfdHlwZV9ncm91cHMsCisJLmNyZWF0ZQkJ CT0gdmZpb19tZGV2X3BjaV9jcmVhdGUsCisJLnJlbW92ZQkJCT0gdmZpb19tZGV2X3BjaV9yZW1v dmUsCisKKwkub3BlbgkJCT0gdmZpb19tZGV2X3BjaV9vcGVuLAorCS5yZWxlYXNlCQk9IHZmaW9f bWRldl9wY2lfcmVsZWFzZSwKKworCS5yZWFkCQkJPSB2ZmlvX21kZXZfcGNpX3JlYWQsCisJLndy aXRlCQkJPSB2ZmlvX21kZXZfcGNpX3dyaXRlLAorCS5tbWFwCQkJPSB2ZmlvX21kZXZfcGNpX21t YXAsCisJLmlvY3RsCQkJPSB2ZmlvX21kZXZfcGNpX2lvY3RsLAorfTsKKworc3RhdGljIGludCB2 ZmlvX21kZXZfcGNpX2RyaXZlcl9wcm9iZShzdHJ1Y3QgcGNpX2RldiAqcGRldiwKKwkJCQkgICAg ICAgY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgKmlkKQoreworCXN0cnVjdCB2ZmlvX3BjaV9k ZXZpY2UgKnZkZXY7CisJaW50IHJldDsKKworCWlmIChwZGV2LT5oZHJfdHlwZSAhPSBQQ0lfSEVB REVSX1RZUEVfTk9STUFMKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCS8qCisJICogUHJldmVudCBi aW5kaW5nIHRvIFBGcyB3aXRoIFZGcyBlbmFibGVkLCB0aGlzIHRvbyBlYXNpbHkgYWxsb3dzCisJ ICogdXNlcnNwYWNlIGluc3RhbmNlIHdpdGggVkZzIGFuZCBQRnMgZnJvbSB0aGUgc2FtZSBkZXZp Y2UsIHdoaWNoCisJICogY2Fubm90IHdvcmsuICBEaXNhYmxpbmcgU1ItSU9WIGhlcmUgd291bGQg aW5pdGlhdGUgcmVtb3ZpbmcgdGhlCisJICogVkZzLCB3aGljaCB3b3VsZCB1bmJpbmQgdGhlIGRy aXZlciwgd2hpY2ggaXMgcHJvbmUgdG8gYmxvY2tpbmcKKwkgKiBpZiB0aGF0IFZGIGlzIGFsc28g aW4gdXNlIGJ5IHZmaW8tcGNpIG9yIHZmaW8tbWRldi1wY2kuIEp1c3QKKwkgKiByZWplY3QgdGhl c2UgUEZzIGFuZCBsZXQgdGhlIHVzZXIgc29ydCBpdCBvdXQuCisJICovCisJaWYgKHBjaV9udW1f dmYocGRldikpIHsKKwkJcGNpX3dhcm4ocGRldiwgIkNhbm5vdCBiaW5kIHRvIFBGIHdpdGggU1It SU9WIGVuYWJsZWRcbiIpOworCQlyZXR1cm4gLUVCVVNZOworCX0KKworCXZkZXYgPSBremFsbG9j KHNpemVvZigqdmRldiksIEdGUF9LRVJORUwpOworCWlmICghdmRldikKKwkJcmV0dXJuIC1FTk9N RU07CisKKwl2ZGV2LT5wZGV2ID0gcGRldjsKKwl2ZGV2LT5pcnFfdHlwZSA9IFZGSU9fUENJX05V TV9JUlFTOworCW11dGV4X2luaXQoJnZkZXYtPmlnYXRlKTsKKwlzcGluX2xvY2tfaW5pdCgmdmRl di0+aXJxbG9jayk7CisJbXV0ZXhfaW5pdCgmdmRldi0+aW9ldmVudGZkc19sb2NrKTsKKwlJTklU X0xJU1RfSEVBRCgmdmRldi0+aW9ldmVudGZkc19saXN0KTsKKwl2ZGV2LT5ub2ludHhtYXNrID0g bm9pbnR4bWFzazsKKyNpZmRlZiBDT05GSUdfVkZJT19QQ0lfVkdBCisJdmRldi0+ZGlzYWJsZV92 Z2EgPSBkaXNhYmxlX3ZnYTsKKyNlbmRpZgorCXZkZXYtPmRpc2FibGVfaWRsZV9kMyA9IGRpc2Fi bGVfaWRsZV9kMzsKKworCXBjaV9zZXRfZHJ2ZGF0YShwZGV2LCB2ZGV2KTsKKworCXJldCA9IHZm aW9fcGNpX3JlZmxja19hdHRhY2godmRldik7CisJaWYgKHJldCkgeworCQlwY2lfc2V0X2RydmRh dGEocGRldiwgTlVMTCk7CisJCWtmcmVlKHZkZXYpOworCQlyZXR1cm4gcmV0OworCX0KKworCWlm ICh2ZmlvX3BjaV9pc192Z2EocGRldikpCisJCXZmaW9fcGNpX3ZnYV9wcm9iZSh2ZGV2KTsKKwor CXZmaW9fcGNpX3Byb2JlX3Bvd2VyX3N0YXRlKHZkZXYpOworCisJaWYgKCFkaXNhYmxlX2lkbGVf ZDMpCisJCXZmaW9fcGNpX3Byb2JlX2lkbGVfZDModmRldik7CisKKwlyZXQgPSBtZGV2X3JlZ2lz dGVyX2RldmljZSgmcGRldi0+ZGV2LCAmdmZpb19tZGV2X3BjaV9vcHMpOworCWlmIChyZXQpCisJ CXByX2VycigiQ2Fubm90IHJlZ2lzdGVyIG1kZXYgZm9yIGRldmljZSAlc1xuIiwKKwkJCWRldl9u YW1lKCZwZGV2LT5kZXYpKTsKKwllbHNlCisJCXByX2luZm8oIldyYXAgZGV2aWNlICVzIGFzIGEg bWRldlxuIiwgZGV2X25hbWUoJnBkZXYtPmRldikpOworCisJcmV0dXJuIHJldDsKK30KKworc3Rh dGljIHZvaWQgdmZpb19tZGV2X3BjaV9kcml2ZXJfcmVtb3ZlKHN0cnVjdCBwY2lfZGV2ICpwZGV2 KQoreworCXN0cnVjdCB2ZmlvX3BjaV9kZXZpY2UgKnZkZXY7CisKKwl2ZGV2ID0gcGNpX2dldF9k cnZkYXRhKHBkZXYpOworCWlmICghdmRldikKKwkJcmV0dXJuOworCisJdmZpb19wY2lfcmVmbGNr X3B1dCh2ZGV2LT5yZWZsY2spOworCisJa2ZyZWUodmRldi0+cmVnaW9uKTsKKwltdXRleF9kZXN0 cm95KCZ2ZGV2LT5pb2V2ZW50ZmRzX2xvY2spOworCisJaWYgKCFkaXNhYmxlX2lkbGVfZDMpCisJ CXZmaW9fcGNpX3NldF9wb3dlcl9zdGF0ZSh2ZGV2LCBQQ0lfRDApOworCisJa2ZyZWUodmRldi0+ cG1fc2F2ZSk7CisKKwlpZiAodmZpb19wY2lfaXNfdmdhKHBkZXYpKSB7CisJCXZmaW9fcGNpX3Zn YV9yZW1vdmUodmRldik7CisJfQorCisJa2ZyZWUodmRldik7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qg cGNpX2RyaXZlciB2ZmlvX21kZXZfcGNpX2RyaXZlciA9IHsKKwkubmFtZQkJPSBWRklPX01ERVZf UENJX05BTUUsCisJLmlkX3RhYmxlCT0gTlVMTCwgLyogb25seSBkeW5hbWljIGlkcyAqLworCS5w cm9iZQkJPSB2ZmlvX21kZXZfcGNpX2RyaXZlcl9wcm9iZSwKKwkucmVtb3ZlCQk9IHZmaW9fbWRl dl9wY2lfZHJpdmVyX3JlbW92ZSwKKwkuZXJyX2hhbmRsZXIJPSAmdmZpb19lcnJfaGFuZGxlcnMs Cit9OworCitzdGF0aWMgdm9pZCBfX2V4aXQgdmZpb19tZGV2X3BjaV9jbGVhbnVwKHZvaWQpCit7 CisJcGNpX3VucmVnaXN0ZXJfZHJpdmVyKCZ2ZmlvX21kZXZfcGNpX2RyaXZlcik7CisJdmZpb19w Y2lfdW5pbml0X3Blcm1fYml0cygpOworfQorCitzdGF0aWMgaW50IF9faW5pdCB2ZmlvX21kZXZf cGNpX2luaXQodm9pZCkKK3sKKwlpbnQgcmV0OworCisJLyogQWxsb2NhdGUgc2hhcmVkIGNvbmZp ZyBzcGFjZSBwZXJtaXNpb24gZGF0YSB1c2VkIGJ5IGFsbCBkZXZpY2VzICovCisJcmV0ID0gdmZp b19wY2lfaW5pdF9wZXJtX2JpdHMoKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJLyog UmVnaXN0ZXIgYW5kIHNjYW4gZm9yIGRldmljZXMgKi8KKwlyZXQgPSBwY2lfcmVnaXN0ZXJfZHJp dmVyKCZ2ZmlvX21kZXZfcGNpX2RyaXZlcik7CisJaWYgKHJldCkKKwkJZ290byBvdXRfZHJpdmVy OworCisJdmZpb19wY2lfZmlsbF9pZHMoaWRzLCAmdmZpb19tZGV2X3BjaV9kcml2ZXIpOworCisJ cmV0dXJuIDA7CitvdXRfZHJpdmVyOgorCXZmaW9fcGNpX3VuaW5pdF9wZXJtX2JpdHMoKTsKKwly ZXR1cm4gcmV0OworfQorCittb2R1bGVfaW5pdCh2ZmlvX21kZXZfcGNpX2luaXQpOworbW9kdWxl X2V4aXQodmZpb19tZGV2X3BjaV9jbGVhbnVwKTsKKworTU9EVUxFX1ZFUlNJT04oRFJJVkVSX1ZF UlNJT04pOworTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOworTU9EVUxFX0FVVEhPUihEUklWRVJf QVVUSE9SKTsKK01PRFVMRV9ERVNDUklQVElPTihEUklWRVJfREVTQyk7CmRpZmYgLS1naXQgYS9z YW1wbGVzL0tjb25maWcgYi9zYW1wbGVzL0tjb25maWcKaW5kZXggZDE5NzU0Yy4uODgyOTczOSAx MDA2NDQKLS0tIGEvc2FtcGxlcy9LY29uZmlnCisrKyBiL3NhbXBsZXMvS2NvbmZpZwpAQCAtMTYw LDQgKzE2MCwxNSBAQCBjb25maWcgU0FNUExFX1NUQVRYCiAJaGVscAogCSAgQnVpbGQgZXhhbXBs ZSB1c2Vyc3BhY2UgcHJvZ3JhbSB0byB1c2UgdGhlIG5ldyBleHRlbmRlZC1zdGF0IHN5c2NhbGwu CiAKK2NvbmZpZyBTQU1QTEVfVkZJT19NREVWX1BDSQorCXRyaXN0YXRlICJTYW1wbGUgZHJpdmVy IGZvciB3cmFwcGluZyBQQ0kgZGV2aWNlIGFzIG1kZXYiCisJZGVwZW5kcyBvbiBQQ0kgJiYgRVZF TlRGRCAmJiBWRklPX01ERVZfREVWSUNFCisJc2VsZWN0IFZGSU9fVklSUUZECisJc2VsZWN0IElS UV9CWVBBU1NfTUFOQUdFUgorCWhlbHAKKwkgIFNhbXBsZSBkcml2ZXIgZm9yIHdyYXBwaW5nIGEg UENJIGRldmljZSBhcyBhIG1kZXYuIE9uY2UgYm91bmQgdG8KKwkgIHRoaXMgZHJpdmVyLCBkZXZp Y2UgcGFzc3RocnUgc2hvdWxkIHRocm91Z2ggbWRldiBwYXRoLgorCisJICBJZiB5b3UgZG9uJ3Qg a25vdyB3aGF0IHRvIGRvIGhlcmUsIHNheSBOLgorCiBlbmRpZiAjIFNBTVBMRVMKLS0gCjIuNy40 CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwppb21tdSBt YWlsaW5nIGxpc3QKaW9tbXVAbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0 cy5saW51eGZvdW5kYXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8vaW9tbXU=