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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 279A9C433EF for ; Thu, 3 Feb 2022 12:10:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S238970AbiBCMKA (ORCPT ); Thu, 3 Feb 2022 07:10:00 -0500 Received: from foss.arm.com ([217.140.110.172]:42900 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229794AbiBCMJ6 (ORCPT ); Thu, 3 Feb 2022 07:09:58 -0500 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 0347D11D4; Thu, 3 Feb 2022 04:09:58 -0800 (PST) Received: from FVFF77S0Q05N (unknown [172.31.20.19]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id E907A3F774; Thu, 3 Feb 2022 04:09:56 -0800 (PST) Date: Thu, 3 Feb 2022 12:09:50 +0000 From: Mark Rutland To: Florian Fainelli Cc: linux-arm-kernel@lists.infradead.org, "maintainer:BROADCOM BCM7XXX ARM ARCHITECTURE" , Lorenzo Pieralisi , open list Subject: Re: [PATCH 3/4] soc: bcm: brcmstb: Added support for PSCI system suspend operations Message-ID: References: <20220122035421.4086618-1-f.fainelli@gmail.com> <20220122035421.4086618-4-f.fainelli@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20220122035421.4086618-4-f.fainelli@gmail.com> Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi, On Fri, Jan 21, 2022 at 07:54:20PM -0800, Florian Fainelli wrote: > Add support for the Broadcom STB system suspend operations which > leverage the standard PSCI functions and uses the > psci_cpu_suspend_enter() operation to power off the system with or > without retention ("echo standby > /sys/power/state"). What exactly does this enable that can't be achieved with the existing PSCI driver as-is? When you say "retention", what specifically do you mean? Retention of CPU state? DRAM contents? We already have SYSTEM_SUSPEND for states where DRAM content is retained but CPU (and some system state) is lost, and IIUC we can do suspend-to-idle with CPU_SUSPEND states. interface necessary? > The system reset path also supports a special "powercycle" mode which > signals to the ARM Trusted Firmware that an external PMIC chip must > force the SoC into a power cycle. How does that compare to the regular SYSTEM_RESET call? The PSCI spec says of SYSTEM_RESET: | This function provides a method for performing a system cold reset. To the | caller, the behavior is equivalent to a hardware power-cycle sequence. ... so I don't follow how this is different, unless this platform's SYSTEM_RESET implementation is *not* actually performing a system cold reset? If that *doesn't* perform a cold rest, it seems like a bug? > As much as possible extensions were built using the SIP namespace rather > than the standard PSCI namespace, however compatibility with the > standard PSCI implementation is retained when CONFIG_BRCMSTB_PM is not > selected. I really don't like this, because it seems to be creating a parallel infrastructure for doing things that can *already* be done with standard PSCI driver. The actual PSCI bits just seem to be playing about with the power_state value, which we should be able to do in the regular PSCI driver, and the SIP-specific functions seem to have nothing to do with PSCI. At the least there needs to be a much better explanation of why this is necessary, but overall I'd very much like to have *any* vendor specific code for suspend states, and if there are limitations in the standard PSCI driver we go and address those. Otherwise we're going to gain a plethora of vendor-specific suspend implementations, which is exactly what PSCI was intended to avoid in the first place. I have some specific comments below, but even with those addressed, I don't think this is the right approach, and as things stand, NAK to this. > Signed-off-by: Florian Fainelli > --- > drivers/soc/bcm/brcmstb/Kconfig | 4 +- > drivers/soc/bcm/brcmstb/pm/Makefile | 1 + > drivers/soc/bcm/brcmstb/pm/pm-psci.c | 315 ++++++++++++++++++++++ > include/linux/soc/brcmstb/brcmstb-smccc.h | 84 ++++++ > 4 files changed, 402 insertions(+), 2 deletions(-) > create mode 100644 drivers/soc/bcm/brcmstb/pm/pm-psci.c > create mode 100644 include/linux/soc/brcmstb/brcmstb-smccc.h > > diff --git a/drivers/soc/bcm/brcmstb/Kconfig b/drivers/soc/bcm/brcmstb/Kconfig > index 38e476905d96..a2b31717096e 100644 > --- a/drivers/soc/bcm/brcmstb/Kconfig > +++ b/drivers/soc/bcm/brcmstb/Kconfig > @@ -2,8 +2,8 @@ > if SOC_BRCMSTB > > config BRCMSTB_PM > - bool "Support suspend/resume for STB platforms" > - default y > + tristate "Support suspend/resume for STB platforms" > + default ARCH_BRCMSTB || BMIPS_GENERIC > depends on PM > depends on ARCH_BRCMSTB || BMIPS_GENERIC > select ARM_CPU_SUSPEND if ARM > diff --git a/drivers/soc/bcm/brcmstb/pm/Makefile b/drivers/soc/bcm/brcmstb/pm/Makefile > index 86004458260c..4ece53db8937 100644 > --- a/drivers/soc/bcm/brcmstb/pm/Makefile > +++ b/drivers/soc/bcm/brcmstb/pm/Makefile > @@ -1,4 +1,5 @@ > # SPDX-License-Identifier: GPL-2.0-only > +obj-$(CONFIG_BRCMSTB_PM) += pm-psci.o > ifndef CONFIG_ARM_PSCI_FW > obj-$(CONFIG_ARM) += s2-arm.o pm-arm.o > AFLAGS_s2-arm.o := -march=armv7-a > diff --git a/drivers/soc/bcm/brcmstb/pm/pm-psci.c b/drivers/soc/bcm/brcmstb/pm/pm-psci.c > new file mode 100644 > index 000000000000..7ba34d01c2fc > --- /dev/null > +++ b/drivers/soc/bcm/brcmstb/pm/pm-psci.c > @@ -0,0 +1,315 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Broadcom STB PSCI based system wide PM support > + * > + * Copyright © 2018-2022 Broadcom > + */ > + > +#define pr_fmt(fmt) "brcmstb-pm-psci: " fmt > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > + > +#include > +#include > + > +#include "aon_defs.h" > + > +static psci_fn *invoke_psci_fn; > +static bool brcmstb_psci_system_reset2_supported; > +static bool brcmstb_psci_system_suspend_supported; > +static bool brcmstb_psci_cpu_retention = true; > + > +static int brcmstb_psci_integ_region(unsigned long function_id, > + unsigned long base, > + unsigned long size) > +{ > + unsigned long end; > + > + if (!size) > + return -EINVAL; > + > + end = DIV_ROUND_UP(base + size, SIP_MIN_REGION_SIZE); > + base /= SIP_MIN_REGION_SIZE; > + size = end - base; > + > + return invoke_psci_fn(function_id, base, size, 0); > +} > + > +static int __maybe_unused brcmstb_psci_integ_region_set(unsigned long base, > + unsigned long size) > +{ > + return brcmstb_psci_integ_region(SIP_FUNC_INTEG_REGION_SET, base, size); > +} > + > +static int __maybe_unused brcmstb_psci_integ_region_del(unsigned long base, > + unsigned long size) > +{ > + return brcmstb_psci_integ_region(SIP_FUNC_INTEG_REGION_DEL, base, size); > +} > + > +static int brcmstb_psci_integ_region_reset_all(void) > +{ > + return invoke_psci_fn(SIP_FUNC_INTEG_REGION_RESET_ALL, 0, 0, 0); > +} What's all this? Below I see the phrase "integrity checking regions", but only the brcmstb_psci_integ_region_reset_all() function is used, and it's not clear what this is supposed to be for. > +static int brcmstb_psci_sys_reset(struct notifier_block *nb, > + unsigned long action, void *data) > +{ > + const char *cmd = data; > + /* > + * reset_type[31] = 0 (architectural) > + * reset_type[30:0] = 0 (SYSTEM_WARM_RESET) > + * cookie = 0 (ignored by the implementation) > + */ > + uint32_t reboot_type = 0; > + > + if ((action == REBOOT_COLD || action == REBOOT_WARM || > + action == REBOOT_SOFT) && > + brcmstb_psci_system_reset2_supported) { > + if (cmd && !strcmp(cmd, "powercycle")) > + reboot_type = BIT(31) | 1; > + invoke_psci_fn(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2), reboot_type, 0, 0); > + } else { > + invoke_psci_fn(PSCI_0_2_FN_SYSTEM_RESET, 0, 0, 0); > + } > + > + return NOTIFY_DONE; > +} If there are a bunch of specific SYSTEM_RESET2 values we want to expose, I'd rather we described those generically in the DT, and somehow handle that in the generic driver. > + > +static struct notifier_block brcmstb_psci_sys_reset_nb = { > + .notifier_call = brcmstb_psci_sys_reset, > + .priority = 128, > +}; > + > +void brcmstb_psci_sys_poweroff(void) > +{ > + invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF, 0, 0, 0); > +} > + > +static int psci_features(u32 psci_func_id) > +{ > + u32 features_func_id; > + > + switch (ARM_SMCCC_OWNER_NUM(psci_func_id)) { > + case ARM_SMCCC_OWNER_SIP: > + features_func_id = SIP_FUNC_PSCI_FEATURES; > + break; > + case ARM_SMCCC_OWNER_STANDARD: > + features_func_id = PSCI_1_0_FN_PSCI_FEATURES; > + break; > + default: > + return PSCI_RET_NOT_SUPPORTED; > + } > + > + return invoke_psci_fn(features_func_id, psci_func_id, 0, 0); > +} > + > +static int brcmstb_psci_enter(suspend_state_t state) > +{ > + /* Request a SYSTEM level power state with retention */ > + u32 pstate = 2 << PSCI_0_2_POWER_STATE_AFFL_SHIFT | > + !brcmstb_psci_cpu_retention << PSCI_0_2_POWER_STATE_TYPE_SHIFT; > + int ret = -EINVAL; > + > + switch (state) { > + case PM_SUSPEND_STANDBY: > + ret = psci_cpu_suspend_enter(pstate); > + break; > + case PM_SUSPEND_MEM: > + ret = brcmstb_psci_system_suspend_supported ? > + psci_system_suspend_enter(state) : -EINVAL; > + break; > + } > + > + return ret; > +} > + > +static int brcmstb_psci_valid(suspend_state_t state) > +{ > + switch (state) { > + case PM_SUSPEND_STANDBY: > + return true; > + case PM_SUSPEND_MEM: > + return brcmstb_psci_system_suspend_supported; > + default: > + return false; > + } > +} > + > +static const struct platform_suspend_ops brcmstb_psci_ops = { > + .enter = brcmstb_psci_enter, > + .valid = brcmstb_psci_valid, > +}; > + > +static int brcmstb_psci_panic_notify(struct notifier_block *nb, > + unsigned long action, void *data) > +{ > + int ret; > + > + ret = invoke_psci_fn(SIP_FUNC_PANIC_NOTIFY, BRCMSTB_PANIC_MAGIC, 0, 0); > + if (ret != PSCI_RET_SUCCESS) > + return NOTIFY_BAD; > + > + return NOTIFY_DONE; > +} > + > +static struct notifier_block brcmstb_psci_nb = { > + .notifier_call = brcmstb_psci_panic_notify, > +}; This appears to have nothing to do with idle/suspend states (and so might be OK on its own if you need it, but it should be in a separate patch with some justification). > +static ssize_t brcmstb_psci_version_show(struct kobject *kobj, > + struct kobj_attribute *attr, > + char *buf) > +{ > + struct arm_smccc_res res = { }; > + u32 version; > + > + if (invoke_psci_fn == __invoke_psci_fn_hvc) > + arm_smccc_hvc(SIP_FUNC_PSCI_BRCMSTB_VERSION, > + 0, 0, 0, 0, 0, 0, 0, &res); > + else > + arm_smccc_smc(SIP_FUNC_PSCI_BRCMSTB_VERSION, > + 0, 0, 0, 0, 0, 0, 0, &res); > + > + if (res.a0 != PSCI_RET_SUCCESS) > + return -EOPNOTSUPP; > + > + version = res.a1; > + > + return sprintf(buf, "%d.%d.%d.%d\n", > + (version >> 24) & 0xff, (version >> 16) & 0xff, > + (version >> 8) & 0xff, version & 0xff); > +} > + > +static struct kobj_attribute brcmstb_psci_version_attr = > + __ATTR(mon_version, 0400, brcmstb_psci_version_show, NULL); > + > +static ssize_t brcmstb_psci_cpu_retention_show(struct kobject *kobj, > + struct kobj_attribute *attr, > + char *buf) > +{ > + return sprintf(buf, "%d\n", brcmstb_psci_cpu_retention); > +} > + > +static ssize_t brcmstb_psci_cpu_retention_store(struct kobject *kobj, > + struct kobj_attribute *attr, > + const char *buf, size_t count) > +{ > + int ret, val; > + > + ret = kstrtoint(buf, 10, &val); > + if (ret < 0) > + return ret; > + > + if (val != 0 && val != 1) > + return -EINVAL; > + > + brcmstb_psci_cpu_retention = !!val; > + > + return count; > +} > + > +static struct kobj_attribute brcmstb_psci_cpu_retention_attr = > + __ATTR(cpu_retention, 0644, brcmstb_psci_cpu_retention_show, > + brcmstb_psci_cpu_retention_store); > + > +static const struct attribute *brcmstb_psci_attributes[] = { > + &brcmstb_psci_version_attr.attr, > + &brcmstb_psci_cpu_retention_attr.attr, > + NULL, > +}; > + > +static int brcmstb_pm_psci_init(void) > +{ > + unsigned long funcs_id[] = { > + PSCI_0_2_FN_SYSTEM_OFF, > + SIP_FUNC_INTEG_REGION_SET, > + SIP_FUNC_INTEG_REGION_DEL, > + SIP_FUNC_INTEG_REGION_RESET_ALL, > + }; > + struct arm_smccc_res res = { }; > + struct kobject *brcmstb_kobj; > + unsigned int i; > + int ret; > + > + switch (arm_smccc_1_1_get_conduit()) { > + case SMCCC_CONDUIT_HVC: > + invoke_psci_fn = __invoke_psci_fn_hvc; > + break; > + case SMCCC_CONDUIT_SMC: > + invoke_psci_fn = __invoke_psci_fn_smc; > + break; > + default: > + return -EINVAL; > + } Immediately after this switch, we know we there is *a* SMCCCv1.1+ implementation, but we have no idea *which* implementation that is. It could be Broadcom's brcmstb implementation, it could be KVM's implementation, or anyone else's... > + > + /* Check the revision of monitor */ > + if (invoke_psci_fn == __invoke_psci_fn_hvc) > + arm_smccc_hvc(SIP_SVC_REVISION, > + 0, 0, 0, 0, 0, 0, 0, &res); > + else > + arm_smccc_smc(SIP_SVC_REVISION, > + 0, 0, 0, 0, 0, 0, 0, &res); This tells us the SIP interface's revision (if implemented), but not that the SIP is Broadcom, and we still don't know that this is the brcmstb implementation specifically. > + /* Test for our supported features */ > + for (i = 0; i < ARRAY_SIZE(funcs_id); i++) { > + ret = psci_features(funcs_id[i]); > + if (ret == PSCI_RET_NOT_SUPPORTED) { > + pr_err("Firmware does not support function 0x%lx\n", > + funcs_id[i]); > + return -EOPNOTSUPP; > + } > + } For the SIP FIDs, this will invoke SIP_FUNC_PSCI_FEATURES, and since we haven't determined the specific FW implementation, that could be another SIP's function that does arbitrary things (e.g. they might just return 0, and mislead you). So this is unsafe. > + > + ret = psci_features(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2)); > + if (ret != PSCI_RET_NOT_SUPPORTED) > + brcmstb_psci_system_reset2_supported = true; > + > + ret = psci_features(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND)); > + if (ret != PSCI_RET_NOT_SUPPORTED) > + brcmstb_psci_system_suspend_supported = true; Even if we've managed to get here, we still don't know that this is a brcmstb implementation... > + > + ret = brcmstb_psci_integ_region_reset_all(); ... and as with all SIP calls, this might do arbitrary things. > + if (ret != PSCI_RET_SUCCESS) { > + pr_err("Error resetting all integrity checking regions\n"); > + return -EIO; > + } > + > + if (res.a0 == SIP_REVISION_MAJOR && res.a1 < SIP_REVISION_MINOR) { > + pr_info("Firmware is too old! Please update\n"); > + return -EOPNOTSUPP; > + } > + > + brcmstb_kobj = kobject_create_and_add("brcmstb", firmware_kobj); > + if (brcmstb_kobj) { > + ret = sysfs_create_files(brcmstb_kobj, brcmstb_psci_attributes); > + if (ret) > + return ret; > + } ... and we can register this on a non-brcmstb implementation... > + > + pm_power_off = brcmstb_psci_sys_poweroff; > + register_restart_handler(&brcmstb_psci_sys_reset_nb); > + suspend_set_ops(&brcmstb_psci_ops); > + atomic_notifier_chain_register(&panic_notifier_list, > + &brcmstb_psci_nb); ... and we break power off, restart, and suspend on other implementations ... > + pr_info("Using PSCI based system PM (full featured)\n"); This should be explicit with something like "Overriding stnadard PSCI functionaliy with brcmstb-specific code". As it stands this is at best meaningless, and at worst misleading and disparaging of standard PSCI. > + > + return 0; > +} > +module_init(brcmstb_pm_psci_init); > + > +MODULE_AUTHOR("Broadcom"); > +MODULE_DESCRIPTION("Broadcom STB PM PSCI operations"); > +MODULE_LICENSE("GPL v2"); > diff --git a/include/linux/soc/brcmstb/brcmstb-smccc.h b/include/linux/soc/brcmstb/brcmstb-smccc.h > new file mode 100644 > index 000000000000..2863e894e1c7 > --- /dev/null > +++ b/include/linux/soc/brcmstb/brcmstb-smccc.h > @@ -0,0 +1,84 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +#ifndef __BRCMSTB_SMCCC_H > +#define __BRCMSTB_SMCCC_H > + > +#include > +#include > + > +#ifdef CONFIG_64BIT > +#define PSCI_FN_NATIVE(version, name) PSCI_##version##_FN64_##name > +#else > +#define PSCI_FN_NATIVE(version, name) PSCI_##version##_FN_##name > +#endif > + > +/* Broadcom STB custom SIP function calls */ > +#define SIP_FUNC_INTEG_REGION_SET \ > + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \ > + IS_ENABLED(CONFIG_64BIT), \ > + ARM_SMCCC_OWNER_SIP, \ > + 0) > +#define SIP_FUNC_INTEG_REGION_DEL \ > + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \ > + IS_ENABLED(CONFIG_64BIT), \ > + ARM_SMCCC_OWNER_SIP, \ > + 1) > +#define SIP_FUNC_INTEG_REGION_RESET_ALL \ > + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \ > + IS_ENABLED(CONFIG_64BIT), \ > + ARM_SMCCC_OWNER_SIP, \ > + 2) > +#define SIP_FUNC_PANIC_NOTIFY \ > + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \ > + IS_ENABLED(CONFIG_64BIT), \ > + ARM_SMCCC_OWNER_SIP, \ > + 3) > +#define SIP_FUNC_PSCI_FEATURES \ > + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \ > + IS_ENABLED(CONFIG_64BIT), \ > + ARM_SMCCC_OWNER_SIP, \ > + 4) > +#define SIP_FUNC_PSCI_BRCMSTB_VERSION \ > + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \ > + IS_ENABLED(CONFIG_64BIT), \ > + ARM_SMCCC_OWNER_SIP, \ > + 5) > + > +#define SIP_SVC_REVISION \ > + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \ > + IS_ENABLED(CONFIG_64BIT), \ > + ARM_SMCCC_OWNER_SIP, \ > + 0xFF02) Looking at the SMCCC spec, isn't the "general service query" REVISION call 0xFF03? 0xFF02 is reserved. Thanks, Mark. > + > +#define SIP_MIN_REGION_SIZE 4096 > +#define SIP_REVISION_MAJOR 0 > +#define SIP_REVISION_MINOR 2 > + > +typedef unsigned long (psci_fn)(unsigned long, unsigned long, > + unsigned long, unsigned long); > + > +static inline unsigned long __invoke_psci_fn_hvc(unsigned long function_id, > + unsigned long arg0, > + unsigned long arg1, > + unsigned long arg2) > +{ > + struct arm_smccc_res res; > + > + arm_smccc_hvc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res); > + > + return res.a0; > +} > + > +static inline unsigned long __invoke_psci_fn_smc(unsigned long function_id, > + unsigned long arg0, > + unsigned long arg1, > + unsigned long arg2) > +{ > + struct arm_smccc_res res; > + > + arm_smccc_smc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res); > + > + return res.a0; > +} > + > + > +#endif /* __BRCMSTB_SMCCC_H */ > -- > 2.25.1 > 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 B331AC433F5 for ; Thu, 3 Feb 2022 12:28:35 +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=fAymxa4Qe2lkLlbgaqdRoDWzTejfWf0WQJ1WTKZqq8o=; b=Dbq+Xd0Ssk4s+Z CSrdgQXTo23+LncuANqcv7QlBCvMum4R2YxF3UUOvhE1gj8lVb3J0KNsOl5fFI7bfXpzTX0J+RriD XJ4CkgpcxyZJAYEcj5shQZKVahQK47xEf+0XzEeC/reIdx0ZYoUuanmuiTsWffZmHJV1KHGMPrTQf OyiTLiDjubDUDi41MLPRQga7tY+srgc59xNLf78l1hRMR2PmK6YYN2OoTIzR+33oJnWWuCh3CT3HB AZKEEAi9/GF/s+GdhTEfUts+BGQ+ikg/z11LRoDxuyHtZkSH+I5RGCh9SAGOZa5QDKnOjPpo6nKgO nYmCdl/bTsjTYADiJ1GQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nFbCb-001FTB-DU; Thu, 03 Feb 2022 12:27:05 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nFaw2-0018mh-QJ for linux-arm-kernel@lists.infradead.org; Thu, 03 Feb 2022 12:10:02 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 0347D11D4; Thu, 3 Feb 2022 04:09:58 -0800 (PST) Received: from FVFF77S0Q05N (unknown [172.31.20.19]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id E907A3F774; Thu, 3 Feb 2022 04:09:56 -0800 (PST) Date: Thu, 3 Feb 2022 12:09:50 +0000 From: Mark Rutland To: Florian Fainelli Cc: linux-arm-kernel@lists.infradead.org, "maintainer:BROADCOM BCM7XXX ARM ARCHITECTURE" , Lorenzo Pieralisi , open list Subject: Re: [PATCH 3/4] soc: bcm: brcmstb: Added support for PSCI system suspend operations Message-ID: References: <20220122035421.4086618-1-f.fainelli@gmail.com> <20220122035421.4086618-4-f.fainelli@gmail.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20220122035421.4086618-4-f.fainelli@gmail.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220203_040959_027423_65232DED X-CRM114-Status: GOOD ( 60.04 ) 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 SGksCgpPbiBGcmksIEphbiAyMSwgMjAyMiBhdCAwNzo1NDoyMFBNIC0wODAwLCBGbG9yaWFuIEZh aW5lbGxpIHdyb3RlOgo+IEFkZCBzdXBwb3J0IGZvciB0aGUgQnJvYWRjb20gU1RCIHN5c3RlbSBz dXNwZW5kIG9wZXJhdGlvbnMgd2hpY2gKPiBsZXZlcmFnZSB0aGUgc3RhbmRhcmQgUFNDSSBmdW5j dGlvbnMgYW5kIHVzZXMgdGhlCj4gcHNjaV9jcHVfc3VzcGVuZF9lbnRlcigpIG9wZXJhdGlvbiB0 byBwb3dlciBvZmYgdGhlIHN5c3RlbSB3aXRoIG9yCj4gd2l0aG91dCByZXRlbnRpb24gKCJlY2hv IHN0YW5kYnkgPiAvc3lzL3Bvd2VyL3N0YXRlIikuCgpXaGF0IGV4YWN0bHkgZG9lcyB0aGlzIGVu YWJsZSB0aGF0IGNhbid0IGJlIGFjaGlldmVkIHdpdGggdGhlIGV4aXN0aW5nIFBTQ0kKZHJpdmVy IGFzLWlzPwoKV2hlbiB5b3Ugc2F5ICJyZXRlbnRpb24iLCB3aGF0IHNwZWNpZmljYWxseSBkbyB5 b3UgbWVhbj8gUmV0ZW50aW9uIG9mIENQVQpzdGF0ZT8gRFJBTSBjb250ZW50cz8KCldlIGFscmVh ZHkgaGF2ZSBTWVNURU1fU1VTUEVORCBmb3Igc3RhdGVzIHdoZXJlIERSQU0gY29udGVudCBpcyBy ZXRhaW5lZCBidXQKQ1BVIChhbmQgc29tZSBzeXN0ZW0gc3RhdGUpIGlzIGxvc3QsIGFuZCBJSVVD IHdlIGNhbiBkbyBzdXNwZW5kLXRvLWlkbGUgd2l0aApDUFVfU1VTUEVORCBzdGF0ZXMuCgppbnRl cmZhY2UgbmVjZXNzYXJ5PwoKPiBUaGUgc3lzdGVtIHJlc2V0IHBhdGggYWxzbyBzdXBwb3J0cyBh IHNwZWNpYWwgInBvd2VyY3ljbGUiIG1vZGUgd2hpY2gKPiBzaWduYWxzIHRvIHRoZSBBUk0gVHJ1 c3RlZCBGaXJtd2FyZSB0aGF0IGFuIGV4dGVybmFsIFBNSUMgY2hpcCBtdXN0Cj4gZm9yY2UgdGhl IFNvQyBpbnRvIGEgcG93ZXIgY3ljbGUuCgpIb3cgZG9lcyB0aGF0IGNvbXBhcmUgdG8gdGhlIHJl Z3VsYXIgU1lTVEVNX1JFU0VUIGNhbGw/CgpUaGUgUFNDSSBzcGVjIHNheXMgb2YgU1lTVEVNX1JF U0VUOgoKfCBUaGlzIGZ1bmN0aW9uIHByb3ZpZGVzIGEgbWV0aG9kIGZvciBwZXJmb3JtaW5nIGEg c3lzdGVtIGNvbGQgcmVzZXQuIFRvIHRoZQp8IGNhbGxlciwgdGhlIGJlaGF2aW9yIGlzIGVxdWl2 YWxlbnQgdG8gYSBoYXJkd2FyZSBwb3dlci1jeWNsZSBzZXF1ZW5jZS4KCi4uLiBzbyBJIGRvbid0 IGZvbGxvdyBob3cgdGhpcyBpcyBkaWZmZXJlbnQsIHVubGVzcyB0aGlzIHBsYXRmb3JtJ3MKU1lT VEVNX1JFU0VUIGltcGxlbWVudGF0aW9uIGlzICpub3QqIGFjdHVhbGx5IHBlcmZvcm1pbmcgYSBz eXN0ZW0gY29sZCByZXNldD8KCklmIHRoYXQgKmRvZXNuJ3QqIHBlcmZvcm0gYSBjb2xkIHJlc3Qs IGl0IHNlZW1zIGxpa2UgYSBidWc/Cgo+IEFzIG11Y2ggYXMgcG9zc2libGUgZXh0ZW5zaW9ucyB3 ZXJlIGJ1aWx0IHVzaW5nIHRoZSBTSVAgbmFtZXNwYWNlIHJhdGhlcgo+IHRoYW4gdGhlIHN0YW5k YXJkIFBTQ0kgbmFtZXNwYWNlLCBob3dldmVyIGNvbXBhdGliaWxpdHkgd2l0aCB0aGUKPiBzdGFu ZGFyZCBQU0NJIGltcGxlbWVudGF0aW9uIGlzIHJldGFpbmVkIHdoZW4gQ09ORklHX0JSQ01TVEJf UE0gaXMgbm90Cj4gc2VsZWN0ZWQuCgpJIHJlYWxseSBkb24ndCBsaWtlIHRoaXMsIGJlY2F1c2Ug aXQgc2VlbXMgdG8gYmUgY3JlYXRpbmcgYSBwYXJhbGxlbAppbmZyYXN0cnVjdHVyZSBmb3IgZG9p bmcgdGhpbmdzIHRoYXQgY2FuICphbHJlYWR5KiBiZSBkb25lIHdpdGggc3RhbmRhcmQgUFNDSQpk cml2ZXIuIFRoZSBhY3R1YWwgUFNDSSBiaXRzIGp1c3Qgc2VlbSB0byBiZSBwbGF5aW5nIGFib3V0 IHdpdGggdGhlIHBvd2VyX3N0YXRlCnZhbHVlLCB3aGljaCB3ZSBzaG91bGQgYmUgYWJsZSB0byBk byBpbiB0aGUgcmVndWxhciBQU0NJIGRyaXZlciwgYW5kIHRoZQpTSVAtc3BlY2lmaWMgZnVuY3Rp b25zIHNlZW0gdG8gaGF2ZSBub3RoaW5nIHRvIGRvIHdpdGggUFNDSS4KCkF0IHRoZSBsZWFzdCB0 aGVyZSBuZWVkcyB0byBiZSBhIG11Y2ggYmV0dGVyIGV4cGxhbmF0aW9uIG9mIHdoeSB0aGlzIGlz Cm5lY2Vzc2FyeSwgYnV0IG92ZXJhbGwgSSdkIHZlcnkgbXVjaCBsaWtlIHRvIGhhdmUgKmFueSog dmVuZG9yIHNwZWNpZmljIGNvZGUKZm9yIHN1c3BlbmQgc3RhdGVzLCBhbmQgaWYgdGhlcmUgYXJl IGxpbWl0YXRpb25zIGluIHRoZSBzdGFuZGFyZCBQU0NJIGRyaXZlciB3ZQpnbyBhbmQgYWRkcmVz cyB0aG9zZS4gT3RoZXJ3aXNlIHdlJ3JlIGdvaW5nIHRvIGdhaW4gYSBwbGV0aG9yYSBvZgp2ZW5k b3Itc3BlY2lmaWMgc3VzcGVuZCBpbXBsZW1lbnRhdGlvbnMsIHdoaWNoIGlzIGV4YWN0bHkgd2hh dCBQU0NJIHdhcwppbnRlbmRlZCB0byBhdm9pZCBpbiB0aGUgZmlyc3QgcGxhY2UuCgpJIGhhdmUg c29tZSBzcGVjaWZpYyBjb21tZW50cyBiZWxvdywgYnV0IGV2ZW4gd2l0aCB0aG9zZSBhZGRyZXNz ZWQsIEkgZG9uJ3QKdGhpbmsgdGhpcyBpcyB0aGUgcmlnaHQgYXBwcm9hY2gsIGFuZCBhcyB0aGlu Z3Mgc3RhbmQsIE5BSyB0byB0aGlzLgoKPiBTaWduZWQtb2ZmLWJ5OiBGbG9yaWFuIEZhaW5lbGxp IDxmLmZhaW5lbGxpQGdtYWlsLmNvbT4KPiAtLS0KPiAgZHJpdmVycy9zb2MvYmNtL2JyY21zdGIv S2NvbmZpZyAgICAgICAgICAgfCAgIDQgKy0KPiAgZHJpdmVycy9zb2MvYmNtL2JyY21zdGIvcG0v TWFrZWZpbGUgICAgICAgfCAgIDEgKwo+ICBkcml2ZXJzL3NvYy9iY20vYnJjbXN0Yi9wbS9wbS1w c2NpLmMgICAgICB8IDMxNSArKysrKysrKysrKysrKysrKysrKysrCj4gIGluY2x1ZGUvbGludXgv c29jL2JyY21zdGIvYnJjbXN0Yi1zbWNjYy5oIHwgIDg0ICsrKysrKwo+ICA0IGZpbGVzIGNoYW5n ZWQsIDQwMiBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQo+ICBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9zb2MvYmNtL2JyY21zdGIvcG0vcG0tcHNjaS5jCj4gIGNyZWF0ZSBtb2RlIDEw MDY0NCBpbmNsdWRlL2xpbnV4L3NvYy9icmNtc3RiL2JyY21zdGItc21jY2MuaAo+IAo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL3NvYy9iY20vYnJjbXN0Yi9LY29uZmlnIGIvZHJpdmVycy9zb2MvYmNt L2JyY21zdGIvS2NvbmZpZwo+IGluZGV4IDM4ZTQ3NjkwNWQ5Ni4uYTJiMzE3MTcwOTZlIDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvc29jL2JjbS9icmNtc3RiL0tjb25maWcKPiArKysgYi9kcml2ZXJz L3NvYy9iY20vYnJjbXN0Yi9LY29uZmlnCj4gQEAgLTIsOCArMiw4IEBACj4gIGlmIFNPQ19CUkNN U1RCCj4gIAo+ICBjb25maWcgQlJDTVNUQl9QTQo+IC0JYm9vbCAiU3VwcG9ydCBzdXNwZW5kL3Jl c3VtZSBmb3IgU1RCIHBsYXRmb3JtcyIKPiAtCWRlZmF1bHQgeQo+ICsJdHJpc3RhdGUgIlN1cHBv cnQgc3VzcGVuZC9yZXN1bWUgZm9yIFNUQiBwbGF0Zm9ybXMiCj4gKwlkZWZhdWx0IEFSQ0hfQlJD TVNUQiB8fCBCTUlQU19HRU5FUklDCj4gIAlkZXBlbmRzIG9uIFBNCj4gIAlkZXBlbmRzIG9uIEFS Q0hfQlJDTVNUQiB8fCBCTUlQU19HRU5FUklDCj4gIAlzZWxlY3QgQVJNX0NQVV9TVVNQRU5EIGlm IEFSTQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3NvYy9iY20vYnJjbXN0Yi9wbS9NYWtlZmlsZSBi L2RyaXZlcnMvc29jL2JjbS9icmNtc3RiL3BtL01ha2VmaWxlCj4gaW5kZXggODYwMDQ0NTgyNjBj Li40ZWNlNTNkYjg5MzcgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9zb2MvYmNtL2JyY21zdGIvcG0v TWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL3NvYy9iY20vYnJjbXN0Yi9wbS9NYWtlZmlsZQo+IEBA IC0xLDQgKzEsNSBAQAo+ICAjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkK PiArb2JqLSQoQ09ORklHX0JSQ01TVEJfUE0pCSs9IHBtLXBzY2kubwo+ICBpZm5kZWYgQ09ORklH X0FSTV9QU0NJX0ZXCj4gIG9iai0kKENPTkZJR19BUk0pCQkrPSBzMi1hcm0ubyBwbS1hcm0ubwo+ ICBBRkxBR1NfczItYXJtLm8JCQk6PSAtbWFyY2g9YXJtdjctYQo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL3NvYy9iY20vYnJjbXN0Yi9wbS9wbS1wc2NpLmMgYi9kcml2ZXJzL3NvYy9iY20vYnJjbXN0 Yi9wbS9wbS1wc2NpLmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAw MC4uN2JhMzRkMDFjMmZjCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvc29jL2JjbS9i cmNtc3RiL3BtL3BtLXBzY2kuYwo+IEBAIC0wLDAgKzEsMzE1IEBACj4gKy8vIFNQRFgtTGljZW5z ZS1JZGVudGlmaWVyOiBHUEwtMi4wCj4gKy8qCj4gKyAqIEJyb2FkY29tIFNUQiBQU0NJIGJhc2Vk IHN5c3RlbSB3aWRlIFBNIHN1cHBvcnQKPiArICoKPiArICogQ29weXJpZ2h0IMKpIDIwMTgtMjAy MiBCcm9hZGNvbQo+ICsgKi8KPiArCj4gKyNkZWZpbmUgcHJfZm10KGZtdCkgImJyY21zdGItcG0t cHNjaTogIiBmbXQKPiArCj4gKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KPiArI2luY2x1ZGUg PGxpbnV4L21vZHVsZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvYXJtLXNtY2NjLmg+Cj4gKyNpbmNs dWRlIDxsaW51eC9wYW5pY19ub3RpZmllci5oPgo+ICsjaW5jbHVkZSA8bGludXgvcHNjaS5oPgo+ ICsjaW5jbHVkZSA8bGludXgvc3VzcGVuZC5oPgo+ICsjaW5jbHVkZSA8bGludXgvc29jL2JyY21z dGIvYnJjbXN0Yi5oPgo+ICsjaW5jbHVkZSA8bGludXgvc29jL2JyY21zdGIvYnJjbXN0Yi1zbWNj Yy5oPgo+ICsjaW5jbHVkZSA8bGludXgvcmVib290Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9rb2Jq ZWN0Lmg+Cj4gKwo+ICsjaW5jbHVkZSA8dWFwaS9saW51eC9wc2NpLmg+Cj4gKwo+ICsjaW5jbHVk ZSA8YXNtL3N1c3BlbmQuaD4KPiArI2luY2x1ZGUgPGFzbS9zeXN0ZW1fbWlzYy5oPgo+ICsKPiAr I2luY2x1ZGUgImFvbl9kZWZzLmgiCj4gKwo+ICtzdGF0aWMgcHNjaV9mbiAqaW52b2tlX3BzY2lf Zm47Cj4gK3N0YXRpYyBib29sIGJyY21zdGJfcHNjaV9zeXN0ZW1fcmVzZXQyX3N1cHBvcnRlZDsK PiArc3RhdGljIGJvb2wgYnJjbXN0Yl9wc2NpX3N5c3RlbV9zdXNwZW5kX3N1cHBvcnRlZDsKPiAr c3RhdGljIGJvb2wgYnJjbXN0Yl9wc2NpX2NwdV9yZXRlbnRpb24gPSB0cnVlOwo+ICsKPiArc3Rh dGljIGludCBicmNtc3RiX3BzY2lfaW50ZWdfcmVnaW9uKHVuc2lnbmVkIGxvbmcgZnVuY3Rpb25f aWQsCj4gKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgYmFzZSwKPiArCQkJCSAgICAgdW5zaWduZWQg bG9uZyBzaXplKQo+ICt7Cj4gKwl1bnNpZ25lZCBsb25nIGVuZDsKPiArCj4gKwlpZiAoIXNpemUp Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwo+ICsJZW5kID0gRElWX1JPVU5EX1VQKGJhc2UgKyBz aXplLCBTSVBfTUlOX1JFR0lPTl9TSVpFKTsKPiArCWJhc2UgLz0gU0lQX01JTl9SRUdJT05fU0la RTsKPiArCXNpemUgPSBlbmQgLSBiYXNlOwo+ICsKPiArCXJldHVybiBpbnZva2VfcHNjaV9mbihm dW5jdGlvbl9pZCwgYmFzZSwgc2l6ZSwgMCk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgX19tYXli ZV91bnVzZWQgYnJjbXN0Yl9wc2NpX2ludGVnX3JlZ2lvbl9zZXQodW5zaWduZWQgbG9uZyBiYXNl LAo+ICsJCQkJCQkJdW5zaWduZWQgbG9uZyBzaXplKQo+ICt7Cj4gKwlyZXR1cm4gYnJjbXN0Yl9w c2NpX2ludGVnX3JlZ2lvbihTSVBfRlVOQ19JTlRFR19SRUdJT05fU0VULCBiYXNlLCBzaXplKTsK PiArfQo+ICsKPiArc3RhdGljIGludCBfX21heWJlX3VudXNlZCBicmNtc3RiX3BzY2lfaW50ZWdf cmVnaW9uX2RlbCh1bnNpZ25lZCBsb25nIGJhc2UsCj4gKwkJCQkJCQl1bnNpZ25lZCBsb25nIHNp emUpCj4gK3sKPiArCXJldHVybiBicmNtc3RiX3BzY2lfaW50ZWdfcmVnaW9uKFNJUF9GVU5DX0lO VEVHX1JFR0lPTl9ERUwsIGJhc2UsIHNpemUpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGJyY21z dGJfcHNjaV9pbnRlZ19yZWdpb25fcmVzZXRfYWxsKHZvaWQpCj4gK3sKPiArCXJldHVybiBpbnZv a2VfcHNjaV9mbihTSVBfRlVOQ19JTlRFR19SRUdJT05fUkVTRVRfQUxMLCAwLCAwLCAwKTsKPiAr fQoKV2hhdCdzIGFsbCB0aGlzPyBCZWxvdyBJIHNlZSB0aGUgcGhyYXNlICJpbnRlZ3JpdHkgY2hl Y2tpbmcgcmVnaW9ucyIsIGJ1dCBvbmx5CnRoZSBicmNtc3RiX3BzY2lfaW50ZWdfcmVnaW9uX3Jl c2V0X2FsbCgpIGZ1bmN0aW9uIGlzIHVzZWQsIGFuZCBpdCdzIG5vdCBjbGVhcgp3aGF0IHRoaXMg aXMgc3VwcG9zZWQgdG8gYmUgZm9yLgoKPiArc3RhdGljIGludCBicmNtc3RiX3BzY2lfc3lzX3Jl c2V0KHN0cnVjdCBub3RpZmllcl9ibG9jayAqbmIsCj4gKwkJCQkgIHVuc2lnbmVkIGxvbmcgYWN0 aW9uLCB2b2lkICpkYXRhKQo+ICt7Cj4gKwljb25zdCBjaGFyICpjbWQgPSBkYXRhOwo+ICsJLyoK PiArCSAqIHJlc2V0X3R5cGVbMzFdID0gMCAoYXJjaGl0ZWN0dXJhbCkKPiArCSAqIHJlc2V0X3R5 cGVbMzA6MF0gPSAwIChTWVNURU1fV0FSTV9SRVNFVCkKPiArCSAqIGNvb2tpZSA9IDAgKGlnbm9y ZWQgYnkgdGhlIGltcGxlbWVudGF0aW9uKQo+ICsJICovCj4gKwl1aW50MzJfdCByZWJvb3RfdHlw ZSA9IDA7Cj4gKwo+ICsJaWYgKChhY3Rpb24gPT0gUkVCT09UX0NPTEQgfHwgYWN0aW9uID09IFJF Qk9PVF9XQVJNIHx8Cj4gKwkgICAgYWN0aW9uID09IFJFQk9PVF9TT0ZUKSAmJgo+ICsJICAgIGJy Y21zdGJfcHNjaV9zeXN0ZW1fcmVzZXQyX3N1cHBvcnRlZCkgewo+ICsJCWlmIChjbWQgJiYgIXN0 cmNtcChjbWQsICJwb3dlcmN5Y2xlIikpCj4gKwkJCXJlYm9vdF90eXBlID0gQklUKDMxKSB8IDE7 Cj4gKwkJaW52b2tlX3BzY2lfZm4oUFNDSV9GTl9OQVRJVkUoMV8xLCBTWVNURU1fUkVTRVQyKSwg cmVib290X3R5cGUsIDAsIDApOwo+ICsJfSBlbHNlIHsKPiArCQlpbnZva2VfcHNjaV9mbihQU0NJ XzBfMl9GTl9TWVNURU1fUkVTRVQsIDAsIDAsIDApOwo+ICsJfQo+ICsKPiArCXJldHVybiBOT1RJ RllfRE9ORTsKPiArfQoKSWYgdGhlcmUgYXJlIGEgYnVuY2ggb2Ygc3BlY2lmaWMgU1lTVEVNX1JF U0VUMiB2YWx1ZXMgd2Ugd2FudCB0byBleHBvc2UsIEknZApyYXRoZXIgd2UgZGVzY3JpYmVkIHRo b3NlIGdlbmVyaWNhbGx5IGluIHRoZSBEVCwgYW5kIHNvbWVob3cgaGFuZGxlIHRoYXQgaW4gdGhl CmdlbmVyaWMgZHJpdmVyLgoKPiArCj4gK3N0YXRpYyBzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgYnJj bXN0Yl9wc2NpX3N5c19yZXNldF9uYiA9IHsKPiArCS5ub3RpZmllcl9jYWxsCT0gYnJjbXN0Yl9w c2NpX3N5c19yZXNldCwKPiArCS5wcmlvcml0eQk9IDEyOCwKPiArfTsKPiArCj4gK3ZvaWQgYnJj bXN0Yl9wc2NpX3N5c19wb3dlcm9mZih2b2lkKQo+ICt7Cj4gKwlpbnZva2VfcHNjaV9mbihQU0NJ XzBfMl9GTl9TWVNURU1fT0ZGLCAwLCAwLCAwKTsKPiArfQo+ICsKPiArc3RhdGljIGludCBwc2Np X2ZlYXR1cmVzKHUzMiBwc2NpX2Z1bmNfaWQpCj4gK3sKPiArCXUzMiBmZWF0dXJlc19mdW5jX2lk Owo+ICsKPiArCXN3aXRjaCAoQVJNX1NNQ0NDX09XTkVSX05VTShwc2NpX2Z1bmNfaWQpKSB7Cj4g KwljYXNlIEFSTV9TTUNDQ19PV05FUl9TSVA6Cj4gKwkJZmVhdHVyZXNfZnVuY19pZCA9IFNJUF9G VU5DX1BTQ0lfRkVBVFVSRVM7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIEFSTV9TTUNDQ19PV05FUl9T VEFOREFSRDoKPiArCQlmZWF0dXJlc19mdW5jX2lkID0gUFNDSV8xXzBfRk5fUFNDSV9GRUFUVVJF UzsKPiArCQlicmVhazsKPiArCWRlZmF1bHQ6Cj4gKwkJcmV0dXJuIFBTQ0lfUkVUX05PVF9TVVBQ T1JURUQ7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIGludm9rZV9wc2NpX2ZuKGZlYXR1cmVzX2Z1bmNf aWQsIHBzY2lfZnVuY19pZCwgMCwgMCk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgYnJjbXN0Yl9w c2NpX2VudGVyKHN1c3BlbmRfc3RhdGVfdCBzdGF0ZSkKPiArewo+ICsJLyogUmVxdWVzdCBhIFNZ U1RFTSBsZXZlbCBwb3dlciBzdGF0ZSB3aXRoIHJldGVudGlvbiAqLwo+ICsJdTMyIHBzdGF0ZSA9 IDIgPDwgUFNDSV8wXzJfUE9XRVJfU1RBVEVfQUZGTF9TSElGVCB8Cj4gKwkJICAgICAhYnJjbXN0 Yl9wc2NpX2NwdV9yZXRlbnRpb24gPDwgUFNDSV8wXzJfUE9XRVJfU1RBVEVfVFlQRV9TSElGVDsK PiArCWludCByZXQgPSAtRUlOVkFMOwo+ICsKPiArCXN3aXRjaCAoc3RhdGUpIHsKPiArCWNhc2Ug UE1fU1VTUEVORF9TVEFOREJZOgo+ICsJCXJldCA9IHBzY2lfY3B1X3N1c3BlbmRfZW50ZXIocHN0 YXRlKTsKPiArCQlicmVhazsKPiArCWNhc2UgUE1fU1VTUEVORF9NRU06Cj4gKwkJcmV0ID0gYnJj bXN0Yl9wc2NpX3N5c3RlbV9zdXNwZW5kX3N1cHBvcnRlZCA/Cj4gKwkJCSBwc2NpX3N5c3RlbV9z dXNwZW5kX2VudGVyKHN0YXRlKSA6IC1FSU5WQUw7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwo+ICsJ cmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIGludCBicmNtc3RiX3BzY2lfdmFsaWQoc3Vz cGVuZF9zdGF0ZV90IHN0YXRlKQo+ICt7Cj4gKwlzd2l0Y2ggKHN0YXRlKSB7Cj4gKwljYXNlIFBN X1NVU1BFTkRfU1RBTkRCWToKPiArCQlyZXR1cm4gdHJ1ZTsKPiArCWNhc2UgUE1fU1VTUEVORF9N RU06Cj4gKwkJcmV0dXJuIGJyY21zdGJfcHNjaV9zeXN0ZW1fc3VzcGVuZF9zdXBwb3J0ZWQ7Cj4g KwlkZWZhdWx0Ogo+ICsJCXJldHVybiBmYWxzZTsKPiArCX0KPiArfQo+ICsKPiArc3RhdGljIGNv bnN0IHN0cnVjdCBwbGF0Zm9ybV9zdXNwZW5kX29wcyBicmNtc3RiX3BzY2lfb3BzID0gewo+ICsJ LmVudGVyCT0gYnJjbXN0Yl9wc2NpX2VudGVyLAo+ICsJLnZhbGlkCT0gYnJjbXN0Yl9wc2NpX3Zh bGlkLAo+ICt9Owo+ICsKPiArc3RhdGljIGludCBicmNtc3RiX3BzY2lfcGFuaWNfbm90aWZ5KHN0 cnVjdCBub3RpZmllcl9ibG9jayAqbmIsCj4gKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgYWN0aW9u LCB2b2lkICpkYXRhKQo+ICt7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IGludm9rZV9wc2Np X2ZuKFNJUF9GVU5DX1BBTklDX05PVElGWSwgQlJDTVNUQl9QQU5JQ19NQUdJQywgMCwgMCk7Cj4g KwlpZiAocmV0ICE9IFBTQ0lfUkVUX1NVQ0NFU1MpCj4gKwkJcmV0dXJuIE5PVElGWV9CQUQ7Cj4g Kwo+ICsJcmV0dXJuIE5PVElGWV9ET05FOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0IG5vdGlm aWVyX2Jsb2NrIGJyY21zdGJfcHNjaV9uYiA9IHsKPiArCS5ub3RpZmllcl9jYWxsID0gYnJjbXN0 Yl9wc2NpX3BhbmljX25vdGlmeSwKPiArfTsKClRoaXMgYXBwZWFycyB0byBoYXZlIG5vdGhpbmcg dG8gZG8gd2l0aCBpZGxlL3N1c3BlbmQgc3RhdGVzIChhbmQgc28gbWlnaHQgYmUgT0sKb24gaXRz IG93biBpZiB5b3UgbmVlZCBpdCwgYnV0IGl0IHNob3VsZCBiZSBpbiBhIHNlcGFyYXRlIHBhdGNo IHdpdGggc29tZQpqdXN0aWZpY2F0aW9uKS4KCj4gK3N0YXRpYyBzc2l6ZV90IGJyY21zdGJfcHNj aV92ZXJzaW9uX3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmosCj4gKwkJCQkJIHN0cnVjdCBrb2Jq X2F0dHJpYnV0ZSAqYXR0ciwKPiArCQkJCQkgY2hhciAqYnVmKQo+ICt7Cj4gKwlzdHJ1Y3QgYXJt X3NtY2NjX3JlcyByZXMgPSB7IH07Cj4gKwl1MzIgdmVyc2lvbjsKPiArCj4gKwlpZiAoaW52b2tl X3BzY2lfZm4gPT0gX19pbnZva2VfcHNjaV9mbl9odmMpCj4gKwkJYXJtX3NtY2NjX2h2YyhTSVBf RlVOQ19QU0NJX0JSQ01TVEJfVkVSU0lPTiwKPiArCQkJICAgICAgMCwgMCwgMCwgMCwgMCwgMCwg MCwgJnJlcyk7Cj4gKwllbHNlCj4gKwkJYXJtX3NtY2NjX3NtYyhTSVBfRlVOQ19QU0NJX0JSQ01T VEJfVkVSU0lPTiwKPiArCQkJICAgICAgMCwgMCwgMCwgMCwgMCwgMCwgMCwgJnJlcyk7Cj4gKwo+ ICsJaWYgKHJlcy5hMCAhPSBQU0NJX1JFVF9TVUNDRVNTKQo+ICsJCXJldHVybiAtRU9QTk9UU1VQ UDsKPiArCj4gKwl2ZXJzaW9uID0gcmVzLmExOwo+ICsKPiArCXJldHVybiBzcHJpbnRmKGJ1Ziwg IiVkLiVkLiVkLiVkXG4iLAo+ICsJCSAgICAgICAodmVyc2lvbiA+PiAyNCkgJiAweGZmLCAodmVy c2lvbiA+PiAxNikgJiAweGZmLAo+ICsJCSAgICAgICAodmVyc2lvbiA+PiA4KSAmIDB4ZmYsIHZl cnNpb24gJiAweGZmKTsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSBi cmNtc3RiX3BzY2lfdmVyc2lvbl9hdHRyID0KPiArCV9fQVRUUihtb25fdmVyc2lvbiwgMDQwMCwg YnJjbXN0Yl9wc2NpX3ZlcnNpb25fc2hvdywgTlVMTCk7Cj4gKwo+ICtzdGF0aWMgc3NpemVfdCBi cmNtc3RiX3BzY2lfY3B1X3JldGVudGlvbl9zaG93KHN0cnVjdCBrb2JqZWN0ICprb2JqLAo+ICsJ CQkJCSAgICAgICBzdHJ1Y3Qga29ial9hdHRyaWJ1dGUgKmF0dHIsCj4gKwkJCQkJICAgICAgIGNo YXIgKmJ1ZikKPiArewo+ICsJcmV0dXJuIHNwcmludGYoYnVmLCAiJWRcbiIsIGJyY21zdGJfcHNj aV9jcHVfcmV0ZW50aW9uKTsKPiArfQo+ICsKPiArc3RhdGljIHNzaXplX3QgYnJjbXN0Yl9wc2Np X2NwdV9yZXRlbnRpb25fc3RvcmUoc3RydWN0IGtvYmplY3QgKmtvYmosCj4gKwkJCQkJCXN0cnVj dCBrb2JqX2F0dHJpYnV0ZSAqYXR0ciwKPiArCQkJCQkJY29uc3QgY2hhciAqYnVmLCBzaXplX3Qg Y291bnQpCj4gK3sKPiArCWludCByZXQsIHZhbDsKPiArCj4gKwlyZXQgPSBrc3RydG9pbnQoYnVm LCAxMCwgJnZhbCk7Cj4gKwlpZiAocmV0IDwgMCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCWlm ICh2YWwgIT0gMCAmJiB2YWwgIT0gMSkKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwlicmNt c3RiX3BzY2lfY3B1X3JldGVudGlvbiA9ICEhdmFsOwo+ICsKPiArCXJldHVybiBjb3VudDsKPiAr fQo+ICsKPiArc3RhdGljIHN0cnVjdCBrb2JqX2F0dHJpYnV0ZSBicmNtc3RiX3BzY2lfY3B1X3Jl dGVudGlvbl9hdHRyID0KPiArCV9fQVRUUihjcHVfcmV0ZW50aW9uLCAwNjQ0LCBicmNtc3RiX3Bz Y2lfY3B1X3JldGVudGlvbl9zaG93LAo+ICsJICAgICAgIGJyY21zdGJfcHNjaV9jcHVfcmV0ZW50 aW9uX3N0b3JlKTsKPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYXR0cmlidXRlICpicmNtc3Ri X3BzY2lfYXR0cmlidXRlc1tdID0gewo+ICsJJmJyY21zdGJfcHNjaV92ZXJzaW9uX2F0dHIuYXR0 ciwKPiArCSZicmNtc3RiX3BzY2lfY3B1X3JldGVudGlvbl9hdHRyLmF0dHIsCj4gKwlOVUxMLAo+ ICt9Owo+ICsKPiArc3RhdGljIGludCBicmNtc3RiX3BtX3BzY2lfaW5pdCh2b2lkKQo+ICt7Cj4g Kwl1bnNpZ25lZCBsb25nIGZ1bmNzX2lkW10gPSB7Cj4gKwkJUFNDSV8wXzJfRk5fU1lTVEVNX09G RiwKPiArCQlTSVBfRlVOQ19JTlRFR19SRUdJT05fU0VULAo+ICsJCVNJUF9GVU5DX0lOVEVHX1JF R0lPTl9ERUwsCj4gKwkJU0lQX0ZVTkNfSU5URUdfUkVHSU9OX1JFU0VUX0FMTCwKPiArCX07Cj4g KwlzdHJ1Y3QgYXJtX3NtY2NjX3JlcyByZXMgPSB7IH07Cj4gKwlzdHJ1Y3Qga29iamVjdCAqYnJj bXN0Yl9rb2JqOwo+ICsJdW5zaWduZWQgaW50IGk7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXN3aXRj aCAoYXJtX3NtY2NjXzFfMV9nZXRfY29uZHVpdCgpKSB7Cj4gKwljYXNlIFNNQ0NDX0NPTkRVSVRf SFZDOgo+ICsJCWludm9rZV9wc2NpX2ZuID0gX19pbnZva2VfcHNjaV9mbl9odmM7Cj4gKwkJYnJl YWs7Cj4gKwljYXNlIFNNQ0NDX0NPTkRVSVRfU01DOgo+ICsJCWludm9rZV9wc2NpX2ZuID0gX19p bnZva2VfcHNjaV9mbl9zbWM7Cj4gKwkJYnJlYWs7Cj4gKwlkZWZhdWx0Ogo+ICsJCXJldHVybiAt RUlOVkFMOwo+ICsJfQoKSW1tZWRpYXRlbHkgYWZ0ZXIgdGhpcyBzd2l0Y2gsIHdlIGtub3cgd2Ug dGhlcmUgaXMgKmEqIFNNQ0NDdjEuMSsKaW1wbGVtZW50YXRpb24sIGJ1dCB3ZSBoYXZlIG5vIGlk ZWEgKndoaWNoKiBpbXBsZW1lbnRhdGlvbiB0aGF0IGlzLiBJdCBjb3VsZCBiZQpCcm9hZGNvbSdz IGJyY21zdGIgaW1wbGVtZW50YXRpb24sIGl0IGNvdWxkIGJlIEtWTSdzIGltcGxlbWVudGF0aW9u LCBvciBhbnlvbmUKZWxzZSdzLi4uCgo+ICsKPiArCS8qIENoZWNrIHRoZSByZXZpc2lvbiBvZiBt b25pdG9yICovCj4gKwlpZiAoaW52b2tlX3BzY2lfZm4gPT0gX19pbnZva2VfcHNjaV9mbl9odmMp Cj4gKwkJYXJtX3NtY2NjX2h2YyhTSVBfU1ZDX1JFVklTSU9OLAo+ICsJCQkgICAgICAwLCAwLCAw LCAwLCAwLCAwLCAwLCAmcmVzKTsKPiArCWVsc2UKPiArCQlhcm1fc21jY2Nfc21jKFNJUF9TVkNf UkVWSVNJT04sCj4gKwkJCSAgICAgIDAsIDAsIDAsIDAsIDAsIDAsIDAsICZyZXMpOwoKVGhpcyB0 ZWxscyB1cyB0aGUgU0lQIGludGVyZmFjZSdzIHJldmlzaW9uIChpZiBpbXBsZW1lbnRlZCksIGJ1 dCBub3QgdGhhdCB0aGUKU0lQIGlzIEJyb2FkY29tLCBhbmQgd2Ugc3RpbGwgZG9uJ3Qga25vdyB0 aGF0IHRoaXMgaXMgdGhlIGJyY21zdGIKaW1wbGVtZW50YXRpb24gc3BlY2lmaWNhbGx5LgoKPiAr CS8qIFRlc3QgZm9yIG91ciBzdXBwb3J0ZWQgZmVhdHVyZXMgKi8KPiArCWZvciAoaSA9IDA7IGkg PCBBUlJBWV9TSVpFKGZ1bmNzX2lkKTsgaSsrKSB7Cj4gKwkJcmV0ID0gcHNjaV9mZWF0dXJlcyhm dW5jc19pZFtpXSk7Cj4gKwkJaWYgKHJldCA9PSBQU0NJX1JFVF9OT1RfU1VQUE9SVEVEKSB7Cj4g KwkJCXByX2VycigiRmlybXdhcmUgZG9lcyBub3Qgc3VwcG9ydCBmdW5jdGlvbiAweCVseFxuIiwK PiArCQkJICAgICAgIGZ1bmNzX2lkW2ldKTsKPiArCQkJcmV0dXJuIC1FT1BOT1RTVVBQOwo+ICsJ CX0KPiArCX0KCkZvciB0aGUgU0lQIEZJRHMsIHRoaXMgd2lsbCBpbnZva2UgU0lQX0ZVTkNfUFND SV9GRUFUVVJFUywgYW5kIHNpbmNlIHdlIGhhdmVuJ3QKZGV0ZXJtaW5lZCB0aGUgc3BlY2lmaWMg RlcgaW1wbGVtZW50YXRpb24sIHRoYXQgY291bGQgYmUgYW5vdGhlciBTSVAncyBmdW5jdGlvbgp0 aGF0IGRvZXMgYXJiaXRyYXJ5IHRoaW5ncyAoZS5nLiB0aGV5IG1pZ2h0IGp1c3QgcmV0dXJuIDAs IGFuZCBtaXNsZWFkIHlvdSkuCgpTbyB0aGlzIGlzIHVuc2FmZS4KCj4gKwo+ICsJcmV0ID0gcHNj aV9mZWF0dXJlcyhQU0NJX0ZOX05BVElWRSgxXzEsIFNZU1RFTV9SRVNFVDIpKTsKPiArCWlmIChy ZXQgIT0gUFNDSV9SRVRfTk9UX1NVUFBPUlRFRCkKPiArCQlicmNtc3RiX3BzY2lfc3lzdGVtX3Jl c2V0Ml9zdXBwb3J0ZWQgPSB0cnVlOwo+ICsKPiArCXJldCA9IHBzY2lfZmVhdHVyZXMoUFNDSV9G Tl9OQVRJVkUoMV8wLCBTWVNURU1fU1VTUEVORCkpOwo+ICsJaWYgKHJldCAhPSBQU0NJX1JFVF9O T1RfU1VQUE9SVEVEKQo+ICsJCWJyY21zdGJfcHNjaV9zeXN0ZW1fc3VzcGVuZF9zdXBwb3J0ZWQg PSB0cnVlOwoKRXZlbiBpZiB3ZSd2ZSBtYW5hZ2VkIHRvIGdldCBoZXJlLCB3ZSBzdGlsbCBkb24n dCBrbm93IHRoYXQgdGhpcyBpcyBhIGJyY21zdGIKaW1wbGVtZW50YXRpb24uLi4KCj4gKwo+ICsJ cmV0ID0gYnJjbXN0Yl9wc2NpX2ludGVnX3JlZ2lvbl9yZXNldF9hbGwoKTsKCi4uLiBhbmQgYXMg d2l0aCBhbGwgU0lQIGNhbGxzLCB0aGlzIG1pZ2h0IGRvIGFyYml0cmFyeSB0aGluZ3MuCgo+ICsJ aWYgKHJldCAhPSBQU0NJX1JFVF9TVUNDRVNTKSB7Cj4gKwkJcHJfZXJyKCJFcnJvciByZXNldHRp bmcgYWxsIGludGVncml0eSBjaGVja2luZyByZWdpb25zXG4iKTsKPiArCQlyZXR1cm4gLUVJTzsK PiArCX0KPiArCj4gKwlpZiAocmVzLmEwID09IFNJUF9SRVZJU0lPTl9NQUpPUiAmJiByZXMuYTEg PCBTSVBfUkVWSVNJT05fTUlOT1IpIHsKPiArCQlwcl9pbmZvKCJGaXJtd2FyZSBpcyB0b28gb2xk ISBQbGVhc2UgdXBkYXRlXG4iKTsKPiArCQlyZXR1cm4gLUVPUE5PVFNVUFA7Cj4gKwl9Cj4gKwo+ ICsJYnJjbXN0Yl9rb2JqID0ga29iamVjdF9jcmVhdGVfYW5kX2FkZCgiYnJjbXN0YiIsIGZpcm13 YXJlX2tvYmopOwo+ICsJaWYgKGJyY21zdGJfa29iaikgewo+ICsJCXJldCA9IHN5c2ZzX2NyZWF0 ZV9maWxlcyhicmNtc3RiX2tvYmosIGJyY21zdGJfcHNjaV9hdHRyaWJ1dGVzKTsKPiArCQlpZiAo cmV0KQo+ICsJCQlyZXR1cm4gcmV0Owo+ICsJfQoKLi4uIGFuZCB3ZSBjYW4gcmVnaXN0ZXIgdGhp cyBvbiBhIG5vbi1icmNtc3RiIGltcGxlbWVudGF0aW9uLi4uCgo+ICsKPiArCXBtX3Bvd2VyX29m ZiA9IGJyY21zdGJfcHNjaV9zeXNfcG93ZXJvZmY7Cj4gKwlyZWdpc3Rlcl9yZXN0YXJ0X2hhbmRs ZXIoJmJyY21zdGJfcHNjaV9zeXNfcmVzZXRfbmIpOwo+ICsJc3VzcGVuZF9zZXRfb3BzKCZicmNt c3RiX3BzY2lfb3BzKTsKPiArCWF0b21pY19ub3RpZmllcl9jaGFpbl9yZWdpc3RlcigmcGFuaWNf bm90aWZpZXJfbGlzdCwKPiArCQkJCSAgICAgICAmYnJjbXN0Yl9wc2NpX25iKTsKCi4uLiBhbmQg d2UgYnJlYWsgcG93ZXIgb2ZmLCByZXN0YXJ0LCBhbmQgc3VzcGVuZCBvbiBvdGhlciBpbXBsZW1l bnRhdGlvbnMgLi4uCgo+ICsJcHJfaW5mbygiVXNpbmcgUFNDSSBiYXNlZCBzeXN0ZW0gUE0gKGZ1 bGwgZmVhdHVyZWQpXG4iKTsKClRoaXMgc2hvdWxkIGJlIGV4cGxpY2l0IHdpdGggc29tZXRoaW5n IGxpa2UgIk92ZXJyaWRpbmcgc3RuYWRhcmQgUFNDSQpmdW5jdGlvbmFsaXkgd2l0aCBicmNtc3Ri LXNwZWNpZmljIGNvZGUiLgoKQXMgaXQgc3RhbmRzIHRoaXMgaXMgYXQgYmVzdCBtZWFuaW5nbGVz cywgYW5kIGF0IHdvcnN0IG1pc2xlYWRpbmcgYW5kCmRpc3BhcmFnaW5nIG9mIHN0YW5kYXJkIFBT Q0kuCgo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gK21vZHVsZV9pbml0KGJyY21zdGJfcG1fcHNj aV9pbml0KTsKPiArCj4gK01PRFVMRV9BVVRIT1IoIkJyb2FkY29tIik7Cj4gK01PRFVMRV9ERVND UklQVElPTigiQnJvYWRjb20gU1RCIFBNIFBTQ0kgb3BlcmF0aW9ucyIpOwo+ICtNT0RVTEVfTElD RU5TRSgiR1BMIHYyIik7Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc29jL2JyY21zdGIv YnJjbXN0Yi1zbWNjYy5oIGIvaW5jbHVkZS9saW51eC9zb2MvYnJjbXN0Yi9icmNtc3RiLXNtY2Nj LmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uMjg2M2U4OTRl MWM3Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2luY2x1ZGUvbGludXgvc29jL2JyY21zdGIvYnJj bXN0Yi1zbWNjYy5oCj4gQEAgLTAsMCArMSw4NCBAQAo+ICsvKiBTUERYLUxpY2Vuc2UtSWRlbnRp ZmllcjogR1BMLTIuMCAqLwo+ICsjaWZuZGVmIF9fQlJDTVNUQl9TTUNDQ19ICj4gKyNkZWZpbmUg X19CUkNNU1RCX1NNQ0NDX0gKPiArCj4gKyNpbmNsdWRlIDxsaW51eC9hcm0tc21jY2MuaD4KPiAr I2luY2x1ZGUgPHVhcGkvbGludXgvcHNjaS5oPgo+ICsKPiArI2lmZGVmIENPTkZJR182NEJJVAo+ ICsjZGVmaW5lIFBTQ0lfRk5fTkFUSVZFKHZlcnNpb24sIG5hbWUpICAgUFNDSV8jI3ZlcnNpb24j I19GTjY0XyMjbmFtZQo+ICsjZWxzZQo+ICsjZGVmaW5lIFBTQ0lfRk5fTkFUSVZFKHZlcnNpb24s IG5hbWUpICAgUFNDSV8jI3ZlcnNpb24jI19GTl8jI25hbWUKPiArI2VuZGlmCj4gKwo+ICsvKiBC cm9hZGNvbSBTVEIgY3VzdG9tIFNJUCBmdW5jdGlvbiBjYWxscyAqLwo+ICsjZGVmaW5lIFNJUF9G VU5DX0lOVEVHX1JFR0lPTl9TRVQJXAo+ICsJQVJNX1NNQ0NDX0NBTExfVkFMKEFSTV9TTUNDQ19G QVNUX0NBTEwsIFwKPiArCQkJICAgSVNfRU5BQkxFRChDT05GSUdfNjRCSVQpLCBcCj4gKwkJCSAg IEFSTV9TTUNDQ19PV05FUl9TSVAsIFwKPiArCQkJICAgMCkKPiArI2RlZmluZSBTSVBfRlVOQ19J TlRFR19SRUdJT05fREVMCVwKPiArCUFSTV9TTUNDQ19DQUxMX1ZBTChBUk1fU01DQ0NfRkFTVF9D QUxMLCBcCj4gKwkJCSAgIElTX0VOQUJMRUQoQ09ORklHXzY0QklUKSwgXAo+ICsJCQkgICBBUk1f U01DQ0NfT1dORVJfU0lQLCBcCj4gKwkJCSAgIDEpCj4gKyNkZWZpbmUgU0lQX0ZVTkNfSU5URUdf UkVHSU9OX1JFU0VUX0FMTAlcCj4gKwlBUk1fU01DQ0NfQ0FMTF9WQUwoQVJNX1NNQ0NDX0ZBU1Rf Q0FMTCwgXAo+ICsJCQkgICBJU19FTkFCTEVEKENPTkZJR182NEJJVCksIFwKPiArCQkJICAgQVJN X1NNQ0NDX09XTkVSX1NJUCwgXAo+ICsJCQkgICAyKQo+ICsjZGVmaW5lIFNJUF9GVU5DX1BBTklD X05PVElGWQkJXAo+ICsJQVJNX1NNQ0NDX0NBTExfVkFMKEFSTV9TTUNDQ19GQVNUX0NBTEwsIFwK PiArCQkJICAgSVNfRU5BQkxFRChDT05GSUdfNjRCSVQpLCBcCj4gKwkJCSAgIEFSTV9TTUNDQ19P V05FUl9TSVAsIFwKPiArCQkJICAgMykKPiArI2RlZmluZSBTSVBfRlVOQ19QU0NJX0ZFQVRVUkVT CQlcCj4gKwlBUk1fU01DQ0NfQ0FMTF9WQUwoQVJNX1NNQ0NDX0ZBU1RfQ0FMTCwgXAo+ICsJCQkg ICBJU19FTkFCTEVEKENPTkZJR182NEJJVCksIFwKPiArCQkJICAgQVJNX1NNQ0NDX09XTkVSX1NJ UCwgXAo+ICsJCQkgICA0KQo+ICsjZGVmaW5lIFNJUF9GVU5DX1BTQ0lfQlJDTVNUQl9WRVJTSU9O CQlcCj4gKwlBUk1fU01DQ0NfQ0FMTF9WQUwoQVJNX1NNQ0NDX0ZBU1RfQ0FMTCwgXAo+ICsJCQkg ICBJU19FTkFCTEVEKENPTkZJR182NEJJVCksIFwKPiArCQkJICAgQVJNX1NNQ0NDX09XTkVSX1NJ UCwgXAo+ICsJCQkgICA1KQo+ICsKPiArI2RlZmluZSBTSVBfU1ZDX1JFVklTSU9OCQlcCj4gKwlB Uk1fU01DQ0NfQ0FMTF9WQUwoQVJNX1NNQ0NDX0ZBU1RfQ0FMTCwgXAo+ICsJCQkgICBJU19FTkFC TEVEKENPTkZJR182NEJJVCksIFwKPiArCQkJICAgQVJNX1NNQ0NDX09XTkVSX1NJUCwgXAo+ICsJ CQkgICAweEZGMDIpCgpMb29raW5nIGF0IHRoZSBTTUNDQyBzcGVjLCBpc24ndCB0aGUgImdlbmVy YWwgc2VydmljZSBxdWVyeSIgUkVWSVNJT04gY2FsbAoweEZGMDM/IDB4RkYwMiBpcyByZXNlcnZl ZC4KClRoYW5rcywKTWFyay4KCj4gKwo+ICsjZGVmaW5lIFNJUF9NSU5fUkVHSU9OX1NJWkUJNDA5 Ngo+ICsjZGVmaW5lIFNJUF9SRVZJU0lPTl9NQUpPUgkwCj4gKyNkZWZpbmUgU0lQX1JFVklTSU9O X01JTk9SCTIKPiArCj4gK3R5cGVkZWYgdW5zaWduZWQgbG9uZyAocHNjaV9mbikodW5zaWduZWQg bG9uZywgdW5zaWduZWQgbG9uZywKPiArCQkJCXVuc2lnbmVkIGxvbmcsIHVuc2lnbmVkIGxvbmcp Owo+ICsKPiArc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIF9faW52b2tlX3BzY2lfZm5faHZj KHVuc2lnbmVkIGxvbmcgZnVuY3Rpb25faWQsCj4gKwkJCQkJCSB1bnNpZ25lZCBsb25nIGFyZzAs Cj4gKwkJCQkJCSB1bnNpZ25lZCBsb25nIGFyZzEsCj4gKwkJCQkJCSB1bnNpZ25lZCBsb25nIGFy ZzIpCj4gK3sKPiArCXN0cnVjdCBhcm1fc21jY2NfcmVzIHJlczsKPiArCj4gKwlhcm1fc21jY2Nf aHZjKGZ1bmN0aW9uX2lkLCBhcmcwLCBhcmcxLCBhcmcyLCAwLCAwLCAwLCAwLCAmcmVzKTsKPiAr Cj4gKwlyZXR1cm4gcmVzLmEwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxv bmcgX19pbnZva2VfcHNjaV9mbl9zbWModW5zaWduZWQgbG9uZyBmdW5jdGlvbl9pZCwKPiArCQkJ CQkJIHVuc2lnbmVkIGxvbmcgYXJnMCwKPiArCQkJCQkJIHVuc2lnbmVkIGxvbmcgYXJnMSwKPiAr CQkJCQkJIHVuc2lnbmVkIGxvbmcgYXJnMikKPiArewo+ICsJc3RydWN0IGFybV9zbWNjY19yZXMg cmVzOwo+ICsKPiArCWFybV9zbWNjY19zbWMoZnVuY3Rpb25faWQsIGFyZzAsIGFyZzEsIGFyZzIs IDAsIDAsIDAsIDAsICZyZXMpOwo+ICsKPiArCXJldHVybiByZXMuYTA7Cj4gK30KPiArCj4gKwo+ ICsjZW5kaWYgLyogX19CUkNNU1RCX1NNQ0NDX0ggKi8KPiAtLSAKPiAyLjI1LjEKPiAKCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJu ZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRw Oi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK