From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 0A430256D for ; Mon, 14 Nov 2022 09:52:48 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id BCC30C433C1; Mon, 14 Nov 2022 09:52:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1668419568; bh=OGA6btIf0O2nItkEUzMrs8IKbLFaQuZsMAW10U2DJxA=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=b2MsAM3sANjbEmcebvNSjsfxpxp4TZcX05V3vHkWcndCtUNvp8RvEG84AJ0qwFeBj vAmhA5nNDs6OHDXOlerusXTu24xMuNGEqw73rKKFeCk8uO9PqPHCSpv4xlTlXiQd6z B2m/hQA34qydX8IGNbzquNDj6vLJ+BUcuUhviuNV9HGTizNDkos+zVWSpIcyux7ELq RoMzKjhaXZlyeYp01wb7ddAxuuiLje8P99hyynf5k+L5A5FbINs8yNaus5+p7CuPr2 dLISTiDp89opsr6XgqDXr7DAGin1R7FG25cPUIfjh0fC7/TEtZBM5vDp+YDhfQPNul NRtXEqLsHy+kg== Date: Mon, 14 Nov 2022 09:52:41 +0000 From: Lee Jones To: Russell King Cc: Linus Walleij , Bartosz Golaszewski , Rob Herring , Alyssa Rosenzweig , Andy Shevchenko , asahi@lists.linux.dev, devicetree@vger.kernel.org, Hector Martin , Jonathan Corbet , Krzysztof Kozlowski , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, linux-gpio@vger.kernel.org, Petr Mladek , Rasmus Villemoes , Sergey Senozhatsky , Steven Rostedt , Sven Peter Subject: Re: [PATCH v3 1/7] mfd: Add core Apple Mac SMC driver Message-ID: References: Precedence: bulk X-Mailing-List: asahi@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: On Tue, 08 Nov 2022, Russell King wrote: > From: Hector Martin > > This driver implements support for the SMC (System Management > Controller) in Apple Macs. In contrast to the existing applesmc driver, > it uses pluggable backends that allow it to support different SMC > implementations, and uses the MFD subsystem to expose the core SMC > functionality so that specific features (gpio, hwmon, battery, etc.) can > be implemented by separate drivers in their respective downstream > subsystems. Could we have Russell's ASCII simplified architecture model here please? > Signed-off-by: Hector Martin > Signed-off-by: Russell King (Oracle) > --- > drivers/mfd/Kconfig | 4 + > drivers/mfd/Makefile | 1 + > drivers/mfd/macsmc.c | 239 +++++++++++++++++++++++++++++++++++++ > include/linux/mfd/macsmc.h | 104 ++++++++++++++++ > 4 files changed, 348 insertions(+) > create mode 100644 drivers/mfd/macsmc.c > create mode 100644 include/linux/mfd/macsmc.h > > diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig > index 8b93856de432..f73e098b7228 100644 > --- a/drivers/mfd/Kconfig > +++ b/drivers/mfd/Kconfig > @@ -224,6 +224,10 @@ config MFD_CROS_EC_DEV > To compile this driver as a module, choose M here: the module will be > called cros-ec-dev. > > +config MFD_MACSMC > + tristate Is this selectable? Worth having a description? > + select MFD_CORE Help section? Copy / paste from the commit log should be enough. > config MFD_MADERA > tristate "Cirrus Logic Madera codecs" > select MFD_CORE > diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile > index 7ed3ef4a698c..a5271b578d31 100644 > --- a/drivers/mfd/Makefile > +++ b/drivers/mfd/Makefile > @@ -17,6 +17,7 @@ obj-$(CONFIG_MFD_CROS_EC_DEV) += cros_ec_dev.o > obj-$(CONFIG_MFD_ENE_KB3930) += ene-kb3930.o > obj-$(CONFIG_MFD_EXYNOS_LPASS) += exynos-lpass.o > obj-$(CONFIG_MFD_GATEWORKS_GSC) += gateworks-gsc.o > +obj-$(CONFIG_MFD_MACSMC) += macsmc.o > > obj-$(CONFIG_HTC_PASIC3) += htc-pasic3.o > obj-$(CONFIG_HTC_I2CPLD) += htc-i2cpld.o > diff --git a/drivers/mfd/macsmc.c b/drivers/mfd/macsmc.c > new file mode 100644 > index 000000000000..e5c3957efea4 > --- /dev/null > +++ b/drivers/mfd/macsmc.c > @@ -0,0 +1,239 @@ > +// SPDX-License-Identifier: GPL-2.0-only OR MIT > +/* > + * Apple SMC core framework "SMC (System Management Controller)" Tiny nit: '\n' > + * Copyright The Asahi Linux Contributors Missing (C) Would you like an Author(s) line here? > + */ > + > +#include > +#include > +#include > +#include > +#include > + Would you be kind enough to add a header here to describe the attributes please. Some of them are non-standard. > +struct apple_smc { > + struct device *dev; > + > + void *be_cookie; > + const struct apple_smc_backend_ops *be; > + > + struct mutex mutex; > + > + u32 key_count; > + smc_key first_key; > + smc_key last_key; > + > + struct blocking_notifier_head event_handlers; > +}; > + > +static const struct mfd_cell apple_smc_devs[] = { > + MFD_CELL_OF("macsmc-gpio", NULL, NULL, 0, 0, "apple,smc-gpio"), > + MFD_CELL_NAME("macsmc-hid"), > + MFD_CELL_NAME("macsmc-power"), > + MFD_CELL_NAME("macsmc-reboot"), > + MFD_CELL_OF("macsmc-rtc", NULL, NULL, 0, 0, "apple,smc-rtc"), > +}; > + > +int apple_smc_read(struct apple_smc *smc, smc_key key, void *buf, size_t size) > +{ > + int ret; > + > + mutex_lock(&smc->mutex); > + ret = smc->be->read_key(smc->be_cookie, key, buf, size); > + mutex_unlock(&smc->mutex); > + > + return ret; > +} > +EXPORT_SYMBOL(apple_smc_read); > + > +int apple_smc_write(struct apple_smc *smc, smc_key key, void *buf, size_t size) > +{ > + int ret; > + > + mutex_lock(&smc->mutex); > + ret = smc->be->write_key(smc->be_cookie, key, buf, size); > + mutex_unlock(&smc->mutex); > + > + return ret; > +} > +EXPORT_SYMBOL(apple_smc_write); > + > +int apple_smc_write_atomic(struct apple_smc *smc, smc_key key, void *buf, size_t size) > +{ > + int ret; > + > + /* > + * Will fail if SMC is busy. This is only used by SMC reboot/poweroff > + * final calls, so it doesn't really matter at that point. > + */ > + if (!mutex_trylock(&smc->mutex)) > + return -EBUSY; > + > + ret = smc->be->write_key_atomic(smc->be_cookie, key, buf, size); > + mutex_unlock(&smc->mutex); > + > + return ret; > +} > +EXPORT_SYMBOL(apple_smc_write_atomic); > + > +int apple_smc_rw(struct apple_smc *smc, smc_key key, void *wbuf, size_t wsize, > + void *rbuf, size_t rsize) > +{ > + int ret; > + > + mutex_lock(&smc->mutex); > + ret = smc->be->rw_key(smc->be_cookie, key, wbuf, wsize, rbuf, rsize); > + mutex_unlock(&smc->mutex); > + > + return ret; > +} > +EXPORT_SYMBOL(apple_smc_rw); > + > +int apple_smc_get_key_by_index(struct apple_smc *smc, int index, smc_key *key) > +{ > + int ret; > + > + mutex_lock(&smc->mutex); > + ret = smc->be->get_key_by_index(smc->be_cookie, index, key); > + mutex_unlock(&smc->mutex); > + > + return ret; > +} > +EXPORT_SYMBOL(apple_smc_get_key_by_index); > + > +int apple_smc_get_key_info(struct apple_smc *smc, smc_key key, struct apple_smc_key_info *info) > +{ > + int ret; > + > + mutex_lock(&smc->mutex); > + ret = smc->be->get_key_info(smc->be_cookie, key, info); > + mutex_unlock(&smc->mutex); > + > + return ret; > +} > +EXPORT_SYMBOL(apple_smc_get_key_info); > + > +int apple_smc_find_first_key_index(struct apple_smc *smc, smc_key key) > +{ > + int start = 0, count = smc->key_count; > + int ret; > + > + if (key <= smc->first_key) > + return 0; > + if (key > smc->last_key) > + return smc->key_count; > + > + while (count > 1) { > + int pivot = start + ((count - 1) >> 1); > + smc_key pkey; > + > + ret = apple_smc_get_key_by_index(smc, pivot, &pkey); > + if (ret < 0) > + return ret; > + > + if (pkey == key) > + return pivot; > + > + pivot++; > + > + if (pkey < key) { > + count -= pivot - start; > + start = pivot; > + } else { > + count = pivot - start; > + } > + } > + > + return start; > +} Maybe a 1 or 2 line comment to provide an overview of what's happening in here please. > +EXPORT_SYMBOL(apple_smc_find_first_key_index); > + > +int apple_smc_get_key_count(struct apple_smc *smc) > +{ > + return smc->key_count; > +} > +EXPORT_SYMBOL(apple_smc_get_key_count); > + > +void apple_smc_event_received(struct apple_smc *smc, uint32_t event) > +{ > + dev_dbg(smc->dev, "Event: 0x%08x\n", event); > + blocking_notifier_call_chain(&smc->event_handlers, event, NULL); > +} > +EXPORT_SYMBOL(apple_smc_event_received); > + > +int apple_smc_register_notifier(struct apple_smc *smc, struct notifier_block *n) > +{ > + return blocking_notifier_chain_register(&smc->event_handlers, n); > +} > +EXPORT_SYMBOL(apple_smc_register_notifier); > + > +int apple_smc_unregister_notifier(struct apple_smc *smc, struct notifier_block *n) > +{ > + return blocking_notifier_chain_unregister(&smc->event_handlers, n); > +} > +EXPORT_SYMBOL(apple_smc_unregister_notifier); > + > +void *apple_smc_get_cookie(struct apple_smc *smc) > +{ > + return smc->be_cookie; > +} > +EXPORT_SYMBOL(apple_smc_get_cookie); These parts seem like abstraction for the sake of abstraction. Any reason why the caller can't use the blocking_notifier_* API and look into the apple_smc for themselves. > +struct apple_smc *apple_smc_probe(struct device *dev, const struct apple_smc_backend_ops *ops, void *cookie) > +{ > + struct apple_smc *smc; > + u32 count; > + int ret; > + > + smc = devm_kzalloc(dev, sizeof(*smc), GFP_KERNEL); > + if (!smc) > + return ERR_PTR(-ENOMEM); > + > + smc->dev = dev; > + smc->be_cookie = cookie; > + smc->be = ops; > + mutex_init(&smc->mutex); > + BLOCKING_INIT_NOTIFIER_HEAD(&smc->event_handlers); > + > + ret = apple_smc_read_u32(smc, SMC_KEY(#KEY), &count); > + if (ret) > + return ERR_PTR(dev_err_probe(dev, ret, "Failed to get key count")); > + smc->key_count = be32_to_cpu(count); > + > + ret = apple_smc_get_key_by_index(smc, 0, &smc->first_key); > + if (ret) > + return ERR_PTR(dev_err_probe(dev, ret, "Failed to get first key")); > + > + ret = apple_smc_get_key_by_index(smc, smc->key_count - 1, &smc->last_key); > + if (ret) > + return ERR_PTR(dev_err_probe(dev, ret, "Failed to get last key")); > + > + /* Enable notifications */ > + apple_smc_write_flag(smc, SMC_KEY(NTAP), 1); > + > + dev_info(dev, "Initialized (%d keys %p4ch..%p4ch)\n", > + smc->key_count, &smc->first_key, &smc->last_key); > + > + dev_set_drvdata(dev, smc); > + > + ret = mfd_add_devices(dev, -1, apple_smc_devs, ARRAY_SIZE(apple_smc_devs), NULL, 0, NULL); Please replace the -1 with the defines provided. > + if (ret) > + return ERR_PTR(dev_err_probe(dev, ret, "Subdevice initialization failed")); "Failed to register sub-devices" > + return smc; > +} > +EXPORT_SYMBOL(apple_smc_probe); > + > +int apple_smc_remove(struct apple_smc *smc) > +{ > + mfd_remove_devices(smc->dev); devm_*? > + /* Disable notifications */ > + apple_smc_write_flag(smc, SMC_KEY(NTAP), 1); The same command enables and disables notifications? > + return 0; > +} > +EXPORT_SYMBOL(apple_smc_remove); > + > +MODULE_AUTHOR("Hector Martin "); > +MODULE_LICENSE("Dual MIT/GPL"); > +MODULE_DESCRIPTION("Apple SMC core"); SMC (System Management Controller) > diff --git a/include/linux/mfd/macsmc.h b/include/linux/mfd/macsmc.h > new file mode 100644 > index 000000000000..99cfa23f27bd > --- /dev/null > +++ b/include/linux/mfd/macsmc.h > @@ -0,0 +1,104 @@ > +// SPDX-License-Identifier: GPL-2.0-only OR MIT > +/* > + * Apple SMC core definitions SMC (System Management Controller) > + * Copyright (C) The Asahi Linux Contributors > + */ > + > +#ifndef _LINUX_MFD_MACSMC_H > +#define _LINUX_MFD_MACSMC_H > + > +struct apple_smc; You can move the definition into here and omit this line. > +typedef u32 smc_key; > + > +#define SMC_KEY(s) (smc_key)(_SMC_KEY(#s)) > +#define _SMC_KEY(s) (((s)[0] << 24) | ((s)[1] << 16) | ((s)[2] << 8) | (s)[3]) > + > +#define APPLE_SMC_READABLE BIT(7) > +#define APPLE_SMC_WRITABLE BIT(6) > +#define APPLE_SMC_FUNCTION BIT(4) > + > +struct apple_smc_key_info { > + u8 size; > + u32 type_code; > + u8 flags; > +}; > + > +int apple_smc_read(struct apple_smc *smc, smc_key key, void *buf, size_t size); > +int apple_smc_write(struct apple_smc *smc, smc_key key, void *buf, size_t size); > +int apple_smc_write_atomic(struct apple_smc *smc, smc_key key, void *buf, size_t size); > +int apple_smc_rw(struct apple_smc *smc, smc_key key, void *wbuf, size_t wsize, > + void *rbuf, size_t rsize); > + > +int apple_smc_get_key_count(struct apple_smc *smc); > +int apple_smc_find_first_key_index(struct apple_smc *smc, smc_key key); > +int apple_smc_get_key_by_index(struct apple_smc *smc, int index, smc_key *key); > +int apple_smc_get_key_info(struct apple_smc *smc, smc_key key, struct apple_smc_key_info *info); > + > +static inline bool apple_smc_key_exists(struct apple_smc *smc, smc_key key) > +{ > + return apple_smc_get_key_info(smc, key, NULL) >= 0; > +} > + > +#define APPLE_SMC_TYPE_OPS(type) \ > + static inline int apple_smc_read_##type(struct apple_smc *smc, smc_key key, type *p) \ > + { \ > + int ret = apple_smc_read(smc, key, p, sizeof(*p)); \ > + return (ret < 0) ? ret : ((ret != sizeof(*p)) ? -EINVAL : 0); \ > + } \ > + static inline int apple_smc_write_##type(struct apple_smc *smc, smc_key key, type p) \ > + { \ > + return apple_smc_write(smc, key, &p, sizeof(p)); \ > + } \ > + static inline int apple_smc_write_##type##_atomic(struct apple_smc *smc, smc_key key, type p) \ > + { \ > + return apple_smc_write_atomic(smc, key, &p, sizeof(p)); \ > + } \ > + static inline int apple_smc_rw_##type(struct apple_smc *smc, smc_key key, \ > + type w, type *r) \ > + { \ > + int ret = apple_smc_rw(smc, key, &w, sizeof(w), r, sizeof(*r)); \ > + return (ret < 0) ? ret : ((ret != sizeof(*r)) ? -EINVAL : 0); \ > + } > + > +APPLE_SMC_TYPE_OPS(u64) > +APPLE_SMC_TYPE_OPS(u32) > +APPLE_SMC_TYPE_OPS(u16) > +APPLE_SMC_TYPE_OPS(u8) > +APPLE_SMC_TYPE_OPS(s64) > +APPLE_SMC_TYPE_OPS(s32) > +APPLE_SMC_TYPE_OPS(s16) > +APPLE_SMC_TYPE_OPS(s8) > + > +static inline int apple_smc_read_flag(struct apple_smc *smc, smc_key key) > +{ > + u8 val; > + int ret = apple_smc_read_u8(smc, key, &val); Nit: Please separate the declaration and assignment via function call with a line break in between. > + if (ret < 0) > + return ret; > + return val ? 1 : 0; > +} > +#define apple_smc_write_flag apple_smc_write_u8 > + > +int apple_smc_register_notifier(struct apple_smc *smc, struct notifier_block *n); > +int apple_smc_unregister_notifier(struct apple_smc *smc, struct notifier_block *n); > + > +/* backend interface */ > + > +struct apple_smc_backend_ops { > + int (*read_key)(void *cookie, smc_key key, void *buf, size_t size); > + int (*write_key)(void *cookie, smc_key key, void *buf, size_t size); > + int (*write_key_atomic)(void *cookie, smc_key key, void *buf, size_t size); > + int (*rw_key)(void *cookie, smc_key key, void *wbuf, size_t wsize, > + void *rbuf, size_t rsize); > + int (*get_key_by_index)(void *cookie, int index, smc_key *key); > + int (*get_key_info)(void *cookie, smc_key key, struct apple_smc_key_info *info); > +}; > + > +struct apple_smc *apple_smc_probe(struct device *dev, const struct apple_smc_backend_ops *ops, > + void *cookie); > +void *apple_smc_get_cookie(struct apple_smc *smc); > +int apple_smc_remove(struct apple_smc *smc); > +void apple_smc_event_received(struct apple_smc *smc, uint32_t event); > + > +#endif -- Lee Jones [李琼斯] 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 60D90C4332F for ; Mon, 14 Nov 2022 09:54:12 +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=lu+0aUT80eH72mshG+osNNJ2Vl1T711g4qX56wf3sgk=; b=aMKiJsvlXULJN1 4KdmdQ6yte2ojwbzkIYZuIlFLJQPbB0po+Hr82XpPgzj99HpD2jSZW9Yp7VzpaowUG/pi+CWRVeeP GD8Np1R/FTZ0D+y6sJt2FvNN2Y3l0SmsA33ywh0GptjRHKM2c7M2WdXR/zB9t+nkx/jPUOvf/awTp P7RmxE00hDEf3U4H7AX5VvagaDrVTUddMA+nX0GpGmypmrXcMdssPHAI54v8pkDy6CKq3RSYQspXy 3EuF8K4rDxjr9A2Kdcx3Gw/PwNenztKm3zSN5Hr8FFAi9DJ6S5PK59KM+9Xhk5dBRUfaG5hHYsy3I FTCo0wpsccwp4jAhrmNw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1ouW9A-00HKf6-Fc; Mon, 14 Nov 2022 09:52:56 +0000 Received: from ams.source.kernel.org ([145.40.68.75]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1ouW95-00HKdp-RQ for linux-arm-kernel@lists.infradead.org; Mon, 14 Nov 2022 09:52:54 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id 0459CB80D6B; Mon, 14 Nov 2022 09:52:50 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id BCC30C433C1; Mon, 14 Nov 2022 09:52:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1668419568; bh=OGA6btIf0O2nItkEUzMrs8IKbLFaQuZsMAW10U2DJxA=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=b2MsAM3sANjbEmcebvNSjsfxpxp4TZcX05V3vHkWcndCtUNvp8RvEG84AJ0qwFeBj vAmhA5nNDs6OHDXOlerusXTu24xMuNGEqw73rKKFeCk8uO9PqPHCSpv4xlTlXiQd6z B2m/hQA34qydX8IGNbzquNDj6vLJ+BUcuUhviuNV9HGTizNDkos+zVWSpIcyux7ELq RoMzKjhaXZlyeYp01wb7ddAxuuiLje8P99hyynf5k+L5A5FbINs8yNaus5+p7CuPr2 dLISTiDp89opsr6XgqDXr7DAGin1R7FG25cPUIfjh0fC7/TEtZBM5vDp+YDhfQPNul NRtXEqLsHy+kg== Date: Mon, 14 Nov 2022 09:52:41 +0000 From: Lee Jones To: Russell King Cc: Linus Walleij , Bartosz Golaszewski , Rob Herring , Alyssa Rosenzweig , Andy Shevchenko , asahi@lists.linux.dev, devicetree@vger.kernel.org, Hector Martin , Jonathan Corbet , Krzysztof Kozlowski , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, linux-gpio@vger.kernel.org, Petr Mladek , Rasmus Villemoes , Sergey Senozhatsky , Steven Rostedt , Sven Peter Subject: Re: [PATCH v3 1/7] mfd: Add core Apple Mac SMC driver Message-ID: References: MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20221114_015252_211535_33615999 X-CRM114-Status: GOOD ( 37.05 ) 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 T24gVHVlLCAwOCBOb3YgMjAyMiwgUnVzc2VsbCBLaW5nIHdyb3RlOgoKPiBGcm9tOiBIZWN0b3Ig TWFydGluIDxtYXJjYW5AbWFyY2FuLnN0Pgo+IAo+IFRoaXMgZHJpdmVyIGltcGxlbWVudHMgc3Vw cG9ydCBmb3IgdGhlIFNNQyAoU3lzdGVtIE1hbmFnZW1lbnQKPiBDb250cm9sbGVyKSBpbiBBcHBs ZSBNYWNzLiBJbiBjb250cmFzdCB0byB0aGUgZXhpc3RpbmcgYXBwbGVzbWMgZHJpdmVyLAo+IGl0 IHVzZXMgcGx1Z2dhYmxlIGJhY2tlbmRzIHRoYXQgYWxsb3cgaXQgdG8gc3VwcG9ydCBkaWZmZXJl bnQgU01DCj4gaW1wbGVtZW50YXRpb25zLCBhbmQgdXNlcyB0aGUgTUZEIHN1YnN5c3RlbSB0byBl eHBvc2UgdGhlIGNvcmUgU01DCj4gZnVuY3Rpb25hbGl0eSBzbyB0aGF0IHNwZWNpZmljIGZlYXR1 cmVzIChncGlvLCBod21vbiwgYmF0dGVyeSwgZXRjLikgY2FuCj4gYmUgaW1wbGVtZW50ZWQgYnkg c2VwYXJhdGUgZHJpdmVycyBpbiB0aGVpciByZXNwZWN0aXZlIGRvd25zdHJlYW0KPiBzdWJzeXN0 ZW1zLgoKQ291bGQgd2UgaGF2ZSBSdXNzZWxsJ3MgQVNDSUkgc2ltcGxpZmllZCBhcmNoaXRlY3R1 cmUgbW9kZWwgaGVyZSBwbGVhc2U/Cgo+IFNpZ25lZC1vZmYtYnk6IEhlY3RvciBNYXJ0aW4gPG1h cmNhbkBtYXJjYW4uc3Q+Cj4gU2lnbmVkLW9mZi1ieTogUnVzc2VsbCBLaW5nIChPcmFjbGUpIDxy bWsra2VybmVsQGFybWxpbnV4Lm9yZy51az4KPiAtLS0KPiAgZHJpdmVycy9tZmQvS2NvbmZpZyAg ICAgICAgfCAgIDQgKwo+ICBkcml2ZXJzL21mZC9NYWtlZmlsZSAgICAgICB8ICAgMSArCj4gIGRy aXZlcnMvbWZkL21hY3NtYy5jICAgICAgIHwgMjM5ICsrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysKPiAgaW5jbHVkZS9saW51eC9tZmQvbWFjc21jLmggfCAxMDQgKysrKysrKysr KysrKysrKwo+ICA0IGZpbGVzIGNoYW5nZWQsIDM0OCBpbnNlcnRpb25zKCspCj4gIGNyZWF0ZSBt b2RlIDEwMDY0NCBkcml2ZXJzL21mZC9tYWNzbWMuYwo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgaW5j bHVkZS9saW51eC9tZmQvbWFjc21jLmgKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvS2Nv bmZpZyBiL2RyaXZlcnMvbWZkL0tjb25maWcKPiBpbmRleCA4YjkzODU2ZGU0MzIuLmY3M2UwOThi NzIyOCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL21mZC9LY29uZmlnCj4gKysrIGIvZHJpdmVycy9t ZmQvS2NvbmZpZwo+IEBAIC0yMjQsNiArMjI0LDEwIEBAIGNvbmZpZyBNRkRfQ1JPU19FQ19ERVYK PiAgCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZTog dGhlIG1vZHVsZSB3aWxsIGJlCj4gIAkgIGNhbGxlZCBjcm9zLWVjLWRldi4KPiAgCj4gK2NvbmZp ZyBNRkRfTUFDU01DCj4gKwl0cmlzdGF0ZQoKSXMgdGhpcyBzZWxlY3RhYmxlPwoKV29ydGggaGF2 aW5nIGEgZGVzY3JpcHRpb24/Cgo+ICsJc2VsZWN0IE1GRF9DT1JFCgpIZWxwIHNlY3Rpb24/CgpD b3B5IC8gcGFzdGUgZnJvbSB0aGUgY29tbWl0IGxvZyBzaG91bGQgYmUgZW5vdWdoLgoKPiAgY29u ZmlnIE1GRF9NQURFUkEKPiAgCXRyaXN0YXRlICJDaXJydXMgTG9naWMgTWFkZXJhIGNvZGVjcyIK PiAgCXNlbGVjdCBNRkRfQ09SRQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC9NYWtlZmlsZSBi L2RyaXZlcnMvbWZkL01ha2VmaWxlCj4gaW5kZXggN2VkM2VmNGE2OThjLi5hNTI3MWI1NzhkMzEg MTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9tZmQvTWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL21mZC9N YWtlZmlsZQo+IEBAIC0xNyw2ICsxNyw3IEBAIG9iai0kKENPTkZJR19NRkRfQ1JPU19FQ19ERVYp CSs9IGNyb3NfZWNfZGV2Lm8KPiAgb2JqLSQoQ09ORklHX01GRF9FTkVfS0IzOTMwKQkrPSBlbmUt a2IzOTMwLm8KPiAgb2JqLSQoQ09ORklHX01GRF9FWFlOT1NfTFBBU1MpCSs9IGV4eW5vcy1scGFz cy5vCj4gIG9iai0kKENPTkZJR19NRkRfR0FURVdPUktTX0dTQykJKz0gZ2F0ZXdvcmtzLWdzYy5v Cj4gK29iai0kKENPTkZJR19NRkRfTUFDU01DKQkrPSBtYWNzbWMubwo+ICAKPiAgb2JqLSQoQ09O RklHX0hUQ19QQVNJQzMpCSs9IGh0Yy1wYXNpYzMubwo+ICBvYmotJChDT05GSUdfSFRDX0kyQ1BM RCkJKz0gaHRjLWkyY3BsZC5vCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL21hY3NtYy5jIGIv ZHJpdmVycy9tZmQvbWFjc21jLmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAw MDAwMDAwMC4uZTVjMzk1N2VmZWE0Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvbWZk L21hY3NtYy5jCj4gQEAgLTAsMCArMSwyMzkgQEAKPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZp ZXI6IEdQTC0yLjAtb25seSBPUiBNSVQKPiArLyoKPiArICogQXBwbGUgU01DIGNvcmUgZnJhbWV3 b3JrCgoiU01DIChTeXN0ZW0gTWFuYWdlbWVudCBDb250cm9sbGVyKSIKClRpbnkgbml0OiAnXG4n Cgo+ICsgKiBDb3B5cmlnaHQgVGhlIEFzYWhpIExpbnV4IENvbnRyaWJ1dG9ycwoKTWlzc2luZyAo QykKCldvdWxkIHlvdSBsaWtlIGFuIEF1dGhvcihzKSBsaW5lIGhlcmU/Cgo+ICsgKi8KPiArCj4g KyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KPiArI2luY2x1ZGUgPGxpbnV4L21mZC9jb3JlLmg+ Cj4gKyNpbmNsdWRlIDxsaW51eC9tZmQvbWFjc21jLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tdXRl eC5oPgo+ICsjaW5jbHVkZSA8bGludXgvbm90aWZpZXIuaD4KPiArCgpXb3VsZCB5b3UgYmUga2lu ZCBlbm91Z2ggdG8gYWRkIGEgaGVhZGVyIGhlcmUgdG8gZGVzY3JpYmUgdGhlCmF0dHJpYnV0ZXMg cGxlYXNlLiAgU29tZSBvZiB0aGVtIGFyZSBub24tc3RhbmRhcmQuCgo+ICtzdHJ1Y3QgYXBwbGVf c21jIHsKPiArCXN0cnVjdCBkZXZpY2UgKmRldjsKPiArCj4gKwl2b2lkICpiZV9jb29raWU7Cj4g Kwljb25zdCBzdHJ1Y3QgYXBwbGVfc21jX2JhY2tlbmRfb3BzICpiZTsKPiArCj4gKwlzdHJ1Y3Qg bXV0ZXggbXV0ZXg7Cj4gKwo+ICsJdTMyIGtleV9jb3VudDsKPiArCXNtY19rZXkgZmlyc3Rfa2V5 Owo+ICsJc21jX2tleSBsYXN0X2tleTsKPiArCj4gKwlzdHJ1Y3QgYmxvY2tpbmdfbm90aWZpZXJf aGVhZCBldmVudF9oYW5kbGVyczsKPiArfTsKPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbWZk X2NlbGwgYXBwbGVfc21jX2RldnNbXSA9IHsKPiArCU1GRF9DRUxMX09GKCJtYWNzbWMtZ3BpbyIs IE5VTEwsIE5VTEwsIDAsIDAsICJhcHBsZSxzbWMtZ3BpbyIpLAo+ICsJTUZEX0NFTExfTkFNRSgi bWFjc21jLWhpZCIpLAo+ICsJTUZEX0NFTExfTkFNRSgibWFjc21jLXBvd2VyIiksCj4gKwlNRkRf Q0VMTF9OQU1FKCJtYWNzbWMtcmVib290IiksCj4gKwlNRkRfQ0VMTF9PRigibWFjc21jLXJ0YyIs IE5VTEwsIE5VTEwsIDAsIDAsICJhcHBsZSxzbWMtcnRjIiksCj4gK307Cj4gKwo+ICtpbnQgYXBw bGVfc21jX3JlYWQoc3RydWN0IGFwcGxlX3NtYyAqc21jLCBzbWNfa2V5IGtleSwgdm9pZCAqYnVm LCBzaXplX3Qgc2l6ZSkKPiArewo+ICsJaW50IHJldDsKPiArCj4gKwltdXRleF9sb2NrKCZzbWMt Pm11dGV4KTsKPiArCXJldCA9IHNtYy0+YmUtPnJlYWRfa2V5KHNtYy0+YmVfY29va2llLCBrZXks IGJ1Ziwgc2l6ZSk7Cj4gKwltdXRleF91bmxvY2soJnNtYy0+bXV0ZXgpOwo+ICsKPiArCXJldHVy biByZXQ7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChhcHBsZV9zbWNfcmVhZCk7Cj4gKwo+ICtpbnQg YXBwbGVfc21jX3dyaXRlKHN0cnVjdCBhcHBsZV9zbWMgKnNtYywgc21jX2tleSBrZXksIHZvaWQg KmJ1Ziwgc2l6ZV90IHNpemUpCj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ICsJbXV0ZXhfbG9jaygm c21jLT5tdXRleCk7Cj4gKwlyZXQgPSBzbWMtPmJlLT53cml0ZV9rZXkoc21jLT5iZV9jb29raWUs IGtleSwgYnVmLCBzaXplKTsKPiArCW11dGV4X3VubG9jaygmc21jLT5tdXRleCk7Cj4gKwo+ICsJ cmV0dXJuIHJldDsKPiArfQo+ICtFWFBPUlRfU1lNQk9MKGFwcGxlX3NtY193cml0ZSk7Cj4gKwo+ ICtpbnQgYXBwbGVfc21jX3dyaXRlX2F0b21pYyhzdHJ1Y3QgYXBwbGVfc21jICpzbWMsIHNtY19r ZXkga2V5LCB2b2lkICpidWYsIHNpemVfdCBzaXplKQo+ICt7Cj4gKwlpbnQgcmV0Owo+ICsKPiAr CS8qCj4gKwkgKiBXaWxsIGZhaWwgaWYgU01DIGlzIGJ1c3kuIFRoaXMgaXMgb25seSB1c2VkIGJ5 IFNNQyByZWJvb3QvcG93ZXJvZmYKPiArCSAqIGZpbmFsIGNhbGxzLCBzbyBpdCBkb2Vzbid0IHJl YWxseSBtYXR0ZXIgYXQgdGhhdCBwb2ludC4KPiArCSAqLwo+ICsJaWYgKCFtdXRleF90cnlsb2Nr KCZzbWMtPm11dGV4KSkKPiArCQlyZXR1cm4gLUVCVVNZOwo+ICsKPiArCXJldCA9IHNtYy0+YmUt PndyaXRlX2tleV9hdG9taWMoc21jLT5iZV9jb29raWUsIGtleSwgYnVmLCBzaXplKTsKPiArCW11 dGV4X3VubG9jaygmc21jLT5tdXRleCk7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICtFWFBP UlRfU1lNQk9MKGFwcGxlX3NtY193cml0ZV9hdG9taWMpOwo+ICsKPiAraW50IGFwcGxlX3NtY19y dyhzdHJ1Y3QgYXBwbGVfc21jICpzbWMsIHNtY19rZXkga2V5LCB2b2lkICp3YnVmLCBzaXplX3Qg d3NpemUsCj4gKwkJIHZvaWQgKnJidWYsIHNpemVfdCByc2l6ZSkKPiArewo+ICsJaW50IHJldDsK PiArCj4gKwltdXRleF9sb2NrKCZzbWMtPm11dGV4KTsKPiArCXJldCA9IHNtYy0+YmUtPnJ3X2tl eShzbWMtPmJlX2Nvb2tpZSwga2V5LCB3YnVmLCB3c2l6ZSwgcmJ1ZiwgcnNpemUpOwo+ICsJbXV0 ZXhfdW5sb2NrKCZzbWMtPm11dGV4KTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gK0VYUE9S VF9TWU1CT0woYXBwbGVfc21jX3J3KTsKPiArCj4gK2ludCBhcHBsZV9zbWNfZ2V0X2tleV9ieV9p bmRleChzdHJ1Y3QgYXBwbGVfc21jICpzbWMsIGludCBpbmRleCwgc21jX2tleSAqa2V5KQo+ICt7 Cj4gKwlpbnQgcmV0Owo+ICsKPiArCW11dGV4X2xvY2soJnNtYy0+bXV0ZXgpOwo+ICsJcmV0ID0g c21jLT5iZS0+Z2V0X2tleV9ieV9pbmRleChzbWMtPmJlX2Nvb2tpZSwgaW5kZXgsIGtleSk7Cj4g KwltdXRleF91bmxvY2soJnNtYy0+bXV0ZXgpOwo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiAr RVhQT1JUX1NZTUJPTChhcHBsZV9zbWNfZ2V0X2tleV9ieV9pbmRleCk7Cj4gKwo+ICtpbnQgYXBw bGVfc21jX2dldF9rZXlfaW5mbyhzdHJ1Y3QgYXBwbGVfc21jICpzbWMsIHNtY19rZXkga2V5LCBz dHJ1Y3QgYXBwbGVfc21jX2tleV9pbmZvICppbmZvKQo+ICt7Cj4gKwlpbnQgcmV0Owo+ICsKPiAr CW11dGV4X2xvY2soJnNtYy0+bXV0ZXgpOwo+ICsJcmV0ID0gc21jLT5iZS0+Z2V0X2tleV9pbmZv KHNtYy0+YmVfY29va2llLCBrZXksIGluZm8pOwo+ICsJbXV0ZXhfdW5sb2NrKCZzbWMtPm11dGV4 KTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gK0VYUE9SVF9TWU1CT0woYXBwbGVfc21jX2dl dF9rZXlfaW5mbyk7Cj4gKwo+ICtpbnQgYXBwbGVfc21jX2ZpbmRfZmlyc3Rfa2V5X2luZGV4KHN0 cnVjdCBhcHBsZV9zbWMgKnNtYywgc21jX2tleSBrZXkpCj4gK3sKPiArCWludCBzdGFydCA9IDAs IGNvdW50ID0gc21jLT5rZXlfY291bnQ7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWlmIChrZXkgPD0g c21jLT5maXJzdF9rZXkpCj4gKwkJcmV0dXJuIDA7Cj4gKwlpZiAoa2V5ID4gc21jLT5sYXN0X2tl eSkKPiArCQlyZXR1cm4gc21jLT5rZXlfY291bnQ7Cj4gKwo+ICsJd2hpbGUgKGNvdW50ID4gMSkg ewo+ICsJCWludCBwaXZvdCA9IHN0YXJ0ICsgKChjb3VudCAtIDEpID4+IDEpOwo+ICsJCXNtY19r ZXkgcGtleTsKPiArCj4gKwkJcmV0ID0gYXBwbGVfc21jX2dldF9rZXlfYnlfaW5kZXgoc21jLCBw aXZvdCwgJnBrZXkpOwo+ICsJCWlmIChyZXQgPCAwKQo+ICsJCQlyZXR1cm4gcmV0Owo+ICsKPiAr CQlpZiAocGtleSA9PSBrZXkpCj4gKwkJCXJldHVybiBwaXZvdDsKPiArCj4gKwkJcGl2b3QrKzsK PiArCj4gKwkJaWYgKHBrZXkgPCBrZXkpIHsKPiArCQkJY291bnQgLT0gcGl2b3QgLSBzdGFydDsK PiArCQkJc3RhcnQgPSBwaXZvdDsKPiArCQl9IGVsc2Ugewo+ICsJCQljb3VudCA9IHBpdm90IC0g c3RhcnQ7Cj4gKwkJfQo+ICsJfQo+ICsKPiArCXJldHVybiBzdGFydDsKPiArfQoKTWF5YmUgYSAx IG9yIDIgbGluZSBjb21tZW50IHRvIHByb3ZpZGUgYW4gb3ZlcnZpZXcgb2Ygd2hhdCdzIGhhcHBl bmluZwppbiBoZXJlIHBsZWFzZS4KCj4gK0VYUE9SVF9TWU1CT0woYXBwbGVfc21jX2ZpbmRfZmly c3Rfa2V5X2luZGV4KTsKPiArCj4gK2ludCBhcHBsZV9zbWNfZ2V0X2tleV9jb3VudChzdHJ1Y3Qg YXBwbGVfc21jICpzbWMpCj4gK3sKPiArCXJldHVybiBzbWMtPmtleV9jb3VudDsKPiArfQo+ICtF WFBPUlRfU1lNQk9MKGFwcGxlX3NtY19nZXRfa2V5X2NvdW50KTsKPiArCj4gK3ZvaWQgYXBwbGVf c21jX2V2ZW50X3JlY2VpdmVkKHN0cnVjdCBhcHBsZV9zbWMgKnNtYywgdWludDMyX3QgZXZlbnQp Cj4gK3sKPiArCWRldl9kYmcoc21jLT5kZXYsICJFdmVudDogMHglMDh4XG4iLCBldmVudCk7Cj4g KwlibG9ja2luZ19ub3RpZmllcl9jYWxsX2NoYWluKCZzbWMtPmV2ZW50X2hhbmRsZXJzLCBldmVu dCwgTlVMTCk7Cj4gK30KPiArRVhQT1JUX1NZTUJPTChhcHBsZV9zbWNfZXZlbnRfcmVjZWl2ZWQp Owo+ICsKPiAraW50IGFwcGxlX3NtY19yZWdpc3Rlcl9ub3RpZmllcihzdHJ1Y3QgYXBwbGVfc21j ICpzbWMsIHN0cnVjdCBub3RpZmllcl9ibG9jayAqbikKPiArewo+ICsJcmV0dXJuIGJsb2NraW5n X25vdGlmaWVyX2NoYWluX3JlZ2lzdGVyKCZzbWMtPmV2ZW50X2hhbmRsZXJzLCBuKTsKPiArfQo+ ICtFWFBPUlRfU1lNQk9MKGFwcGxlX3NtY19yZWdpc3Rlcl9ub3RpZmllcik7Cj4gKwo+ICtpbnQg YXBwbGVfc21jX3VucmVnaXN0ZXJfbm90aWZpZXIoc3RydWN0IGFwcGxlX3NtYyAqc21jLCBzdHJ1 Y3Qgbm90aWZpZXJfYmxvY2sgKm4pCj4gK3sKPiArCXJldHVybiBibG9ja2luZ19ub3RpZmllcl9j aGFpbl91bnJlZ2lzdGVyKCZzbWMtPmV2ZW50X2hhbmRsZXJzLCBuKTsKPiArfQo+ICtFWFBPUlRf U1lNQk9MKGFwcGxlX3NtY191bnJlZ2lzdGVyX25vdGlmaWVyKTsKPiArCj4gK3ZvaWQgKmFwcGxl X3NtY19nZXRfY29va2llKHN0cnVjdCBhcHBsZV9zbWMgKnNtYykKPiArewo+ICsJcmV0dXJuIHNt Yy0+YmVfY29va2llOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0woYXBwbGVfc21jX2dldF9jb29raWUp OwoKVGhlc2UgcGFydHMgc2VlbSBsaWtlIGFic3RyYWN0aW9uIGZvciB0aGUgc2FrZSBvZiBhYnN0 cmFjdGlvbi4KCkFueSByZWFzb24gd2h5IHRoZSBjYWxsZXIgY2FuJ3QgdXNlIHRoZSBibG9ja2lu Z19ub3RpZmllcl8qIEFQSSBhbmQKbG9vayBpbnRvIHRoZSBhcHBsZV9zbWMgZm9yIHRoZW1zZWx2 ZXMuCgo+ICtzdHJ1Y3QgYXBwbGVfc21jICphcHBsZV9zbWNfcHJvYmUoc3RydWN0IGRldmljZSAq ZGV2LCBjb25zdCBzdHJ1Y3QgYXBwbGVfc21jX2JhY2tlbmRfb3BzICpvcHMsIHZvaWQgKmNvb2tp ZSkKPiArewo+ICsJc3RydWN0IGFwcGxlX3NtYyAqc21jOwo+ICsJdTMyIGNvdW50Owo+ICsJaW50 IHJldDsKPiArCj4gKwlzbWMgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKnNtYyksIEdGUF9L RVJORUwpOwo+ICsJaWYgKCFzbWMpCj4gKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7Cj4gKwo+ ICsJc21jLT5kZXYgPSBkZXY7Cj4gKwlzbWMtPmJlX2Nvb2tpZSA9IGNvb2tpZTsKPiArCXNtYy0+ YmUgPSBvcHM7Cj4gKwltdXRleF9pbml0KCZzbWMtPm11dGV4KTsKPiArCUJMT0NLSU5HX0lOSVRf Tk9USUZJRVJfSEVBRCgmc21jLT5ldmVudF9oYW5kbGVycyk7Cj4gKwo+ICsJcmV0ID0gYXBwbGVf c21jX3JlYWRfdTMyKHNtYywgU01DX0tFWSgjS0VZKSwgJmNvdW50KTsKPiArCWlmIChyZXQpCj4g KwkJcmV0dXJuIEVSUl9QVFIoZGV2X2Vycl9wcm9iZShkZXYsIHJldCwgIkZhaWxlZCB0byBnZXQg a2V5IGNvdW50IikpOwo+ICsJc21jLT5rZXlfY291bnQgPSBiZTMyX3RvX2NwdShjb3VudCk7Cj4g Kwo+ICsJcmV0ID0gYXBwbGVfc21jX2dldF9rZXlfYnlfaW5kZXgoc21jLCAwLCAmc21jLT5maXJz dF9rZXkpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gRVJSX1BUUihkZXZfZXJyX3Byb2JlKGRl diwgcmV0LCAiRmFpbGVkIHRvIGdldCBmaXJzdCBrZXkiKSk7Cj4gKwo+ICsJcmV0ID0gYXBwbGVf c21jX2dldF9rZXlfYnlfaW5kZXgoc21jLCBzbWMtPmtleV9jb3VudCAtIDEsICZzbWMtPmxhc3Rf a2V5KTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIEVSUl9QVFIoZGV2X2Vycl9wcm9iZShkZXYs IHJldCwgIkZhaWxlZCB0byBnZXQgbGFzdCBrZXkiKSk7Cj4gKwo+ICsJLyogRW5hYmxlIG5vdGlm aWNhdGlvbnMgKi8KPiArCWFwcGxlX3NtY193cml0ZV9mbGFnKHNtYywgU01DX0tFWShOVEFQKSwg MSk7Cj4gKwo+ICsJZGV2X2luZm8oZGV2LCAiSW5pdGlhbGl6ZWQgKCVkIGtleXMgJXA0Y2guLiVw NGNoKVxuIiwKPiArCQkgc21jLT5rZXlfY291bnQsICZzbWMtPmZpcnN0X2tleSwgJnNtYy0+bGFz dF9rZXkpOwo+ICsKPiArCWRldl9zZXRfZHJ2ZGF0YShkZXYsIHNtYyk7Cj4gKwo+ICsJcmV0ID0g bWZkX2FkZF9kZXZpY2VzKGRldiwgLTEsIGFwcGxlX3NtY19kZXZzLCBBUlJBWV9TSVpFKGFwcGxl X3NtY19kZXZzKSwgTlVMTCwgMCwgTlVMTCk7CgpQbGVhc2UgcmVwbGFjZSB0aGUgLTEgd2l0aCB0 aGUgZGVmaW5lcyBwcm92aWRlZC4KCj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiBFUlJfUFRSKGRl dl9lcnJfcHJvYmUoZGV2LCByZXQsICJTdWJkZXZpY2UgaW5pdGlhbGl6YXRpb24gZmFpbGVkIikp OwoKIkZhaWxlZCB0byByZWdpc3RlciBzdWItZGV2aWNlcyIKCj4gKwlyZXR1cm4gc21jOwo+ICt9 Cj4gK0VYUE9SVF9TWU1CT0woYXBwbGVfc21jX3Byb2JlKTsKPiArCj4gK2ludCBhcHBsZV9zbWNf cmVtb3ZlKHN0cnVjdCBhcHBsZV9zbWMgKnNtYykKPiArewo+ICsJbWZkX3JlbW92ZV9kZXZpY2Vz KHNtYy0+ZGV2KTsKCmRldm1fKj8KCj4gKwkvKiBEaXNhYmxlIG5vdGlmaWNhdGlvbnMgKi8KPiAr CWFwcGxlX3NtY193cml0ZV9mbGFnKHNtYywgU01DX0tFWShOVEFQKSwgMSk7CgpUaGUgc2FtZSBj b21tYW5kIGVuYWJsZXMgYW5kIGRpc2FibGVzIG5vdGlmaWNhdGlvbnM/Cgo+ICsJcmV0dXJuIDA7 Cj4gK30KPiArRVhQT1JUX1NZTUJPTChhcHBsZV9zbWNfcmVtb3ZlKTsKPiArCj4gK01PRFVMRV9B VVRIT1IoIkhlY3RvciBNYXJ0aW4gPG1hcmNhbkBtYXJjYW4uc3Q+Iik7Cj4gK01PRFVMRV9MSUNF TlNFKCJEdWFsIE1JVC9HUEwiKTsKPiArTU9EVUxFX0RFU0NSSVBUSU9OKCJBcHBsZSBTTUMgY29y ZSIpOwoKU01DIChTeXN0ZW0gTWFuYWdlbWVudCBDb250cm9sbGVyKQoKPiBkaWZmIC0tZ2l0IGEv aW5jbHVkZS9saW51eC9tZmQvbWFjc21jLmggYi9pbmNsdWRlL2xpbnV4L21mZC9tYWNzbWMuaAo+ IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi45OWNmYTIzZjI3YmQK PiAtLS0gL2Rldi9udWxsCj4gKysrIGIvaW5jbHVkZS9saW51eC9tZmQvbWFjc21jLmgKPiBAQCAt MCwwICsxLDEwNCBAQAo+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5 IE9SIE1JVAo+ICsvKgo+ICsgKiBBcHBsZSBTTUMgY29yZSBkZWZpbml0aW9ucwoKU01DIChTeXN0 ZW0gTWFuYWdlbWVudCBDb250cm9sbGVyKQoKPiArICogQ29weXJpZ2h0IChDKSBUaGUgQXNhaGkg TGludXggQ29udHJpYnV0b3JzCj4gKyAqLwo+ICsKPiArI2lmbmRlZiBfTElOVVhfTUZEX01BQ1NN Q19ICj4gKyNkZWZpbmUgX0xJTlVYX01GRF9NQUNTTUNfSAo+ICsKPiArc3RydWN0IGFwcGxlX3Nt YzsKCllvdSBjYW4gbW92ZSB0aGUgZGVmaW5pdGlvbiBpbnRvIGhlcmUgYW5kIG9taXQgdGhpcyBs aW5lLgoKPiArdHlwZWRlZiB1MzIgc21jX2tleTsKPiArCj4gKyNkZWZpbmUgU01DX0tFWShzKSAo c21jX2tleSkoX1NNQ19LRVkoI3MpKQo+ICsjZGVmaW5lIF9TTUNfS0VZKHMpICgoKHMpWzBdIDw8 IDI0KSB8ICgocylbMV0gPDwgMTYpIHwgKChzKVsyXSA8PCA4KSB8IChzKVszXSkKPiArCj4gKyNk ZWZpbmUgQVBQTEVfU01DX1JFQURBQkxFIEJJVCg3KQo+ICsjZGVmaW5lIEFQUExFX1NNQ19XUklU QUJMRSBCSVQoNikKPiArI2RlZmluZSBBUFBMRV9TTUNfRlVOQ1RJT04gQklUKDQpCj4gKwo+ICtz dHJ1Y3QgYXBwbGVfc21jX2tleV9pbmZvIHsKPiArCXU4IHNpemU7Cj4gKwl1MzIgdHlwZV9jb2Rl Owo+ICsJdTggZmxhZ3M7Cj4gK307Cj4gKwo+ICtpbnQgYXBwbGVfc21jX3JlYWQoc3RydWN0IGFw cGxlX3NtYyAqc21jLCBzbWNfa2V5IGtleSwgdm9pZCAqYnVmLCBzaXplX3Qgc2l6ZSk7Cj4gK2lu dCBhcHBsZV9zbWNfd3JpdGUoc3RydWN0IGFwcGxlX3NtYyAqc21jLCBzbWNfa2V5IGtleSwgdm9p ZCAqYnVmLCBzaXplX3Qgc2l6ZSk7Cj4gK2ludCBhcHBsZV9zbWNfd3JpdGVfYXRvbWljKHN0cnVj dCBhcHBsZV9zbWMgKnNtYywgc21jX2tleSBrZXksIHZvaWQgKmJ1Ziwgc2l6ZV90IHNpemUpOwo+ ICtpbnQgYXBwbGVfc21jX3J3KHN0cnVjdCBhcHBsZV9zbWMgKnNtYywgc21jX2tleSBrZXksIHZv aWQgKndidWYsIHNpemVfdCB3c2l6ZSwKPiArCQkgdm9pZCAqcmJ1Ziwgc2l6ZV90IHJzaXplKTsK PiArCj4gK2ludCBhcHBsZV9zbWNfZ2V0X2tleV9jb3VudChzdHJ1Y3QgYXBwbGVfc21jICpzbWMp Owo+ICtpbnQgYXBwbGVfc21jX2ZpbmRfZmlyc3Rfa2V5X2luZGV4KHN0cnVjdCBhcHBsZV9zbWMg KnNtYywgc21jX2tleSBrZXkpOwo+ICtpbnQgYXBwbGVfc21jX2dldF9rZXlfYnlfaW5kZXgoc3Ry dWN0IGFwcGxlX3NtYyAqc21jLCBpbnQgaW5kZXgsIHNtY19rZXkgKmtleSk7Cj4gK2ludCBhcHBs ZV9zbWNfZ2V0X2tleV9pbmZvKHN0cnVjdCBhcHBsZV9zbWMgKnNtYywgc21jX2tleSBrZXksIHN0 cnVjdCBhcHBsZV9zbWNfa2V5X2luZm8gKmluZm8pOwo+ICsKPiArc3RhdGljIGlubGluZSBib29s IGFwcGxlX3NtY19rZXlfZXhpc3RzKHN0cnVjdCBhcHBsZV9zbWMgKnNtYywgc21jX2tleSBrZXkp Cj4gK3sKPiArCXJldHVybiBhcHBsZV9zbWNfZ2V0X2tleV9pbmZvKHNtYywga2V5LCBOVUxMKSA+ PSAwOwo+ICt9Cj4gKwo+ICsjZGVmaW5lIEFQUExFX1NNQ19UWVBFX09QUyh0eXBlKSBcCj4gKwlz dGF0aWMgaW5saW5lIGludCBhcHBsZV9zbWNfcmVhZF8jI3R5cGUoc3RydWN0IGFwcGxlX3NtYyAq c21jLCBzbWNfa2V5IGtleSwgdHlwZSAqcCkgXAo+ICsJeyBcCj4gKwkJaW50IHJldCA9IGFwcGxl X3NtY19yZWFkKHNtYywga2V5LCBwLCBzaXplb2YoKnApKTsgXAo+ICsJCXJldHVybiAocmV0IDwg MCkgPyByZXQgOiAoKHJldCAhPSBzaXplb2YoKnApKSA/IC1FSU5WQUwgOiAwKTsgXAo+ICsJfSBc Cj4gKwlzdGF0aWMgaW5saW5lIGludCBhcHBsZV9zbWNfd3JpdGVfIyN0eXBlKHN0cnVjdCBhcHBs ZV9zbWMgKnNtYywgc21jX2tleSBrZXksIHR5cGUgcCkgXAo+ICsJeyBcCj4gKwkJcmV0dXJuIGFw cGxlX3NtY193cml0ZShzbWMsIGtleSwgJnAsIHNpemVvZihwKSk7IFwKPiArCX0gXAo+ICsJc3Rh dGljIGlubGluZSBpbnQgYXBwbGVfc21jX3dyaXRlXyMjdHlwZSMjX2F0b21pYyhzdHJ1Y3QgYXBw bGVfc21jICpzbWMsIHNtY19rZXkga2V5LCB0eXBlIHApIFwKPiArCXsgXAo+ICsJCXJldHVybiBh cHBsZV9zbWNfd3JpdGVfYXRvbWljKHNtYywga2V5LCAmcCwgc2l6ZW9mKHApKTsgXAo+ICsJfSBc Cj4gKwlzdGF0aWMgaW5saW5lIGludCBhcHBsZV9zbWNfcndfIyN0eXBlKHN0cnVjdCBhcHBsZV9z bWMgKnNtYywgc21jX2tleSBrZXksIFwKPiArCQkJCQkgICAgICB0eXBlIHcsIHR5cGUgKnIpIFwK PiArCXsgXAo+ICsJCWludCByZXQgPSBhcHBsZV9zbWNfcncoc21jLCBrZXksICZ3LCBzaXplb2Yo dyksIHIsIHNpemVvZigqcikpOyBcCj4gKwkJcmV0dXJuIChyZXQgPCAwKSA/IHJldCA6ICgocmV0 ICE9IHNpemVvZigqcikpID8gLUVJTlZBTCA6IDApOyBcCj4gKwl9Cj4gKwo+ICtBUFBMRV9TTUNf VFlQRV9PUFModTY0KQo+ICtBUFBMRV9TTUNfVFlQRV9PUFModTMyKQo+ICtBUFBMRV9TTUNfVFlQ RV9PUFModTE2KQo+ICtBUFBMRV9TTUNfVFlQRV9PUFModTgpCj4gK0FQUExFX1NNQ19UWVBFX09Q UyhzNjQpCj4gK0FQUExFX1NNQ19UWVBFX09QUyhzMzIpCj4gK0FQUExFX1NNQ19UWVBFX09QUyhz MTYpCj4gK0FQUExFX1NNQ19UWVBFX09QUyhzOCkKPiArCj4gK3N0YXRpYyBpbmxpbmUgaW50IGFw cGxlX3NtY19yZWFkX2ZsYWcoc3RydWN0IGFwcGxlX3NtYyAqc21jLCBzbWNfa2V5IGtleSkKPiAr ewo+ICsJdTggdmFsOwo+ICsJaW50IHJldCA9IGFwcGxlX3NtY19yZWFkX3U4KHNtYywga2V5LCAm dmFsKTsKCk5pdDogUGxlYXNlIHNlcGFyYXRlIHRoZSBkZWNsYXJhdGlvbiBhbmQgYXNzaWdubWVu dCB2aWEgZnVuY3Rpb24gY2FsbAp3aXRoIGEgbGluZSBicmVhayBpbiBiZXR3ZWVuLgoKPiArCWlm IChyZXQgPCAwKQo+ICsJCXJldHVybiByZXQ7Cj4gKwlyZXR1cm4gdmFsID8gMSA6IDA7Cj4gK30K PiArI2RlZmluZSBhcHBsZV9zbWNfd3JpdGVfZmxhZyBhcHBsZV9zbWNfd3JpdGVfdTgKPiArCj4g K2ludCBhcHBsZV9zbWNfcmVnaXN0ZXJfbm90aWZpZXIoc3RydWN0IGFwcGxlX3NtYyAqc21jLCBz dHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm4pOwo+ICtpbnQgYXBwbGVfc21jX3VucmVnaXN0ZXJfbm90 aWZpZXIoc3RydWN0IGFwcGxlX3NtYyAqc21jLCBzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm4pOwo+ ICsKPiArLyogYmFja2VuZCBpbnRlcmZhY2UgKi8KPiArCj4gK3N0cnVjdCBhcHBsZV9zbWNfYmFj a2VuZF9vcHMgewo+ICsJaW50ICgqcmVhZF9rZXkpKHZvaWQgKmNvb2tpZSwgc21jX2tleSBrZXks IHZvaWQgKmJ1Ziwgc2l6ZV90IHNpemUpOwo+ICsJaW50ICgqd3JpdGVfa2V5KSh2b2lkICpjb29r aWUsIHNtY19rZXkga2V5LCB2b2lkICpidWYsIHNpemVfdCBzaXplKTsKPiArCWludCAoKndyaXRl X2tleV9hdG9taWMpKHZvaWQgKmNvb2tpZSwgc21jX2tleSBrZXksIHZvaWQgKmJ1Ziwgc2l6ZV90 IHNpemUpOwo+ICsJaW50ICgqcndfa2V5KSh2b2lkICpjb29raWUsIHNtY19rZXkga2V5LCB2b2lk ICp3YnVmLCBzaXplX3Qgd3NpemUsCj4gKwkJICAgICAgdm9pZCAqcmJ1Ziwgc2l6ZV90IHJzaXpl KTsKPiArCWludCAoKmdldF9rZXlfYnlfaW5kZXgpKHZvaWQgKmNvb2tpZSwgaW50IGluZGV4LCBz bWNfa2V5ICprZXkpOwo+ICsJaW50ICgqZ2V0X2tleV9pbmZvKSh2b2lkICpjb29raWUsIHNtY19r ZXkga2V5LCBzdHJ1Y3QgYXBwbGVfc21jX2tleV9pbmZvICppbmZvKTsKPiArfTsKPiArCj4gK3N0 cnVjdCBhcHBsZV9zbWMgKmFwcGxlX3NtY19wcm9iZShzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0 IHN0cnVjdCBhcHBsZV9zbWNfYmFja2VuZF9vcHMgKm9wcywKPiArCQkJCSAgdm9pZCAqY29va2ll KTsKPiArdm9pZCAqYXBwbGVfc21jX2dldF9jb29raWUoc3RydWN0IGFwcGxlX3NtYyAqc21jKTsK PiAraW50IGFwcGxlX3NtY19yZW1vdmUoc3RydWN0IGFwcGxlX3NtYyAqc21jKTsKPiArdm9pZCBh cHBsZV9zbWNfZXZlbnRfcmVjZWl2ZWQoc3RydWN0IGFwcGxlX3NtYyAqc21jLCB1aW50MzJfdCBl dmVudCk7Cj4gKwo+ICsjZW5kaWYKCi0tIApMZWUgSm9uZXMgW+adjueQvOaWr10KCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwg bWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8v bGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK