From mboxrd@z Thu Jan 1 00:00:00 1970 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 smtp.subspace.kernel.org (Postfix) with ESMTPS id 7A5A114F94 for ; Thu, 11 Jan 2024 10:26:38 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=armlinux.org.uk header.i=@armlinux.org.uk header.b="BYZDBswK" Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id EAE8C43845 for ; Thu, 11 Jan 2024 10:26:37 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp2.osuosl.org EAE8C43845 Authentication-Results: smtp2.osuosl.org; dkim=pass (2048-bit key) header.d=armlinux.org.uk header.i=@armlinux.org.uk header.a=rsa-sha256 header.s=pandora-2019 header.b=BYZDBswK X-Virus-Scanned: amavisd-new at osuosl.org X-Spam-Flag: NO X-Spam-Score: -2.098 X-Spam-Level: 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 MwwknDTCnpY9 for ; Thu, 11 Jan 2024 10:26:36 +0000 (UTC) Received: from pandora.armlinux.org.uk (pandora.armlinux.org.uk [IPv6:2001:4d48:ad52:32c8:5054:ff:fe00:142]) by smtp2.osuosl.org (Postfix) with ESMTPS id 34F5843839 for ; Thu, 11 Jan 2024 10:26:34 +0000 (UTC) DKIM-Filter: OpenDKIM Filter v2.11.0 smtp2.osuosl.org 34F5843839 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=armlinux.org.uk; s=pandora-2019; h=Sender:In-Reply-To: Content-Transfer-Encoding:Content-Type:MIME-Version:References:Message-ID: Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=pDZNBMDn2+p6BZE/RBnm0b+eYsTn5JNJblyxFwWjLwk=; b=BYZDBswK7aOutgUjZLmuntw9C6 /yYD+iZVGMuStm1/46YVQPXa4jHRv6Z8U/xIa+GSGAwKVe34SOytP3Tx9xGkr72yv80XAwvbHV0bI sPo8k0+woUMNdoNp9uCH8fzeyQBvulH5ie2B1EvuuxPpAgFAxaDTDH6o16MImnNWfDZMt4MUpeydd 4Z4CGcT1w4kbIrcckE3oSmD9z4loTIDryx40alX5lGpP8DdcjKsh3Da0sjJdRoK9DB6NjVdi+llFX fk+jEeT0JRIaRq95XtNKWwqN3BzgOn30vMAbYjbfZoJNdvcaRvtz18LFYQCvuQFlzqBBOaeWenMGv Od4lYmnQ==; Received: from shell.armlinux.org.uk ([fd8f:7570:feb6:1:5054:ff:fe00:4ec]:57484) by pandora.armlinux.org.uk with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1rNsGM-0006OP-2L; Thu, 11 Jan 2024 10:26:14 +0000 Received: from linux by shell.armlinux.org.uk with local (Exim 4.94.2) (envelope-from ) id 1rNsGN-0006HT-CT; Thu, 11 Jan 2024 10:26:15 +0000 Date: Thu, 11 Jan 2024 10:26:15 +0000 From: "Russell King (Oracle)" To: Jonathan Cameron Cc: "Rafael J. Wysocki" , "Rafael J. Wysocki" , linux-pm@vger.kernel.org, loongarch@lists.linux.dev, linux-acpi@vger.kernel.org, linux-arch@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-riscv@lists.infradead.org, kvmarm@lists.linux.dev, x86@kernel.org, acpica-devel@lists.linuxfoundation.org, linux-csky@vger.kernel.org, linux-doc@vger.kernel.org, linux-ia64@vger.kernel.org, linux-parisc@vger.kernel.org, Salil Mehta , Jean-Philippe Brucker , jianyong.wu@arm.com, justin.he@arm.com, James Morse Subject: Re: [PATCH RFC v3 01/21] ACPI: Only enumerate enabled (or functional) devices Message-ID: References: <20231215161539.00000940@Huawei.com> <5760569.DvuYhMxLoT@kreacher> <20240102143925.00004361@Huawei.com> <20240111101949.000075dc@Huawei.com> Precedence: bulk X-Mailing-List: acpica-devel@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20240111101949.000075dc@Huawei.com> Sender: Russell King (Oracle) On Thu, Jan 11, 2024 at 10:19:49AM +0000, Jonathan Cameron wrote: > On Tue, 2 Jan 2024 14:39:25 +0000 > Jonathan Cameron wrote: > > > On Fri, 15 Dec 2023 20:47:31 +0100 > > "Rafael J. Wysocki" wrote: > > > > > On Friday, December 15, 2023 5:15:39 PM CET Jonathan Cameron wrote: > > > > On Fri, 15 Dec 2023 15:31:55 +0000 > > > > "Russell King (Oracle)" wrote: > > > > > > > > > On Thu, Dec 14, 2023 at 07:37:10PM +0100, Rafael J. Wysocki wrote: > > > > > > On Thu, Dec 14, 2023 at 7:16 PM Rafael J. Wysocki wrote: > > > > > > > > > > > > > > On Thu, Dec 14, 2023 at 7:10 PM Russell King (Oracle) > > > > > > > wrote: > > > > > > > > I guess we need something like: > > > > > > > > > > > > > > > > if (device->status.present) > > > > > > > > return device->device_type != ACPI_BUS_TYPE_PROCESSOR || > > > > > > > > device->status.enabled; > > > > > > > > else > > > > > > > > return device->status.functional; > > > > > > > > > > > > > > > > so we only check device->status.enabled for processor-type devices? > > > > > > > > > > > > > > Yes, something like this. > > > > > > > > > > > > However, that is not sufficient, because there are > > > > > > ACPI_BUS_TYPE_DEVICE devices representing processors. > > > > > > > > > > > > I'm not sure about a clean way to do it ATM. > > > > > > > > > > Ok, how about: > > > > > > > > > > static bool acpi_dev_is_processor(const struct acpi_device *device) > > > > > { > > > > > struct acpi_hardware_id *hwid; > > > > > > > > > > if (device->device_type == ACPI_BUS_TYPE_PROCESSOR) > > > > > return true; > > > > > > > > > > if (device->device_type != ACPI_BUS_TYPE_DEVICE) > > > > > return false; > > > > > > > > > > list_for_each_entry(hwid, &device->pnp.ids, list) > > > > > if (!strcmp(ACPI_PROCESSOR_OBJECT_HID, hwid->id) || > > > > > !strcmp(ACPI_PROCESSOR_DEVICE_HID, hwid->id)) > > > > > return true; > > > > > > > > > > return false; > > > > > } > > > > > > > > > > and then: > > > > > > > > > > if (device->status.present) > > > > > return !acpi_dev_is_processor(device) || device->status.enabled; > > > > > else > > > > > return device->status.functional; > > > > > > > > > > ? > > > > > > > > > Changing it to CPU only for now makes sense to me and I think this code snippet should do the > > > > job. Nice and simple. > > > > > > Well, except that it does checks that are done elsewhere slightly > > > differently, which from the maintenance POV is not nice. > > > > > > Maybe something like the appended patch (untested). > > > > Hi Rafael, > > > > As far as I can see that's functionally equivalent, so looks good to me. > > I'm not set up to test this today though, so will defer to Russell on whether > > there is anything missing > > > > Thanks for putting this together. > > This is rather embarrassing... > > I span this up on a QEMU instance with some prints to find out we need > the !acpi_device_is_processor() restriction. > On my 'random' test setup it fails on one device. ACPI0017 - which I > happen to know rather well. It's the weird pseudo device that lets > a CXL aware OS know there is a CEDT table to probe. > > Whilst I really don't like that hack (it is all about making software > distribution of out of tree modules easier rather than something > fundamental), I'm the CXL QEMU maintainer :( > > Will fix that, but it shows there is at least one broken firmware out > there. > > On plus side, Rafael's code seems to work as expected and lets that > buggy firwmare carry on working :) So lets pretend the bug in qemu > is a deliberate test case! Lol, thanks for a test case and showing that Rafael's approach is indeed necessary. Would your test quality for a tested-by for this? For reference, this is my current version below with Rafael's update: 8<==== From: Russell King (Oracle) Subject: [PATCH] ACPI: Only enumerate enabled (or functional) processor devices From: James Morse Today the ACPI enumeration code 'visits' all devices that are present. This is a problem for arm64, where CPUs are always present, but not always enabled. When a device-check occurs because the firmware-policy has changed and a CPU is now enabled, the following error occurs: | acpi ACPI0007:48: Enumeration failure This is ultimately because acpi_dev_ready_for_enumeration() returns true for a device that is not enabled. The ACPI Processor driver will not register such CPUs as they are not 'decoding their resources'. ACPI allows a device to be functional instead of maintaining the present and enabled bit, but we can't simply check the enabled bit for all devices since firmware can be buggy. If ACPI indicates that the device is present and enabled, then all well and good, we can enumate it. However, if the device is present and not enabled, then we also check whether the device is a processor device to limit the impact of this new check to just processor devices. This avoids enumerating present && functional processor devices that are not enabled. Signed-off-by: James Morse Co-developed-by: Rafael J. Wysocki Signed-off-by: Russell King (Oracle) --- Changes since RFC v2: * Incorporate comment suggestion by Gavin Shan. Changes since RFC v3: * Fixed "sert" typo. Changes since RFC v3 (smaller series): * Restrict checking the enabled bit to processor devices, update commit comments. * Use Rafael's suggestion in https://lore.kernel.org/r/5760569.DvuYhMxLoT@kreacher --- drivers/acpi/acpi_processor.c | 11 ++++++++ drivers/acpi/device_pm.c | 2 +- drivers/acpi/device_sysfs.c | 2 +- drivers/acpi/internal.h | 4 ++- drivers/acpi/property.c | 2 +- drivers/acpi/scan.c | 49 ++++++++++++++++++++++++++++------- 6 files changed, 56 insertions(+), 14 deletions(-) diff --git a/drivers/acpi/acpi_processor.c b/drivers/acpi/acpi_processor.c index 4fe2ef54088c..cf7c1cca69dd 100644 --- a/drivers/acpi/acpi_processor.c +++ b/drivers/acpi/acpi_processor.c @@ -626,6 +626,17 @@ static struct acpi_scan_handler processor_handler = { }, }; +bool acpi_device_is_processor(const struct acpi_device *adev) +{ + if (adev->device_type == ACPI_BUS_TYPE_PROCESSOR) + return true; + + if (adev->device_type != ACPI_BUS_TYPE_DEVICE) + return false; + + return acpi_scan_check_handler(adev, &processor_handler); +} + static int acpi_processor_container_attach(struct acpi_device *dev, const struct acpi_device_id *id) { diff --git a/drivers/acpi/device_pm.c b/drivers/acpi/device_pm.c index 3b4d048c4941..e3c80f3b3b57 100644 --- a/drivers/acpi/device_pm.c +++ b/drivers/acpi/device_pm.c @@ -313,7 +313,7 @@ int acpi_bus_init_power(struct acpi_device *device) return -EINVAL; device->power.state = ACPI_STATE_UNKNOWN; - if (!acpi_device_is_present(device)) { + if (!acpi_dev_ready_for_enumeration(device)) { device->flags.initialized = false; return -ENXIO; } diff --git a/drivers/acpi/device_sysfs.c b/drivers/acpi/device_sysfs.c index 23373faa35ec..a0256d2493a7 100644 --- a/drivers/acpi/device_sysfs.c +++ b/drivers/acpi/device_sysfs.c @@ -141,7 +141,7 @@ static int create_pnp_modalias(const struct acpi_device *acpi_dev, char *modalia struct acpi_hardware_id *id; /* Avoid unnecessarily loading modules for non present devices. */ - if (!acpi_device_is_present(acpi_dev)) + if (!acpi_dev_ready_for_enumeration(acpi_dev)) return 0; /* diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h index 866c7c4ed233..9388d4c8674a 100644 --- a/drivers/acpi/internal.h +++ b/drivers/acpi/internal.h @@ -62,6 +62,8 @@ void acpi_sysfs_add_hotplug_profile(struct acpi_hotplug_profile *hotplug, int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler *handler, const char *hotplug_profile_name); void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile *hotplug, bool val); +bool acpi_scan_check_handler(const struct acpi_device *adev, + struct acpi_scan_handler *handler); #ifdef CONFIG_DEBUG_FS extern struct dentry *acpi_debugfs_dir; @@ -107,7 +109,6 @@ int acpi_device_setup_files(struct acpi_device *dev); void acpi_device_remove_files(struct acpi_device *dev); void acpi_device_add_finalize(struct acpi_device *device); void acpi_free_pnp_ids(struct acpi_device_pnp *pnp); -bool acpi_device_is_present(const struct acpi_device *adev); bool acpi_device_is_battery(struct acpi_device *adev); bool acpi_device_is_first_physical_node(struct acpi_device *adev, const struct device *dev); @@ -119,6 +120,7 @@ int acpi_bus_register_early_device(int type); const struct acpi_device *acpi_companion_match(const struct device *dev); int __acpi_device_uevent_modalias(const struct acpi_device *adev, struct kobj_uevent_env *env); +bool acpi_device_is_processor(const struct acpi_device *adev); /* -------------------------------------------------------------------------- Power Resource diff --git a/drivers/acpi/property.c b/drivers/acpi/property.c index 6979a3f9f90a..14d6948fd88a 100644 --- a/drivers/acpi/property.c +++ b/drivers/acpi/property.c @@ -1420,7 +1420,7 @@ static bool acpi_fwnode_device_is_available(const struct fwnode_handle *fwnode) if (!is_acpi_device_node(fwnode)) return false; - return acpi_device_is_present(to_acpi_device_node(fwnode)); + return acpi_dev_ready_for_enumeration(to_acpi_device_node(fwnode)); } static const void * diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c index 02bb2cce423f..f94d1f744bcc 100644 --- a/drivers/acpi/scan.c +++ b/drivers/acpi/scan.c @@ -304,7 +304,7 @@ static int acpi_scan_device_check(struct acpi_device *adev) int error; acpi_bus_get_status(adev); - if (acpi_device_is_present(adev)) { + if (acpi_dev_ready_for_enumeration(adev)) { /* * This function is only called for device objects for which * matching scan handlers exist. The only situation in which @@ -338,7 +338,7 @@ static int acpi_scan_bus_check(struct acpi_device *adev, void *not_used) int error; acpi_bus_get_status(adev); - if (!acpi_device_is_present(adev)) { + if (!acpi_dev_ready_for_enumeration(adev)) { acpi_scan_device_not_enumerated(adev); return 0; } @@ -1913,11 +1913,6 @@ static bool acpi_device_should_be_hidden(acpi_handle handle) return true; } -bool acpi_device_is_present(const struct acpi_device *adev) -{ - return adev->status.present || adev->status.functional; -} - static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler, const char *idstr, const struct acpi_device_id **matchid) @@ -1938,6 +1933,18 @@ static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler, return false; } +bool acpi_scan_check_handler(const struct acpi_device *adev, + struct acpi_scan_handler *handler) +{ + struct acpi_hardware_id *hwid; + + list_for_each_entry(hwid, &adev->pnp.ids, list) + if (acpi_scan_handler_matching(handler, hwid->id, NULL)) + return true; + + return false; +} + static struct acpi_scan_handler *acpi_scan_match_handler(const char *idstr, const struct acpi_device_id **matchid) { @@ -2381,16 +2388,38 @@ EXPORT_SYMBOL_GPL(acpi_dev_clear_dependencies); * acpi_dev_ready_for_enumeration - Check if the ACPI device is ready for enumeration * @device: Pointer to the &struct acpi_device to check * - * Check if the device is present and has no unmet dependencies. + * Check if the device is functional or enabled and has no unmet dependencies. * - * Return true if the device is ready for enumeratino. Otherwise, return false. + * Return true if the device is ready for enumeration. Otherwise, return false. */ bool acpi_dev_ready_for_enumeration(const struct acpi_device *device) { if (device->flags.honor_deps && device->dep_unmet) return false; - return acpi_device_is_present(device); + /* + * ACPI 6.5's 6.3.7 "_STA (Device Status)" allows firmware to return + * (!present && functional) for certain types of devices that should be + * enumerated. Note that the enabled bit should not be set unless the + * present bit is set. + * + * However, limit this only to processor devices to reduce possible + * regressions with firmware. + */ + if (device->status.functional) + return true; + + if (!device->status.present) + return false; + + /* + * Fast path - if enabled is set, avoid the more expensive test to + * check whether this device is a processor. + */ + if (device->status.enabled) + return true; + + return !acpi_device_is_processor(device); } EXPORT_SYMBOL_GPL(acpi_dev_ready_for_enumeration); -- 2.30.2 -- RMK's Patch system: https://www.armlinux.org.uk/developer/patches/ FTTP is here! 80Mbps down 10Mbps up. Decent connectivity at last! From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 7A6D6C47077 for ; Thu, 11 Jan 2024 10:26:49 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=PUU92Ir2nAqCA/4IQbSo2hcYiQeqw99IBO9VACtF/+o=; b=JhDaHKpLRFwa6P weY0UOIBlUtue8lwaek7pSviTE9/h0l18N+kNmLSZbMcNLJz8S4osK9Jz4BcLo8JFd8FFYSyahFwn ANv1VdWML2W7CMbAyPa82ITS9+5VQtZmuDki52bd3uEzNOmFc8Bo4vx85Q5aZjDL5MyrzTjiTNgau E7ttmVU1E854RI2MnpNnVaISOdQAtVuxuDGTcH6se8xSp7JwvWqU4dy/sJdqltUl6tqWvrVpceMxm AN96KmDb//TgblEMLWapRbBAD7RU+5dqefQokRyxL71FjiTS/xybJIHJCtM+UT0dfSzbOvc0E2rUF ZzeaFfYOhIvSTCGUzx3w==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1rNsGi-00GzNP-03; Thu, 11 Jan 2024 10:26:36 +0000 Received: from pandora.armlinux.org.uk ([2001:4d48:ad52:32c8:5054:ff:fe00:142]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1rNsGc-00GzKt-0x; Thu, 11 Jan 2024 10:26:32 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=armlinux.org.uk; s=pandora-2019; h=Sender:In-Reply-To: Content-Transfer-Encoding:Content-Type:MIME-Version:References:Message-ID: Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=pDZNBMDn2+p6BZE/RBnm0b+eYsTn5JNJblyxFwWjLwk=; b=BYZDBswK7aOutgUjZLmuntw9C6 /yYD+iZVGMuStm1/46YVQPXa4jHRv6Z8U/xIa+GSGAwKVe34SOytP3Tx9xGkr72yv80XAwvbHV0bI sPo8k0+woUMNdoNp9uCH8fzeyQBvulH5ie2B1EvuuxPpAgFAxaDTDH6o16MImnNWfDZMt4MUpeydd 4Z4CGcT1w4kbIrcckE3oSmD9z4loTIDryx40alX5lGpP8DdcjKsh3Da0sjJdRoK9DB6NjVdi+llFX fk+jEeT0JRIaRq95XtNKWwqN3BzgOn30vMAbYjbfZoJNdvcaRvtz18LFYQCvuQFlzqBBOaeWenMGv Od4lYmnQ==; Received: from shell.armlinux.org.uk ([fd8f:7570:feb6:1:5054:ff:fe00:4ec]:57484) by pandora.armlinux.org.uk with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1rNsGM-0006OP-2L; Thu, 11 Jan 2024 10:26:14 +0000 Received: from linux by shell.armlinux.org.uk with local (Exim 4.94.2) (envelope-from ) id 1rNsGN-0006HT-CT; Thu, 11 Jan 2024 10:26:15 +0000 Date: Thu, 11 Jan 2024 10:26:15 +0000 From: "Russell King (Oracle)" To: Jonathan Cameron Cc: "Rafael J. Wysocki" , "Rafael J. Wysocki" , linux-pm@vger.kernel.org, loongarch@lists.linux.dev, linux-acpi@vger.kernel.org, linux-arch@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-riscv@lists.infradead.org, kvmarm@lists.linux.dev, x86@kernel.org, acpica-devel@lists.linuxfoundation.org, linux-csky@vger.kernel.org, linux-doc@vger.kernel.org, linux-ia64@vger.kernel.org, linux-parisc@vger.kernel.org, Salil Mehta , Jean-Philippe Brucker , jianyong.wu@arm.com, justin.he@arm.com, James Morse Subject: Re: [PATCH RFC v3 01/21] ACPI: Only enumerate enabled (or functional) devices Message-ID: References: <20231215161539.00000940@Huawei.com> <5760569.DvuYhMxLoT@kreacher> <20240102143925.00004361@Huawei.com> <20240111101949.000075dc@Huawei.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20240111101949.000075dc@Huawei.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240111_022630_494668_E6CB0FAA X-CRM114-Status: GOOD ( 55.14 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org T24gVGh1LCBKYW4gMTEsIDIwMjQgYXQgMTA6MTk6NDlBTSArMDAwMCwgSm9uYXRoYW4gQ2FtZXJv biB3cm90ZToKPiBPbiBUdWUsIDIgSmFuIDIwMjQgMTQ6Mzk6MjUgKzAwMDAKPiBKb25hdGhhbiBD YW1lcm9uIDxKb25hdGhhbi5DYW1lcm9uQEh1YXdlaS5jb20+IHdyb3RlOgo+IAo+ID4gT24gRnJp LCAxNSBEZWMgMjAyMyAyMDo0NzozMSArMDEwMAo+ID4gIlJhZmFlbCBKLiBXeXNvY2tpIiA8cmp3 QHJqd3lzb2NraS5uZXQ+IHdyb3RlOgo+ID4gCj4gPiA+IE9uIEZyaWRheSwgRGVjZW1iZXIgMTUs IDIwMjMgNToxNTozOSBQTSBDRVQgSm9uYXRoYW4gQ2FtZXJvbiB3cm90ZTogIAo+ID4gPiA+IE9u IEZyaSwgMTUgRGVjIDIwMjMgMTU6MzE6NTUgKzAwMDAKPiA+ID4gPiAiUnVzc2VsbCBLaW5nIChP cmFjbGUpIiA8bGludXhAYXJtbGludXgub3JnLnVrPiB3cm90ZToKPiA+ID4gPiAgICAgCj4gPiA+ ID4gPiBPbiBUaHUsIERlYyAxNCwgMjAyMyBhdCAwNzozNzoxMFBNICswMTAwLCBSYWZhZWwgSi4g V3lzb2NraSB3cm90ZTogICAgCj4gPiA+ID4gPiA+IE9uIFRodSwgRGVjIDE0LCAyMDIzIGF0IDc6 MTbigK9QTSBSYWZhZWwgSi4gV3lzb2NraSA8cmFmYWVsQGtlcm5lbC5vcmc+IHdyb3RlOiAgICAg IAo+ID4gPiA+ID4gPiA+Cj4gPiA+ID4gPiA+ID4gT24gVGh1LCBEZWMgMTQsIDIwMjMgYXQgNzox MOKAr1BNIFJ1c3NlbGwgS2luZyAoT3JhY2xlKQo+ID4gPiA+ID4gPiA+IDxsaW51eEBhcm1saW51 eC5vcmcudWs+IHdyb3RlOiAgICAgIAo+ID4gPiA+ID4gPiA+ID4gSSBndWVzcyB3ZSBuZWVkIHNv bWV0aGluZyBsaWtlOgo+ID4gPiA+ID4gPiA+ID4KPiA+ID4gPiA+ID4gPiA+ICAgICAgICAgaWYg KGRldmljZS0+c3RhdHVzLnByZXNlbnQpCj4gPiA+ID4gPiA+ID4gPiAgICAgICAgICAgICAgICAg cmV0dXJuIGRldmljZS0+ZGV2aWNlX3R5cGUgIT0gQUNQSV9CVVNfVFlQRV9QUk9DRVNTT1IgfHwK PiA+ID4gPiA+ID4gPiA+ICAgICAgICAgICAgICAgICAgICAgICAgZGV2aWNlLT5zdGF0dXMuZW5h YmxlZDsKPiA+ID4gPiA+ID4gPiA+ICAgICAgICAgZWxzZQo+ID4gPiA+ID4gPiA+ID4gICAgICAg ICAgICAgICAgIHJldHVybiBkZXZpY2UtPnN0YXR1cy5mdW5jdGlvbmFsOwo+ID4gPiA+ID4gPiA+ ID4KPiA+ID4gPiA+ID4gPiA+IHNvIHdlIG9ubHkgY2hlY2sgZGV2aWNlLT5zdGF0dXMuZW5hYmxl ZCBmb3IgcHJvY2Vzc29yLXR5cGUgZGV2aWNlcz8gICAgICAKPiA+ID4gPiA+ID4gPgo+ID4gPiA+ ID4gPiA+IFllcywgc29tZXRoaW5nIGxpa2UgdGhpcy4gICAgICAKPiA+ID4gPiA+ID4gCj4gPiA+ ID4gPiA+IEhvd2V2ZXIsIHRoYXQgaXMgbm90IHN1ZmZpY2llbnQsIGJlY2F1c2UgdGhlcmUgYXJl Cj4gPiA+ID4gPiA+IEFDUElfQlVTX1RZUEVfREVWSUNFIGRldmljZXMgcmVwcmVzZW50aW5nIHBy b2Nlc3NvcnMuCj4gPiA+ID4gPiA+IAo+ID4gPiA+ID4gPiBJJ20gbm90IHN1cmUgYWJvdXQgYSBj bGVhbiB3YXkgdG8gZG8gaXQgQVRNLiAgICAgIAo+ID4gPiA+ID4gCj4gPiA+ID4gPiBPaywgaG93 IGFib3V0Ogo+ID4gPiA+ID4gCj4gPiA+ID4gPiBzdGF0aWMgYm9vbCBhY3BpX2Rldl9pc19wcm9j ZXNzb3IoY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpCj4gPiA+ID4gPiB7Cj4gPiA+ ID4gPiAJc3RydWN0IGFjcGlfaGFyZHdhcmVfaWQgKmh3aWQ7Cj4gPiA+ID4gPiAKPiA+ID4gPiA+ IAlpZiAoZGV2aWNlLT5kZXZpY2VfdHlwZSA9PSBBQ1BJX0JVU19UWVBFX1BST0NFU1NPUikKPiA+ ID4gPiA+IAkJcmV0dXJuIHRydWU7Cj4gPiA+ID4gPiAKPiA+ID4gPiA+IAlpZiAoZGV2aWNlLT5k ZXZpY2VfdHlwZSAhPSBBQ1BJX0JVU19UWVBFX0RFVklDRSkKPiA+ID4gPiA+IAkJcmV0dXJuIGZh bHNlOwo+ID4gPiA+ID4gCj4gPiA+ID4gPiAJbGlzdF9mb3JfZWFjaF9lbnRyeShod2lkLCAmZGV2 aWNlLT5wbnAuaWRzLCBsaXN0KQo+ID4gPiA+ID4gCQlpZiAoIXN0cmNtcChBQ1BJX1BST0NFU1NP Ul9PQkpFQ1RfSElELCBod2lkLT5pZCkgfHwKPiA+ID4gPiA+IAkJICAgICFzdHJjbXAoQUNQSV9Q Uk9DRVNTT1JfREVWSUNFX0hJRCwgaHdpZC0+aWQpKQo+ID4gPiA+ID4gCQkJcmV0dXJuIHRydWU7 Cj4gPiA+ID4gPiAKPiA+ID4gPiA+IAlyZXR1cm4gZmFsc2U7Cj4gPiA+ID4gPiB9Cj4gPiA+ID4g PiAKPiA+ID4gPiA+IGFuZCB0aGVuOgo+ID4gPiA+ID4gCj4gPiA+ID4gPiAJaWYgKGRldmljZS0+ c3RhdHVzLnByZXNlbnQpCj4gPiA+ID4gPiAJCXJldHVybiAhYWNwaV9kZXZfaXNfcHJvY2Vzc29y KGRldmljZSkgfHwgZGV2aWNlLT5zdGF0dXMuZW5hYmxlZDsKPiA+ID4gPiA+IAllbHNlCj4gPiA+ ID4gPiAJCXJldHVybiBkZXZpY2UtPnN0YXR1cy5mdW5jdGlvbmFsOwo+ID4gPiA+ID4gCj4gPiA+ ID4gPiA/Cj4gPiA+ID4gPiAgICAgCj4gPiA+ID4gQ2hhbmdpbmcgaXQgdG8gQ1BVIG9ubHkgZm9y IG5vdyBtYWtlcyBzZW5zZSB0byBtZSBhbmQgSSB0aGluayB0aGlzIGNvZGUgc25pcHBldCBzaG91 bGQgZG8gdGhlCj4gPiA+ID4gam9iLiAgTmljZSBhbmQgc2ltcGxlLiAgICAKPiA+ID4gCj4gPiA+ IFdlbGwsIGV4Y2VwdCB0aGF0IGl0IGRvZXMgY2hlY2tzIHRoYXQgYXJlIGRvbmUgZWxzZXdoZXJl IHNsaWdodGx5Cj4gPiA+IGRpZmZlcmVudGx5LCB3aGljaCBmcm9tIHRoZSBtYWludGVuYW5jZSBQ T1YgaXMgbm90IG5pY2UuCj4gPiA+IAo+ID4gPiBNYXliZSBzb21ldGhpbmcgbGlrZSB0aGUgYXBw ZW5kZWQgcGF0Y2ggKHVudGVzdGVkKS4gIAo+ID4gCj4gPiBIaSBSYWZhZWwsCj4gPiAKPiA+IEFz IGZhciBhcyBJIGNhbiBzZWUgdGhhdCdzIGZ1bmN0aW9uYWxseSBlcXVpdmFsZW50LCBzbyBsb29r cyBnb29kIHRvIG1lLgo+ID4gSSdtIG5vdCBzZXQgdXAgdG8gdGVzdCB0aGlzIHRvZGF5IHRob3Vn aCwgc28gd2lsbCBkZWZlciB0byBSdXNzZWxsIG9uIHdoZXRoZXIKPiA+IHRoZXJlIGlzIGFueXRo aW5nIG1pc3NpbmcKPiA+IAo+ID4gVGhhbmtzIGZvciBwdXR0aW5nIHRoaXMgdG9nZXRoZXIuCj4g Cj4gVGhpcyBpcyByYXRoZXIgZW1iYXJyYXNzaW5nLi4uCj4gCj4gSSBzcGFuIHRoaXMgdXAgb24g YSBRRU1VIGluc3RhbmNlIHdpdGggc29tZSBwcmludHMgdG8gZmluZCBvdXQgd2UgbmVlZAo+IHRo ZSAhYWNwaV9kZXZpY2VfaXNfcHJvY2Vzc29yKCkgcmVzdHJpY3Rpb24uCj4gT24gbXkgJ3JhbmRv bScgdGVzdCBzZXR1cCBpdCBmYWlscyBvbiBvbmUgZGV2aWNlLiBBQ1BJMDAxNyAtIHdoaWNoIEkK PiBoYXBwZW4gdG8ga25vdyByYXRoZXIgd2VsbC4gSXQncyB0aGUgd2VpcmQgcHNldWRvIGRldmlj ZSB0aGF0IGxldHMKPiBhIENYTCBhd2FyZSBPUyBrbm93IHRoZXJlIGlzIGEgQ0VEVCB0YWJsZSB0 byBwcm9iZS4KPiAKPiBXaGlsc3QgSSByZWFsbHkgZG9uJ3QgbGlrZSB0aGF0IGhhY2sgKGl0IGlz IGFsbCBhYm91dCBtYWtpbmcgc29mdHdhcmUKPiBkaXN0cmlidXRpb24gb2Ygb3V0IG9mIHRyZWUg bW9kdWxlcyBlYXNpZXIgcmF0aGVyIHRoYW4gc29tZXRoaW5nCj4gZnVuZGFtZW50YWwpLCBJJ20g dGhlIENYTCBRRU1VIG1haW50YWluZXIgOigKPiAKPiBXaWxsIGZpeCB0aGF0LCBidXQgaXQgc2hv d3MgdGhlcmUgaXMgYXQgbGVhc3Qgb25lIGJyb2tlbiBmaXJtd2FyZSBvdXQKPiB0aGVyZS4KPiAK PiBPbiBwbHVzIHNpZGUsIFJhZmFlbCdzIGNvZGUgc2VlbXMgdG8gd29yayBhcyBleHBlY3RlZCBh bmQgbGV0cyB0aGF0Cj4gYnVnZ3kgZmlyd21hcmUgY2Fycnkgb24gd29ya2luZyA6KSBTbyBsZXRz IHByZXRlbmQgdGhlIGJ1ZyBpbiBxZW11Cj4gaXMgYSBkZWxpYmVyYXRlIHRlc3QgY2FzZSEKCkxv bCwgdGhhbmtzIGZvciBhIHRlc3QgY2FzZSBhbmQgc2hvd2luZyB0aGF0IFJhZmFlbCdzIGFwcHJv YWNoIGlzCmluZGVlZCBuZWNlc3NhcnkuCgpXb3VsZCB5b3VyIHRlc3QgcXVhbGl0eSBmb3IgYSB0 ZXN0ZWQtYnkgZm9yIHRoaXM/IEZvciByZWZlcmVuY2UsIHRoaXMKaXMgbXkgY3VycmVudCB2ZXJz aW9uIGJlbG93IHdpdGggUmFmYWVsJ3MgdXBkYXRlOgoKODw9PT09CkZyb206IFJ1c3NlbGwgS2lu ZyAoT3JhY2xlKSA8cm1rK2tlcm5lbEBhcm1saW51eC5vcmcudWs+ClN1YmplY3Q6IFtQQVRDSF0g QUNQSTogT25seSBlbnVtZXJhdGUgZW5hYmxlZCAob3IgZnVuY3Rpb25hbCkgcHJvY2Vzc29yCiBk ZXZpY2VzCgpGcm9tOiBKYW1lcyBNb3JzZSA8amFtZXMubW9yc2VAYXJtLmNvbT4KClRvZGF5IHRo ZSBBQ1BJIGVudW1lcmF0aW9uIGNvZGUgJ3Zpc2l0cycgYWxsIGRldmljZXMgdGhhdCBhcmUgcHJl c2VudC4KClRoaXMgaXMgYSBwcm9ibGVtIGZvciBhcm02NCwgd2hlcmUgQ1BVcyBhcmUgYWx3YXlz IHByZXNlbnQsIGJ1dCBub3QKYWx3YXlzIGVuYWJsZWQuIFdoZW4gYSBkZXZpY2UtY2hlY2sgb2Nj dXJzIGJlY2F1c2UgdGhlIGZpcm13YXJlLXBvbGljeQpoYXMgY2hhbmdlZCBhbmQgYSBDUFUgaXMg bm93IGVuYWJsZWQsIHRoZSBmb2xsb3dpbmcgZXJyb3Igb2NjdXJzOgp8IGFjcGkgQUNQSTAwMDc6 NDg6IEVudW1lcmF0aW9uIGZhaWx1cmUKClRoaXMgaXMgdWx0aW1hdGVseSBiZWNhdXNlIGFjcGlf ZGV2X3JlYWR5X2Zvcl9lbnVtZXJhdGlvbigpIHJldHVybnMKdHJ1ZSBmb3IgYSBkZXZpY2UgdGhh dCBpcyBub3QgZW5hYmxlZC4gVGhlIEFDUEkgUHJvY2Vzc29yIGRyaXZlcgp3aWxsIG5vdCByZWdp c3RlciBzdWNoIENQVXMgYXMgdGhleSBhcmUgbm90ICdkZWNvZGluZyB0aGVpciByZXNvdXJjZXMn LgoKQUNQSSBhbGxvd3MgYSBkZXZpY2UgdG8gYmUgZnVuY3Rpb25hbCBpbnN0ZWFkIG9mIG1haW50 YWluaW5nIHRoZQpwcmVzZW50IGFuZCBlbmFibGVkIGJpdCwgYnV0IHdlIGNhbid0IHNpbXBseSBj aGVjayB0aGUgZW5hYmxlZCBiaXQKZm9yIGFsbCBkZXZpY2VzIHNpbmNlIGZpcm13YXJlIGNhbiBi ZSBidWdneS4KCklmIEFDUEkgaW5kaWNhdGVzIHRoYXQgdGhlIGRldmljZSBpcyBwcmVzZW50IGFu ZCBlbmFibGVkLCB0aGVuIGFsbCB3ZWxsCmFuZCBnb29kLCB3ZSBjYW4gZW51bWF0ZSBpdC4gSG93 ZXZlciwgaWYgdGhlIGRldmljZSBpcyBwcmVzZW50IGFuZCBub3QKZW5hYmxlZCwgdGhlbiB3ZSBh bHNvIGNoZWNrIHdoZXRoZXIgdGhlIGRldmljZSBpcyBhIHByb2Nlc3NvciBkZXZpY2UKdG8gbGlt aXQgdGhlIGltcGFjdCBvZiB0aGlzIG5ldyBjaGVjayB0byBqdXN0IHByb2Nlc3NvciBkZXZpY2Vz LgoKVGhpcyBhdm9pZHMgZW51bWVyYXRpbmcgcHJlc2VudCAmJiBmdW5jdGlvbmFsIHByb2Nlc3Nv ciBkZXZpY2VzIHRoYXQKYXJlIG5vdCBlbmFibGVkLgoKU2lnbmVkLW9mZi1ieTogSmFtZXMgTW9y c2UgPGphbWVzLm1vcnNlQGFybS5jb20+CkNvLWRldmVsb3BlZC1ieTogUmFmYWVsIEouIFd5c29j a2kgPHJqd0Byand5c29ja2kubmV0PgpTaWduZWQtb2ZmLWJ5OiBSdXNzZWxsIEtpbmcgKE9yYWNs ZSkgPHJtaytrZXJuZWxAYXJtbGludXgub3JnLnVrPgotLS0KQ2hhbmdlcyBzaW5jZSBSRkMgdjI6 CiAqIEluY29ycG9yYXRlIGNvbW1lbnQgc3VnZ2VzdGlvbiBieSBHYXZpbiBTaGFuLgpDaGFuZ2Vz IHNpbmNlIFJGQyB2MzoKICogRml4ZWQgInNlcnQiIHR5cG8uCkNoYW5nZXMgc2luY2UgUkZDIHYz IChzbWFsbGVyIHNlcmllcyk6CiAqIFJlc3RyaWN0IGNoZWNraW5nIHRoZSBlbmFibGVkIGJpdCB0 byBwcm9jZXNzb3IgZGV2aWNlcywgdXBkYXRlCiAgIGNvbW1pdCBjb21tZW50cy4KICogVXNlIFJh ZmFlbCdzIHN1Z2dlc3Rpb24gaW4KICAgaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvci81NzYwNTY5 LkR2dVloTXhMb1RAa3JlYWNoZXIKLS0tCiBkcml2ZXJzL2FjcGkvYWNwaV9wcm9jZXNzb3IuYyB8 IDExICsrKysrKysrCiBkcml2ZXJzL2FjcGkvZGV2aWNlX3BtLmMgICAgICB8ICAyICstCiBkcml2 ZXJzL2FjcGkvZGV2aWNlX3N5c2ZzLmMgICB8ICAyICstCiBkcml2ZXJzL2FjcGkvaW50ZXJuYWwu aCAgICAgICB8ICA0ICsrLQogZHJpdmVycy9hY3BpL3Byb3BlcnR5LmMgICAgICAgfCAgMiArLQog ZHJpdmVycy9hY3BpL3NjYW4uYyAgICAgICAgICAgfCA0OSArKysrKysrKysrKysrKysrKysrKysr KysrKysrLS0tLS0tLQogNiBmaWxlcyBjaGFuZ2VkLCA1NiBpbnNlcnRpb25zKCspLCAxNCBkZWxl dGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaV9wcm9jZXNzb3IuYyBiL2Ry aXZlcnMvYWNwaS9hY3BpX3Byb2Nlc3Nvci5jCmluZGV4IDRmZTJlZjU0MDg4Yy4uY2Y3YzFjY2E2 OWRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaV9wcm9jZXNzb3IuYworKysgYi9kcml2 ZXJzL2FjcGkvYWNwaV9wcm9jZXNzb3IuYwpAQCAtNjI2LDYgKzYyNiwxNyBAQCBzdGF0aWMgc3Ry dWN0IGFjcGlfc2Nhbl9oYW5kbGVyIHByb2Nlc3Nvcl9oYW5kbGVyID0gewogCX0sCiB9OwogCiti b29sIGFjcGlfZGV2aWNlX2lzX3Byb2Nlc3Nvcihjb25zdCBzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFk ZXYpCit7CisJaWYgKGFkZXYtPmRldmljZV90eXBlID09IEFDUElfQlVTX1RZUEVfUFJPQ0VTU09S KQorCQlyZXR1cm4gdHJ1ZTsKKworCWlmIChhZGV2LT5kZXZpY2VfdHlwZSAhPSBBQ1BJX0JVU19U WVBFX0RFVklDRSkKKwkJcmV0dXJuIGZhbHNlOworCisJcmV0dXJuIGFjcGlfc2Nhbl9jaGVja19o YW5kbGVyKGFkZXYsICZwcm9jZXNzb3JfaGFuZGxlcik7Cit9CisKIHN0YXRpYyBpbnQgYWNwaV9w cm9jZXNzb3JfY29udGFpbmVyX2F0dGFjaChzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldiwKIAkJCQkJ ICAgY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlX2lkICppZCkKIHsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvYWNwaS9kZXZpY2VfcG0uYyBiL2RyaXZlcnMvYWNwaS9kZXZpY2VfcG0uYwppbmRleCAzYjRk MDQ4YzQ5NDEuLmUzYzgwZjNiM2I1NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2RldmljZV9w bS5jCisrKyBiL2RyaXZlcnMvYWNwaS9kZXZpY2VfcG0uYwpAQCAtMzEzLDcgKzMxMyw3IEBAIGlu dCBhY3BpX2J1c19pbml0X3Bvd2VyKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlKQogCQlyZXR1 cm4gLUVJTlZBTDsKIAogCWRldmljZS0+cG93ZXIuc3RhdGUgPSBBQ1BJX1NUQVRFX1VOS05PV047 Ci0JaWYgKCFhY3BpX2RldmljZV9pc19wcmVzZW50KGRldmljZSkpIHsKKwlpZiAoIWFjcGlfZGV2 X3JlYWR5X2Zvcl9lbnVtZXJhdGlvbihkZXZpY2UpKSB7CiAJCWRldmljZS0+ZmxhZ3MuaW5pdGlh bGl6ZWQgPSBmYWxzZTsKIAkJcmV0dXJuIC1FTlhJTzsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJz L2FjcGkvZGV2aWNlX3N5c2ZzLmMgYi9kcml2ZXJzL2FjcGkvZGV2aWNlX3N5c2ZzLmMKaW5kZXgg MjMzNzNmYWEzNWVjLi5hMDI1NmQyNDkzYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9kZXZp Y2Vfc3lzZnMuYworKysgYi9kcml2ZXJzL2FjcGkvZGV2aWNlX3N5c2ZzLmMKQEAgLTE0MSw3ICsx NDEsNyBAQCBzdGF0aWMgaW50IGNyZWF0ZV9wbnBfbW9kYWxpYXMoY29uc3Qgc3RydWN0IGFjcGlf ZGV2aWNlICphY3BpX2RldiwgY2hhciAqbW9kYWxpYQogCXN0cnVjdCBhY3BpX2hhcmR3YXJlX2lk ICppZDsKIAogCS8qIEF2b2lkIHVubmVjZXNzYXJpbHkgbG9hZGluZyBtb2R1bGVzIGZvciBub24g cHJlc2VudCBkZXZpY2VzLiAqLwotCWlmICghYWNwaV9kZXZpY2VfaXNfcHJlc2VudChhY3BpX2Rl dikpCisJaWYgKCFhY3BpX2Rldl9yZWFkeV9mb3JfZW51bWVyYXRpb24oYWNwaV9kZXYpKQogCQly ZXR1cm4gMDsKIAogCS8qCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvaW50ZXJuYWwuaCBiL2Ry aXZlcnMvYWNwaS9pbnRlcm5hbC5oCmluZGV4IDg2NmM3YzRlZDIzMy4uOTM4OGQ0Yzg2NzRhIDEw MDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvaW50ZXJuYWwuaAorKysgYi9kcml2ZXJzL2FjcGkvaW50 ZXJuYWwuaApAQCAtNjIsNiArNjIsOCBAQCB2b2lkIGFjcGlfc3lzZnNfYWRkX2hvdHBsdWdfcHJv ZmlsZShzdHJ1Y3QgYWNwaV9ob3RwbHVnX3Byb2ZpbGUgKmhvdHBsdWcsCiBpbnQgYWNwaV9zY2Fu X2FkZF9oYW5kbGVyX3dpdGhfaG90cGx1ZyhzdHJ1Y3QgYWNwaV9zY2FuX2hhbmRsZXIgKmhhbmRs ZXIsCiAJCQkJICAgICAgIGNvbnN0IGNoYXIgKmhvdHBsdWdfcHJvZmlsZV9uYW1lKTsKIHZvaWQg YWNwaV9zY2FuX2hvdHBsdWdfZW5hYmxlZChzdHJ1Y3QgYWNwaV9ob3RwbHVnX3Byb2ZpbGUgKmhv dHBsdWcsIGJvb2wgdmFsKTsKK2Jvb2wgYWNwaV9zY2FuX2NoZWNrX2hhbmRsZXIoY29uc3Qgc3Ry dWN0IGFjcGlfZGV2aWNlICphZGV2LAorCQkJICAgICBzdHJ1Y3QgYWNwaV9zY2FuX2hhbmRsZXIg KmhhbmRsZXIpOwogCiAjaWZkZWYgQ09ORklHX0RFQlVHX0ZTCiBleHRlcm4gc3RydWN0IGRlbnRy eSAqYWNwaV9kZWJ1Z2ZzX2RpcjsKQEAgLTEwNyw3ICsxMDksNiBAQCBpbnQgYWNwaV9kZXZpY2Vf c2V0dXBfZmlsZXMoc3RydWN0IGFjcGlfZGV2aWNlICpkZXYpOwogdm9pZCBhY3BpX2RldmljZV9y ZW1vdmVfZmlsZXMoc3RydWN0IGFjcGlfZGV2aWNlICpkZXYpOwogdm9pZCBhY3BpX2RldmljZV9h ZGRfZmluYWxpemUoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpOwogdm9pZCBhY3BpX2ZyZWVf cG5wX2lkcyhzdHJ1Y3QgYWNwaV9kZXZpY2VfcG5wICpwbnApOwotYm9vbCBhY3BpX2RldmljZV9p c19wcmVzZW50KGNvbnN0IHN0cnVjdCBhY3BpX2RldmljZSAqYWRldik7CiBib29sIGFjcGlfZGV2 aWNlX2lzX2JhdHRlcnkoc3RydWN0IGFjcGlfZGV2aWNlICphZGV2KTsKIGJvb2wgYWNwaV9kZXZp Y2VfaXNfZmlyc3RfcGh5c2ljYWxfbm9kZShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFkZXYsCiAJCQkJ CWNvbnN0IHN0cnVjdCBkZXZpY2UgKmRldik7CkBAIC0xMTksNiArMTIwLDcgQEAgaW50IGFjcGlf YnVzX3JlZ2lzdGVyX2Vhcmx5X2RldmljZShpbnQgdHlwZSk7CiBjb25zdCBzdHJ1Y3QgYWNwaV9k ZXZpY2UgKmFjcGlfY29tcGFuaW9uX21hdGNoKGNvbnN0IHN0cnVjdCBkZXZpY2UgKmRldik7CiBp bnQgX19hY3BpX2RldmljZV91ZXZlbnRfbW9kYWxpYXMoY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNl ICphZGV2LAogCQkJCSAgc3RydWN0IGtvYmpfdWV2ZW50X2VudiAqZW52KTsKK2Jvb2wgYWNwaV9k ZXZpY2VfaXNfcHJvY2Vzc29yKGNvbnN0IHN0cnVjdCBhY3BpX2RldmljZSAqYWRldik7CiAKIC8q IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUG93 ZXIgUmVzb3VyY2UKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9wcm9wZXJ0eS5jIGIvZHJpdmVy cy9hY3BpL3Byb3BlcnR5LmMKaW5kZXggNjk3OWEzZjlmOTBhLi4xNGQ2OTQ4ZmQ4OGEgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvYWNwaS9wcm9wZXJ0eS5jCisrKyBiL2RyaXZlcnMvYWNwaS9wcm9wZXJ0 eS5jCkBAIC0xNDIwLDcgKzE0MjAsNyBAQCBzdGF0aWMgYm9vbCBhY3BpX2Z3bm9kZV9kZXZpY2Vf aXNfYXZhaWxhYmxlKGNvbnN0IHN0cnVjdCBmd25vZGVfaGFuZGxlICpmd25vZGUpCiAJaWYgKCFp c19hY3BpX2RldmljZV9ub2RlKGZ3bm9kZSkpCiAJCXJldHVybiBmYWxzZTsKIAotCXJldHVybiBh Y3BpX2RldmljZV9pc19wcmVzZW50KHRvX2FjcGlfZGV2aWNlX25vZGUoZndub2RlKSk7CisJcmV0 dXJuIGFjcGlfZGV2X3JlYWR5X2Zvcl9lbnVtZXJhdGlvbih0b19hY3BpX2RldmljZV9ub2RlKGZ3 bm9kZSkpOwogfQogCiBzdGF0aWMgY29uc3Qgdm9pZCAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Fj cGkvc2Nhbi5jIGIvZHJpdmVycy9hY3BpL3NjYW4uYwppbmRleCAwMmJiMmNjZTQyM2YuLmY5NGQx Zjc0NGJjYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL3NjYW4uYworKysgYi9kcml2ZXJzL2Fj cGkvc2Nhbi5jCkBAIC0zMDQsNyArMzA0LDcgQEAgc3RhdGljIGludCBhY3BpX3NjYW5fZGV2aWNl X2NoZWNrKHN0cnVjdCBhY3BpX2RldmljZSAqYWRldikKIAlpbnQgZXJyb3I7CiAKIAlhY3BpX2J1 c19nZXRfc3RhdHVzKGFkZXYpOwotCWlmIChhY3BpX2RldmljZV9pc19wcmVzZW50KGFkZXYpKSB7 CisJaWYgKGFjcGlfZGV2X3JlYWR5X2Zvcl9lbnVtZXJhdGlvbihhZGV2KSkgewogCQkvKgogCQkg KiBUaGlzIGZ1bmN0aW9uIGlzIG9ubHkgY2FsbGVkIGZvciBkZXZpY2Ugb2JqZWN0cyBmb3Igd2hp Y2gKIAkJICogbWF0Y2hpbmcgc2NhbiBoYW5kbGVycyBleGlzdC4gIFRoZSBvbmx5IHNpdHVhdGlv biBpbiB3aGljaApAQCAtMzM4LDcgKzMzOCw3IEBAIHN0YXRpYyBpbnQgYWNwaV9zY2FuX2J1c19j aGVjayhzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFkZXYsIHZvaWQgKm5vdF91c2VkKQogCWludCBlcnJv cjsKIAogCWFjcGlfYnVzX2dldF9zdGF0dXMoYWRldik7Ci0JaWYgKCFhY3BpX2RldmljZV9pc19w cmVzZW50KGFkZXYpKSB7CisJaWYgKCFhY3BpX2Rldl9yZWFkeV9mb3JfZW51bWVyYXRpb24oYWRl dikpIHsKIAkJYWNwaV9zY2FuX2RldmljZV9ub3RfZW51bWVyYXRlZChhZGV2KTsKIAkJcmV0dXJu IDA7CiAJfQpAQCAtMTkxMywxMSArMTkxMyw2IEBAIHN0YXRpYyBib29sIGFjcGlfZGV2aWNlX3No b3VsZF9iZV9oaWRkZW4oYWNwaV9oYW5kbGUgaGFuZGxlKQogCXJldHVybiB0cnVlOwogfQogCi1i b29sIGFjcGlfZGV2aWNlX2lzX3ByZXNlbnQoY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlICphZGV2 KQotewotCXJldHVybiBhZGV2LT5zdGF0dXMucHJlc2VudCB8fCBhZGV2LT5zdGF0dXMuZnVuY3Rp b25hbDsKLX0KLQogc3RhdGljIGJvb2wgYWNwaV9zY2FuX2hhbmRsZXJfbWF0Y2hpbmcoc3RydWN0 IGFjcGlfc2Nhbl9oYW5kbGVyICpoYW5kbGVyLAogCQkJCSAgICAgICBjb25zdCBjaGFyICppZHN0 ciwKIAkJCQkgICAgICAgY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlX2lkICoqbWF0Y2hpZCkKQEAg LTE5MzgsNiArMTkzMywxOCBAQCBzdGF0aWMgYm9vbCBhY3BpX3NjYW5faGFuZGxlcl9tYXRjaGlu ZyhzdHJ1Y3QgYWNwaV9zY2FuX2hhbmRsZXIgKmhhbmRsZXIsCiAJcmV0dXJuIGZhbHNlOwogfQog Citib29sIGFjcGlfc2Nhbl9jaGVja19oYW5kbGVyKGNvbnN0IHN0cnVjdCBhY3BpX2RldmljZSAq YWRldiwKKwkJCSAgICAgc3RydWN0IGFjcGlfc2Nhbl9oYW5kbGVyICpoYW5kbGVyKQoreworCXN0 cnVjdCBhY3BpX2hhcmR3YXJlX2lkICpod2lkOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShod2lk LCAmYWRldi0+cG5wLmlkcywgbGlzdCkKKwkJaWYgKGFjcGlfc2Nhbl9oYW5kbGVyX21hdGNoaW5n KGhhbmRsZXIsIGh3aWQtPmlkLCBOVUxMKSkKKwkJCXJldHVybiB0cnVlOworCisJcmV0dXJuIGZh bHNlOworfQorCiBzdGF0aWMgc3RydWN0IGFjcGlfc2Nhbl9oYW5kbGVyICphY3BpX3NjYW5fbWF0 Y2hfaGFuZGxlcihjb25zdCBjaGFyICppZHN0ciwKIAkJCQkJY29uc3Qgc3RydWN0IGFjcGlfZGV2 aWNlX2lkICoqbWF0Y2hpZCkKIHsKQEAgLTIzODEsMTYgKzIzODgsMzggQEAgRVhQT1JUX1NZTUJP TF9HUEwoYWNwaV9kZXZfY2xlYXJfZGVwZW5kZW5jaWVzKTsKICAqIGFjcGlfZGV2X3JlYWR5X2Zv cl9lbnVtZXJhdGlvbiAtIENoZWNrIGlmIHRoZSBBQ1BJIGRldmljZSBpcyByZWFkeSBmb3IgZW51 bWVyYXRpb24KICAqIEBkZXZpY2U6IFBvaW50ZXIgdG8gdGhlICZzdHJ1Y3QgYWNwaV9kZXZpY2Ug dG8gY2hlY2sKICAqCi0gKiBDaGVjayBpZiB0aGUgZGV2aWNlIGlzIHByZXNlbnQgYW5kIGhhcyBu byB1bm1ldCBkZXBlbmRlbmNpZXMuCisgKiBDaGVjayBpZiB0aGUgZGV2aWNlIGlzIGZ1bmN0aW9u YWwgb3IgZW5hYmxlZCBhbmQgaGFzIG5vIHVubWV0IGRlcGVuZGVuY2llcy4KICAqCi0gKiBSZXR1 cm4gdHJ1ZSBpZiB0aGUgZGV2aWNlIGlzIHJlYWR5IGZvciBlbnVtZXJhdGluby4gT3RoZXJ3aXNl LCByZXR1cm4gZmFsc2UuCisgKiBSZXR1cm4gdHJ1ZSBpZiB0aGUgZGV2aWNlIGlzIHJlYWR5IGZv ciBlbnVtZXJhdGlvbi4gT3RoZXJ3aXNlLCByZXR1cm4gZmFsc2UuCiAgKi8KIGJvb2wgYWNwaV9k ZXZfcmVhZHlfZm9yX2VudW1lcmF0aW9uKGNvbnN0IHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNl KQogewogCWlmIChkZXZpY2UtPmZsYWdzLmhvbm9yX2RlcHMgJiYgZGV2aWNlLT5kZXBfdW5tZXQp CiAJCXJldHVybiBmYWxzZTsKIAotCXJldHVybiBhY3BpX2RldmljZV9pc19wcmVzZW50KGRldmlj ZSk7CisJLyoKKwkgKiBBQ1BJIDYuNSdzIDYuMy43ICJfU1RBIChEZXZpY2UgU3RhdHVzKSIgYWxs b3dzIGZpcm13YXJlIHRvIHJldHVybgorCSAqICghcHJlc2VudCAmJiBmdW5jdGlvbmFsKSBmb3Ig Y2VydGFpbiB0eXBlcyBvZiBkZXZpY2VzIHRoYXQgc2hvdWxkIGJlCisJICogZW51bWVyYXRlZC4g Tm90ZSB0aGF0IHRoZSBlbmFibGVkIGJpdCBzaG91bGQgbm90IGJlIHNldCB1bmxlc3MgdGhlCisJ ICogcHJlc2VudCBiaXQgaXMgc2V0LgorCSAqCisJICogSG93ZXZlciwgbGltaXQgdGhpcyBvbmx5 IHRvIHByb2Nlc3NvciBkZXZpY2VzIHRvIHJlZHVjZSBwb3NzaWJsZQorCSAqIHJlZ3Jlc3Npb25z IHdpdGggZmlybXdhcmUuCisJICovCisJaWYgKGRldmljZS0+c3RhdHVzLmZ1bmN0aW9uYWwpCisJ CXJldHVybiB0cnVlOworCisJaWYgKCFkZXZpY2UtPnN0YXR1cy5wcmVzZW50KQorCQlyZXR1cm4g ZmFsc2U7CisKKwkvKgorCSAqIEZhc3QgcGF0aCAtIGlmIGVuYWJsZWQgaXMgc2V0LCBhdm9pZCB0 aGUgbW9yZSBleHBlbnNpdmUgdGVzdCB0bworCSAqIGNoZWNrIHdoZXRoZXIgdGhpcyBkZXZpY2Ug aXMgYSBwcm9jZXNzb3IuCisJICovCisJaWYgKGRldmljZS0+c3RhdHVzLmVuYWJsZWQpCisJCXJl dHVybiB0cnVlOworCisJcmV0dXJuICFhY3BpX2RldmljZV9pc19wcm9jZXNzb3IoZGV2aWNlKTsK IH0KIEVYUE9SVF9TWU1CT0xfR1BMKGFjcGlfZGV2X3JlYWR5X2Zvcl9lbnVtZXJhdGlvbik7CiAK LS0gCjIuMzAuMgoKCi0tIApSTUsncyBQYXRjaCBzeXN0ZW06IGh0dHBzOi8vd3d3LmFybWxpbnV4 Lm9yZy51ay9kZXZlbG9wZXIvcGF0Y2hlcy8KRlRUUCBpcyBoZXJlISA4ME1icHMgZG93biAxME1i cHMgdXAuIERlY2VudCBjb25uZWN0aXZpdHkgYXQgbGFzdCEKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51 eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21h aWxtYW4vbGlzdGluZm8vbGludXgtcmlzY3YK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 06572C4707B for ; Thu, 11 Jan 2024 10:27:02 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=gcJGf+5iadZIp/sxUq0hn3BvmmfMhTUdjrXz6wrx/vk=; b=CagpOHg7U+anHL 9FL9nR8mcDLbYI0fIt5yWC8sXc9mCi6j2kX7LszxGO9wLgrPx2xIQNpiaaHPhKjOhVHQGjzaa8O4E 1bhGhtxZ934bUZ43RAOKYcm+QqGz4x/WdDMKfsex/4oBJWa10Xjqw1SUALRSzR6/axs9AvFabWKSe nC0RRaF6lBQsZt2m1qkp3Th+EHuWO9k+SIPF7UtC+nOlx0pv18TfTdPU+bRvw2iSPczgm2pJD5Gf+ OjbAOv+0mfGTg+2zbRdOhJbKImF85z3hERjvbauUa+Oyw/FD6cVOOmaUHuPuJPdc58DhkaZ5Dv2tb Dfcovb/vSyVqD+k9AiFA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1rNsGh-00GzN3-1O; Thu, 11 Jan 2024 10:26:35 +0000 Received: from pandora.armlinux.org.uk ([2001:4d48:ad52:32c8:5054:ff:fe00:142]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1rNsGc-00GzKt-0x; Thu, 11 Jan 2024 10:26:32 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=armlinux.org.uk; s=pandora-2019; h=Sender:In-Reply-To: Content-Transfer-Encoding:Content-Type:MIME-Version:References:Message-ID: Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=pDZNBMDn2+p6BZE/RBnm0b+eYsTn5JNJblyxFwWjLwk=; b=BYZDBswK7aOutgUjZLmuntw9C6 /yYD+iZVGMuStm1/46YVQPXa4jHRv6Z8U/xIa+GSGAwKVe34SOytP3Tx9xGkr72yv80XAwvbHV0bI sPo8k0+woUMNdoNp9uCH8fzeyQBvulH5ie2B1EvuuxPpAgFAxaDTDH6o16MImnNWfDZMt4MUpeydd 4Z4CGcT1w4kbIrcckE3oSmD9z4loTIDryx40alX5lGpP8DdcjKsh3Da0sjJdRoK9DB6NjVdi+llFX fk+jEeT0JRIaRq95XtNKWwqN3BzgOn30vMAbYjbfZoJNdvcaRvtz18LFYQCvuQFlzqBBOaeWenMGv Od4lYmnQ==; Received: from shell.armlinux.org.uk ([fd8f:7570:feb6:1:5054:ff:fe00:4ec]:57484) by pandora.armlinux.org.uk with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1rNsGM-0006OP-2L; Thu, 11 Jan 2024 10:26:14 +0000 Received: from linux by shell.armlinux.org.uk with local (Exim 4.94.2) (envelope-from ) id 1rNsGN-0006HT-CT; Thu, 11 Jan 2024 10:26:15 +0000 Date: Thu, 11 Jan 2024 10:26:15 +0000 From: "Russell King (Oracle)" To: Jonathan Cameron Cc: "Rafael J. Wysocki" , "Rafael J. Wysocki" , linux-pm@vger.kernel.org, loongarch@lists.linux.dev, linux-acpi@vger.kernel.org, linux-arch@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-riscv@lists.infradead.org, kvmarm@lists.linux.dev, x86@kernel.org, acpica-devel@lists.linuxfoundation.org, linux-csky@vger.kernel.org, linux-doc@vger.kernel.org, linux-ia64@vger.kernel.org, linux-parisc@vger.kernel.org, Salil Mehta , Jean-Philippe Brucker , jianyong.wu@arm.com, justin.he@arm.com, James Morse Subject: Re: [PATCH RFC v3 01/21] ACPI: Only enumerate enabled (or functional) devices Message-ID: References: <20231215161539.00000940@Huawei.com> <5760569.DvuYhMxLoT@kreacher> <20240102143925.00004361@Huawei.com> <20240111101949.000075dc@Huawei.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20240111101949.000075dc@Huawei.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240111_022630_494668_E6CB0FAA X-CRM114-Status: GOOD ( 55.14 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org T24gVGh1LCBKYW4gMTEsIDIwMjQgYXQgMTA6MTk6NDlBTSArMDAwMCwgSm9uYXRoYW4gQ2FtZXJv biB3cm90ZToKPiBPbiBUdWUsIDIgSmFuIDIwMjQgMTQ6Mzk6MjUgKzAwMDAKPiBKb25hdGhhbiBD YW1lcm9uIDxKb25hdGhhbi5DYW1lcm9uQEh1YXdlaS5jb20+IHdyb3RlOgo+IAo+ID4gT24gRnJp LCAxNSBEZWMgMjAyMyAyMDo0NzozMSArMDEwMAo+ID4gIlJhZmFlbCBKLiBXeXNvY2tpIiA8cmp3 QHJqd3lzb2NraS5uZXQ+IHdyb3RlOgo+ID4gCj4gPiA+IE9uIEZyaWRheSwgRGVjZW1iZXIgMTUs IDIwMjMgNToxNTozOSBQTSBDRVQgSm9uYXRoYW4gQ2FtZXJvbiB3cm90ZTogIAo+ID4gPiA+IE9u IEZyaSwgMTUgRGVjIDIwMjMgMTU6MzE6NTUgKzAwMDAKPiA+ID4gPiAiUnVzc2VsbCBLaW5nIChP cmFjbGUpIiA8bGludXhAYXJtbGludXgub3JnLnVrPiB3cm90ZToKPiA+ID4gPiAgICAgCj4gPiA+ ID4gPiBPbiBUaHUsIERlYyAxNCwgMjAyMyBhdCAwNzozNzoxMFBNICswMTAwLCBSYWZhZWwgSi4g V3lzb2NraSB3cm90ZTogICAgCj4gPiA+ID4gPiA+IE9uIFRodSwgRGVjIDE0LCAyMDIzIGF0IDc6 MTbigK9QTSBSYWZhZWwgSi4gV3lzb2NraSA8cmFmYWVsQGtlcm5lbC5vcmc+IHdyb3RlOiAgICAg IAo+ID4gPiA+ID4gPiA+Cj4gPiA+ID4gPiA+ID4gT24gVGh1LCBEZWMgMTQsIDIwMjMgYXQgNzox MOKAr1BNIFJ1c3NlbGwgS2luZyAoT3JhY2xlKQo+ID4gPiA+ID4gPiA+IDxsaW51eEBhcm1saW51 eC5vcmcudWs+IHdyb3RlOiAgICAgIAo+ID4gPiA+ID4gPiA+ID4gSSBndWVzcyB3ZSBuZWVkIHNv bWV0aGluZyBsaWtlOgo+ID4gPiA+ID4gPiA+ID4KPiA+ID4gPiA+ID4gPiA+ICAgICAgICAgaWYg KGRldmljZS0+c3RhdHVzLnByZXNlbnQpCj4gPiA+ID4gPiA+ID4gPiAgICAgICAgICAgICAgICAg cmV0dXJuIGRldmljZS0+ZGV2aWNlX3R5cGUgIT0gQUNQSV9CVVNfVFlQRV9QUk9DRVNTT1IgfHwK PiA+ID4gPiA+ID4gPiA+ICAgICAgICAgICAgICAgICAgICAgICAgZGV2aWNlLT5zdGF0dXMuZW5h YmxlZDsKPiA+ID4gPiA+ID4gPiA+ICAgICAgICAgZWxzZQo+ID4gPiA+ID4gPiA+ID4gICAgICAg ICAgICAgICAgIHJldHVybiBkZXZpY2UtPnN0YXR1cy5mdW5jdGlvbmFsOwo+ID4gPiA+ID4gPiA+ ID4KPiA+ID4gPiA+ID4gPiA+IHNvIHdlIG9ubHkgY2hlY2sgZGV2aWNlLT5zdGF0dXMuZW5hYmxl ZCBmb3IgcHJvY2Vzc29yLXR5cGUgZGV2aWNlcz8gICAgICAKPiA+ID4gPiA+ID4gPgo+ID4gPiA+ ID4gPiA+IFllcywgc29tZXRoaW5nIGxpa2UgdGhpcy4gICAgICAKPiA+ID4gPiA+ID4gCj4gPiA+ ID4gPiA+IEhvd2V2ZXIsIHRoYXQgaXMgbm90IHN1ZmZpY2llbnQsIGJlY2F1c2UgdGhlcmUgYXJl Cj4gPiA+ID4gPiA+IEFDUElfQlVTX1RZUEVfREVWSUNFIGRldmljZXMgcmVwcmVzZW50aW5nIHBy b2Nlc3NvcnMuCj4gPiA+ID4gPiA+IAo+ID4gPiA+ID4gPiBJJ20gbm90IHN1cmUgYWJvdXQgYSBj bGVhbiB3YXkgdG8gZG8gaXQgQVRNLiAgICAgIAo+ID4gPiA+ID4gCj4gPiA+ID4gPiBPaywgaG93 IGFib3V0Ogo+ID4gPiA+ID4gCj4gPiA+ID4gPiBzdGF0aWMgYm9vbCBhY3BpX2Rldl9pc19wcm9j ZXNzb3IoY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpCj4gPiA+ID4gPiB7Cj4gPiA+ ID4gPiAJc3RydWN0IGFjcGlfaGFyZHdhcmVfaWQgKmh3aWQ7Cj4gPiA+ID4gPiAKPiA+ID4gPiA+ IAlpZiAoZGV2aWNlLT5kZXZpY2VfdHlwZSA9PSBBQ1BJX0JVU19UWVBFX1BST0NFU1NPUikKPiA+ ID4gPiA+IAkJcmV0dXJuIHRydWU7Cj4gPiA+ID4gPiAKPiA+ID4gPiA+IAlpZiAoZGV2aWNlLT5k ZXZpY2VfdHlwZSAhPSBBQ1BJX0JVU19UWVBFX0RFVklDRSkKPiA+ID4gPiA+IAkJcmV0dXJuIGZh bHNlOwo+ID4gPiA+ID4gCj4gPiA+ID4gPiAJbGlzdF9mb3JfZWFjaF9lbnRyeShod2lkLCAmZGV2 aWNlLT5wbnAuaWRzLCBsaXN0KQo+ID4gPiA+ID4gCQlpZiAoIXN0cmNtcChBQ1BJX1BST0NFU1NP Ul9PQkpFQ1RfSElELCBod2lkLT5pZCkgfHwKPiA+ID4gPiA+IAkJICAgICFzdHJjbXAoQUNQSV9Q Uk9DRVNTT1JfREVWSUNFX0hJRCwgaHdpZC0+aWQpKQo+ID4gPiA+ID4gCQkJcmV0dXJuIHRydWU7 Cj4gPiA+ID4gPiAKPiA+ID4gPiA+IAlyZXR1cm4gZmFsc2U7Cj4gPiA+ID4gPiB9Cj4gPiA+ID4g PiAKPiA+ID4gPiA+IGFuZCB0aGVuOgo+ID4gPiA+ID4gCj4gPiA+ID4gPiAJaWYgKGRldmljZS0+ c3RhdHVzLnByZXNlbnQpCj4gPiA+ID4gPiAJCXJldHVybiAhYWNwaV9kZXZfaXNfcHJvY2Vzc29y KGRldmljZSkgfHwgZGV2aWNlLT5zdGF0dXMuZW5hYmxlZDsKPiA+ID4gPiA+IAllbHNlCj4gPiA+ ID4gPiAJCXJldHVybiBkZXZpY2UtPnN0YXR1cy5mdW5jdGlvbmFsOwo+ID4gPiA+ID4gCj4gPiA+ ID4gPiA/Cj4gPiA+ID4gPiAgICAgCj4gPiA+ID4gQ2hhbmdpbmcgaXQgdG8gQ1BVIG9ubHkgZm9y IG5vdyBtYWtlcyBzZW5zZSB0byBtZSBhbmQgSSB0aGluayB0aGlzIGNvZGUgc25pcHBldCBzaG91 bGQgZG8gdGhlCj4gPiA+ID4gam9iLiAgTmljZSBhbmQgc2ltcGxlLiAgICAKPiA+ID4gCj4gPiA+ IFdlbGwsIGV4Y2VwdCB0aGF0IGl0IGRvZXMgY2hlY2tzIHRoYXQgYXJlIGRvbmUgZWxzZXdoZXJl IHNsaWdodGx5Cj4gPiA+IGRpZmZlcmVudGx5LCB3aGljaCBmcm9tIHRoZSBtYWludGVuYW5jZSBQ T1YgaXMgbm90IG5pY2UuCj4gPiA+IAo+ID4gPiBNYXliZSBzb21ldGhpbmcgbGlrZSB0aGUgYXBw ZW5kZWQgcGF0Y2ggKHVudGVzdGVkKS4gIAo+ID4gCj4gPiBIaSBSYWZhZWwsCj4gPiAKPiA+IEFz IGZhciBhcyBJIGNhbiBzZWUgdGhhdCdzIGZ1bmN0aW9uYWxseSBlcXVpdmFsZW50LCBzbyBsb29r cyBnb29kIHRvIG1lLgo+ID4gSSdtIG5vdCBzZXQgdXAgdG8gdGVzdCB0aGlzIHRvZGF5IHRob3Vn aCwgc28gd2lsbCBkZWZlciB0byBSdXNzZWxsIG9uIHdoZXRoZXIKPiA+IHRoZXJlIGlzIGFueXRo aW5nIG1pc3NpbmcKPiA+IAo+ID4gVGhhbmtzIGZvciBwdXR0aW5nIHRoaXMgdG9nZXRoZXIuCj4g Cj4gVGhpcyBpcyByYXRoZXIgZW1iYXJyYXNzaW5nLi4uCj4gCj4gSSBzcGFuIHRoaXMgdXAgb24g YSBRRU1VIGluc3RhbmNlIHdpdGggc29tZSBwcmludHMgdG8gZmluZCBvdXQgd2UgbmVlZAo+IHRo ZSAhYWNwaV9kZXZpY2VfaXNfcHJvY2Vzc29yKCkgcmVzdHJpY3Rpb24uCj4gT24gbXkgJ3JhbmRv bScgdGVzdCBzZXR1cCBpdCBmYWlscyBvbiBvbmUgZGV2aWNlLiBBQ1BJMDAxNyAtIHdoaWNoIEkK PiBoYXBwZW4gdG8ga25vdyByYXRoZXIgd2VsbC4gSXQncyB0aGUgd2VpcmQgcHNldWRvIGRldmlj ZSB0aGF0IGxldHMKPiBhIENYTCBhd2FyZSBPUyBrbm93IHRoZXJlIGlzIGEgQ0VEVCB0YWJsZSB0 byBwcm9iZS4KPiAKPiBXaGlsc3QgSSByZWFsbHkgZG9uJ3QgbGlrZSB0aGF0IGhhY2sgKGl0IGlz IGFsbCBhYm91dCBtYWtpbmcgc29mdHdhcmUKPiBkaXN0cmlidXRpb24gb2Ygb3V0IG9mIHRyZWUg bW9kdWxlcyBlYXNpZXIgcmF0aGVyIHRoYW4gc29tZXRoaW5nCj4gZnVuZGFtZW50YWwpLCBJJ20g dGhlIENYTCBRRU1VIG1haW50YWluZXIgOigKPiAKPiBXaWxsIGZpeCB0aGF0LCBidXQgaXQgc2hv d3MgdGhlcmUgaXMgYXQgbGVhc3Qgb25lIGJyb2tlbiBmaXJtd2FyZSBvdXQKPiB0aGVyZS4KPiAK PiBPbiBwbHVzIHNpZGUsIFJhZmFlbCdzIGNvZGUgc2VlbXMgdG8gd29yayBhcyBleHBlY3RlZCBh bmQgbGV0cyB0aGF0Cj4gYnVnZ3kgZmlyd21hcmUgY2Fycnkgb24gd29ya2luZyA6KSBTbyBsZXRz IHByZXRlbmQgdGhlIGJ1ZyBpbiBxZW11Cj4gaXMgYSBkZWxpYmVyYXRlIHRlc3QgY2FzZSEKCkxv bCwgdGhhbmtzIGZvciBhIHRlc3QgY2FzZSBhbmQgc2hvd2luZyB0aGF0IFJhZmFlbCdzIGFwcHJv YWNoIGlzCmluZGVlZCBuZWNlc3NhcnkuCgpXb3VsZCB5b3VyIHRlc3QgcXVhbGl0eSBmb3IgYSB0 ZXN0ZWQtYnkgZm9yIHRoaXM/IEZvciByZWZlcmVuY2UsIHRoaXMKaXMgbXkgY3VycmVudCB2ZXJz aW9uIGJlbG93IHdpdGggUmFmYWVsJ3MgdXBkYXRlOgoKODw9PT09CkZyb206IFJ1c3NlbGwgS2lu ZyAoT3JhY2xlKSA8cm1rK2tlcm5lbEBhcm1saW51eC5vcmcudWs+ClN1YmplY3Q6IFtQQVRDSF0g QUNQSTogT25seSBlbnVtZXJhdGUgZW5hYmxlZCAob3IgZnVuY3Rpb25hbCkgcHJvY2Vzc29yCiBk ZXZpY2VzCgpGcm9tOiBKYW1lcyBNb3JzZSA8amFtZXMubW9yc2VAYXJtLmNvbT4KClRvZGF5IHRo ZSBBQ1BJIGVudW1lcmF0aW9uIGNvZGUgJ3Zpc2l0cycgYWxsIGRldmljZXMgdGhhdCBhcmUgcHJl c2VudC4KClRoaXMgaXMgYSBwcm9ibGVtIGZvciBhcm02NCwgd2hlcmUgQ1BVcyBhcmUgYWx3YXlz IHByZXNlbnQsIGJ1dCBub3QKYWx3YXlzIGVuYWJsZWQuIFdoZW4gYSBkZXZpY2UtY2hlY2sgb2Nj dXJzIGJlY2F1c2UgdGhlIGZpcm13YXJlLXBvbGljeQpoYXMgY2hhbmdlZCBhbmQgYSBDUFUgaXMg bm93IGVuYWJsZWQsIHRoZSBmb2xsb3dpbmcgZXJyb3Igb2NjdXJzOgp8IGFjcGkgQUNQSTAwMDc6 NDg6IEVudW1lcmF0aW9uIGZhaWx1cmUKClRoaXMgaXMgdWx0aW1hdGVseSBiZWNhdXNlIGFjcGlf ZGV2X3JlYWR5X2Zvcl9lbnVtZXJhdGlvbigpIHJldHVybnMKdHJ1ZSBmb3IgYSBkZXZpY2UgdGhh dCBpcyBub3QgZW5hYmxlZC4gVGhlIEFDUEkgUHJvY2Vzc29yIGRyaXZlcgp3aWxsIG5vdCByZWdp c3RlciBzdWNoIENQVXMgYXMgdGhleSBhcmUgbm90ICdkZWNvZGluZyB0aGVpciByZXNvdXJjZXMn LgoKQUNQSSBhbGxvd3MgYSBkZXZpY2UgdG8gYmUgZnVuY3Rpb25hbCBpbnN0ZWFkIG9mIG1haW50 YWluaW5nIHRoZQpwcmVzZW50IGFuZCBlbmFibGVkIGJpdCwgYnV0IHdlIGNhbid0IHNpbXBseSBj aGVjayB0aGUgZW5hYmxlZCBiaXQKZm9yIGFsbCBkZXZpY2VzIHNpbmNlIGZpcm13YXJlIGNhbiBi ZSBidWdneS4KCklmIEFDUEkgaW5kaWNhdGVzIHRoYXQgdGhlIGRldmljZSBpcyBwcmVzZW50IGFu ZCBlbmFibGVkLCB0aGVuIGFsbCB3ZWxsCmFuZCBnb29kLCB3ZSBjYW4gZW51bWF0ZSBpdC4gSG93 ZXZlciwgaWYgdGhlIGRldmljZSBpcyBwcmVzZW50IGFuZCBub3QKZW5hYmxlZCwgdGhlbiB3ZSBh bHNvIGNoZWNrIHdoZXRoZXIgdGhlIGRldmljZSBpcyBhIHByb2Nlc3NvciBkZXZpY2UKdG8gbGlt aXQgdGhlIGltcGFjdCBvZiB0aGlzIG5ldyBjaGVjayB0byBqdXN0IHByb2Nlc3NvciBkZXZpY2Vz LgoKVGhpcyBhdm9pZHMgZW51bWVyYXRpbmcgcHJlc2VudCAmJiBmdW5jdGlvbmFsIHByb2Nlc3Nv ciBkZXZpY2VzIHRoYXQKYXJlIG5vdCBlbmFibGVkLgoKU2lnbmVkLW9mZi1ieTogSmFtZXMgTW9y c2UgPGphbWVzLm1vcnNlQGFybS5jb20+CkNvLWRldmVsb3BlZC1ieTogUmFmYWVsIEouIFd5c29j a2kgPHJqd0Byand5c29ja2kubmV0PgpTaWduZWQtb2ZmLWJ5OiBSdXNzZWxsIEtpbmcgKE9yYWNs ZSkgPHJtaytrZXJuZWxAYXJtbGludXgub3JnLnVrPgotLS0KQ2hhbmdlcyBzaW5jZSBSRkMgdjI6 CiAqIEluY29ycG9yYXRlIGNvbW1lbnQgc3VnZ2VzdGlvbiBieSBHYXZpbiBTaGFuLgpDaGFuZ2Vz IHNpbmNlIFJGQyB2MzoKICogRml4ZWQgInNlcnQiIHR5cG8uCkNoYW5nZXMgc2luY2UgUkZDIHYz IChzbWFsbGVyIHNlcmllcyk6CiAqIFJlc3RyaWN0IGNoZWNraW5nIHRoZSBlbmFibGVkIGJpdCB0 byBwcm9jZXNzb3IgZGV2aWNlcywgdXBkYXRlCiAgIGNvbW1pdCBjb21tZW50cy4KICogVXNlIFJh ZmFlbCdzIHN1Z2dlc3Rpb24gaW4KICAgaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvci81NzYwNTY5 LkR2dVloTXhMb1RAa3JlYWNoZXIKLS0tCiBkcml2ZXJzL2FjcGkvYWNwaV9wcm9jZXNzb3IuYyB8 IDExICsrKysrKysrCiBkcml2ZXJzL2FjcGkvZGV2aWNlX3BtLmMgICAgICB8ICAyICstCiBkcml2 ZXJzL2FjcGkvZGV2aWNlX3N5c2ZzLmMgICB8ICAyICstCiBkcml2ZXJzL2FjcGkvaW50ZXJuYWwu aCAgICAgICB8ICA0ICsrLQogZHJpdmVycy9hY3BpL3Byb3BlcnR5LmMgICAgICAgfCAgMiArLQog ZHJpdmVycy9hY3BpL3NjYW4uYyAgICAgICAgICAgfCA0OSArKysrKysrKysrKysrKysrKysrKysr KysrKysrLS0tLS0tLQogNiBmaWxlcyBjaGFuZ2VkLCA1NiBpbnNlcnRpb25zKCspLCAxNCBkZWxl dGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYWNwaV9wcm9jZXNzb3IuYyBiL2Ry aXZlcnMvYWNwaS9hY3BpX3Byb2Nlc3Nvci5jCmluZGV4IDRmZTJlZjU0MDg4Yy4uY2Y3YzFjY2E2 OWRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWNwaV9wcm9jZXNzb3IuYworKysgYi9kcml2 ZXJzL2FjcGkvYWNwaV9wcm9jZXNzb3IuYwpAQCAtNjI2LDYgKzYyNiwxNyBAQCBzdGF0aWMgc3Ry dWN0IGFjcGlfc2Nhbl9oYW5kbGVyIHByb2Nlc3Nvcl9oYW5kbGVyID0gewogCX0sCiB9OwogCiti b29sIGFjcGlfZGV2aWNlX2lzX3Byb2Nlc3Nvcihjb25zdCBzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFk ZXYpCit7CisJaWYgKGFkZXYtPmRldmljZV90eXBlID09IEFDUElfQlVTX1RZUEVfUFJPQ0VTU09S KQorCQlyZXR1cm4gdHJ1ZTsKKworCWlmIChhZGV2LT5kZXZpY2VfdHlwZSAhPSBBQ1BJX0JVU19U WVBFX0RFVklDRSkKKwkJcmV0dXJuIGZhbHNlOworCisJcmV0dXJuIGFjcGlfc2Nhbl9jaGVja19o YW5kbGVyKGFkZXYsICZwcm9jZXNzb3JfaGFuZGxlcik7Cit9CisKIHN0YXRpYyBpbnQgYWNwaV9w cm9jZXNzb3JfY29udGFpbmVyX2F0dGFjaChzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldiwKIAkJCQkJ ICAgY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlX2lkICppZCkKIHsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvYWNwaS9kZXZpY2VfcG0uYyBiL2RyaXZlcnMvYWNwaS9kZXZpY2VfcG0uYwppbmRleCAzYjRk MDQ4YzQ5NDEuLmUzYzgwZjNiM2I1NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2RldmljZV9w bS5jCisrKyBiL2RyaXZlcnMvYWNwaS9kZXZpY2VfcG0uYwpAQCAtMzEzLDcgKzMxMyw3IEBAIGlu dCBhY3BpX2J1c19pbml0X3Bvd2VyKHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNlKQogCQlyZXR1 cm4gLUVJTlZBTDsKIAogCWRldmljZS0+cG93ZXIuc3RhdGUgPSBBQ1BJX1NUQVRFX1VOS05PV047 Ci0JaWYgKCFhY3BpX2RldmljZV9pc19wcmVzZW50KGRldmljZSkpIHsKKwlpZiAoIWFjcGlfZGV2 X3JlYWR5X2Zvcl9lbnVtZXJhdGlvbihkZXZpY2UpKSB7CiAJCWRldmljZS0+ZmxhZ3MuaW5pdGlh bGl6ZWQgPSBmYWxzZTsKIAkJcmV0dXJuIC1FTlhJTzsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJz L2FjcGkvZGV2aWNlX3N5c2ZzLmMgYi9kcml2ZXJzL2FjcGkvZGV2aWNlX3N5c2ZzLmMKaW5kZXgg MjMzNzNmYWEzNWVjLi5hMDI1NmQyNDkzYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS9kZXZp Y2Vfc3lzZnMuYworKysgYi9kcml2ZXJzL2FjcGkvZGV2aWNlX3N5c2ZzLmMKQEAgLTE0MSw3ICsx NDEsNyBAQCBzdGF0aWMgaW50IGNyZWF0ZV9wbnBfbW9kYWxpYXMoY29uc3Qgc3RydWN0IGFjcGlf ZGV2aWNlICphY3BpX2RldiwgY2hhciAqbW9kYWxpYQogCXN0cnVjdCBhY3BpX2hhcmR3YXJlX2lk ICppZDsKIAogCS8qIEF2b2lkIHVubmVjZXNzYXJpbHkgbG9hZGluZyBtb2R1bGVzIGZvciBub24g cHJlc2VudCBkZXZpY2VzLiAqLwotCWlmICghYWNwaV9kZXZpY2VfaXNfcHJlc2VudChhY3BpX2Rl dikpCisJaWYgKCFhY3BpX2Rldl9yZWFkeV9mb3JfZW51bWVyYXRpb24oYWNwaV9kZXYpKQogCQly ZXR1cm4gMDsKIAogCS8qCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvaW50ZXJuYWwuaCBiL2Ry aXZlcnMvYWNwaS9pbnRlcm5hbC5oCmluZGV4IDg2NmM3YzRlZDIzMy4uOTM4OGQ0Yzg2NzRhIDEw MDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvaW50ZXJuYWwuaAorKysgYi9kcml2ZXJzL2FjcGkvaW50 ZXJuYWwuaApAQCAtNjIsNiArNjIsOCBAQCB2b2lkIGFjcGlfc3lzZnNfYWRkX2hvdHBsdWdfcHJv ZmlsZShzdHJ1Y3QgYWNwaV9ob3RwbHVnX3Byb2ZpbGUgKmhvdHBsdWcsCiBpbnQgYWNwaV9zY2Fu X2FkZF9oYW5kbGVyX3dpdGhfaG90cGx1ZyhzdHJ1Y3QgYWNwaV9zY2FuX2hhbmRsZXIgKmhhbmRs ZXIsCiAJCQkJICAgICAgIGNvbnN0IGNoYXIgKmhvdHBsdWdfcHJvZmlsZV9uYW1lKTsKIHZvaWQg YWNwaV9zY2FuX2hvdHBsdWdfZW5hYmxlZChzdHJ1Y3QgYWNwaV9ob3RwbHVnX3Byb2ZpbGUgKmhv dHBsdWcsIGJvb2wgdmFsKTsKK2Jvb2wgYWNwaV9zY2FuX2NoZWNrX2hhbmRsZXIoY29uc3Qgc3Ry dWN0IGFjcGlfZGV2aWNlICphZGV2LAorCQkJICAgICBzdHJ1Y3QgYWNwaV9zY2FuX2hhbmRsZXIg KmhhbmRsZXIpOwogCiAjaWZkZWYgQ09ORklHX0RFQlVHX0ZTCiBleHRlcm4gc3RydWN0IGRlbnRy eSAqYWNwaV9kZWJ1Z2ZzX2RpcjsKQEAgLTEwNyw3ICsxMDksNiBAQCBpbnQgYWNwaV9kZXZpY2Vf c2V0dXBfZmlsZXMoc3RydWN0IGFjcGlfZGV2aWNlICpkZXYpOwogdm9pZCBhY3BpX2RldmljZV9y ZW1vdmVfZmlsZXMoc3RydWN0IGFjcGlfZGV2aWNlICpkZXYpOwogdm9pZCBhY3BpX2RldmljZV9h ZGRfZmluYWxpemUoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpOwogdm9pZCBhY3BpX2ZyZWVf cG5wX2lkcyhzdHJ1Y3QgYWNwaV9kZXZpY2VfcG5wICpwbnApOwotYm9vbCBhY3BpX2RldmljZV9p c19wcmVzZW50KGNvbnN0IHN0cnVjdCBhY3BpX2RldmljZSAqYWRldik7CiBib29sIGFjcGlfZGV2 aWNlX2lzX2JhdHRlcnkoc3RydWN0IGFjcGlfZGV2aWNlICphZGV2KTsKIGJvb2wgYWNwaV9kZXZp Y2VfaXNfZmlyc3RfcGh5c2ljYWxfbm9kZShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFkZXYsCiAJCQkJ CWNvbnN0IHN0cnVjdCBkZXZpY2UgKmRldik7CkBAIC0xMTksNiArMTIwLDcgQEAgaW50IGFjcGlf YnVzX3JlZ2lzdGVyX2Vhcmx5X2RldmljZShpbnQgdHlwZSk7CiBjb25zdCBzdHJ1Y3QgYWNwaV9k ZXZpY2UgKmFjcGlfY29tcGFuaW9uX21hdGNoKGNvbnN0IHN0cnVjdCBkZXZpY2UgKmRldik7CiBp bnQgX19hY3BpX2RldmljZV91ZXZlbnRfbW9kYWxpYXMoY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNl ICphZGV2LAogCQkJCSAgc3RydWN0IGtvYmpfdWV2ZW50X2VudiAqZW52KTsKK2Jvb2wgYWNwaV9k ZXZpY2VfaXNfcHJvY2Vzc29yKGNvbnN0IHN0cnVjdCBhY3BpX2RldmljZSAqYWRldik7CiAKIC8q IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUG93 ZXIgUmVzb3VyY2UKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9wcm9wZXJ0eS5jIGIvZHJpdmVy cy9hY3BpL3Byb3BlcnR5LmMKaW5kZXggNjk3OWEzZjlmOTBhLi4xNGQ2OTQ4ZmQ4OGEgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvYWNwaS9wcm9wZXJ0eS5jCisrKyBiL2RyaXZlcnMvYWNwaS9wcm9wZXJ0 eS5jCkBAIC0xNDIwLDcgKzE0MjAsNyBAQCBzdGF0aWMgYm9vbCBhY3BpX2Z3bm9kZV9kZXZpY2Vf aXNfYXZhaWxhYmxlKGNvbnN0IHN0cnVjdCBmd25vZGVfaGFuZGxlICpmd25vZGUpCiAJaWYgKCFp c19hY3BpX2RldmljZV9ub2RlKGZ3bm9kZSkpCiAJCXJldHVybiBmYWxzZTsKIAotCXJldHVybiBh Y3BpX2RldmljZV9pc19wcmVzZW50KHRvX2FjcGlfZGV2aWNlX25vZGUoZndub2RlKSk7CisJcmV0 dXJuIGFjcGlfZGV2X3JlYWR5X2Zvcl9lbnVtZXJhdGlvbih0b19hY3BpX2RldmljZV9ub2RlKGZ3 bm9kZSkpOwogfQogCiBzdGF0aWMgY29uc3Qgdm9pZCAqCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Fj cGkvc2Nhbi5jIGIvZHJpdmVycy9hY3BpL3NjYW4uYwppbmRleCAwMmJiMmNjZTQyM2YuLmY5NGQx Zjc0NGJjYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL3NjYW4uYworKysgYi9kcml2ZXJzL2Fj cGkvc2Nhbi5jCkBAIC0zMDQsNyArMzA0LDcgQEAgc3RhdGljIGludCBhY3BpX3NjYW5fZGV2aWNl X2NoZWNrKHN0cnVjdCBhY3BpX2RldmljZSAqYWRldikKIAlpbnQgZXJyb3I7CiAKIAlhY3BpX2J1 c19nZXRfc3RhdHVzKGFkZXYpOwotCWlmIChhY3BpX2RldmljZV9pc19wcmVzZW50KGFkZXYpKSB7 CisJaWYgKGFjcGlfZGV2X3JlYWR5X2Zvcl9lbnVtZXJhdGlvbihhZGV2KSkgewogCQkvKgogCQkg KiBUaGlzIGZ1bmN0aW9uIGlzIG9ubHkgY2FsbGVkIGZvciBkZXZpY2Ugb2JqZWN0cyBmb3Igd2hp Y2gKIAkJICogbWF0Y2hpbmcgc2NhbiBoYW5kbGVycyBleGlzdC4gIFRoZSBvbmx5IHNpdHVhdGlv biBpbiB3aGljaApAQCAtMzM4LDcgKzMzOCw3IEBAIHN0YXRpYyBpbnQgYWNwaV9zY2FuX2J1c19j aGVjayhzdHJ1Y3QgYWNwaV9kZXZpY2UgKmFkZXYsIHZvaWQgKm5vdF91c2VkKQogCWludCBlcnJv cjsKIAogCWFjcGlfYnVzX2dldF9zdGF0dXMoYWRldik7Ci0JaWYgKCFhY3BpX2RldmljZV9pc19w cmVzZW50KGFkZXYpKSB7CisJaWYgKCFhY3BpX2Rldl9yZWFkeV9mb3JfZW51bWVyYXRpb24oYWRl dikpIHsKIAkJYWNwaV9zY2FuX2RldmljZV9ub3RfZW51bWVyYXRlZChhZGV2KTsKIAkJcmV0dXJu IDA7CiAJfQpAQCAtMTkxMywxMSArMTkxMyw2IEBAIHN0YXRpYyBib29sIGFjcGlfZGV2aWNlX3No b3VsZF9iZV9oaWRkZW4oYWNwaV9oYW5kbGUgaGFuZGxlKQogCXJldHVybiB0cnVlOwogfQogCi1i b29sIGFjcGlfZGV2aWNlX2lzX3ByZXNlbnQoY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlICphZGV2 KQotewotCXJldHVybiBhZGV2LT5zdGF0dXMucHJlc2VudCB8fCBhZGV2LT5zdGF0dXMuZnVuY3Rp b25hbDsKLX0KLQogc3RhdGljIGJvb2wgYWNwaV9zY2FuX2hhbmRsZXJfbWF0Y2hpbmcoc3RydWN0 IGFjcGlfc2Nhbl9oYW5kbGVyICpoYW5kbGVyLAogCQkJCSAgICAgICBjb25zdCBjaGFyICppZHN0 ciwKIAkJCQkgICAgICAgY29uc3Qgc3RydWN0IGFjcGlfZGV2aWNlX2lkICoqbWF0Y2hpZCkKQEAg LTE5MzgsNiArMTkzMywxOCBAQCBzdGF0aWMgYm9vbCBhY3BpX3NjYW5faGFuZGxlcl9tYXRjaGlu ZyhzdHJ1Y3QgYWNwaV9zY2FuX2hhbmRsZXIgKmhhbmRsZXIsCiAJcmV0dXJuIGZhbHNlOwogfQog Citib29sIGFjcGlfc2Nhbl9jaGVja19oYW5kbGVyKGNvbnN0IHN0cnVjdCBhY3BpX2RldmljZSAq YWRldiwKKwkJCSAgICAgc3RydWN0IGFjcGlfc2Nhbl9oYW5kbGVyICpoYW5kbGVyKQoreworCXN0 cnVjdCBhY3BpX2hhcmR3YXJlX2lkICpod2lkOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShod2lk LCAmYWRldi0+cG5wLmlkcywgbGlzdCkKKwkJaWYgKGFjcGlfc2Nhbl9oYW5kbGVyX21hdGNoaW5n KGhhbmRsZXIsIGh3aWQtPmlkLCBOVUxMKSkKKwkJCXJldHVybiB0cnVlOworCisJcmV0dXJuIGZh bHNlOworfQorCiBzdGF0aWMgc3RydWN0IGFjcGlfc2Nhbl9oYW5kbGVyICphY3BpX3NjYW5fbWF0 Y2hfaGFuZGxlcihjb25zdCBjaGFyICppZHN0ciwKIAkJCQkJY29uc3Qgc3RydWN0IGFjcGlfZGV2 aWNlX2lkICoqbWF0Y2hpZCkKIHsKQEAgLTIzODEsMTYgKzIzODgsMzggQEAgRVhQT1JUX1NZTUJP TF9HUEwoYWNwaV9kZXZfY2xlYXJfZGVwZW5kZW5jaWVzKTsKICAqIGFjcGlfZGV2X3JlYWR5X2Zv cl9lbnVtZXJhdGlvbiAtIENoZWNrIGlmIHRoZSBBQ1BJIGRldmljZSBpcyByZWFkeSBmb3IgZW51 bWVyYXRpb24KICAqIEBkZXZpY2U6IFBvaW50ZXIgdG8gdGhlICZzdHJ1Y3QgYWNwaV9kZXZpY2Ug dG8gY2hlY2sKICAqCi0gKiBDaGVjayBpZiB0aGUgZGV2aWNlIGlzIHByZXNlbnQgYW5kIGhhcyBu byB1bm1ldCBkZXBlbmRlbmNpZXMuCisgKiBDaGVjayBpZiB0aGUgZGV2aWNlIGlzIGZ1bmN0aW9u YWwgb3IgZW5hYmxlZCBhbmQgaGFzIG5vIHVubWV0IGRlcGVuZGVuY2llcy4KICAqCi0gKiBSZXR1 cm4gdHJ1ZSBpZiB0aGUgZGV2aWNlIGlzIHJlYWR5IGZvciBlbnVtZXJhdGluby4gT3RoZXJ3aXNl LCByZXR1cm4gZmFsc2UuCisgKiBSZXR1cm4gdHJ1ZSBpZiB0aGUgZGV2aWNlIGlzIHJlYWR5IGZv ciBlbnVtZXJhdGlvbi4gT3RoZXJ3aXNlLCByZXR1cm4gZmFsc2UuCiAgKi8KIGJvb2wgYWNwaV9k ZXZfcmVhZHlfZm9yX2VudW1lcmF0aW9uKGNvbnN0IHN0cnVjdCBhY3BpX2RldmljZSAqZGV2aWNl KQogewogCWlmIChkZXZpY2UtPmZsYWdzLmhvbm9yX2RlcHMgJiYgZGV2aWNlLT5kZXBfdW5tZXQp CiAJCXJldHVybiBmYWxzZTsKIAotCXJldHVybiBhY3BpX2RldmljZV9pc19wcmVzZW50KGRldmlj ZSk7CisJLyoKKwkgKiBBQ1BJIDYuNSdzIDYuMy43ICJfU1RBIChEZXZpY2UgU3RhdHVzKSIgYWxs b3dzIGZpcm13YXJlIHRvIHJldHVybgorCSAqICghcHJlc2VudCAmJiBmdW5jdGlvbmFsKSBmb3Ig Y2VydGFpbiB0eXBlcyBvZiBkZXZpY2VzIHRoYXQgc2hvdWxkIGJlCisJICogZW51bWVyYXRlZC4g Tm90ZSB0aGF0IHRoZSBlbmFibGVkIGJpdCBzaG91bGQgbm90IGJlIHNldCB1bmxlc3MgdGhlCisJ ICogcHJlc2VudCBiaXQgaXMgc2V0LgorCSAqCisJICogSG93ZXZlciwgbGltaXQgdGhpcyBvbmx5 IHRvIHByb2Nlc3NvciBkZXZpY2VzIHRvIHJlZHVjZSBwb3NzaWJsZQorCSAqIHJlZ3Jlc3Npb25z IHdpdGggZmlybXdhcmUuCisJICovCisJaWYgKGRldmljZS0+c3RhdHVzLmZ1bmN0aW9uYWwpCisJ CXJldHVybiB0cnVlOworCisJaWYgKCFkZXZpY2UtPnN0YXR1cy5wcmVzZW50KQorCQlyZXR1cm4g ZmFsc2U7CisKKwkvKgorCSAqIEZhc3QgcGF0aCAtIGlmIGVuYWJsZWQgaXMgc2V0LCBhdm9pZCB0 aGUgbW9yZSBleHBlbnNpdmUgdGVzdCB0bworCSAqIGNoZWNrIHdoZXRoZXIgdGhpcyBkZXZpY2Ug aXMgYSBwcm9jZXNzb3IuCisJICovCisJaWYgKGRldmljZS0+c3RhdHVzLmVuYWJsZWQpCisJCXJl dHVybiB0cnVlOworCisJcmV0dXJuICFhY3BpX2RldmljZV9pc19wcm9jZXNzb3IoZGV2aWNlKTsK IH0KIEVYUE9SVF9TWU1CT0xfR1BMKGFjcGlfZGV2X3JlYWR5X2Zvcl9lbnVtZXJhdGlvbik7CiAK LS0gCjIuMzAuMgoKCi0tIApSTUsncyBQYXRjaCBzeXN0ZW06IGh0dHBzOi8vd3d3LmFybWxpbnV4 Lm9yZy51ay9kZXZlbG9wZXIvcGF0Y2hlcy8KRlRUUCBpcyBoZXJlISA4ME1icHMgZG93biAxME1i cHMgdXAuIERlY2VudCBjb25uZWN0aXZpdHkgYXQgbGFzdCEKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0 CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFk ZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK