From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8F899C4321E for ; Fri, 10 Sep 2021 18:42:38 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 7DD7B61213 for ; Fri, 10 Sep 2021 18:42:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232893AbhIJSns (ORCPT ); Fri, 10 Sep 2021 14:43:48 -0400 Received: from relay10.mail.gandi.net ([217.70.178.230]:46671 "EHLO relay10.mail.gandi.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232649AbhIJSno (ORCPT ); Fri, 10 Sep 2021 14:43:44 -0400 Received: (Authenticated sender: paul.kocialkowski@bootlin.com) by relay10.mail.gandi.net (Postfix) with ESMTPSA id A2243240010; Fri, 10 Sep 2021 18:42:30 +0000 (UTC) From: Paul Kocialkowski To: linux-media@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sunxi@lists.linux.dev, linux-kernel@vger.kernel.org, linux-phy@lists.infradead.org, linux-clk@vger.kernel.org, linux-staging@lists.linux.dev Cc: Yong Deng , Mauro Carvalho Chehab , Rob Herring , Maxime Ripard , Sakari Ailus , Hans Verkuil , Chen-Yu Tsai , Jernej Skrabec , Paul Kocialkowski , Greg Kroah-Hartman , Helen Koike , Laurent Pinchart , Thomas Petazzoni Subject: [PATCH 11/22] media: sunxi: Add support for the A83T MIPI CSI-2 controller Date: Fri, 10 Sep 2021 20:41:36 +0200 Message-Id: <20210910184147.336618-12-paul.kocialkowski@bootlin.com> X-Mailer: git-send-email 2.32.0 In-Reply-To: <20210910184147.336618-1-paul.kocialkowski@bootlin.com> References: <20210910184147.336618-1-paul.kocialkowski@bootlin.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-clk@vger.kernel.org The A83T supports MIPI CSI-2 with a composite controller, covering both the protocol logic and the D-PHY implementation. This controller seems to be found on the A83T only and probably was abandoned since. This implementation splits the protocol and D-PHY registers and uses the PHY framework internally. The D-PHY is not registered as a standalone PHY driver since it cannot be used with any other controller. There are a few notable points about the controller: - The initialisation sequence involes writing specific magic init values that do not seem to make any particular sense given the concerned register fields; - Interrupts appear to be hitting regardless of the interrupt mask registers, which can cause a serious flood when transmission errors occur. Only 8-bit and 10-bit Bayer formats are currently supported. While up to 4 internal channels to the CSI controller exist, only one is currently supported by this implementation. This work is based on the first version of the driver submitted by Kévin L'hôpital, which was adapted to mainline from the Allwinner BSP. This version integrates MIPI CSI-2 support as a standalone V4L2 subdev instead of merging it in the sun6i-csi driver. It was tested on a Banana Pi M3 board with an OV8865 sensor in a 4-lane configuration. Signed-off-by: Paul Kocialkowski Acked-by: Maxime Ripard --- drivers/media/platform/sunxi/Kconfig | 1 + drivers/media/platform/sunxi/Makefile | 1 + .../sunxi/sun8i-a83t-mipi-csi2/Kconfig | 11 + .../sunxi/sun8i-a83t-mipi-csi2/Makefile | 4 + .../sun8i-a83t-mipi-csi2/sun8i_a83t_dphy.c | 72 ++ .../sun8i-a83t-mipi-csi2/sun8i_a83t_dphy.h | 39 + .../sun8i_a83t_mipi_csi2.c | 812 ++++++++++++++++++ .../sun8i_a83t_mipi_csi2.h | 55 ++ .../sun8i_a83t_mipi_csi2_reg.h | 157 ++++ 9 files changed, 1152 insertions(+) create mode 100644 drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/Kconfig create mode 100644 drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/Makefile create mode 100644 drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_dphy.c create mode 100644 drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_dphy.h create mode 100644 drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_mipi_csi2.c create mode 100644 drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_mipi_csi2.h create mode 100644 drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_mipi_csi2_reg.h diff --git a/drivers/media/platform/sunxi/Kconfig b/drivers/media/platform/sunxi/Kconfig index 9684e07454ad..db4c07be7e4c 100644 --- a/drivers/media/platform/sunxi/Kconfig +++ b/drivers/media/platform/sunxi/Kconfig @@ -3,3 +3,4 @@ source "drivers/media/platform/sunxi/sun4i-csi/Kconfig" source "drivers/media/platform/sunxi/sun6i-csi/Kconfig" source "drivers/media/platform/sunxi/sun6i-mipi-csi2/Kconfig" +source "drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/Kconfig" diff --git a/drivers/media/platform/sunxi/Makefile b/drivers/media/platform/sunxi/Makefile index 887a7cae8fca..9aa01cb01883 100644 --- a/drivers/media/platform/sunxi/Makefile +++ b/drivers/media/platform/sunxi/Makefile @@ -3,5 +3,6 @@ obj-y += sun4i-csi/ obj-y += sun6i-csi/ obj-y += sun6i-mipi-csi2/ +obj-y += sun8i-a83t-mipi-csi2/ obj-y += sun8i-di/ obj-y += sun8i-rotate/ diff --git a/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/Kconfig b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/Kconfig new file mode 100644 index 000000000000..60e7a9c41065 --- /dev/null +++ b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/Kconfig @@ -0,0 +1,11 @@ +# SPDX-License-Identifier: GPL-2.0-only +config VIDEO_SUN8I_A83T_MIPI_CSI2 + tristate "Allwinner A83T MIPI CSI-2 Controller and D-PHY Driver" + depends on ARCH_SUNXI || COMPILE_TEST + depends on PM && COMMON_CLK && VIDEO_V4L2 + select REGMAP_MMIO + select MEDIA_CONTROLLER + select VIDEO_V4L2_SUBDEV_API + select V4L2_FWNODE + help + Support for the Allwinner A83T MIPI CSI-2 Controller and D-PHY. diff --git a/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/Makefile b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/Makefile new file mode 100644 index 000000000000..1427d15a879a --- /dev/null +++ b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/Makefile @@ -0,0 +1,4 @@ +# SPDX-License-Identifier: GPL-2.0-only +sun8i-a83t-mipi-csi2-y += sun8i_a83t_mipi_csi2.o sun8i_a83t_dphy.o + +obj-$(CONFIG_VIDEO_SUN8I_A83T_MIPI_CSI2) += sun8i-a83t-mipi-csi2.o diff --git a/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_dphy.c b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_dphy.c new file mode 100644 index 000000000000..15cec91ee38c --- /dev/null +++ b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_dphy.c @@ -0,0 +1,72 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Copyright 2020 Bootlin + * Author: Paul Kocialkowski + */ + +#include +#include + +#include "sun8i_a83t_dphy.h" +#include "sun8i_a83t_mipi_csi2.h" + +static int sun8i_a83t_dphy_configure(struct phy *dphy, + union phy_configure_opts *opts) +{ + return phy_mipi_dphy_config_validate(&opts->mipi_dphy); +} + +static int sun8i_a83t_dphy_power_on(struct phy *dphy) +{ + struct sun8i_a83t_mipi_csi2_device *csi2_dev = phy_get_drvdata(dphy); + struct regmap *regmap = csi2_dev->regmap; + + regmap_write(regmap, SUN8I_A83T_DPHY_CTRL_REG, + SUN8I_A83T_DPHY_CTRL_RESET_N | + SUN8I_A83T_DPHY_CTRL_SHUTDOWN_N); + + regmap_write(regmap, SUN8I_A83T_DPHY_ANA0_REG, + SUN8I_A83T_DPHY_ANA0_REXT_EN | + SUN8I_A83T_DPHY_ANA0_RINT(2) | + SUN8I_A83T_DPHY_ANA0_SNK(2)); + + return 0; +}; + +static int sun8i_a83t_dphy_power_off(struct phy *dphy) +{ + struct sun8i_a83t_mipi_csi2_device *csi2_dev = phy_get_drvdata(dphy); + struct regmap *regmap = csi2_dev->regmap; + + regmap_write(regmap, SUN8I_A83T_DPHY_CTRL_REG, 0); + + return 0; +}; + +static const struct phy_ops sun8i_a83t_dphy_ops = { + .configure = sun8i_a83t_dphy_configure, + .power_on = sun8i_a83t_dphy_power_on, + .power_off = sun8i_a83t_dphy_power_off, +}; + +int sun8i_a83t_dphy_register(struct sun8i_a83t_mipi_csi2_device *csi2_dev) +{ + struct device *dev = csi2_dev->dev; + struct phy_provider *phy_provider; + + csi2_dev->dphy = devm_phy_create(dev, NULL, &sun8i_a83t_dphy_ops); + if (IS_ERR(csi2_dev->dphy)) { + dev_err(dev, "failed to create D-PHY\n"); + return PTR_ERR(csi2_dev->dphy); + } + + phy_set_drvdata(csi2_dev->dphy, csi2_dev); + + phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate); + if (IS_ERR(phy_provider)) { + dev_err(dev, "failed to register D-PHY provider\n"); + return PTR_ERR(phy_provider); + } + + return 0; +} diff --git a/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_dphy.h b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_dphy.h new file mode 100644 index 000000000000..18779060fd32 --- /dev/null +++ b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_dphy.h @@ -0,0 +1,39 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright 2020 Kévin L'hôpital + * Copyright 2020-2021 Bootlin + * Author: Paul Kocialkowski + */ + +#ifndef _SUN8I_A83T_DPHY_H_ +#define _SUN8I_A83T_DPHY_H_ + +#include "sun8i_a83t_mipi_csi2.h" + +#define SUN8I_A83T_DPHY_CTRL_REG 0x10 +#define SUN8I_A83T_DPHY_CTRL_INIT_VALUE 0xb8df698e +#define SUN8I_A83T_DPHY_CTRL_RESET_N BIT(31) +#define SUN8I_A83T_DPHY_CTRL_SHUTDOWN_N BIT(15) +#define SUN8I_A83T_DPHY_CTRL_DEBUG BIT(8) +#define SUN8I_A83T_DPHY_STATUS_REG 0x14 +#define SUN8I_A83T_DPHY_STATUS_CLK_STOP BIT(10) +#define SUN8I_A83T_DPHY_STATUS_CLK_ULPS BIT(9) +#define SUN8I_A83T_DPHY_STATUS_HSCLK BIT(8) +#define SUN8I_A83T_DPHY_STATUS_D3_STOP BIT(7) +#define SUN8I_A83T_DPHY_STATUS_D2_STOP BIT(6) +#define SUN8I_A83T_DPHY_STATUS_D1_STOP BIT(5) +#define SUN8I_A83T_DPHY_STATUS_D0_STOP BIT(4) +#define SUN8I_A83T_DPHY_STATUS_D3_ULPS BIT(3) +#define SUN8I_A83T_DPHY_STATUS_D2_ULPS BIT(2) +#define SUN8I_A83T_DPHY_STATUS_D1_ULPS BIT(1) +#define SUN8I_A83T_DPHY_STATUS_D0_ULPS BIT(0) + +#define SUN8I_A83T_DPHY_ANA0_REG 0x30 +#define SUN8I_A83T_DPHY_ANA0_REXT_EN BIT(31) +#define SUN8I_A83T_DPHY_ANA0_REXT BIT(30) +#define SUN8I_A83T_DPHY_ANA0_RINT(v) (((v) << 28) & GENMASK(29, 28)) +#define SUN8I_A83T_DPHY_ANA0_SNK(v) (((v) << 20) & GENMASK(22, 20)) + +int sun8i_a83t_dphy_register(struct sun8i_a83t_mipi_csi2_device *csi2_dev); + +#endif diff --git a/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_mipi_csi2.c b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_mipi_csi2.c new file mode 100644 index 000000000000..6b010e74f057 --- /dev/null +++ b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_mipi_csi2.c @@ -0,0 +1,812 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Copyright 2020 Kévin L'hôpital + * Copyright 2020-2021 Bootlin + * Author: Paul Kocialkowski + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "sun8i_a83t_dphy.h" +#include "sun8i_a83t_mipi_csi2.h" +#include "sun8i_a83t_mipi_csi2_reg.h" + +/* Format */ + +static const struct sun8i_a83t_mipi_csi2_format +sun8i_a83t_mipi_csi2_formats[] = { + { + .mbus_code = MEDIA_BUS_FMT_SBGGR8_1X8, + .data_type = MIPI_CSI2_DATA_TYPE_RAW8, + .bpp = 8, + }, + { + .mbus_code = MEDIA_BUS_FMT_SGBRG8_1X8, + .data_type = MIPI_CSI2_DATA_TYPE_RAW8, + .bpp = 8, + }, + { + .mbus_code = MEDIA_BUS_FMT_SGRBG8_1X8, + .data_type = MIPI_CSI2_DATA_TYPE_RAW8, + .bpp = 8, + }, + { + .mbus_code = MEDIA_BUS_FMT_SRGGB8_1X8, + .data_type = MIPI_CSI2_DATA_TYPE_RAW8, + .bpp = 8, + }, + { + .mbus_code = MEDIA_BUS_FMT_SBGGR10_1X10, + .data_type = MIPI_CSI2_DATA_TYPE_RAW10, + .bpp = 10, + }, + { + .mbus_code = MEDIA_BUS_FMT_SGBRG10_1X10, + .data_type = MIPI_CSI2_DATA_TYPE_RAW10, + .bpp = 10, + }, + { + .mbus_code = MEDIA_BUS_FMT_SGRBG10_1X10, + .data_type = MIPI_CSI2_DATA_TYPE_RAW10, + .bpp = 10, + }, + { + .mbus_code = MEDIA_BUS_FMT_SRGGB10_1X10, + .data_type = MIPI_CSI2_DATA_TYPE_RAW10, + .bpp = 10, + }, +}; + +static const struct sun8i_a83t_mipi_csi2_format * +sun8i_a83t_mipi_csi2_format_find(u32 mbus_code) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(sun8i_a83t_mipi_csi2_formats); i++) + if (sun8i_a83t_mipi_csi2_formats[i].mbus_code == mbus_code) + return &sun8i_a83t_mipi_csi2_formats[i]; + + return NULL; +} + +/* Controller */ + +static void +sun8i_a83t_mipi_csi2_init(struct sun8i_a83t_mipi_csi2_device *csi2_dev) +{ + struct regmap *regmap = csi2_dev->regmap; + + /* + * The Allwinner BSP sets various magic values on a bunch of registers. + * This is apparently a necessary initialization process that will cause + * the capture to fail with unsolicited interrupts hitting if skipped. + * + * Most of the registers are set to proper values later, except for the + * two reserved registers. They are said to hold a "hardware lock" + * value, without more information available. + */ + + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_CTRL_REG, 0); + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_CTRL_REG, + SUN8I_A83T_MIPI_CSI2_CTRL_INIT_VALUE); + + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_RX_PKT_NUM_REG, 0); + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_RX_PKT_NUM_REG, + SUN8I_A83T_MIPI_CSI2_RX_PKT_NUM_INIT_VALUE); + + regmap_write(regmap, SUN8I_A83T_DPHY_CTRL_REG, 0); + regmap_write(regmap, SUN8I_A83T_DPHY_CTRL_REG, + SUN8I_A83T_DPHY_CTRL_INIT_VALUE); + + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_RSVD1_REG, 0); + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_RSVD1_REG, + SUN8I_A83T_MIPI_CSI2_RSVD1_HW_LOCK_VALUE); + + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_RSVD2_REG, 0); + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_RSVD2_REG, + SUN8I_A83T_MIPI_CSI2_RSVD2_HW_LOCK_VALUE); + + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_CFG_REG, 0); + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_CFG_REG, + SUN8I_A83T_MIPI_CSI2_CFG_INIT_VALUE); +} + +static void +sun8i_a83t_mipi_csi2_enable(struct sun8i_a83t_mipi_csi2_device *csi2_dev) +{ + struct regmap *regmap = csi2_dev->regmap; + + regmap_update_bits(regmap, SUN8I_A83T_MIPI_CSI2_CFG_REG, + SUN8I_A83T_MIPI_CSI2_CFG_SYNC_EN, + SUN8I_A83T_MIPI_CSI2_CFG_SYNC_EN); +} + +static void +sun8i_a83t_mipi_csi2_disable(struct sun8i_a83t_mipi_csi2_device *csi2_dev) +{ + struct regmap *regmap = csi2_dev->regmap; + + regmap_update_bits(regmap, SUN8I_A83T_MIPI_CSI2_CFG_REG, + SUN8I_A83T_MIPI_CSI2_CFG_SYNC_EN, 0); + + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_CTRL_REG, 0); +} + +static void +sun8i_a83t_mipi_csi2_configure(struct sun8i_a83t_mipi_csi2_device *csi2_dev) +{ + struct regmap *regmap = csi2_dev->regmap; + unsigned int lanes_count = + csi2_dev->bridge.endpoint.bus.mipi_csi2.num_data_lanes; + struct v4l2_mbus_framefmt *mbus_format = &csi2_dev->bridge.mbus_format; + const struct sun8i_a83t_mipi_csi2_format *format; + struct device *dev = csi2_dev->dev; + u32 version = 0; + + format = sun8i_a83t_mipi_csi2_format_find(mbus_format->code); + if (WARN_ON(!format)) + return; + + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_CTRL_REG, + SUN8I_A83T_MIPI_CSI2_CTRL_RESET_N); + + regmap_read(regmap, SUN8I_A83T_MIPI_CSI2_VERSION_REG, &version); + + dev_dbg(dev, "A83T MIPI CSI-2 version: %04x\n", version); + + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_CFG_REG, + SUN8I_A83T_MIPI_CSI2_CFG_UNPKT_EN | + SUN8I_A83T_MIPI_CSI2_CFG_SYNC_DLY_CYCLE(8) | + SUN8I_A83T_MIPI_CSI2_CFG_N_CHANNEL(1) | + SUN8I_A83T_MIPI_CSI2_CFG_N_LANE(lanes_count)); + + /* + * Only a single virtual channel (index 0) is currently supported. + * While the registers do mention multiple physical channels being + * available (which can be configured to match a specific virtual + * channel or data type), it's unclear whether channels > 0 are actually + * connected and available and the reference source code only makes use + * of channel 0. + * + * Using extra channels would also require matching channels to be + * available on the CSI (and ISP) side, which is also unsure although + * some CSI implementations are said to support multiple channels for + * BT656 time-sharing. + * + * We still configure virtual channel numbers to ensure that virtual + * channel 0 only goes to channel 0. + */ + + regmap_write(regmap, SUN8I_A83T_MIPI_CSI2_VCDT0_REG, + SUN8I_A83T_MIPI_CSI2_VCDT0_CH_VC(3, 3) | + SUN8I_A83T_MIPI_CSI2_VCDT0_CH_VC(2, 2) | + SUN8I_A83T_MIPI_CSI2_VCDT0_CH_VC(1, 1) | + SUN8I_A83T_MIPI_CSI2_VCDT0_CH_VC(0, 0) | + SUN8I_A83T_MIPI_CSI2_VCDT0_CH_DT(0, format->data_type)); +} + +/* V4L2 Subdev */ + +static int sun8i_a83t_mipi_csi2_s_stream(struct v4l2_subdev *subdev, int on) +{ + struct sun8i_a83t_mipi_csi2_device *csi2_dev = + v4l2_get_subdevdata(subdev); + struct v4l2_subdev *source_subdev = csi2_dev->bridge.source_subdev; + union phy_configure_opts dphy_opts = { 0 }; + struct phy_configure_opts_mipi_dphy *dphy_cfg = &dphy_opts.mipi_dphy; + struct v4l2_mbus_framefmt *mbus_format = &csi2_dev->bridge.mbus_format; + const struct sun8i_a83t_mipi_csi2_format *format; + struct phy *dphy = csi2_dev->dphy; + struct device *dev = csi2_dev->dev; + struct v4l2_ctrl *ctrl; + unsigned int lanes_count = + csi2_dev->bridge.endpoint.bus.mipi_csi2.num_data_lanes; + unsigned long pixel_rate; + /* Initialize to 0 to use both in disable label (ret != 0) and off. */ + int ret = 0; + + if (!source_subdev) + return -ENODEV; + + if (!on) { + v4l2_subdev_call(source_subdev, video, s_stream, 0); + goto disable; + } + + /* Runtime PM */ + + ret = pm_runtime_resume_and_get(dev); + if (ret < 0) + return ret; + + /* Sensor pixel rate */ + + ctrl = v4l2_ctrl_find(source_subdev->ctrl_handler, V4L2_CID_PIXEL_RATE); + if (!ctrl) { + dev_err(dev, "missing sensor pixel rate\n"); + ret = -ENODEV; + goto error_pm; + } + + pixel_rate = (unsigned long)v4l2_ctrl_g_ctrl_int64(ctrl); + if (!pixel_rate) { + dev_err(dev, "missing (zero) sensor pixel rate\n"); + ret = -ENODEV; + goto error_pm; + } + + /* D-PHY */ + + if (!lanes_count) { + dev_err(dev, "missing (zero) MIPI CSI-2 lanes count\n"); + ret = -ENODEV; + goto error_pm; + } + + format = sun8i_a83t_mipi_csi2_format_find(mbus_format->code); + if (WARN_ON(!format)) { + ret = -ENODEV; + goto error_pm; + } + + phy_mipi_dphy_get_default_config(pixel_rate, format->bpp, lanes_count, + dphy_cfg); + + /* + * Note that our hardware is using DDR, which is not taken in account by + * phy_mipi_dphy_get_default_config when calculating hs_clk_rate from + * the pixel rate, lanes count and bpp. + * + * The resulting clock rate is basically the symbol rate over the whole + * link. The actual clock rate is calculated with division by two since + * DDR samples both on rising and falling edges. + */ + + dev_dbg(dev, "A83T MIPI CSI-2 config:\n"); + dev_dbg(dev, "%ld pixels/s, %u bits/pixel, %u lanes, %lu Hz clock\n", + pixel_rate, format->bpp, lanes_count, + dphy_cfg->hs_clk_rate / 2); + + ret = phy_reset(dphy); + if (ret) { + dev_err(dev, "failed to reset MIPI D-PHY\n"); + goto error_pm; + } + + ret = phy_configure(dphy, &dphy_opts); + if (ret) { + dev_err(dev, "failed to configure MIPI D-PHY\n"); + goto error_pm; + } + + /* Controller */ + + sun8i_a83t_mipi_csi2_configure(csi2_dev); + sun8i_a83t_mipi_csi2_enable(csi2_dev); + + /* D-PHY */ + + ret = phy_power_on(dphy); + if (ret) { + dev_err(dev, "failed to power on MIPI D-PHY\n"); + goto error_pm; + } + + /* Source */ + + ret = v4l2_subdev_call(source_subdev, video, s_stream, 1); + if (ret && ret != -ENOIOCTLCMD) + goto disable; + + return 0; + +disable: + phy_power_off(dphy); + sun8i_a83t_mipi_csi2_disable(csi2_dev); + +error_pm: + pm_runtime_put(dev); + + return ret; +} + +static const struct v4l2_subdev_video_ops +sun8i_a83t_mipi_csi2_video_ops = { + .s_stream = sun8i_a83t_mipi_csi2_s_stream, +}; + +static void +sun8i_a83t_mipi_csi2_mbus_format_prepare(struct v4l2_mbus_framefmt *mbus_format) +{ + if (!sun8i_a83t_mipi_csi2_format_find(mbus_format->code)) + mbus_format->code = sun8i_a83t_mipi_csi2_formats[0].mbus_code; + + mbus_format->field = V4L2_FIELD_NONE; + mbus_format->colorspace = V4L2_COLORSPACE_RAW; + mbus_format->quantization = V4L2_QUANTIZATION_DEFAULT; + mbus_format->xfer_func = V4L2_XFER_FUNC_DEFAULT; +} + +static int sun8i_a83t_mipi_csi2_init_cfg(struct v4l2_subdev *subdev, + struct v4l2_subdev_state *state) +{ + unsigned int pad = SUN8I_A83T_MIPI_CSI2_PAD_SINK; + struct v4l2_mbus_framefmt *mbus_format = + v4l2_subdev_get_try_format(subdev, state, pad); + + mbus_format->code = sun8i_a83t_mipi_csi2_formats[0].mbus_code; + mbus_format->width = 640; + mbus_format->height = 480; + + sun8i_a83t_mipi_csi2_mbus_format_prepare(mbus_format); + + return 0; +} + +static int +sun8i_a83t_mipi_csi2_enum_mbus_code(struct v4l2_subdev *subdev, + struct v4l2_subdev_state *state, + struct v4l2_subdev_mbus_code_enum *code_enum) +{ + if (code_enum->index >= ARRAY_SIZE(sun8i_a83t_mipi_csi2_formats)) + return -EINVAL; + + code_enum->code = + sun8i_a83t_mipi_csi2_formats[code_enum->index].mbus_code; + + return 0; +} + +static int sun8i_a83t_mipi_csi2_get_fmt(struct v4l2_subdev *subdev, + struct v4l2_subdev_state *state, + struct v4l2_subdev_format *format) +{ + struct sun8i_a83t_mipi_csi2_device *csi2_dev = + v4l2_get_subdevdata(subdev); + struct v4l2_mbus_framefmt *mbus_format = &format->format; + + if (format->which == V4L2_SUBDEV_FORMAT_TRY) + *mbus_format = *v4l2_subdev_get_try_format(subdev, state, + format->pad); + else + *mbus_format = csi2_dev->bridge.mbus_format; + + return 0; +} + +static int sun8i_a83t_mipi_csi2_set_fmt(struct v4l2_subdev *subdev, + struct v4l2_subdev_state *state, + struct v4l2_subdev_format *format) +{ + struct sun8i_a83t_mipi_csi2_device *csi2_dev = + v4l2_get_subdevdata(subdev); + struct v4l2_mbus_framefmt *mbus_format = &format->format; + + sun8i_a83t_mipi_csi2_mbus_format_prepare(mbus_format); + + if (format->which == V4L2_SUBDEV_FORMAT_TRY) + *v4l2_subdev_get_try_format(subdev, state, format->pad) = + *mbus_format; + else + csi2_dev->bridge.mbus_format = *mbus_format; + + return 0; +} + +static const struct v4l2_subdev_pad_ops sun8i_a83t_mipi_csi2_pad_ops = { + .init_cfg = sun8i_a83t_mipi_csi2_init_cfg, + .enum_mbus_code = sun8i_a83t_mipi_csi2_enum_mbus_code, + .get_fmt = sun8i_a83t_mipi_csi2_get_fmt, + .set_fmt = sun8i_a83t_mipi_csi2_set_fmt, +}; + +static const struct v4l2_subdev_ops sun8i_a83t_mipi_csi2_subdev_ops = { + .video = &sun8i_a83t_mipi_csi2_video_ops, + .pad = &sun8i_a83t_mipi_csi2_pad_ops, +}; + +/* Media Entity */ + +static const struct media_entity_operations sun8i_a83t_mipi_csi2_entity_ops = { + .link_validate = v4l2_subdev_link_validate, +}; + +/* V4L2 Async */ + +static int +sun8i_a83t_mipi_csi2_notifier_bound(struct v4l2_async_notifier *notifier, + struct v4l2_subdev *remote_subdev, + struct v4l2_async_subdev *async_subdev) +{ + struct v4l2_subdev *subdev = notifier->sd; + struct sun8i_a83t_mipi_csi2_device *csi2_dev = + container_of(notifier, struct sun8i_a83t_mipi_csi2_device, + bridge.notifier); + struct media_entity *sink_entity = &subdev->entity; + struct media_entity *source_entity = &remote_subdev->entity; + struct device *dev = csi2_dev->dev; + int sink_pad_index = 0; + int source_pad_index; + int ret; + + ret = media_entity_get_fwnode_pad(source_entity, remote_subdev->fwnode, + MEDIA_PAD_FL_SOURCE); + if (ret < 0) { + dev_err(dev, "missing source pad in external entity %s\n", + source_entity->name); + return -EINVAL; + } + + source_pad_index = ret; + + dev_dbg(dev, "creating %s:%u -> %s:%u link\n", source_entity->name, + source_pad_index, sink_entity->name, sink_pad_index); + + ret = media_create_pad_link(source_entity, source_pad_index, + sink_entity, sink_pad_index, + MEDIA_LNK_FL_ENABLED | + MEDIA_LNK_FL_IMMUTABLE); + if (ret) { + dev_err(dev, "failed to create %s:%u -> %s:%u link\n", + source_entity->name, source_pad_index, + sink_entity->name, sink_pad_index); + return ret; + } + + csi2_dev->bridge.source_subdev = remote_subdev; + + return 0; +} + +static const struct v4l2_async_notifier_operations +sun8i_a83t_mipi_csi2_notifier_ops = { + .bound = sun8i_a83t_mipi_csi2_notifier_bound, +}; + +/* Bridge */ + +static int +sun8i_a83t_mipi_csi2_bridge_source_setup(struct sun8i_a83t_mipi_csi2_device *csi2_dev) +{ + struct v4l2_async_notifier *notifier = &csi2_dev->bridge.notifier; + struct v4l2_fwnode_endpoint *endpoint = &csi2_dev->bridge.endpoint; + struct v4l2_async_subdev *subdev_async; + struct fwnode_handle *handle; + struct device *dev = csi2_dev->dev; + int ret; + + handle = fwnode_graph_get_endpoint_by_id(dev_fwnode(dev), 0, 0, + FWNODE_GRAPH_ENDPOINT_NEXT); + if (!handle) + return -ENODEV; + + endpoint->bus_type = V4L2_MBUS_CSI2_DPHY; + + ret = v4l2_fwnode_endpoint_parse(handle, endpoint); + if (ret) + goto complete; + + subdev_async = v4l2_async_notifier_add_fwnode_remote_subdev(notifier, + handle, struct v4l2_async_subdev); + if (IS_ERR(subdev_async)) + ret = PTR_ERR(subdev_async); + +complete: + fwnode_handle_put(handle); + + return ret; +} + +static int +sun8i_a83t_mipi_csi2_bridge_setup(struct sun8i_a83t_mipi_csi2_device *csi2_dev) +{ + struct v4l2_subdev *subdev = &csi2_dev->bridge.subdev; + struct v4l2_async_notifier *notifier = &csi2_dev->bridge.notifier; + struct media_pad *pads = csi2_dev->bridge.pads; + struct device *dev = csi2_dev->dev; + int ret; + + /* V4L2 Subdev */ + + v4l2_subdev_init(subdev, &sun8i_a83t_mipi_csi2_subdev_ops); + strscpy(subdev->name, SUN8I_A83T_MIPI_CSI2_NAME, sizeof(subdev->name)); + subdev->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; + subdev->owner = THIS_MODULE; + subdev->dev = dev; + + v4l2_set_subdevdata(subdev, csi2_dev); + + /* Media Entity */ + + subdev->entity.function = MEDIA_ENT_F_VID_IF_BRIDGE; + subdev->entity.ops = &sun8i_a83t_mipi_csi2_entity_ops; + + /* Media Pads */ + + pads[SUN8I_A83T_MIPI_CSI2_PAD_SINK].flags = MEDIA_PAD_FL_SINK; + pads[SUN8I_A83T_MIPI_CSI2_PAD_SOURCE].flags = MEDIA_PAD_FL_SOURCE; + + ret = media_entity_pads_init(&subdev->entity, + SUN8I_A83T_MIPI_CSI2_PAD_COUNT, pads); + if (ret) + return ret; + + /* V4L2 Async */ + + v4l2_async_notifier_init(notifier); + notifier->ops = &sun8i_a83t_mipi_csi2_notifier_ops; + + ret = sun8i_a83t_mipi_csi2_bridge_source_setup(csi2_dev); + if (ret) + goto error_v4l2_notifier_cleanup; + + ret = v4l2_async_subdev_notifier_register(subdev, notifier); + if (ret < 0) + goto error_v4l2_notifier_cleanup; + + /* V4L2 Subdev */ + + ret = v4l2_async_register_subdev(subdev); + if (ret < 0) + goto error_v4l2_notifier_unregister; + + return 0; + +error_v4l2_notifier_unregister: + v4l2_async_notifier_unregister(notifier); + +error_v4l2_notifier_cleanup: + v4l2_async_notifier_cleanup(notifier); + + media_entity_cleanup(&subdev->entity); + + return ret; +} + +static void +sun8i_a83t_mipi_csi2_bridge_cleanup(struct sun8i_a83t_mipi_csi2_device *csi2_dev) +{ + struct v4l2_subdev *subdev = &csi2_dev->bridge.subdev; + struct v4l2_async_notifier *notifier = &csi2_dev->bridge.notifier; + + v4l2_async_unregister_subdev(subdev); + v4l2_async_notifier_unregister(notifier); + v4l2_async_notifier_cleanup(notifier); + media_entity_cleanup(&subdev->entity); +} + +/* Platform */ + +static int sun8i_a83t_mipi_csi2_suspend(struct device *dev) +{ + struct sun8i_a83t_mipi_csi2_device *csi2_dev = dev_get_drvdata(dev); + + clk_disable_unprepare(csi2_dev->clk_misc); + clk_disable_unprepare(csi2_dev->clk_mipi); + clk_disable_unprepare(csi2_dev->clk_mod); + clk_disable_unprepare(csi2_dev->clk_bus); + reset_control_assert(csi2_dev->reset); + + return 0; +} + +static int sun8i_a83t_mipi_csi2_resume(struct device *dev) +{ + struct sun8i_a83t_mipi_csi2_device *csi2_dev = dev_get_drvdata(dev); + int ret; + + ret = reset_control_deassert(csi2_dev->reset); + if (ret) { + dev_err(dev, "failed to deassert reset\n"); + return ret; + } + + ret = clk_prepare_enable(csi2_dev->clk_bus); + if (ret) { + dev_err(dev, "failed to enable bus clock\n"); + goto error_reset; + } + + ret = clk_prepare_enable(csi2_dev->clk_mod); + if (ret) { + dev_err(dev, "failed to enable module clock\n"); + goto error_clk_bus; + } + + ret = clk_prepare_enable(csi2_dev->clk_mipi); + if (ret) { + dev_err(dev, "failed to enable MIPI clock\n"); + goto error_clk_mod; + } + + ret = clk_prepare_enable(csi2_dev->clk_misc); + if (ret) { + dev_err(dev, "failed to enable CSI misc clock\n"); + goto error_clk_mipi; + } + + sun8i_a83t_mipi_csi2_init(csi2_dev); + + return 0; + +error_clk_mipi: + clk_disable_unprepare(csi2_dev->clk_mipi); + +error_clk_mod: + clk_disable_unprepare(csi2_dev->clk_mod); + +error_clk_bus: + clk_disable_unprepare(csi2_dev->clk_bus); + +error_reset: + reset_control_assert(csi2_dev->reset); + + return ret; +} + +static const struct dev_pm_ops sun8i_a83t_mipi_csi2_pm_ops = { + SET_RUNTIME_PM_OPS(sun8i_a83t_mipi_csi2_suspend, + sun8i_a83t_mipi_csi2_resume, NULL) +}; + +static const struct regmap_config sun8i_a83t_mipi_csi2_regmap_config = { + .reg_bits = 32, + .reg_stride = 4, + .val_bits = 32, + .max_register = 0x120, +}; + +static int +sun8i_a83t_mipi_csi2_resources_setup(struct sun8i_a83t_mipi_csi2_device *csi2_dev, + struct platform_device *platform_dev) +{ + struct device *dev = csi2_dev->dev; + struct resource *res; + void __iomem *io_base; + int ret; + + /* Registers */ + + res = platform_get_resource(platform_dev, IORESOURCE_MEM, 0); + io_base = devm_ioremap_resource(dev, res); + if (IS_ERR(io_base)) + return PTR_ERR(io_base); + + csi2_dev->regmap = + devm_regmap_init_mmio(dev, io_base, + &sun8i_a83t_mipi_csi2_regmap_config); + if (IS_ERR(csi2_dev->regmap)) { + dev_err(dev, "failed to init register map\n"); + return PTR_ERR(csi2_dev->regmap); + } + + /* Clocks */ + + csi2_dev->clk_bus = devm_clk_get(dev, "bus"); + if (IS_ERR(csi2_dev->clk_bus)) { + dev_err(dev, "failed to acquire bus clock\n"); + return PTR_ERR(csi2_dev->clk_bus); + } + + csi2_dev->clk_mod = devm_clk_get(dev, "mod"); + if (IS_ERR(csi2_dev->clk_mod)) { + dev_err(dev, "failed to acquire mod clock\n"); + return PTR_ERR(csi2_dev->clk_mod); + } + + ret = clk_set_rate_exclusive(csi2_dev->clk_mod, 297000000); + if (ret) { + dev_err(dev, "failed to set mod clock rate\n"); + return ret; + } + + csi2_dev->clk_mipi = devm_clk_get(dev, "mipi"); + if (IS_ERR(csi2_dev->clk_mipi)) { + dev_err(dev, "failed to acquire mipi clock\n"); + return PTR_ERR(csi2_dev->clk_mipi); + } + + csi2_dev->clk_misc = devm_clk_get(dev, "misc"); + if (IS_ERR(csi2_dev->clk_misc)) { + dev_err(dev, "failed to acquire misc clock\n"); + return PTR_ERR(csi2_dev->clk_misc); + } + + /* Reset */ + + csi2_dev->reset = devm_reset_control_get_shared(dev, NULL); + if (IS_ERR(csi2_dev->reset)) { + dev_err(dev, "failed to get reset controller\n"); + return PTR_ERR(csi2_dev->reset); + } + + /* D-PHY */ + + ret = sun8i_a83t_dphy_register(csi2_dev); + if (ret) { + dev_err(dev, "failed to initialize MIPI D-PHY\n"); + return ret; + } + + /* Runtime PM */ + + pm_runtime_enable(dev); + pm_runtime_set_suspended(dev); + + return 0; +} + +static void +sun8i_a83t_mipi_csi2_resources_cleanup(struct sun8i_a83t_mipi_csi2_device *csi2_dev) +{ + pm_runtime_disable(csi2_dev->dev); + phy_exit(csi2_dev->dphy); + clk_rate_exclusive_put(csi2_dev->clk_mod); +} + +static int sun8i_a83t_mipi_csi2_probe(struct platform_device *platform_dev) +{ + struct sun8i_a83t_mipi_csi2_device *csi2_dev; + struct device *dev = &platform_dev->dev; + int ret; + + csi2_dev = devm_kzalloc(dev, sizeof(*csi2_dev), GFP_KERNEL); + if (!csi2_dev) + return -ENOMEM; + + csi2_dev->dev = dev; + platform_set_drvdata(platform_dev, csi2_dev); + + ret = sun8i_a83t_mipi_csi2_resources_setup(csi2_dev, platform_dev); + if (ret) + return ret; + + ret = sun8i_a83t_mipi_csi2_bridge_setup(csi2_dev); + if (ret) + return ret; + + return 0; +} + +static int sun8i_a83t_mipi_csi2_remove(struct platform_device *platform_dev) +{ + struct sun8i_a83t_mipi_csi2_device *csi2_dev = + platform_get_drvdata(platform_dev); + + sun8i_a83t_mipi_csi2_bridge_cleanup(csi2_dev); + sun8i_a83t_mipi_csi2_resources_cleanup(csi2_dev); + + return 0; +} + +static const struct of_device_id sun8i_a83t_mipi_csi2_of_match[] = { + { .compatible = "allwinner,sun8i-a83t-mipi-csi2" }, + {}, +}; +MODULE_DEVICE_TABLE(of, sun8i_a83t_mipi_csi2_of_match); + +static struct platform_driver sun8i_a83t_mipi_csi2_platform_driver = { + .probe = sun8i_a83t_mipi_csi2_probe, + .remove = sun8i_a83t_mipi_csi2_remove, + .driver = { + .name = SUN8I_A83T_MIPI_CSI2_NAME, + .of_match_table = of_match_ptr(sun8i_a83t_mipi_csi2_of_match), + .pm = &sun8i_a83t_mipi_csi2_pm_ops, + }, +}; +module_platform_driver(sun8i_a83t_mipi_csi2_platform_driver); + +MODULE_DESCRIPTION("Allwinner A83T MIPI CSI-2 and D-PHY Controller Driver"); +MODULE_AUTHOR("Paul Kocialkowski "); +MODULE_LICENSE("GPL"); diff --git a/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_mipi_csi2.h b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_mipi_csi2.h new file mode 100644 index 000000000000..183f42339c57 --- /dev/null +++ b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_mipi_csi2.h @@ -0,0 +1,55 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright 2020 Kévin L'hôpital + * Copyright 2020 Bootlin + * Author: Paul Kocialkowski + */ + +#ifndef _SUN8I_A83T_MIPI_CSI2_H_ +#define _SUN8I_A83T_MIPI_CSI2_H_ + +#include +#include +#include +#include +#include + +#define SUN8I_A83T_MIPI_CSI2_NAME "sun8i-a83t-mipi-csi2" + +enum sun8i_a83t_mipi_csi2_pad { + SUN8I_A83T_MIPI_CSI2_PAD_SINK = 0, + SUN8I_A83T_MIPI_CSI2_PAD_SOURCE = 1, + SUN8I_A83T_MIPI_CSI2_PAD_COUNT = 2, +}; + +struct sun8i_a83t_mipi_csi2_format { + u32 mbus_code; + u8 data_type; + u32 bpp; +}; + +struct sun8i_a83t_mipi_csi2_bridge { + struct v4l2_subdev subdev; + struct media_pad pads[SUN8I_A83T_MIPI_CSI2_PAD_COUNT]; + struct v4l2_fwnode_endpoint endpoint; + struct v4l2_async_notifier notifier; + struct v4l2_mbus_framefmt mbus_format; + + struct v4l2_subdev *source_subdev; +}; + +struct sun8i_a83t_mipi_csi2_device { + struct device *dev; + + struct regmap *regmap; + struct clk *clk_bus; + struct clk *clk_mod; + struct clk *clk_mipi; + struct clk *clk_misc; + struct reset_control *reset; + struct phy *dphy; + + struct sun8i_a83t_mipi_csi2_bridge bridge; +}; + +#endif diff --git a/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_mipi_csi2_reg.h b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_mipi_csi2_reg.h new file mode 100644 index 000000000000..f3317bd8ad24 --- /dev/null +++ b/drivers/media/platform/sunxi/sun8i-a83t-mipi-csi2/sun8i_a83t_mipi_csi2_reg.h @@ -0,0 +1,157 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright 2020 Kévin L'hôpital + * Copyright 2020-2021 Bootlin + * Author: Paul Kocialkowski + */ + +#ifndef _SUN8I_A83T_MIPI_CSI2_REG_H_ +#define _SUN8I_A83T_MIPI_CSI2_REG_H_ + +#define SUN8I_A83T_MIPI_CSI2_VERSION_REG 0x0 +#define SUN8I_A83T_MIPI_CSI2_CTRL_REG 0x4 +#define SUN8I_A83T_MIPI_CSI2_CTRL_INIT_VALUE 0xb8c39bec +#define SUN8I_A83T_MIPI_CSI2_CTRL_RESET_N BIT(31) +#define SUN8I_A83T_MIPI_CSI2_RX_PKT_NUM_REG 0x8 +#define SUN8I_A83T_MIPI_CSI2_RX_PKT_NUM_INIT_VALUE 0xb8d257f8 +#define SUN8I_A83T_MIPI_CSI2_RSVD0_REG 0xc + +#define SUN8I_A83T_MIPI_CSI2_RSVD1_REG 0x18 +#define SUN8I_A83T_MIPI_CSI2_RSVD1_HW_LOCK_VALUE 0xb8c8a30c +#define SUN8I_A83T_MIPI_CSI2_RSVD2_REG 0x1c +#define SUN8I_A83T_MIPI_CSI2_RSVD2_HW_LOCK_VALUE 0xb8df8ad7 +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_REG 0x20 +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_ECC_ERR_DBL BIT(28) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_LINE_CKSM_ERR_VC3 BIT(27) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_LINE_CKSM_ERR_VC2 BIT(26) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_LINE_CKSM_ERR_VC1 BIT(25) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_LINE_CKSM_ERR_VC0 BIT(24) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_LINE_SEQ_ERR_DT3 BIT(23) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_LINE_SEQ_ERR_DT2 BIT(22) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_LINE_SEQ_ERR_DT1 BIT(21) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_LINE_SEQ_ERR_DT0 BIT(20) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_LS_LE_ERR_DT3 BIT(19) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_LS_LE_ERR_DT2 BIT(18) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_LS_LE_ERR_DT1 BIT(17) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_LS_LE_ERR_DT0 BIT(16) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_CRC_ERR_VC3 BIT(15) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_CRC_ERR_VC2 BIT(14) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_CRC_ERR_VC1 BIT(13) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_CRC_ERR_VC0 BIT(12) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_FRM_SEQ_ERR_VC3 BIT(11) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_FRM_SEQ_ERR_VC2 BIT(10) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_FRM_SEQ_ERR_VC1 BIT(9) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_FRM_SEQ_ERR_VC0 BIT(8) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_FS_FE_ERR_VC3 BIT(7) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_FS_FE_ERR_VC2 BIT(6) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_FS_FE_ERR_VC1 BIT(5) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_FS_FE_ERR_VC0 BIT(4) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_SOT_SYNC_ERR_3 BIT(3) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_SOT_SYNC_ERR_2 BIT(2) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_SOT_SYNC_ERR_1 BIT(1) +#define SUN8I_A83T_MIPI_CSI2_INT_STA0_SOT_SYNC_ERR_0 BIT(0) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_REG 0x24 +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_LINE_SEQ_ERR_DT7 BIT(23) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_LINE_SEQ_ERR_DT6 BIT(22) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_LINE_SEQ_ERR_DT5 BIT(21) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_LINE_SEQ_ERR_DT4 BIT(20) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_LS_LE_ERR_DT7 BIT(19) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_LS_LE_ERR_DT6 BIT(18) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_LS_LE_ERR_DT5 BIT(17) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_LS_LE_ERR_DT4 BIT(16) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_DT_ERR_VC3 BIT(15) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_DT_ERR_VC2 BIT(14) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_DT_ERR_VC1 BIT(13) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_DT_ERR_VC0 BIT(12) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_ECC_ERR1_VC3 BIT(11) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_ECC_ERR1_VC2 BIT(10) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_ECC_ERR1_VC1 BIT(9) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_ECC_ERR1_VC0 BIT(8) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_SOT_ERR_3 BIT(7) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_SOT_ERR_2 BIT(6) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_SOT_ERR_1 BIT(5) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_SOT_ERR_0 BIT(4) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_ESC_ENTRY_ERR_3 BIT(3) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_ESC_ENTRY_ERR_2 BIT(2) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_ESC_ENTRY_ERR_1 BIT(1) +#define SUN8I_A83T_MIPI_CSI2_INT_STA1_ESC_ENTRY_ERR_0 BIT(0) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_REG 0x28 +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_ECC_ERR_DBL BIT(28) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_CKSM_ERR_VC3 BIT(27) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_CKSM_ERR_VC2 BIT(26) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_CKSM_ERR_VC1 BIT(25) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_CKSM_ERR_VC0 BIT(24) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_LINE_SEQ_ERR_DT3 BIT(23) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_LINE_SEQ_ERR_DT2 BIT(22) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_LINE_SEQ_ERR_DT1 BIT(21) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_LINE_SEQ_ERR_DT0 BIT(20) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_LS_LE_ERR_DT3 BIT(19) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_LS_LE_ERR_DT2 BIT(18) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_LS_LE_ERR_DT1 BIT(17) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_LS_LE_ERR_DT0 BIT(16) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_CRC_ERR_VC3 BIT(15) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_CRC_ERR_VC2 BIT(14) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_CRC_ERR_VC1 BIT(13) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_CRC_ERR_VC0 BIT(12) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_FRM_SEQ_ERR_VC3 BIT(11) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_FRM_SEQ_ERR_VC2 BIT(10) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_FRM_SEQ_ERR_VC1 BIT(9) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_FRM_SEQ_ERR_VC0 BIT(8) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_FS_FE_ERR_VC3 BIT(7) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_FS_FE_ERR_VC2 BIT(6) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_FS_FE_ERR_VC1 BIT(5) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_FS_FE_ERR_VC0 BIT(4) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_SOT_SYNC_ERR_3 BIT(3) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_SOT_SYNC_ERR_2 BIT(2) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_SOT_SYNC_ERR_1 BIT(1) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK0_SOT_SYNC_ERR_0 BIT(0) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_REG 0x2c +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_DT_ERR_VC3 BIT(15) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_DT_ERR_VC2 BIT(14) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_DT_ERR_VC1 BIT(13) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_DT_ERR_VC0 BIT(12) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_ECC_ERR1_VC3 BIT(11) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_ECC_ERR1_VC2 BIT(10) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_ECC_ERR1_VC1 BIT(9) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_ECC_ERR1_VC0 BIT(8) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_SOT_ERR_3 BIT(7) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_SOT_ERR_2 BIT(6) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_SOT_ERR_1 BIT(5) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_SOT_ERR_0 BIT(4) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_ESC_ENTRY_ERR_3 BIT(3) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_ESC_ENTRY_ERR_2 BIT(2) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_ESC_ENTRY_ERR_1 BIT(1) +#define SUN8I_A83T_MIPI_CSI2_INT_MSK1_ESC_ENTRY_ERR_0 BIT(0) + +#define SUN8I_A83T_MIPI_CSI2_CFG_REG 0x100 +#define SUN8I_A83T_MIPI_CSI2_CFG_INIT_VALUE 0xb8c64f24 +#define SUN8I_A83T_MIPI_CSI2_CFG_SYNC_EN BIT(31) +#define SUN8I_A83T_MIPI_CSI2_CFG_BYPASS_ECC_EN BIT(29) +#define SUN8I_A83T_MIPI_CSI2_CFG_UNPKT_EN BIT(28) +#define SUN8I_A83T_MIPI_CSI2_CFG_NONE_UNPKT_RX_MODE BIT(27) +#define SUN8I_A83T_MIPI_CSI2_CFG_YC_SWAB BIT(26) +#define SUN8I_A83T_MIPI_CSI2_CFG_N_BYTE BIT(24) +#define SUN8I_A83T_MIPI_CSI2_CFG_SYNC_DLY_CYCLE(v) (((v) << 18) & \ + GENMASK(22, 18)) +#define SUN8I_A83T_MIPI_CSI2_CFG_N_CHANNEL(v) ((((v) - 1) << 16) & \ + GENMASK(17, 16)) +#define SUN8I_A83T_MIPI_CSI2_CFG_N_LANE(v) ((((v) - 1) << 4) & \ + GENMASK(5, 4)) +#define SUN8I_A83T_MIPI_CSI2_VCDT0_REG 0x104 +#define SUN8I_A83T_MIPI_CSI2_VCDT0_CH_VC(ch, vc) (((vc) & GENMASK(1, 0)) << \ + ((ch) * 8 + 6)) +#define SUN8I_A83T_MIPI_CSI2_VCDT0_CH_DT(ch, t) (((t) & GENMASK(5, 0)) << \ + ((ch) * 8)) +#define SUN8I_A83T_MIPI_CSI2_VCDT1_REG 0x108 +#define SUN8I_A83T_MIPI_CSI2_VCDT1_CH_VC(ch, vc) (((vc) & GENMASK(1, 0)) << \ + (((ch) - 4) * 8 + 6)) +#define SUN8I_A83T_MIPI_CSI2_VCDT1_CH_DT(ch, t) (((t) & GENMASK(5, 0)) << \ + (((ch) - 4) * 8)) + +enum mipi_csi2_data_type { + MIPI_CSI2_DATA_TYPE_RAW8 = 0x2a, + MIPI_CSI2_DATA_TYPE_RAW10 = 0x2b, + MIPI_CSI2_DATA_TYPE_RAW12 = 0x2c, +}; + +#endif -- 2.32.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-17.1 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4896EC433FE for ; Fri, 10 Sep 2021 18:49:21 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id EEE2C61250 for ; Fri, 10 Sep 2021 18:49:20 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org EEE2C61250 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=bootlin.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.infradead.org 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:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=7jjvkizktThNok6kkNqbRu9+Of1arPA9UvBcLCG/E6g=; b=zBzN44/QhWsPSV qKf2LDPK1EG4DUrr1hGYZZR6SZ5+7rZenzmotdabg5zwaJBfsrEmrq+c93rDDZZbGW3umK3JBKFGE Y1/FKyuoqvG1YTcN2vgsiGeJo/4o2ETdUdT0U97KyCtbkQvxdyItycfCW3Y1ZZKaJATiATAso8FK5 EZKlAFrUSzzCkBqfP2v5hE0Xyf/flF4WbUQIThta89PrTeLIZiqNdjBljKs49FxbIZEHNaFuJcL0e JBqYargtAbuMdexdOGohPnDpEpXFSmvVbbpz87jXQBeqF2I+YyLf20A1kbaEE4cJbsf7NBL2chYiW sT+OuzMpLhp5jw0hwrPw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1mOlaS-00DPR2-6g; Fri, 10 Sep 2021 18:49:20 +0000 Received: from relay10.mail.gandi.net ([217.70.178.230]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1mOlTt-00DLzv-Oe; Fri, 10 Sep 2021 18:42:40 +0000 Received: (Authenticated sender: paul.kocialkowski@bootlin.com) by relay10.mail.gandi.net (Postfix) with ESMTPSA id A2243240010; Fri, 10 Sep 2021 18:42:30 +0000 (UTC) From: Paul Kocialkowski To: linux-media@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sunxi@lists.linux.dev, linux-kernel@vger.kernel.org, linux-phy@lists.infradead.org, linux-clk@vger.kernel.org, linux-staging@lists.linux.dev Cc: Yong Deng , Mauro Carvalho Chehab , Rob Herring , Maxime Ripard , Sakari Ailus , Hans Verkuil , Chen-Yu Tsai , Jernej Skrabec , Paul Kocialkowski , Greg Kroah-Hartman , Helen Koike , Laurent Pinchart , Thomas Petazzoni Subject: [PATCH 11/22] media: sunxi: Add support for the A83T MIPI CSI-2 controller Date: Fri, 10 Sep 2021 20:41:36 +0200 Message-Id: <20210910184147.336618-12-paul.kocialkowski@bootlin.com> X-Mailer: git-send-email 2.32.0 In-Reply-To: <20210910184147.336618-1-paul.kocialkowski@bootlin.com> References: <20210910184147.336618-1-paul.kocialkowski@bootlin.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210910_114234_316285_73FF27C2 X-CRM114-Status: GOOD ( 32.17 ) X-BeenThere: linux-phy@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux Phy Mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-phy" Errors-To: linux-phy-bounces+linux-phy=archiver.kernel.org@lists.infradead.org VGhlIEE4M1Qgc3VwcG9ydHMgTUlQSSBDU0ktMiB3aXRoIGEgY29tcG9zaXRlIGNvbnRyb2xsZXIs IGNvdmVyaW5nCmJvdGggdGhlIHByb3RvY29sIGxvZ2ljIGFuZCB0aGUgRC1QSFkgaW1wbGVtZW50 YXRpb24uIFRoaXMgY29udHJvbGxlcgpzZWVtcyB0byBiZSBmb3VuZCBvbiB0aGUgQTgzVCBvbmx5 IGFuZCBwcm9iYWJseSB3YXMgYWJhbmRvbmVkIHNpbmNlLgoKVGhpcyBpbXBsZW1lbnRhdGlvbiBz cGxpdHMgdGhlIHByb3RvY29sIGFuZCBELVBIWSByZWdpc3RlcnMgYW5kCnVzZXMgdGhlIFBIWSBm cmFtZXdvcmsgaW50ZXJuYWxseS4gVGhlIEQtUEhZIGlzIG5vdCByZWdpc3RlcmVkIGFzIGEKc3Rh bmRhbG9uZSBQSFkgZHJpdmVyIHNpbmNlIGl0IGNhbm5vdCBiZSB1c2VkIHdpdGggYW55IG90aGVy CmNvbnRyb2xsZXIuCgpUaGVyZSBhcmUgYSBmZXcgbm90YWJsZSBwb2ludHMgYWJvdXQgdGhlIGNv bnRyb2xsZXI6Ci0gVGhlIGluaXRpYWxpc2F0aW9uIHNlcXVlbmNlIGludm9sZXMgd3JpdGluZyBz cGVjaWZpYyBtYWdpYyBpbml0CiAgdmFsdWVzIHRoYXQgZG8gbm90IHNlZW0gdG8gbWFrZSBhbnkg cGFydGljdWxhciBzZW5zZSBnaXZlbiB0aGUKICBjb25jZXJuZWQgcmVnaXN0ZXIgZmllbGRzOwot IEludGVycnVwdHMgYXBwZWFyIHRvIGJlIGhpdHRpbmcgcmVnYXJkbGVzcyBvZiB0aGUgaW50ZXJy dXB0IG1hc2sKICByZWdpc3RlcnMsIHdoaWNoIGNhbiBjYXVzZSBhIHNlcmlvdXMgZmxvb2Qgd2hl biB0cmFuc21pc3Npb24gZXJyb3JzCiAgb2NjdXIuCgpPbmx5IDgtYml0IGFuZCAxMC1iaXQgQmF5 ZXIgZm9ybWF0cyBhcmUgY3VycmVudGx5IHN1cHBvcnRlZC4KV2hpbGUgdXAgdG8gNCBpbnRlcm5h bCBjaGFubmVscyB0byB0aGUgQ1NJIGNvbnRyb2xsZXIgZXhpc3QsIG9ubHkgb25lCmlzIGN1cnJl bnRseSBzdXBwb3J0ZWQgYnkgdGhpcyBpbXBsZW1lbnRhdGlvbi4KClRoaXMgd29yayBpcyBiYXNl ZCBvbiB0aGUgZmlyc3QgdmVyc2lvbiBvZiB0aGUgZHJpdmVyIHN1Ym1pdHRlZCBieQpLw6l2aW4g TCdow7RwaXRhbCwgd2hpY2ggd2FzIGFkYXB0ZWQgdG8gbWFpbmxpbmUgZnJvbSB0aGUgQWxsd2lu bmVyIEJTUC4KVGhpcyB2ZXJzaW9uIGludGVncmF0ZXMgTUlQSSBDU0ktMiBzdXBwb3J0IGFzIGEg c3RhbmRhbG9uZSBWNEwyIHN1YmRldgppbnN0ZWFkIG9mIG1lcmdpbmcgaXQgaW4gdGhlIHN1bjZp LWNzaSBkcml2ZXIuCgpJdCB3YXMgdGVzdGVkIG9uIGEgQmFuYW5hIFBpIE0zIGJvYXJkIHdpdGgg YW4gT1Y4ODY1IHNlbnNvciBpbiBhIDQtbGFuZQpjb25maWd1cmF0aW9uLgoKU2lnbmVkLW9mZi1i eTogUGF1bCBLb2NpYWxrb3dza2kgPHBhdWwua29jaWFsa293c2tpQGJvb3RsaW4uY29tPgpBY2tl ZC1ieTogTWF4aW1lIFJpcGFyZCA8bXJpcGFyZEBrZXJuZWwub3JnPgotLS0KIGRyaXZlcnMvbWVk aWEvcGxhdGZvcm0vc3VueGkvS2NvbmZpZyAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL21lZGlh L3BsYXRmb3JtL3N1bnhpL01ha2VmaWxlICAgICAgICAgfCAgIDEgKwogLi4uL3N1bnhpL3N1bjhp LWE4M3QtbWlwaS1jc2kyL0tjb25maWcgICAgICAgIHwgIDExICsKIC4uLi9zdW54aS9zdW44aS1h ODN0LW1pcGktY3NpMi9NYWtlZmlsZSAgICAgICB8ICAgNCArCiAuLi4vc3VuOGktYTgzdC1taXBp LWNzaTIvc3VuOGlfYTgzdF9kcGh5LmMgICAgfCAgNzIgKysKIC4uLi9zdW44aS1hODN0LW1pcGkt Y3NpMi9zdW44aV9hODN0X2RwaHkuaCAgICB8ICAzOSArCiAuLi4vc3VuOGlfYTgzdF9taXBpX2Nz aTIuYyAgICAgICAgICAgICAgICAgICAgfCA4MTIgKysrKysrKysrKysrKysrKysrCiAuLi4vc3Vu OGlfYTgzdF9taXBpX2NzaTIuaCAgICAgICAgICAgICAgICAgICAgfCAgNTUgKysKIC4uLi9zdW44 aV9hODN0X21pcGlfY3NpMl9yZWcuaCAgICAgICAgICAgICAgICB8IDE1NyArKysrCiA5IGZpbGVz IGNoYW5nZWQsIDExNTIgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMv bWVkaWEvcGxhdGZvcm0vc3VueGkvc3VuOGktYTgzdC1taXBpLWNzaTIvS2NvbmZpZwogY3JlYXRl IG1vZGUgMTAwNjQ0IGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3VueGkvc3VuOGktYTgzdC1taXBp LWNzaTIvTWFrZWZpbGUKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21lZGlhL3BsYXRmb3Jt L3N1bnhpL3N1bjhpLWE4M3QtbWlwaS1jc2kyL3N1bjhpX2E4M3RfZHBoeS5jCiBjcmVhdGUgbW9k ZSAxMDA2NDQgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3Np Mi9zdW44aV9hODN0X2RwaHkuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbWVkaWEvcGxh dGZvcm0vc3VueGkvc3VuOGktYTgzdC1taXBpLWNzaTIvc3VuOGlfYTgzdF9taXBpX2NzaTIuYwog Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3VueGkvc3VuOGktYTgz dC1taXBpLWNzaTIvc3VuOGlfYTgzdF9taXBpX2NzaTIuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRy aXZlcnMvbWVkaWEvcGxhdGZvcm0vc3VueGkvc3VuOGktYTgzdC1taXBpLWNzaTIvc3VuOGlfYTgz dF9taXBpX2NzaTJfcmVnLmgKCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1 bnhpL0tjb25maWcgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhpL0tjb25maWcKaW5kZXgg OTY4NGUwNzQ1NGFkLi5kYjRjMDdiZTdlNGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcGxh dGZvcm0vc3VueGkvS2NvbmZpZworKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhpL0tj b25maWcKQEAgLTMsMyArMyw0IEBACiBzb3VyY2UgImRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3Vu eGkvc3VuNGktY3NpL0tjb25maWciCiBzb3VyY2UgImRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3Vu eGkvc3VuNmktY3NpL0tjb25maWciCiBzb3VyY2UgImRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3Vu eGkvc3VuNmktbWlwaS1jc2kyL0tjb25maWciCitzb3VyY2UgImRyaXZlcnMvbWVkaWEvcGxhdGZv cm0vc3VueGkvc3VuOGktYTgzdC1taXBpLWNzaTIvS2NvbmZpZyIKZGlmZiAtLWdpdCBhL2RyaXZl cnMvbWVkaWEvcGxhdGZvcm0vc3VueGkvTWFrZWZpbGUgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3Jt L3N1bnhpL01ha2VmaWxlCmluZGV4IDg4N2E3Y2FlOGZjYS4uOWFhMDFjYjAxODgzIDEwMDY0NAot LS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhpL01ha2VmaWxlCisrKyBiL2RyaXZlcnMv bWVkaWEvcGxhdGZvcm0vc3VueGkvTWFrZWZpbGUKQEAgLTMsNSArMyw2IEBACiBvYmoteQkJKz0g c3VuNGktY3NpLwogb2JqLXkJCSs9IHN1bjZpLWNzaS8KIG9iai15CQkrPSBzdW42aS1taXBpLWNz aTIvCitvYmoteQkJKz0gc3VuOGktYTgzdC1taXBpLWNzaTIvCiBvYmoteQkJKz0gc3VuOGktZGkv CiBvYmoteQkJKz0gc3VuOGktcm90YXRlLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9LY29uZmlnIGIvZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9LY29uZmlnCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNjBlN2E5YzQxMDY1Ci0tLSAvZGV2L251bGwKKysr IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9LY29u ZmlnCkBAIC0wLDAgKzEsMTEgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAt b25seQorY29uZmlnIFZJREVPX1NVTjhJX0E4M1RfTUlQSV9DU0kyCisJdHJpc3RhdGUgIkFsbHdp bm5lciBBODNUIE1JUEkgQ1NJLTIgQ29udHJvbGxlciBhbmQgRC1QSFkgRHJpdmVyIgorCWRlcGVu ZHMgb24gQVJDSF9TVU5YSSB8fCBDT01QSUxFX1RFU1QKKwlkZXBlbmRzIG9uIFBNICYmIENPTU1P Tl9DTEsgJiYgVklERU9fVjRMMgorCXNlbGVjdCBSRUdNQVBfTU1JTworCXNlbGVjdCBNRURJQV9D T05UUk9MTEVSCisJc2VsZWN0IFZJREVPX1Y0TDJfU1VCREVWX0FQSQorCXNlbGVjdCBWNEwyX0ZX Tk9ERQorCWhlbHAKKwkgICBTdXBwb3J0IGZvciB0aGUgQWxsd2lubmVyIEE4M1QgTUlQSSBDU0kt MiBDb250cm9sbGVyIGFuZCBELVBIWS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZv cm0vc3VueGkvc3VuOGktYTgzdC1taXBpLWNzaTIvTWFrZWZpbGUgYi9kcml2ZXJzL21lZGlhL3Bs YXRmb3JtL3N1bnhpL3N1bjhpLWE4M3QtbWlwaS1jc2kyL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMTQyN2QxNWE4NzlhCi0tLSAvZGV2L251bGwKKysr IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9NYWtl ZmlsZQpAQCAtMCwwICsxLDQgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAt b25seQorc3VuOGktYTgzdC1taXBpLWNzaTIteSArPSBzdW44aV9hODN0X21pcGlfY3NpMi5vIHN1 bjhpX2E4M3RfZHBoeS5vCisKK29iai0kKENPTkZJR19WSURFT19TVU44SV9BODNUX01JUElfQ1NJ MikgKz0gc3VuOGktYTgzdC1taXBpLWNzaTIubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9zdW44aV9hODN0X2RwaHkuYyBiL2Ry aXZlcnMvbWVkaWEvcGxhdGZvcm0vc3VueGkvc3VuOGktYTgzdC1taXBpLWNzaTIvc3VuOGlfYTgz dF9kcGh5LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xNWNlYzkx ZWUzOGMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhpL3N1 bjhpLWE4M3QtbWlwaS1jc2kyL3N1bjhpX2E4M3RfZHBoeS5jCkBAIC0wLDAgKzEsNzIgQEAKKy8v IFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKworLyoKKyAqIENvcHlyaWdodCAyMDIw IEJvb3RsaW4KKyAqIEF1dGhvcjogUGF1bCBLb2NpYWxrb3dza2kgPHBhdWwua29jaWFsa293c2tp QGJvb3RsaW4uY29tPgorICovCisKKyNpbmNsdWRlIDxsaW51eC9waHkvcGh5Lmg+CisjaW5jbHVk ZSA8bGludXgvcmVnbWFwLmg+CisKKyNpbmNsdWRlICJzdW44aV9hODN0X2RwaHkuaCIKKyNpbmNs dWRlICJzdW44aV9hODN0X21pcGlfY3NpMi5oIgorCitzdGF0aWMgaW50IHN1bjhpX2E4M3RfZHBo eV9jb25maWd1cmUoc3RydWN0IHBoeSAqZHBoeSwKKwkJCQkgICAgIHVuaW9uIHBoeV9jb25maWd1 cmVfb3B0cyAqb3B0cykKK3sKKwlyZXR1cm4gcGh5X21pcGlfZHBoeV9jb25maWdfdmFsaWRhdGUo Jm9wdHMtPm1pcGlfZHBoeSk7Cit9CisKK3N0YXRpYyBpbnQgc3VuOGlfYTgzdF9kcGh5X3Bvd2Vy X29uKHN0cnVjdCBwaHkgKmRwaHkpCit7CisJc3RydWN0IHN1bjhpX2E4M3RfbWlwaV9jc2kyX2Rl dmljZSAqY3NpMl9kZXYgPSBwaHlfZ2V0X2RydmRhdGEoZHBoeSk7CisJc3RydWN0IHJlZ21hcCAq cmVnbWFwID0gY3NpMl9kZXYtPnJlZ21hcDsKKworCXJlZ21hcF93cml0ZShyZWdtYXAsIFNVTjhJ X0E4M1RfRFBIWV9DVFJMX1JFRywKKwkJICAgICBTVU44SV9BODNUX0RQSFlfQ1RSTF9SRVNFVF9O IHwKKwkJICAgICBTVU44SV9BODNUX0RQSFlfQ1RSTF9TSFVURE9XTl9OKTsKKworCXJlZ21hcF93 cml0ZShyZWdtYXAsIFNVTjhJX0E4M1RfRFBIWV9BTkEwX1JFRywKKwkJICAgICBTVU44SV9BODNU X0RQSFlfQU5BMF9SRVhUX0VOIHwKKwkJICAgICBTVU44SV9BODNUX0RQSFlfQU5BMF9SSU5UKDIp IHwKKwkJICAgICBTVU44SV9BODNUX0RQSFlfQU5BMF9TTksoMikpOworCisJcmV0dXJuIDA7Cit9 OworCitzdGF0aWMgaW50IHN1bjhpX2E4M3RfZHBoeV9wb3dlcl9vZmYoc3RydWN0IHBoeSAqZHBo eSkKK3sKKwlzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJfZGV2aWNlICpjc2kyX2RldiA9IHBo eV9nZXRfZHJ2ZGF0YShkcGh5KTsKKwlzdHJ1Y3QgcmVnbWFwICpyZWdtYXAgPSBjc2kyX2Rldi0+ cmVnbWFwOworCisJcmVnbWFwX3dyaXRlKHJlZ21hcCwgU1VOOElfQTgzVF9EUEhZX0NUUkxfUkVH LCAwKTsKKworCXJldHVybiAwOworfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBwaHlfb3BzIHN1 bjhpX2E4M3RfZHBoeV9vcHMgPSB7CisJLmNvbmZpZ3VyZQk9IHN1bjhpX2E4M3RfZHBoeV9jb25m aWd1cmUsCisJLnBvd2VyX29uCT0gc3VuOGlfYTgzdF9kcGh5X3Bvd2VyX29uLAorCS5wb3dlcl9v ZmYJPSBzdW44aV9hODN0X2RwaHlfcG93ZXJfb2ZmLAorfTsKKworaW50IHN1bjhpX2E4M3RfZHBo eV9yZWdpc3RlcihzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJfZGV2aWNlICpjc2kyX2RldikK K3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBjc2kyX2Rldi0+ZGV2OworCXN0cnVjdCBwaHlfcHJv dmlkZXIgKnBoeV9wcm92aWRlcjsKKworCWNzaTJfZGV2LT5kcGh5ID0gZGV2bV9waHlfY3JlYXRl KGRldiwgTlVMTCwgJnN1bjhpX2E4M3RfZHBoeV9vcHMpOworCWlmIChJU19FUlIoY3NpMl9kZXYt PmRwaHkpKSB7CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGNyZWF0ZSBELVBIWVxuIik7CisJ CXJldHVybiBQVFJfRVJSKGNzaTJfZGV2LT5kcGh5KTsKKwl9CisKKwlwaHlfc2V0X2RydmRhdGEo Y3NpMl9kZXYtPmRwaHksIGNzaTJfZGV2KTsKKworCXBoeV9wcm92aWRlciA9IGRldm1fb2ZfcGh5 X3Byb3ZpZGVyX3JlZ2lzdGVyKGRldiwgb2ZfcGh5X3NpbXBsZV94bGF0ZSk7CisJaWYgKElTX0VS UihwaHlfcHJvdmlkZXIpKSB7CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIHJlZ2lzdGVyIEQt UEhZIHByb3ZpZGVyXG4iKTsKKwkJcmV0dXJuIFBUUl9FUlIocGh5X3Byb3ZpZGVyKTsKKwl9CisK KwlyZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3VueGkv c3VuOGktYTgzdC1taXBpLWNzaTIvc3VuOGlfYTgzdF9kcGh5LmggYi9kcml2ZXJzL21lZGlhL3Bs YXRmb3JtL3N1bnhpL3N1bjhpLWE4M3QtbWlwaS1jc2kyL3N1bjhpX2E4M3RfZHBoeS5oCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMTg3NzkwNjBmZDMyCi0tLSAvZGV2 L251bGwKKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGkt Y3NpMi9zdW44aV9hODN0X2RwaHkuaApAQCAtMCwwICsxLDM5IEBACisvKiBTUERYLUxpY2Vuc2Ut SWRlbnRpZmllcjogR1BMLTIuMCsgKi8KKy8qCisgKiBDb3B5cmlnaHQgMjAyMCBLw6l2aW4gTCdo w7RwaXRhbCA8a2V2aW4ubGhvcGl0YWxAYm9vdGxpbi5jb20+CisgKiBDb3B5cmlnaHQgMjAyMC0y MDIxIEJvb3RsaW4KKyAqIEF1dGhvcjogUGF1bCBLb2NpYWxrb3dza2kgPHBhdWwua29jaWFsa293 c2tpQGJvb3RsaW4uY29tPgorICovCisKKyNpZm5kZWYgX1NVTjhJX0E4M1RfRFBIWV9IXworI2Rl ZmluZSBfU1VOOElfQTgzVF9EUEhZX0hfCisKKyNpbmNsdWRlICJzdW44aV9hODN0X21pcGlfY3Np Mi5oIgorCisjZGVmaW5lIFNVTjhJX0E4M1RfRFBIWV9DVFJMX1JFRwkJMHgxMAorI2RlZmluZSBT VU44SV9BODNUX0RQSFlfQ1RSTF9JTklUX1ZBTFVFCQkweGI4ZGY2OThlCisjZGVmaW5lIFNVTjhJ X0E4M1RfRFBIWV9DVFJMX1JFU0VUX04JCUJJVCgzMSkKKyNkZWZpbmUgU1VOOElfQTgzVF9EUEhZ X0NUUkxfU0hVVERPV05fTgkJQklUKDE1KQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlfQ1RSTF9E RUJVRwkJQklUKDgpCisjZGVmaW5lIFNVTjhJX0E4M1RfRFBIWV9TVEFUVVNfUkVHCQkweDE0Cisj ZGVmaW5lIFNVTjhJX0E4M1RfRFBIWV9TVEFUVVNfQ0xLX1NUT1AJCUJJVCgxMCkKKyNkZWZpbmUg U1VOOElfQTgzVF9EUEhZX1NUQVRVU19DTEtfVUxQUwkJQklUKDkpCisjZGVmaW5lIFNVTjhJX0E4 M1RfRFBIWV9TVEFUVVNfSFNDTEsJCUJJVCg4KQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlfU1RB VFVTX0QzX1NUT1AJCUJJVCg3KQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlfU1RBVFVTX0QyX1NU T1AJCUJJVCg2KQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlfU1RBVFVTX0QxX1NUT1AJCUJJVCg1 KQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlfU1RBVFVTX0QwX1NUT1AJCUJJVCg0KQorI2RlZmlu ZSBTVU44SV9BODNUX0RQSFlfU1RBVFVTX0QzX1VMUFMJCUJJVCgzKQorI2RlZmluZSBTVU44SV9B ODNUX0RQSFlfU1RBVFVTX0QyX1VMUFMJCUJJVCgyKQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlf U1RBVFVTX0QxX1VMUFMJCUJJVCgxKQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlfU1RBVFVTX0Qw X1VMUFMJCUJJVCgwKQorCisjZGVmaW5lIFNVTjhJX0E4M1RfRFBIWV9BTkEwX1JFRwkJMHgzMAor I2RlZmluZSBTVU44SV9BODNUX0RQSFlfQU5BMF9SRVhUX0VOCQlCSVQoMzEpCisjZGVmaW5lIFNV TjhJX0E4M1RfRFBIWV9BTkEwX1JFWFQJCUJJVCgzMCkKKyNkZWZpbmUgU1VOOElfQTgzVF9EUEhZ X0FOQTBfUklOVCh2KQkJKCgodikgPDwgMjgpICYgR0VOTUFTSygyOSwgMjgpKQorI2RlZmluZSBT VU44SV9BODNUX0RQSFlfQU5BMF9TTksodikJCSgoKHYpIDw8IDIwKSAmIEdFTk1BU0soMjIsIDIw KSkKKworaW50IHN1bjhpX2E4M3RfZHBoeV9yZWdpc3RlcihzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBp X2NzaTJfZGV2aWNlICpjc2kyX2Rldik7CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9t ZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9zdW44aV9hODN0X21pcGlf Y3NpMi5jIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3Np Mi9zdW44aV9hODN0X21pcGlfY3NpMi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMC4uNmIwMTBlNzRmMDU3Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9zdW44aV9hODN0X21pcGlfY3NpMi5j CkBAIC0wLDAgKzEsODEyIEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsK Ky8qCisgKiBDb3B5cmlnaHQgMjAyMCBLw6l2aW4gTCdow7RwaXRhbCA8a2V2aW4ubGhvcGl0YWxA Ym9vdGxpbi5jb20+CisgKiBDb3B5cmlnaHQgMjAyMC0yMDIxIEJvb3RsaW4KKyAqIEF1dGhvcjog UGF1bCBLb2NpYWxrb3dza2kgPHBhdWwua29jaWFsa293c2tpQGJvb3RsaW4uY29tPgorICovCisK KyNpbmNsdWRlIDxsaW51eC9jbGsuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNs dWRlIDxsaW51eC9vZi5oPgorI2luY2x1ZGUgPGxpbnV4L29mX2RldmljZS5oPgorI2luY2x1ZGUg PGxpbnV4L3BoeS9waHkuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNp bmNsdWRlIDxsaW51eC9wbV9ydW50aW1lLmg+CisjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+Cisj aW5jbHVkZSA8bGludXgvcmVzZXQuaD4KKyNpbmNsdWRlIDxtZWRpYS92NGwyLWN0cmxzLmg+Cisj aW5jbHVkZSA8bWVkaWEvdjRsMi1kZXZpY2UuaD4KKyNpbmNsdWRlIDxtZWRpYS92NGwyLWZ3bm9k ZS5oPgorCisjaW5jbHVkZSAic3VuOGlfYTgzdF9kcGh5LmgiCisjaW5jbHVkZSAic3VuOGlfYTgz dF9taXBpX2NzaTIuaCIKKyNpbmNsdWRlICJzdW44aV9hODN0X21pcGlfY3NpMl9yZWcuaCIKKwor LyogRm9ybWF0ICovCisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJf Zm9ybWF0CitzdW44aV9hODN0X21pcGlfY3NpMl9mb3JtYXRzW10gPSB7CisJeworCQkubWJ1c19j b2RlCT0gTUVESUFfQlVTX0ZNVF9TQkdHUjhfMVg4LAorCQkuZGF0YV90eXBlCT0gTUlQSV9DU0ky X0RBVEFfVFlQRV9SQVc4LAorCQkuYnBwCQk9IDgsCisJfSwKKwl7CisJCS5tYnVzX2NvZGUJPSBN RURJQV9CVVNfRk1UX1NHQlJHOF8xWDgsCisJCS5kYXRhX3R5cGUJPSBNSVBJX0NTSTJfREFUQV9U WVBFX1JBVzgsCisJCS5icHAJCT0gOCwKKwl9LAorCXsKKwkJLm1idXNfY29kZQk9IE1FRElBX0JV U19GTVRfU0dSQkc4XzFYOCwKKwkJLmRhdGFfdHlwZQk9IE1JUElfQ1NJMl9EQVRBX1RZUEVfUkFX OCwKKwkJLmJwcAkJPSA4LAorCX0sCisJeworCQkubWJ1c19jb2RlCT0gTUVESUFfQlVTX0ZNVF9T UkdHQjhfMVg4LAorCQkuZGF0YV90eXBlCT0gTUlQSV9DU0kyX0RBVEFfVFlQRV9SQVc4LAorCQku YnBwCQk9IDgsCisJfSwKKwl7CisJCS5tYnVzX2NvZGUJPSBNRURJQV9CVVNfRk1UX1NCR0dSMTBf MVgxMCwKKwkJLmRhdGFfdHlwZQk9IE1JUElfQ1NJMl9EQVRBX1RZUEVfUkFXMTAsCisJCS5icHAJ CT0gMTAsCisJfSwKKwl7CisJCS5tYnVzX2NvZGUJPSBNRURJQV9CVVNfRk1UX1NHQlJHMTBfMVgx MCwKKwkJLmRhdGFfdHlwZQk9IE1JUElfQ1NJMl9EQVRBX1RZUEVfUkFXMTAsCisJCS5icHAJCT0g MTAsCisJfSwKKwl7CisJCS5tYnVzX2NvZGUJPSBNRURJQV9CVVNfRk1UX1NHUkJHMTBfMVgxMCwK KwkJLmRhdGFfdHlwZQk9IE1JUElfQ1NJMl9EQVRBX1RZUEVfUkFXMTAsCisJCS5icHAJCT0gMTAs CisJfSwKKwl7CisJCS5tYnVzX2NvZGUJPSBNRURJQV9CVVNfRk1UX1NSR0dCMTBfMVgxMCwKKwkJ LmRhdGFfdHlwZQk9IE1JUElfQ1NJMl9EQVRBX1RZUEVfUkFXMTAsCisJCS5icHAJCT0gMTAsCisJ fSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJfZm9ybWF0 ICoKK3N1bjhpX2E4M3RfbWlwaV9jc2kyX2Zvcm1hdF9maW5kKHUzMiBtYnVzX2NvZGUpCit7CisJ dW5zaWduZWQgaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShzdW44aV9hODN0 X21pcGlfY3NpMl9mb3JtYXRzKTsgaSsrKQorCQlpZiAoc3VuOGlfYTgzdF9taXBpX2NzaTJfZm9y bWF0c1tpXS5tYnVzX2NvZGUgPT0gbWJ1c19jb2RlKQorCQkJcmV0dXJuICZzdW44aV9hODN0X21p cGlfY3NpMl9mb3JtYXRzW2ldOworCisJcmV0dXJuIE5VTEw7Cit9CisKKy8qIENvbnRyb2xsZXIg Ki8KKworc3RhdGljIHZvaWQKK3N1bjhpX2E4M3RfbWlwaV9jc2kyX2luaXQoc3RydWN0IHN1bjhp X2E4M3RfbWlwaV9jc2kyX2RldmljZSAqY3NpMl9kZXYpCit7CisJc3RydWN0IHJlZ21hcCAqcmVn bWFwID0gY3NpMl9kZXYtPnJlZ21hcDsKKworCS8qCisJICogVGhlIEFsbHdpbm5lciBCU1Agc2V0 cyB2YXJpb3VzIG1hZ2ljIHZhbHVlcyBvbiBhIGJ1bmNoIG9mIHJlZ2lzdGVycy4KKwkgKiBUaGlz IGlzIGFwcGFyZW50bHkgYSBuZWNlc3NhcnkgaW5pdGlhbGl6YXRpb24gcHJvY2VzcyB0aGF0IHdp bGwgY2F1c2UKKwkgKiB0aGUgY2FwdHVyZSB0byBmYWlsIHdpdGggdW5zb2xpY2l0ZWQgaW50ZXJy dXB0cyBoaXR0aW5nIGlmIHNraXBwZWQuCisJICoKKwkgKiBNb3N0IG9mIHRoZSByZWdpc3RlcnMg YXJlIHNldCB0byBwcm9wZXIgdmFsdWVzIGxhdGVyLCBleGNlcHQgZm9yIHRoZQorCSAqIHR3byBy ZXNlcnZlZCByZWdpc3RlcnMuIFRoZXkgYXJlIHNhaWQgdG8gaG9sZCBhICJoYXJkd2FyZSBsb2Nr IgorCSAqIHZhbHVlLCB3aXRob3V0IG1vcmUgaW5mb3JtYXRpb24gYXZhaWxhYmxlLgorCSAqLwor CisJcmVnbWFwX3dyaXRlKHJlZ21hcCwgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ1RSTF9SRUcsIDAp OworCXJlZ21hcF93cml0ZShyZWdtYXAsIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0NUUkxfUkVHLAor CQkgICAgIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0NUUkxfSU5JVF9WQUxVRSk7CisKKwlyZWdtYXBf d3JpdGUocmVnbWFwLCBTVU44SV9BODNUX01JUElfQ1NJMl9SWF9QS1RfTlVNX1JFRywgMCk7CisJ cmVnbWFwX3dyaXRlKHJlZ21hcCwgU1VOOElfQTgzVF9NSVBJX0NTSTJfUlhfUEtUX05VTV9SRUcs CisJCSAgICAgU1VOOElfQTgzVF9NSVBJX0NTSTJfUlhfUEtUX05VTV9JTklUX1ZBTFVFKTsKKwor CXJlZ21hcF93cml0ZShyZWdtYXAsIFNVTjhJX0E4M1RfRFBIWV9DVFJMX1JFRywgMCk7CisJcmVn bWFwX3dyaXRlKHJlZ21hcCwgU1VOOElfQTgzVF9EUEhZX0NUUkxfUkVHLAorCQkgICAgIFNVTjhJ X0E4M1RfRFBIWV9DVFJMX0lOSVRfVkFMVUUpOworCisJcmVnbWFwX3dyaXRlKHJlZ21hcCwgU1VO OElfQTgzVF9NSVBJX0NTSTJfUlNWRDFfUkVHLCAwKTsKKwlyZWdtYXBfd3JpdGUocmVnbWFwLCBT VU44SV9BODNUX01JUElfQ1NJMl9SU1ZEMV9SRUcsCisJCSAgICAgU1VOOElfQTgzVF9NSVBJX0NT STJfUlNWRDFfSFdfTE9DS19WQUxVRSk7CisKKwlyZWdtYXBfd3JpdGUocmVnbWFwLCBTVU44SV9B ODNUX01JUElfQ1NJMl9SU1ZEMl9SRUcsIDApOworCXJlZ21hcF93cml0ZShyZWdtYXAsIFNVTjhJ X0E4M1RfTUlQSV9DU0kyX1JTVkQyX1JFRywKKwkJICAgICBTVU44SV9BODNUX01JUElfQ1NJMl9S U1ZEMl9IV19MT0NLX1ZBTFVFKTsKKworCXJlZ21hcF93cml0ZShyZWdtYXAsIFNVTjhJX0E4M1Rf TUlQSV9DU0kyX0NGR19SRUcsIDApOworCXJlZ21hcF93cml0ZShyZWdtYXAsIFNVTjhJX0E4M1Rf TUlQSV9DU0kyX0NGR19SRUcsCisJCSAgICAgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ0ZHX0lOSVRf VkFMVUUpOworfQorCitzdGF0aWMgdm9pZAorc3VuOGlfYTgzdF9taXBpX2NzaTJfZW5hYmxlKHN0 cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZpY2UgKmNzaTJfZGV2KQoreworCXN0cnVjdCBy ZWdtYXAgKnJlZ21hcCA9IGNzaTJfZGV2LT5yZWdtYXA7CisKKwlyZWdtYXBfdXBkYXRlX2JpdHMo cmVnbWFwLCBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfUkVHLAorCQkJICAgU1VOOElfQTgzVF9N SVBJX0NTSTJfQ0ZHX1NZTkNfRU4sCisJCQkgICBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfU1lO Q19FTik7Cit9CisKK3N0YXRpYyB2b2lkCitzdW44aV9hODN0X21pcGlfY3NpMl9kaXNhYmxlKHN0 cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZpY2UgKmNzaTJfZGV2KQoreworCXN0cnVjdCBy ZWdtYXAgKnJlZ21hcCA9IGNzaTJfZGV2LT5yZWdtYXA7CisKKwlyZWdtYXBfdXBkYXRlX2JpdHMo cmVnbWFwLCBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfUkVHLAorCQkJICAgU1VOOElfQTgzVF9N SVBJX0NTSTJfQ0ZHX1NZTkNfRU4sIDApOworCisJcmVnbWFwX3dyaXRlKHJlZ21hcCwgU1VOOElf QTgzVF9NSVBJX0NTSTJfQ1RSTF9SRUcsIDApOworfQorCitzdGF0aWMgdm9pZAorc3VuOGlfYTgz dF9taXBpX2NzaTJfY29uZmlndXJlKHN0cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZpY2Ug KmNzaTJfZGV2KQoreworCXN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IGNzaTJfZGV2LT5yZWdtYXA7 CisJdW5zaWduZWQgaW50IGxhbmVzX2NvdW50ID0KKwkJY3NpMl9kZXYtPmJyaWRnZS5lbmRwb2lu dC5idXMubWlwaV9jc2kyLm51bV9kYXRhX2xhbmVzOworCXN0cnVjdCB2NGwyX21idXNfZnJhbWVm bXQgKm1idXNfZm9ybWF0ID0gJmNzaTJfZGV2LT5icmlkZ2UubWJ1c19mb3JtYXQ7CisJY29uc3Qg c3RydWN0IHN1bjhpX2E4M3RfbWlwaV9jc2kyX2Zvcm1hdCAqZm9ybWF0OworCXN0cnVjdCBkZXZp Y2UgKmRldiA9IGNzaTJfZGV2LT5kZXY7CisJdTMyIHZlcnNpb24gPSAwOworCisJZm9ybWF0ID0g c3VuOGlfYTgzdF9taXBpX2NzaTJfZm9ybWF0X2ZpbmQobWJ1c19mb3JtYXQtPmNvZGUpOworCWlm IChXQVJOX09OKCFmb3JtYXQpKQorCQlyZXR1cm47CisKKwlyZWdtYXBfd3JpdGUocmVnbWFwLCBT VU44SV9BODNUX01JUElfQ1NJMl9DVFJMX1JFRywKKwkJICAgICBTVU44SV9BODNUX01JUElfQ1NJ Ml9DVFJMX1JFU0VUX04pOworCisJcmVnbWFwX3JlYWQocmVnbWFwLCBTVU44SV9BODNUX01JUElf Q1NJMl9WRVJTSU9OX1JFRywgJnZlcnNpb24pOworCisJZGV2X2RiZyhkZXYsICJBODNUIE1JUEkg Q1NJLTIgdmVyc2lvbjogJTA0eFxuIiwgdmVyc2lvbik7CisKKwlyZWdtYXBfd3JpdGUocmVnbWFw LCBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfUkVHLAorCQkgICAgIFNVTjhJX0E4M1RfTUlQSV9D U0kyX0NGR19VTlBLVF9FTiB8CisJCSAgICAgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ0ZHX1NZTkNf RExZX0NZQ0xFKDgpIHwKKwkJICAgICBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfTl9DSEFOTkVM KDEpIHwKKwkJICAgICBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfTl9MQU5FKGxhbmVzX2NvdW50 KSk7CisKKwkvKgorCSAqIE9ubHkgYSBzaW5nbGUgdmlydHVhbCBjaGFubmVsIChpbmRleCAwKSBp cyBjdXJyZW50bHkgc3VwcG9ydGVkLgorCSAqIFdoaWxlIHRoZSByZWdpc3RlcnMgZG8gbWVudGlv biBtdWx0aXBsZSBwaHlzaWNhbCBjaGFubmVscyBiZWluZworCSAqIGF2YWlsYWJsZSAod2hpY2gg Y2FuIGJlIGNvbmZpZ3VyZWQgdG8gbWF0Y2ggYSBzcGVjaWZpYyB2aXJ0dWFsCisJICogY2hhbm5l bCBvciBkYXRhIHR5cGUpLCBpdCdzIHVuY2xlYXIgd2hldGhlciBjaGFubmVscyA+IDAgYXJlIGFj dHVhbGx5CisJICogY29ubmVjdGVkIGFuZCBhdmFpbGFibGUgYW5kIHRoZSByZWZlcmVuY2Ugc291 cmNlIGNvZGUgb25seSBtYWtlcyB1c2UKKwkgKiBvZiBjaGFubmVsIDAuCisJICoKKwkgKiBVc2lu ZyBleHRyYSBjaGFubmVscyB3b3VsZCBhbHNvIHJlcXVpcmUgbWF0Y2hpbmcgY2hhbm5lbHMgdG8g YmUKKwkgKiBhdmFpbGFibGUgb24gdGhlIENTSSAoYW5kIElTUCkgc2lkZSwgd2hpY2ggaXMgYWxz byB1bnN1cmUgYWx0aG91Z2gKKwkgKiBzb21lIENTSSBpbXBsZW1lbnRhdGlvbnMgYXJlIHNhaWQg dG8gc3VwcG9ydCBtdWx0aXBsZSBjaGFubmVscyBmb3IKKwkgKiBCVDY1NiB0aW1lLXNoYXJpbmcu CisJICoKKwkgKiBXZSBzdGlsbCBjb25maWd1cmUgdmlydHVhbCBjaGFubmVsIG51bWJlcnMgdG8g ZW5zdXJlIHRoYXQgdmlydHVhbAorCSAqIGNoYW5uZWwgMCBvbmx5IGdvZXMgdG8gY2hhbm5lbCAw LgorCSAqLworCisJcmVnbWFwX3dyaXRlKHJlZ21hcCwgU1VOOElfQTgzVF9NSVBJX0NTSTJfVkNE VDBfUkVHLAorCQkgICAgIFNVTjhJX0E4M1RfTUlQSV9DU0kyX1ZDRFQwX0NIX1ZDKDMsIDMpIHwK KwkJICAgICBTVU44SV9BODNUX01JUElfQ1NJMl9WQ0RUMF9DSF9WQygyLCAyKSB8CisJCSAgICAg U1VOOElfQTgzVF9NSVBJX0NTSTJfVkNEVDBfQ0hfVkMoMSwgMSkgfAorCQkgICAgIFNVTjhJX0E4 M1RfTUlQSV9DU0kyX1ZDRFQwX0NIX1ZDKDAsIDApIHwKKwkJICAgICBTVU44SV9BODNUX01JUElf Q1NJMl9WQ0RUMF9DSF9EVCgwLCBmb3JtYXQtPmRhdGFfdHlwZSkpOworfQorCisvKiBWNEwyIFN1 YmRldiAqLworCitzdGF0aWMgaW50IHN1bjhpX2E4M3RfbWlwaV9jc2kyX3Nfc3RyZWFtKHN0cnVj dCB2NGwyX3N1YmRldiAqc3ViZGV2LCBpbnQgb24pCit7CisJc3RydWN0IHN1bjhpX2E4M3RfbWlw aV9jc2kyX2RldmljZSAqY3NpMl9kZXYgPQorCQl2NGwyX2dldF9zdWJkZXZkYXRhKHN1YmRldik7 CisJc3RydWN0IHY0bDJfc3ViZGV2ICpzb3VyY2Vfc3ViZGV2ID0gY3NpMl9kZXYtPmJyaWRnZS5z b3VyY2Vfc3ViZGV2OworCXVuaW9uIHBoeV9jb25maWd1cmVfb3B0cyBkcGh5X29wdHMgPSB7IDAg fTsKKwlzdHJ1Y3QgcGh5X2NvbmZpZ3VyZV9vcHRzX21pcGlfZHBoeSAqZHBoeV9jZmcgPSAmZHBo eV9vcHRzLm1pcGlfZHBoeTsKKwlzdHJ1Y3QgdjRsMl9tYnVzX2ZyYW1lZm10ICptYnVzX2Zvcm1h dCA9ICZjc2kyX2Rldi0+YnJpZGdlLm1idXNfZm9ybWF0OworCWNvbnN0IHN0cnVjdCBzdW44aV9h ODN0X21pcGlfY3NpMl9mb3JtYXQgKmZvcm1hdDsKKwlzdHJ1Y3QgcGh5ICpkcGh5ID0gY3NpMl9k ZXYtPmRwaHk7CisJc3RydWN0IGRldmljZSAqZGV2ID0gY3NpMl9kZXYtPmRldjsKKwlzdHJ1Y3Qg djRsMl9jdHJsICpjdHJsOworCXVuc2lnbmVkIGludCBsYW5lc19jb3VudCA9CisJCWNzaTJfZGV2 LT5icmlkZ2UuZW5kcG9pbnQuYnVzLm1pcGlfY3NpMi5udW1fZGF0YV9sYW5lczsKKwl1bnNpZ25l ZCBsb25nIHBpeGVsX3JhdGU7CisJLyogSW5pdGlhbGl6ZSB0byAwIHRvIHVzZSBib3RoIGluIGRp c2FibGUgbGFiZWwgKHJldCAhPSAwKSBhbmQgb2ZmLiAqLworCWludCByZXQgPSAwOworCisJaWYg KCFzb3VyY2Vfc3ViZGV2KQorCQlyZXR1cm4gLUVOT0RFVjsKKworCWlmICghb24pIHsKKwkJdjRs Ml9zdWJkZXZfY2FsbChzb3VyY2Vfc3ViZGV2LCB2aWRlbywgc19zdHJlYW0sIDApOworCQlnb3Rv IGRpc2FibGU7CisJfQorCisJLyogUnVudGltZSBQTSAqLworCisJcmV0ID0gcG1fcnVudGltZV9y ZXN1bWVfYW5kX2dldChkZXYpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJLyog U2Vuc29yIHBpeGVsIHJhdGUgKi8KKworCWN0cmwgPSB2NGwyX2N0cmxfZmluZChzb3VyY2Vfc3Vi ZGV2LT5jdHJsX2hhbmRsZXIsIFY0TDJfQ0lEX1BJWEVMX1JBVEUpOworCWlmICghY3RybCkgewor CQlkZXZfZXJyKGRldiwgIm1pc3Npbmcgc2Vuc29yIHBpeGVsIHJhdGVcbiIpOworCQlyZXQgPSAt RU5PREVWOworCQlnb3RvIGVycm9yX3BtOworCX0KKworCXBpeGVsX3JhdGUgPSAodW5zaWduZWQg bG9uZyl2NGwyX2N0cmxfZ19jdHJsX2ludDY0KGN0cmwpOworCWlmICghcGl4ZWxfcmF0ZSkgewor CQlkZXZfZXJyKGRldiwgIm1pc3NpbmcgKHplcm8pIHNlbnNvciBwaXhlbCByYXRlXG4iKTsKKwkJ cmV0ID0gLUVOT0RFVjsKKwkJZ290byBlcnJvcl9wbTsKKwl9CisKKwkvKiBELVBIWSAqLworCisJ aWYgKCFsYW5lc19jb3VudCkgeworCQlkZXZfZXJyKGRldiwgIm1pc3NpbmcgKHplcm8pIE1JUEkg Q1NJLTIgbGFuZXMgY291bnRcbiIpOworCQlyZXQgPSAtRU5PREVWOworCQlnb3RvIGVycm9yX3Bt OworCX0KKworCWZvcm1hdCA9IHN1bjhpX2E4M3RfbWlwaV9jc2kyX2Zvcm1hdF9maW5kKG1idXNf Zm9ybWF0LT5jb2RlKTsKKwlpZiAoV0FSTl9PTighZm9ybWF0KSkgeworCQlyZXQgPSAtRU5PREVW OworCQlnb3RvIGVycm9yX3BtOworCX0KKworCXBoeV9taXBpX2RwaHlfZ2V0X2RlZmF1bHRfY29u ZmlnKHBpeGVsX3JhdGUsIGZvcm1hdC0+YnBwLCBsYW5lc19jb3VudCwKKwkJCQkJIGRwaHlfY2Zn KTsKKworCS8qCisJICogTm90ZSB0aGF0IG91ciBoYXJkd2FyZSBpcyB1c2luZyBERFIsIHdoaWNo IGlzIG5vdCB0YWtlbiBpbiBhY2NvdW50IGJ5CisJICogcGh5X21pcGlfZHBoeV9nZXRfZGVmYXVs dF9jb25maWcgd2hlbiBjYWxjdWxhdGluZyBoc19jbGtfcmF0ZSBmcm9tCisJICogdGhlIHBpeGVs IHJhdGUsIGxhbmVzIGNvdW50IGFuZCBicHAuCisJICoKKwkgKiBUaGUgcmVzdWx0aW5nIGNsb2Nr IHJhdGUgaXMgYmFzaWNhbGx5IHRoZSBzeW1ib2wgcmF0ZSBvdmVyIHRoZSB3aG9sZQorCSAqIGxp bmsuIFRoZSBhY3R1YWwgY2xvY2sgcmF0ZSBpcyBjYWxjdWxhdGVkIHdpdGggZGl2aXNpb24gYnkg dHdvIHNpbmNlCisJICogRERSIHNhbXBsZXMgYm90aCBvbiByaXNpbmcgYW5kIGZhbGxpbmcgZWRn ZXMuCisJICovCisKKwlkZXZfZGJnKGRldiwgIkE4M1QgTUlQSSBDU0ktMiBjb25maWc6XG4iKTsK KwlkZXZfZGJnKGRldiwgIiVsZCBwaXhlbHMvcywgJXUgYml0cy9waXhlbCwgJXUgbGFuZXMsICVs dSBIeiBjbG9ja1xuIiwKKwkJcGl4ZWxfcmF0ZSwgZm9ybWF0LT5icHAsIGxhbmVzX2NvdW50LAor CQlkcGh5X2NmZy0+aHNfY2xrX3JhdGUgLyAyKTsKKworCXJldCA9IHBoeV9yZXNldChkcGh5KTsK KwlpZiAocmV0KSB7CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIHJlc2V0IE1JUEkgRC1QSFlc biIpOworCQlnb3RvIGVycm9yX3BtOworCX0KKworCXJldCA9IHBoeV9jb25maWd1cmUoZHBoeSwg JmRwaHlfb3B0cyk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBjb25m aWd1cmUgTUlQSSBELVBIWVxuIik7CisJCWdvdG8gZXJyb3JfcG07CisJfQorCisJLyogQ29udHJv bGxlciAqLworCisJc3VuOGlfYTgzdF9taXBpX2NzaTJfY29uZmlndXJlKGNzaTJfZGV2KTsKKwlz dW44aV9hODN0X21pcGlfY3NpMl9lbmFibGUoY3NpMl9kZXYpOworCisJLyogRC1QSFkgKi8KKwor CXJldCA9IHBoeV9wb3dlcl9vbihkcGh5KTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIoZGV2LCAi ZmFpbGVkIHRvIHBvd2VyIG9uIE1JUEkgRC1QSFlcbiIpOworCQlnb3RvIGVycm9yX3BtOworCX0K KworCS8qIFNvdXJjZSAqLworCisJcmV0ID0gdjRsMl9zdWJkZXZfY2FsbChzb3VyY2Vfc3ViZGV2 LCB2aWRlbywgc19zdHJlYW0sIDEpOworCWlmIChyZXQgJiYgcmV0ICE9IC1FTk9JT0NUTENNRCkK KwkJZ290byBkaXNhYmxlOworCisJcmV0dXJuIDA7CisKK2Rpc2FibGU6CisJcGh5X3Bvd2VyX29m ZihkcGh5KTsKKwlzdW44aV9hODN0X21pcGlfY3NpMl9kaXNhYmxlKGNzaTJfZGV2KTsKKworZXJy b3JfcG06CisJcG1fcnVudGltZV9wdXQoZGV2KTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRp YyBjb25zdCBzdHJ1Y3QgdjRsMl9zdWJkZXZfdmlkZW9fb3BzCitzdW44aV9hODN0X21pcGlfY3Np Ml92aWRlb19vcHMgPSB7CisJLnNfc3RyZWFtCT0gc3VuOGlfYTgzdF9taXBpX2NzaTJfc19zdHJl YW0sCit9OworCitzdGF0aWMgdm9pZAorc3VuOGlfYTgzdF9taXBpX2NzaTJfbWJ1c19mb3JtYXRf cHJlcGFyZShzdHJ1Y3QgdjRsMl9tYnVzX2ZyYW1lZm10ICptYnVzX2Zvcm1hdCkKK3sKKwlpZiAo IXN1bjhpX2E4M3RfbWlwaV9jc2kyX2Zvcm1hdF9maW5kKG1idXNfZm9ybWF0LT5jb2RlKSkKKwkJ bWJ1c19mb3JtYXQtPmNvZGUgPSBzdW44aV9hODN0X21pcGlfY3NpMl9mb3JtYXRzWzBdLm1idXNf Y29kZTsKKworCW1idXNfZm9ybWF0LT5maWVsZCA9IFY0TDJfRklFTERfTk9ORTsKKwltYnVzX2Zv cm1hdC0+Y29sb3JzcGFjZSA9IFY0TDJfQ09MT1JTUEFDRV9SQVc7CisJbWJ1c19mb3JtYXQtPnF1 YW50aXphdGlvbiA9IFY0TDJfUVVBTlRJWkFUSU9OX0RFRkFVTFQ7CisJbWJ1c19mb3JtYXQtPnhm ZXJfZnVuYyA9IFY0TDJfWEZFUl9GVU5DX0RFRkFVTFQ7Cit9CisKK3N0YXRpYyBpbnQgc3VuOGlf YTgzdF9taXBpX2NzaTJfaW5pdF9jZmcoc3RydWN0IHY0bDJfc3ViZGV2ICpzdWJkZXYsCisJCQkJ CSBzdHJ1Y3QgdjRsMl9zdWJkZXZfc3RhdGUgKnN0YXRlKQoreworCXVuc2lnbmVkIGludCBwYWQg PSBTVU44SV9BODNUX01JUElfQ1NJMl9QQURfU0lOSzsKKwlzdHJ1Y3QgdjRsMl9tYnVzX2ZyYW1l Zm10ICptYnVzX2Zvcm1hdCA9CisJCXY0bDJfc3ViZGV2X2dldF90cnlfZm9ybWF0KHN1YmRldiwg c3RhdGUsIHBhZCk7CisKKwltYnVzX2Zvcm1hdC0+Y29kZSA9IHN1bjhpX2E4M3RfbWlwaV9jc2ky X2Zvcm1hdHNbMF0ubWJ1c19jb2RlOworCW1idXNfZm9ybWF0LT53aWR0aCA9IDY0MDsKKwltYnVz X2Zvcm1hdC0+aGVpZ2h0ID0gNDgwOworCisJc3VuOGlfYTgzdF9taXBpX2NzaTJfbWJ1c19mb3Jt YXRfcHJlcGFyZShtYnVzX2Zvcm1hdCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludAor c3VuOGlfYTgzdF9taXBpX2NzaTJfZW51bV9tYnVzX2NvZGUoc3RydWN0IHY0bDJfc3ViZGV2ICpz dWJkZXYsCisJCQkJICAgIHN0cnVjdCB2NGwyX3N1YmRldl9zdGF0ZSAqc3RhdGUsCisJCQkJICAg IHN0cnVjdCB2NGwyX3N1YmRldl9tYnVzX2NvZGVfZW51bSAqY29kZV9lbnVtKQoreworCWlmIChj b2RlX2VudW0tPmluZGV4ID49IEFSUkFZX1NJWkUoc3VuOGlfYTgzdF9taXBpX2NzaTJfZm9ybWF0 cykpCisJCXJldHVybiAtRUlOVkFMOworCisJY29kZV9lbnVtLT5jb2RlID0KKwkJc3VuOGlfYTgz dF9taXBpX2NzaTJfZm9ybWF0c1tjb2RlX2VudW0tPmluZGV4XS5tYnVzX2NvZGU7CisKKwlyZXR1 cm4gMDsKK30KKworc3RhdGljIGludCBzdW44aV9hODN0X21pcGlfY3NpMl9nZXRfZm10KHN0cnVj dCB2NGwyX3N1YmRldiAqc3ViZGV2LAorCQkJCQlzdHJ1Y3QgdjRsMl9zdWJkZXZfc3RhdGUgKnN0 YXRlLAorCQkJCQlzdHJ1Y3QgdjRsMl9zdWJkZXZfZm9ybWF0ICpmb3JtYXQpCit7CisJc3RydWN0 IHN1bjhpX2E4M3RfbWlwaV9jc2kyX2RldmljZSAqY3NpMl9kZXYgPQorCQl2NGwyX2dldF9zdWJk ZXZkYXRhKHN1YmRldik7CisJc3RydWN0IHY0bDJfbWJ1c19mcmFtZWZtdCAqbWJ1c19mb3JtYXQg PSAmZm9ybWF0LT5mb3JtYXQ7CisKKwlpZiAoZm9ybWF0LT53aGljaCA9PSBWNEwyX1NVQkRFVl9G T1JNQVRfVFJZKQorCQkqbWJ1c19mb3JtYXQgPSAqdjRsMl9zdWJkZXZfZ2V0X3RyeV9mb3JtYXQo c3ViZGV2LCBzdGF0ZSwKKwkJCQkJCQkgICBmb3JtYXQtPnBhZCk7CisJZWxzZQorCQkqbWJ1c19m b3JtYXQgPSBjc2kyX2Rldi0+YnJpZGdlLm1idXNfZm9ybWF0OworCisJcmV0dXJuIDA7Cit9CisK K3N0YXRpYyBpbnQgc3VuOGlfYTgzdF9taXBpX2NzaTJfc2V0X2ZtdChzdHJ1Y3QgdjRsMl9zdWJk ZXYgKnN1YmRldiwKKwkJCQkJc3RydWN0IHY0bDJfc3ViZGV2X3N0YXRlICpzdGF0ZSwKKwkJCQkJ c3RydWN0IHY0bDJfc3ViZGV2X2Zvcm1hdCAqZm9ybWF0KQoreworCXN0cnVjdCBzdW44aV9hODN0 X21pcGlfY3NpMl9kZXZpY2UgKmNzaTJfZGV2ID0KKwkJdjRsMl9nZXRfc3ViZGV2ZGF0YShzdWJk ZXYpOworCXN0cnVjdCB2NGwyX21idXNfZnJhbWVmbXQgKm1idXNfZm9ybWF0ID0gJmZvcm1hdC0+ Zm9ybWF0OworCisJc3VuOGlfYTgzdF9taXBpX2NzaTJfbWJ1c19mb3JtYXRfcHJlcGFyZShtYnVz X2Zvcm1hdCk7CisKKwlpZiAoZm9ybWF0LT53aGljaCA9PSBWNEwyX1NVQkRFVl9GT1JNQVRfVFJZ KQorCQkqdjRsMl9zdWJkZXZfZ2V0X3RyeV9mb3JtYXQoc3ViZGV2LCBzdGF0ZSwgZm9ybWF0LT5w YWQpID0KKwkJCSptYnVzX2Zvcm1hdDsKKwllbHNlCisJCWNzaTJfZGV2LT5icmlkZ2UubWJ1c19m b3JtYXQgPSAqbWJ1c19mb3JtYXQ7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0 cnVjdCB2NGwyX3N1YmRldl9wYWRfb3BzIHN1bjhpX2E4M3RfbWlwaV9jc2kyX3BhZF9vcHMgPSB7 CisJLmluaXRfY2ZnCT0gc3VuOGlfYTgzdF9taXBpX2NzaTJfaW5pdF9jZmcsCisJLmVudW1fbWJ1 c19jb2RlCT0gc3VuOGlfYTgzdF9taXBpX2NzaTJfZW51bV9tYnVzX2NvZGUsCisJLmdldF9mbXQJ PSBzdW44aV9hODN0X21pcGlfY3NpMl9nZXRfZm10LAorCS5zZXRfZm10CT0gc3VuOGlfYTgzdF9t aXBpX2NzaTJfc2V0X2ZtdCwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdjRsMl9zdWJkZXZf b3BzIHN1bjhpX2E4M3RfbWlwaV9jc2kyX3N1YmRldl9vcHMgPSB7CisJLnZpZGVvCT0gJnN1bjhp X2E4M3RfbWlwaV9jc2kyX3ZpZGVvX29wcywKKwkucGFkCT0gJnN1bjhpX2E4M3RfbWlwaV9jc2ky X3BhZF9vcHMsCit9OworCisvKiBNZWRpYSBFbnRpdHkgKi8KKworc3RhdGljIGNvbnN0IHN0cnVj dCBtZWRpYV9lbnRpdHlfb3BlcmF0aW9ucyBzdW44aV9hODN0X21pcGlfY3NpMl9lbnRpdHlfb3Bz ID0geworCS5saW5rX3ZhbGlkYXRlCT0gdjRsMl9zdWJkZXZfbGlua192YWxpZGF0ZSwKK307CisK Ky8qIFY0TDIgQXN5bmMgKi8KKworc3RhdGljIGludAorc3VuOGlfYTgzdF9taXBpX2NzaTJfbm90 aWZpZXJfYm91bmQoc3RydWN0IHY0bDJfYXN5bmNfbm90aWZpZXIgKm5vdGlmaWVyLAorCQkJCSAg ICBzdHJ1Y3QgdjRsMl9zdWJkZXYgKnJlbW90ZV9zdWJkZXYsCisJCQkJICAgIHN0cnVjdCB2NGwy X2FzeW5jX3N1YmRldiAqYXN5bmNfc3ViZGV2KQoreworCXN0cnVjdCB2NGwyX3N1YmRldiAqc3Vi ZGV2ID0gbm90aWZpZXItPnNkOworCXN0cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZpY2Ug KmNzaTJfZGV2ID0KKwkJY29udGFpbmVyX29mKG5vdGlmaWVyLCBzdHJ1Y3Qgc3VuOGlfYTgzdF9t aXBpX2NzaTJfZGV2aWNlLAorCQkJICAgICBicmlkZ2Uubm90aWZpZXIpOworCXN0cnVjdCBtZWRp YV9lbnRpdHkgKnNpbmtfZW50aXR5ID0gJnN1YmRldi0+ZW50aXR5OworCXN0cnVjdCBtZWRpYV9l bnRpdHkgKnNvdXJjZV9lbnRpdHkgPSAmcmVtb3RlX3N1YmRldi0+ZW50aXR5OworCXN0cnVjdCBk ZXZpY2UgKmRldiA9IGNzaTJfZGV2LT5kZXY7CisJaW50IHNpbmtfcGFkX2luZGV4ID0gMDsKKwlp bnQgc291cmNlX3BhZF9pbmRleDsKKwlpbnQgcmV0OworCisJcmV0ID0gbWVkaWFfZW50aXR5X2dl dF9md25vZGVfcGFkKHNvdXJjZV9lbnRpdHksIHJlbW90ZV9zdWJkZXYtPmZ3bm9kZSwKKwkJCQkJ ICBNRURJQV9QQURfRkxfU09VUkNFKTsKKwlpZiAocmV0IDwgMCkgeworCQlkZXZfZXJyKGRldiwg Im1pc3Npbmcgc291cmNlIHBhZCBpbiBleHRlcm5hbCBlbnRpdHkgJXNcbiIsCisJCQlzb3VyY2Vf ZW50aXR5LT5uYW1lKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJc291cmNlX3BhZF9pbmRl eCA9IHJldDsKKworCWRldl9kYmcoZGV2LCAiY3JlYXRpbmcgJXM6JXUgLT4gJXM6JXUgbGlua1xu Iiwgc291cmNlX2VudGl0eS0+bmFtZSwKKwkJc291cmNlX3BhZF9pbmRleCwgc2lua19lbnRpdHkt Pm5hbWUsIHNpbmtfcGFkX2luZGV4KTsKKworCXJldCA9IG1lZGlhX2NyZWF0ZV9wYWRfbGluayhz b3VyY2VfZW50aXR5LCBzb3VyY2VfcGFkX2luZGV4LAorCQkJCSAgICBzaW5rX2VudGl0eSwgc2lu a19wYWRfaW5kZXgsCisJCQkJICAgIE1FRElBX0xOS19GTF9FTkFCTEVEIHwKKwkJCQkgICAgTUVE SUFfTE5LX0ZMX0lNTVVUQUJMRSk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgImZhaWxl ZCB0byBjcmVhdGUgJXM6JXUgLT4gJXM6JXUgbGlua1xuIiwKKwkJCXNvdXJjZV9lbnRpdHktPm5h bWUsIHNvdXJjZV9wYWRfaW5kZXgsCisJCQlzaW5rX2VudGl0eS0+bmFtZSwgc2lua19wYWRfaW5k ZXgpOworCQlyZXR1cm4gcmV0OworCX0KKworCWNzaTJfZGV2LT5icmlkZ2Uuc291cmNlX3N1YmRl diA9IHJlbW90ZV9zdWJkZXY7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVj dCB2NGwyX2FzeW5jX25vdGlmaWVyX29wZXJhdGlvbnMKK3N1bjhpX2E4M3RfbWlwaV9jc2kyX25v dGlmaWVyX29wcyA9IHsKKwkuYm91bmQJPSBzdW44aV9hODN0X21pcGlfY3NpMl9ub3RpZmllcl9i b3VuZCwKK307CisKKy8qIEJyaWRnZSAqLworCitzdGF0aWMgaW50CitzdW44aV9hODN0X21pcGlf Y3NpMl9icmlkZ2Vfc291cmNlX3NldHVwKHN0cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZp Y2UgKmNzaTJfZGV2KQoreworCXN0cnVjdCB2NGwyX2FzeW5jX25vdGlmaWVyICpub3RpZmllciA9 ICZjc2kyX2Rldi0+YnJpZGdlLm5vdGlmaWVyOworCXN0cnVjdCB2NGwyX2Z3bm9kZV9lbmRwb2lu dCAqZW5kcG9pbnQgPSAmY3NpMl9kZXYtPmJyaWRnZS5lbmRwb2ludDsKKwlzdHJ1Y3QgdjRsMl9h c3luY19zdWJkZXYgKnN1YmRldl9hc3luYzsKKwlzdHJ1Y3QgZndub2RlX2hhbmRsZSAqaGFuZGxl OworCXN0cnVjdCBkZXZpY2UgKmRldiA9IGNzaTJfZGV2LT5kZXY7CisJaW50IHJldDsKKworCWhh bmRsZSA9IGZ3bm9kZV9ncmFwaF9nZXRfZW5kcG9pbnRfYnlfaWQoZGV2X2Z3bm9kZShkZXYpLCAw LCAwLAorCQkJCQkJIEZXTk9ERV9HUkFQSF9FTkRQT0lOVF9ORVhUKTsKKwlpZiAoIWhhbmRsZSkK KwkJcmV0dXJuIC1FTk9ERVY7CisKKwllbmRwb2ludC0+YnVzX3R5cGUgPSBWNEwyX01CVVNfQ1NJ Ml9EUEhZOworCisJcmV0ID0gdjRsMl9md25vZGVfZW5kcG9pbnRfcGFyc2UoaGFuZGxlLCBlbmRw b2ludCk7CisJaWYgKHJldCkKKwkJZ290byBjb21wbGV0ZTsKKworCXN1YmRldl9hc3luYyA9IHY0 bDJfYXN5bmNfbm90aWZpZXJfYWRkX2Z3bm9kZV9yZW1vdGVfc3ViZGV2KG5vdGlmaWVyLAorCQlo YW5kbGUsIHN0cnVjdCB2NGwyX2FzeW5jX3N1YmRldik7CisJaWYgKElTX0VSUihzdWJkZXZfYXN5 bmMpKQorCQlyZXQgPSBQVFJfRVJSKHN1YmRldl9hc3luYyk7CisKK2NvbXBsZXRlOgorCWZ3bm9k ZV9oYW5kbGVfcHV0KGhhbmRsZSk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50Citz dW44aV9hODN0X21pcGlfY3NpMl9icmlkZ2Vfc2V0dXAoc3RydWN0IHN1bjhpX2E4M3RfbWlwaV9j c2kyX2RldmljZSAqY3NpMl9kZXYpCit7CisJc3RydWN0IHY0bDJfc3ViZGV2ICpzdWJkZXYgPSAm Y3NpMl9kZXYtPmJyaWRnZS5zdWJkZXY7CisJc3RydWN0IHY0bDJfYXN5bmNfbm90aWZpZXIgKm5v dGlmaWVyID0gJmNzaTJfZGV2LT5icmlkZ2Uubm90aWZpZXI7CisJc3RydWN0IG1lZGlhX3BhZCAq cGFkcyA9IGNzaTJfZGV2LT5icmlkZ2UucGFkczsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBjc2ky X2Rldi0+ZGV2OworCWludCByZXQ7CisKKwkvKiBWNEwyIFN1YmRldiAqLworCisJdjRsMl9zdWJk ZXZfaW5pdChzdWJkZXYsICZzdW44aV9hODN0X21pcGlfY3NpMl9zdWJkZXZfb3BzKTsKKwlzdHJz Y3B5KHN1YmRldi0+bmFtZSwgU1VOOElfQTgzVF9NSVBJX0NTSTJfTkFNRSwgc2l6ZW9mKHN1YmRl di0+bmFtZSkpOworCXN1YmRldi0+ZmxhZ3MgfD0gVjRMMl9TVUJERVZfRkxfSEFTX0RFVk5PREU7 CisJc3ViZGV2LT5vd25lciA9IFRISVNfTU9EVUxFOworCXN1YmRldi0+ZGV2ID0gZGV2OworCisJ djRsMl9zZXRfc3ViZGV2ZGF0YShzdWJkZXYsIGNzaTJfZGV2KTsKKworCS8qIE1lZGlhIEVudGl0 eSAqLworCisJc3ViZGV2LT5lbnRpdHkuZnVuY3Rpb24gPSBNRURJQV9FTlRfRl9WSURfSUZfQlJJ REdFOworCXN1YmRldi0+ZW50aXR5Lm9wcyA9ICZzdW44aV9hODN0X21pcGlfY3NpMl9lbnRpdHlf b3BzOworCisJLyogTWVkaWEgUGFkcyAqLworCisJcGFkc1tTVU44SV9BODNUX01JUElfQ1NJMl9Q QURfU0lOS10uZmxhZ3MgPSBNRURJQV9QQURfRkxfU0lOSzsKKwlwYWRzW1NVTjhJX0E4M1RfTUlQ SV9DU0kyX1BBRF9TT1VSQ0VdLmZsYWdzID0gTUVESUFfUEFEX0ZMX1NPVVJDRTsKKworCXJldCA9 IG1lZGlhX2VudGl0eV9wYWRzX2luaXQoJnN1YmRldi0+ZW50aXR5LAorCQkJCSAgICAgU1VOOElf QTgzVF9NSVBJX0NTSTJfUEFEX0NPVU5ULCBwYWRzKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0 OworCisJLyogVjRMMiBBc3luYyAqLworCisJdjRsMl9hc3luY19ub3RpZmllcl9pbml0KG5vdGlm aWVyKTsKKwlub3RpZmllci0+b3BzID0gJnN1bjhpX2E4M3RfbWlwaV9jc2kyX25vdGlmaWVyX29w czsKKworCXJldCA9IHN1bjhpX2E4M3RfbWlwaV9jc2kyX2JyaWRnZV9zb3VyY2Vfc2V0dXAoY3Np Ml9kZXYpOworCWlmIChyZXQpCisJCWdvdG8gZXJyb3JfdjRsMl9ub3RpZmllcl9jbGVhbnVwOwor CisJcmV0ID0gdjRsMl9hc3luY19zdWJkZXZfbm90aWZpZXJfcmVnaXN0ZXIoc3ViZGV2LCBub3Rp Zmllcik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZXJyb3JfdjRsMl9ub3RpZmllcl9jbGVhbnVw OworCisJLyogVjRMMiBTdWJkZXYgKi8KKworCXJldCA9IHY0bDJfYXN5bmNfcmVnaXN0ZXJfc3Vi ZGV2KHN1YmRldik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZXJyb3JfdjRsMl9ub3RpZmllcl91 bnJlZ2lzdGVyOworCisJcmV0dXJuIDA7CisKK2Vycm9yX3Y0bDJfbm90aWZpZXJfdW5yZWdpc3Rl cjoKKwl2NGwyX2FzeW5jX25vdGlmaWVyX3VucmVnaXN0ZXIobm90aWZpZXIpOworCitlcnJvcl92 NGwyX25vdGlmaWVyX2NsZWFudXA6CisJdjRsMl9hc3luY19ub3RpZmllcl9jbGVhbnVwKG5vdGlm aWVyKTsKKworCW1lZGlhX2VudGl0eV9jbGVhbnVwKCZzdWJkZXYtPmVudGl0eSk7CisKKwlyZXR1 cm4gcmV0OworfQorCitzdGF0aWMgdm9pZAorc3VuOGlfYTgzdF9taXBpX2NzaTJfYnJpZGdlX2Ns ZWFudXAoc3RydWN0IHN1bjhpX2E4M3RfbWlwaV9jc2kyX2RldmljZSAqY3NpMl9kZXYpCit7CisJ c3RydWN0IHY0bDJfc3ViZGV2ICpzdWJkZXYgPSAmY3NpMl9kZXYtPmJyaWRnZS5zdWJkZXY7CisJ c3RydWN0IHY0bDJfYXN5bmNfbm90aWZpZXIgKm5vdGlmaWVyID0gJmNzaTJfZGV2LT5icmlkZ2Uu bm90aWZpZXI7CisKKwl2NGwyX2FzeW5jX3VucmVnaXN0ZXJfc3ViZGV2KHN1YmRldik7CisJdjRs Ml9hc3luY19ub3RpZmllcl91bnJlZ2lzdGVyKG5vdGlmaWVyKTsKKwl2NGwyX2FzeW5jX25vdGlm aWVyX2NsZWFudXAobm90aWZpZXIpOworCW1lZGlhX2VudGl0eV9jbGVhbnVwKCZzdWJkZXYtPmVu dGl0eSk7Cit9CisKKy8qIFBsYXRmb3JtICovCisKK3N0YXRpYyBpbnQgc3VuOGlfYTgzdF9taXBp X2NzaTJfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHN1bjhpX2E4M3Rf bWlwaV9jc2kyX2RldmljZSAqY3NpMl9kZXYgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKKworCWNs a19kaXNhYmxlX3VucHJlcGFyZShjc2kyX2Rldi0+Y2xrX21pc2MpOworCWNsa19kaXNhYmxlX3Vu cHJlcGFyZShjc2kyX2Rldi0+Y2xrX21pcGkpOworCWNsa19kaXNhYmxlX3VucHJlcGFyZShjc2ky X2Rldi0+Y2xrX21vZCk7CisJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGNzaTJfZGV2LT5jbGtfYnVz KTsKKwlyZXNldF9jb250cm9sX2Fzc2VydChjc2kyX2Rldi0+cmVzZXQpOworCisJcmV0dXJuIDA7 Cit9CisKK3N0YXRpYyBpbnQgc3VuOGlfYTgzdF9taXBpX2NzaTJfcmVzdW1lKHN0cnVjdCBkZXZp Y2UgKmRldikKK3sKKwlzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJfZGV2aWNlICpjc2kyX2Rl diA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCWludCByZXQ7CisKKwlyZXQgPSByZXNldF9jb250 cm9sX2RlYXNzZXJ0KGNzaTJfZGV2LT5yZXNldCk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRl diwgImZhaWxlZCB0byBkZWFzc2VydCByZXNldFxuIik7CisJCXJldHVybiByZXQ7CisJfQorCisJ cmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxlKGNzaTJfZGV2LT5jbGtfYnVzKTsKKwlpZiAocmV0KSB7 CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGVuYWJsZSBidXMgY2xvY2tcbiIpOworCQlnb3Rv IGVycm9yX3Jlc2V0OworCX0KKworCXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShjc2kyX2Rldi0+ Y2xrX21vZCk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBlbmFibGUg bW9kdWxlIGNsb2NrXG4iKTsKKwkJZ290byBlcnJvcl9jbGtfYnVzOworCX0KKworCXJldCA9IGNs a19wcmVwYXJlX2VuYWJsZShjc2kyX2Rldi0+Y2xrX21pcGkpOworCWlmIChyZXQpIHsKKwkJZGV2 X2VycihkZXYsICJmYWlsZWQgdG8gZW5hYmxlIE1JUEkgY2xvY2tcbiIpOworCQlnb3RvIGVycm9y X2Nsa19tb2Q7CisJfQorCisJcmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxlKGNzaTJfZGV2LT5jbGtf bWlzYyk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBlbmFibGUgQ1NJ IG1pc2MgY2xvY2tcbiIpOworCQlnb3RvIGVycm9yX2Nsa19taXBpOworCX0KKworCXN1bjhpX2E4 M3RfbWlwaV9jc2kyX2luaXQoY3NpMl9kZXYpOworCisJcmV0dXJuIDA7CisKK2Vycm9yX2Nsa19t aXBpOgorCWNsa19kaXNhYmxlX3VucHJlcGFyZShjc2kyX2Rldi0+Y2xrX21pcGkpOworCitlcnJv cl9jbGtfbW9kOgorCWNsa19kaXNhYmxlX3VucHJlcGFyZShjc2kyX2Rldi0+Y2xrX21vZCk7CisK K2Vycm9yX2Nsa19idXM6CisJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGNzaTJfZGV2LT5jbGtfYnVz KTsKKworZXJyb3JfcmVzZXQ6CisJcmVzZXRfY29udHJvbF9hc3NlcnQoY3NpMl9kZXYtPnJlc2V0 KTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZGV2X3BtX29wcyBz dW44aV9hODN0X21pcGlfY3NpMl9wbV9vcHMgPSB7CisJU0VUX1JVTlRJTUVfUE1fT1BTKHN1bjhp X2E4M3RfbWlwaV9jc2kyX3N1c3BlbmQsCisJCQkgICBzdW44aV9hODN0X21pcGlfY3NpMl9yZXN1 bWUsIE5VTEwpCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IHJlZ21hcF9jb25maWcgc3VuOGlf YTgzdF9taXBpX2NzaTJfcmVnbWFwX2NvbmZpZyA9IHsKKwkucmVnX2JpdHMgICAgICAgPSAzMiwK KwkucmVnX3N0cmlkZSAgICAgPSA0LAorCS52YWxfYml0cyAgICAgICA9IDMyLAorCS5tYXhfcmVn aXN0ZXIJPSAweDEyMCwKK307CisKK3N0YXRpYyBpbnQKK3N1bjhpX2E4M3RfbWlwaV9jc2kyX3Jl c291cmNlc19zZXR1cChzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJfZGV2aWNlICpjc2kyX2Rl diwKKwkJCQkgICAgIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBsYXRmb3JtX2RldikKK3sKKwlz dHJ1Y3QgZGV2aWNlICpkZXYgPSBjc2kyX2Rldi0+ZGV2OworCXN0cnVjdCByZXNvdXJjZSAqcmVz OworCXZvaWQgX19pb21lbSAqaW9fYmFzZTsKKwlpbnQgcmV0OworCisJLyogUmVnaXN0ZXJzICov CisKKwlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGxhdGZvcm1fZGV2LCBJT1JFU09VUkNF X01FTSwgMCk7CisJaW9fYmFzZSA9IGRldm1faW9yZW1hcF9yZXNvdXJjZShkZXYsIHJlcyk7CisJ aWYgKElTX0VSUihpb19iYXNlKSkKKwkJcmV0dXJuIFBUUl9FUlIoaW9fYmFzZSk7CisKKwljc2ky X2Rldi0+cmVnbWFwID0KKwkJZGV2bV9yZWdtYXBfaW5pdF9tbWlvKGRldiwgaW9fYmFzZSwKKwkJ CQkgICAgICAmc3VuOGlfYTgzdF9taXBpX2NzaTJfcmVnbWFwX2NvbmZpZyk7CisJaWYgKElTX0VS Uihjc2kyX2Rldi0+cmVnbWFwKSkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBpbml0IHJl Z2lzdGVyIG1hcFxuIik7CisJCXJldHVybiBQVFJfRVJSKGNzaTJfZGV2LT5yZWdtYXApOworCX0K KworCS8qIENsb2NrcyAqLworCisJY3NpMl9kZXYtPmNsa19idXMgPSBkZXZtX2Nsa19nZXQoZGV2 LCAiYnVzIik7CisJaWYgKElTX0VSUihjc2kyX2Rldi0+Y2xrX2J1cykpIHsKKwkJZGV2X2Vycihk ZXYsICJmYWlsZWQgdG8gYWNxdWlyZSBidXMgY2xvY2tcbiIpOworCQlyZXR1cm4gUFRSX0VSUihj c2kyX2Rldi0+Y2xrX2J1cyk7CisJfQorCisJY3NpMl9kZXYtPmNsa19tb2QgPSBkZXZtX2Nsa19n ZXQoZGV2LCAibW9kIik7CisJaWYgKElTX0VSUihjc2kyX2Rldi0+Y2xrX21vZCkpIHsKKwkJZGV2 X2VycihkZXYsICJmYWlsZWQgdG8gYWNxdWlyZSBtb2QgY2xvY2tcbiIpOworCQlyZXR1cm4gUFRS X0VSUihjc2kyX2Rldi0+Y2xrX21vZCk7CisJfQorCisJcmV0ID0gY2xrX3NldF9yYXRlX2V4Y2x1 c2l2ZShjc2kyX2Rldi0+Y2xrX21vZCwgMjk3MDAwMDAwKTsKKwlpZiAocmV0KSB7CisJCWRldl9l cnIoZGV2LCAiZmFpbGVkIHRvIHNldCBtb2QgY2xvY2sgcmF0ZVxuIik7CisJCXJldHVybiByZXQ7 CisJfQorCisJY3NpMl9kZXYtPmNsa19taXBpID0gZGV2bV9jbGtfZ2V0KGRldiwgIm1pcGkiKTsK KwlpZiAoSVNfRVJSKGNzaTJfZGV2LT5jbGtfbWlwaSkpIHsKKwkJZGV2X2VycihkZXYsICJmYWls ZWQgdG8gYWNxdWlyZSBtaXBpIGNsb2NrXG4iKTsKKwkJcmV0dXJuIFBUUl9FUlIoY3NpMl9kZXYt PmNsa19taXBpKTsKKwl9CisKKwljc2kyX2Rldi0+Y2xrX21pc2MgPSBkZXZtX2Nsa19nZXQoZGV2 LCAibWlzYyIpOworCWlmIChJU19FUlIoY3NpMl9kZXYtPmNsa19taXNjKSkgeworCQlkZXZfZXJy KGRldiwgImZhaWxlZCB0byBhY3F1aXJlIG1pc2MgY2xvY2tcbiIpOworCQlyZXR1cm4gUFRSX0VS Uihjc2kyX2Rldi0+Y2xrX21pc2MpOworCX0KKworCS8qIFJlc2V0ICovCisKKwljc2kyX2Rldi0+ cmVzZXQgPSBkZXZtX3Jlc2V0X2NvbnRyb2xfZ2V0X3NoYXJlZChkZXYsIE5VTEwpOworCWlmIChJ U19FUlIoY3NpMl9kZXYtPnJlc2V0KSkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBnZXQg cmVzZXQgY29udHJvbGxlclxuIik7CisJCXJldHVybiBQVFJfRVJSKGNzaTJfZGV2LT5yZXNldCk7 CisJfQorCisJLyogRC1QSFkgKi8KKworCXJldCA9IHN1bjhpX2E4M3RfZHBoeV9yZWdpc3Rlcihj c2kyX2Rldik7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBpbml0aWFs aXplIE1JUEkgRC1QSFlcbiIpOworCQlyZXR1cm4gcmV0OworCX0KKworCS8qIFJ1bnRpbWUgUE0g Ki8KKworCXBtX3J1bnRpbWVfZW5hYmxlKGRldik7CisJcG1fcnVudGltZV9zZXRfc3VzcGVuZGVk KGRldik7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQKK3N1bjhpX2E4M3RfbWlwaV9j c2kyX3Jlc291cmNlc19jbGVhbnVwKHN0cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZpY2Ug KmNzaTJfZGV2KQoreworCXBtX3J1bnRpbWVfZGlzYWJsZShjc2kyX2Rldi0+ZGV2KTsKKwlwaHlf ZXhpdChjc2kyX2Rldi0+ZHBoeSk7CisJY2xrX3JhdGVfZXhjbHVzaXZlX3B1dChjc2kyX2Rldi0+ Y2xrX21vZCk7Cit9CisKK3N0YXRpYyBpbnQgc3VuOGlfYTgzdF9taXBpX2NzaTJfcHJvYmUoc3Ry dWN0IHBsYXRmb3JtX2RldmljZSAqcGxhdGZvcm1fZGV2KQoreworCXN0cnVjdCBzdW44aV9hODN0 X21pcGlfY3NpMl9kZXZpY2UgKmNzaTJfZGV2OworCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZwbGF0 Zm9ybV9kZXYtPmRldjsKKwlpbnQgcmV0OworCisJY3NpMl9kZXYgPSBkZXZtX2t6YWxsb2MoZGV2 LCBzaXplb2YoKmNzaTJfZGV2KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFjc2kyX2RldikKKwkJcmV0 dXJuIC1FTk9NRU07CisKKwljc2kyX2Rldi0+ZGV2ID0gZGV2OworCXBsYXRmb3JtX3NldF9kcnZk YXRhKHBsYXRmb3JtX2RldiwgY3NpMl9kZXYpOworCisJcmV0ID0gc3VuOGlfYTgzdF9taXBpX2Nz aTJfcmVzb3VyY2VzX3NldHVwKGNzaTJfZGV2LCBwbGF0Zm9ybV9kZXYpOworCWlmIChyZXQpCisJ CXJldHVybiByZXQ7CisKKwlyZXQgPSBzdW44aV9hODN0X21pcGlfY3NpMl9icmlkZ2Vfc2V0dXAo Y3NpMl9kZXYpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIGludCBzdW44aV9hODN0X21pcGlfY3NpMl9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGxhdGZvcm1fZGV2KQoreworCXN0cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZp Y2UgKmNzaTJfZGV2ID0KKwkJcGxhdGZvcm1fZ2V0X2RydmRhdGEocGxhdGZvcm1fZGV2KTsKKwor CXN1bjhpX2E4M3RfbWlwaV9jc2kyX2JyaWRnZV9jbGVhbnVwKGNzaTJfZGV2KTsKKwlzdW44aV9h ODN0X21pcGlfY3NpMl9yZXNvdXJjZXNfY2xlYW51cChjc2kyX2Rldik7CisKKwlyZXR1cm4gMDsK K30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgc3VuOGlfYTgzdF9taXBpX2Nz aTJfb2ZfbWF0Y2hbXSA9IHsKKwl7IC5jb21wYXRpYmxlID0gImFsbHdpbm5lcixzdW44aS1hODN0 LW1pcGktY3NpMiIgfSwKKwl7fSwKK307CitNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBzdW44aV9h ODN0X21pcGlfY3NpMl9vZl9tYXRjaCk7CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVy IHN1bjhpX2E4M3RfbWlwaV9jc2kyX3BsYXRmb3JtX2RyaXZlciA9IHsKKwkucHJvYmUgPSBzdW44 aV9hODN0X21pcGlfY3NpMl9wcm9iZSwKKwkucmVtb3ZlID0gc3VuOGlfYTgzdF9taXBpX2NzaTJf cmVtb3ZlLAorCS5kcml2ZXIgPSB7CisJCS5uYW1lID0gU1VOOElfQTgzVF9NSVBJX0NTSTJfTkFN RSwKKwkJLm9mX21hdGNoX3RhYmxlID0gb2ZfbWF0Y2hfcHRyKHN1bjhpX2E4M3RfbWlwaV9jc2ky X29mX21hdGNoKSwKKwkJLnBtID0gJnN1bjhpX2E4M3RfbWlwaV9jc2kyX3BtX29wcywKKwl9LAor fTsKK21vZHVsZV9wbGF0Zm9ybV9kcml2ZXIoc3VuOGlfYTgzdF9taXBpX2NzaTJfcGxhdGZvcm1f ZHJpdmVyKTsKKworTU9EVUxFX0RFU0NSSVBUSU9OKCJBbGx3aW5uZXIgQTgzVCBNSVBJIENTSS0y IGFuZCBELVBIWSBDb250cm9sbGVyIERyaXZlciIpOworTU9EVUxFX0FVVEhPUigiUGF1bCBLb2Np YWxrb3dza2kgPHBhdWwua29jaWFsa293c2tpQGJvb3RsaW4uY29tPiIpOworTU9EVUxFX0xJQ0VO U0UoIkdQTCIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44 aS1hODN0LW1pcGktY3NpMi9zdW44aV9hODN0X21pcGlfY3NpMi5oIGIvZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9zdW44aV9hODN0X21pcGlfY3NpMi5o Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMTgzZjQyMzM5YzU3Ci0t LSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0 LW1pcGktY3NpMi9zdW44aV9hODN0X21pcGlfY3NpMi5oCkBAIC0wLDAgKzEsNTUgQEAKKy8qIFNQ RFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKyAqLworLyoKKyAqIENvcHlyaWdodCAyMDIw IEvDqXZpbiBMJ2jDtHBpdGFsIDxrZXZpbi5saG9waXRhbEBib290bGluLmNvbT4KKyAqIENvcHly aWdodCAyMDIwIEJvb3RsaW4KKyAqIEF1dGhvcjogUGF1bCBLb2NpYWxrb3dza2kgPHBhdWwua29j aWFsa293c2tpQGJvb3RsaW4uY29tPgorICovCisKKyNpZm5kZWYgX1NVTjhJX0E4M1RfTUlQSV9D U0kyX0hfCisjZGVmaW5lIF9TVU44SV9BODNUX01JUElfQ1NJMl9IXworCisjaW5jbHVkZSA8bGlu dXgvcGh5L3BoeS5oPgorI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgorI2luY2x1ZGUgPGxpbnV4 L3Jlc2V0Lmg+CisjaW5jbHVkZSA8bWVkaWEvdjRsMi1kZXZpY2UuaD4KKyNpbmNsdWRlIDxtZWRp YS92NGwyLWZ3bm9kZS5oPgorCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX05BTUUJInN1 bjhpLWE4M3QtbWlwaS1jc2kyIgorCitlbnVtIHN1bjhpX2E4M3RfbWlwaV9jc2kyX3BhZCB7CisJ U1VOOElfQTgzVF9NSVBJX0NTSTJfUEFEX1NJTksJPSAwLAorCVNVTjhJX0E4M1RfTUlQSV9DU0ky X1BBRF9TT1VSQ0UJPSAxLAorCVNVTjhJX0E4M1RfTUlQSV9DU0kyX1BBRF9DT1VOVAk9IDIsCit9 OworCitzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJfZm9ybWF0IHsKKwl1MzIJbWJ1c19jb2Rl OworCXU4CWRhdGFfdHlwZTsKKwl1MzIJYnBwOworfTsKKworc3RydWN0IHN1bjhpX2E4M3RfbWlw aV9jc2kyX2JyaWRnZSB7CisJc3RydWN0IHY0bDJfc3ViZGV2CQlzdWJkZXY7CisJc3RydWN0IG1l ZGlhX3BhZAkJcGFkc1tTVU44SV9BODNUX01JUElfQ1NJMl9QQURfQ09VTlRdOworCXN0cnVjdCB2 NGwyX2Z3bm9kZV9lbmRwb2ludAllbmRwb2ludDsKKwlzdHJ1Y3QgdjRsMl9hc3luY19ub3RpZmll cglub3RpZmllcjsKKwlzdHJ1Y3QgdjRsMl9tYnVzX2ZyYW1lZm10CW1idXNfZm9ybWF0OworCisJ c3RydWN0IHY0bDJfc3ViZGV2CQkqc291cmNlX3N1YmRldjsKK307CisKK3N0cnVjdCBzdW44aV9h ODN0X21pcGlfY3NpMl9kZXZpY2UgeworCXN0cnVjdCBkZXZpY2UJCQkJKmRldjsKKworCXN0cnVj dCByZWdtYXAJCQkJKnJlZ21hcDsKKwlzdHJ1Y3QgY2xrCQkJCSpjbGtfYnVzOworCXN0cnVjdCBj bGsJCQkJKmNsa19tb2Q7CisJc3RydWN0IGNsawkJCQkqY2xrX21pcGk7CisJc3RydWN0IGNsawkJ CQkqY2xrX21pc2M7CisJc3RydWN0IHJlc2V0X2NvbnRyb2wJCQkqcmVzZXQ7CisJc3RydWN0IHBo eQkJCQkqZHBoeTsKKworCXN0cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9icmlkZ2UJYnJpZGdl OworfTsKKworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhp L3N1bjhpLWE4M3QtbWlwaS1jc2kyL3N1bjhpX2E4M3RfbWlwaV9jc2kyX3JlZy5oIGIvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9zdW44aV9hODN0X21p cGlfY3NpMl9yZWcuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmYz MzE3YmQ4YWQyNAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3Vu eGkvc3VuOGktYTgzdC1taXBpLWNzaTIvc3VuOGlfYTgzdF9taXBpX2NzaTJfcmVnLmgKQEAgLTAs MCArMSwxNTcgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKyAqLworLyoK KyAqIENvcHlyaWdodCAyMDIwIEvDqXZpbiBMJ2jDtHBpdGFsIDxrZXZpbi5saG9waXRhbEBib290 bGluLmNvbT4KKyAqIENvcHlyaWdodCAyMDIwLTIwMjEgQm9vdGxpbgorICogQXV0aG9yOiBQYXVs IEtvY2lhbGtvd3NraSA8cGF1bC5rb2NpYWxrb3dza2lAYm9vdGxpbi5jb20+CisgKi8KKworI2lm bmRlZiBfU1VOOElfQTgzVF9NSVBJX0NTSTJfUkVHX0hfCisjZGVmaW5lIF9TVU44SV9BODNUX01J UElfQ1NJMl9SRUdfSF8KKworI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9WRVJTSU9OX1JF RwkJCTB4MAorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9DVFJMX1JFRwkJCQkweDQKKyNk ZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ1RSTF9JTklUX1ZBTFVFCQkJMHhiOGMzOWJlYwor I2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9DVFJMX1JFU0VUX04JCQlCSVQoMzEpCisjZGVm aW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX1JYX1BLVF9OVU1fUkVHCQkJMHg4CisjZGVmaW5lIFNV TjhJX0E4M1RfTUlQSV9DU0kyX1JYX1BLVF9OVU1fSU5JVF9WQUxVRQkJMHhiOGQyNTdmOAorI2Rl ZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9SU1ZEMF9SRUcJCQkJMHhjCisKKyNkZWZpbmUgU1VO OElfQTgzVF9NSVBJX0NTSTJfUlNWRDFfUkVHCQkJCTB4MTgKKyNkZWZpbmUgU1VOOElfQTgzVF9N SVBJX0NTSTJfUlNWRDFfSFdfTE9DS19WQUxVRQkJMHhiOGM4YTMwYworI2RlZmluZSBTVU44SV9B ODNUX01JUElfQ1NJMl9SU1ZEMl9SRUcJCQkJMHgxYworI2RlZmluZSBTVU44SV9BODNUX01JUElf Q1NJMl9SU1ZEMl9IV19MT0NLX1ZBTFVFCQkweGI4ZGY4YWQ3CisjZGVmaW5lIFNVTjhJX0E4M1Rf TUlQSV9DU0kyX0lOVF9TVEEwX1JFRwkJCTB4MjAKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NT STJfSU5UX1NUQTBfRUNDX0VSUl9EQkwJCUJJVCgyOCkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJ X0NTSTJfSU5UX1NUQTBfTElORV9DS1NNX0VSUl9WQzMJCUJJVCgyNykKKyNkZWZpbmUgU1VOOElf QTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfTElORV9DS1NNX0VSUl9WQzIJCUJJVCgyNikKKyNkZWZp bmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfTElORV9DS1NNX0VSUl9WQzEJCUJJVCgy NSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfTElORV9DS1NNX0VSUl9W QzAJCUJJVCgyNCkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfTElORV9T RVFfRVJSX0RUMwkJQklUKDIzKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RB MF9MSU5FX1NFUV9FUlJfRFQyCQlCSVQoMjIpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0ky X0lOVF9TVEEwX0xJTkVfU0VRX0VSUl9EVDEJCUJJVCgyMSkKKyNkZWZpbmUgU1VOOElfQTgzVF9N SVBJX0NTSTJfSU5UX1NUQTBfTElORV9TRVFfRVJSX0RUMAkJQklUKDIwKQorI2RlZmluZSBTVU44 SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMF9MU19MRV9FUlJfRFQzCQlCSVQoMTkpCisjZGVmaW5l IFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX0xTX0xFX0VSUl9EVDIJCUJJVCgxOCkKKyNk ZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfTFNfTEVfRVJSX0RUMQkJQklUKDE3 KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMF9MU19MRV9FUlJfRFQwCQlC SVQoMTYpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX0NSQ19FUlJfVkMz CQlCSVQoMTUpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX0NSQ19FUlJf VkMyCQlCSVQoMTQpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX0NSQ19F UlJfVkMxCQlCSVQoMTMpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX0NS Q19FUlJfVkMwCQlCSVQoMTIpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEw X0ZSTV9TRVFfRVJSX1ZDMwkJQklUKDExKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9J TlRfU1RBMF9GUk1fU0VRX0VSUl9WQzIJCUJJVCgxMCkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJ X0NTSTJfSU5UX1NUQTBfRlJNX1NFUV9FUlJfVkMxCQlCSVQoOSkKKyNkZWZpbmUgU1VOOElfQTgz VF9NSVBJX0NTSTJfSU5UX1NUQTBfRlJNX1NFUV9FUlJfVkMwCQlCSVQoOCkKKyNkZWZpbmUgU1VO OElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfRlNfRkVfRVJSX1ZDMwkJQklUKDcpCisjZGVmaW5l IFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX0ZTX0ZFX0VSUl9WQzIJCUJJVCg2KQorI2Rl ZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMF9GU19GRV9FUlJfVkMxCQlCSVQoNSkK KyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfRlNfRkVfRVJSX1ZDMAkJQklU KDQpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX1NPVF9TWU5DX0VSUl8z CQlCSVQoMykKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfU09UX1NZTkNf RVJSXzIJCUJJVCgyKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMF9TT1Rf U1lOQ19FUlJfMQkJQklUKDEpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEw X1NPVF9TWU5DX0VSUl8wCQlCSVQoMCkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5U X1NUQTFfUkVHCQkJMHgyNAorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMV9M SU5FX1NFUV9FUlJfRFQ3CQlCSVQoMjMpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lO VF9TVEExX0xJTkVfU0VRX0VSUl9EVDYJCUJJVCgyMikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJ X0NTSTJfSU5UX1NUQTFfTElORV9TRVFfRVJSX0RUNQkJQklUKDIxKQorI2RlZmluZSBTVU44SV9B ODNUX01JUElfQ1NJMl9JTlRfU1RBMV9MSU5FX1NFUV9FUlJfRFQ0CQlCSVQoMjApCisjZGVmaW5l IFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEExX0xTX0xFX0VSUl9EVDcJCUJJVCgxOSkKKyNk ZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTFfTFNfTEVfRVJSX0RUNgkJQklUKDE4 KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMV9MU19MRV9FUlJfRFQ1CQlC SVQoMTcpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEExX0xTX0xFX0VSUl9E VDQJCUJJVCgxNikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTFfRFRfRVJS X1ZDMwkJQklUKDE1KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMV9EVF9F UlJfVkMyCQlCSVQoMTQpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEExX0RU X0VSUl9WQzEJCUJJVCgxMykKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTFf RFRfRVJSX1ZDMAkJQklUKDEyKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RB MV9FQ0NfRVJSMV9WQzMJCUJJVCgxMSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5U X1NUQTFfRUNDX0VSUjFfVkMyCQlCSVQoMTApCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0ky X0lOVF9TVEExX0VDQ19FUlIxX1ZDMQkJQklUKDkpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9D U0kyX0lOVF9TVEExX0VDQ19FUlIxX1ZDMAkJQklUKDgpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQ SV9DU0kyX0lOVF9TVEExX1NPVF9FUlJfMwkJCUJJVCg3KQorI2RlZmluZSBTVU44SV9BODNUX01J UElfQ1NJMl9JTlRfU1RBMV9TT1RfRVJSXzIJCQlCSVQoNikKKyNkZWZpbmUgU1VOOElfQTgzVF9N SVBJX0NTSTJfSU5UX1NUQTFfU09UX0VSUl8xCQkJQklUKDUpCisjZGVmaW5lIFNVTjhJX0E4M1Rf TUlQSV9DU0kyX0lOVF9TVEExX1NPVF9FUlJfMAkJCUJJVCg0KQorI2RlZmluZSBTVU44SV9BODNU X01JUElfQ1NJMl9JTlRfU1RBMV9FU0NfRU5UUllfRVJSXzMJCUJJVCgzKQorI2RlZmluZSBTVU44 SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMV9FU0NfRU5UUllfRVJSXzIJCUJJVCgyKQorI2RlZmlu ZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMV9FU0NfRU5UUllfRVJSXzEJCUJJVCgxKQor I2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMV9FU0NfRU5UUllfRVJSXzAJCUJJ VCgwKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9SRUcJCQkweDI4Cisj ZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0swX0VDQ19FUlJfREJMCQlCSVQoMjgp CisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0swX0NLU01fRVJSX1ZDMwkJQklU KDI3KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9DS1NNX0VSUl9WQzIJ CUJJVCgyNikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBfQ0tTTV9FUlJf VkMxCQlCSVQoMjUpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0swX0NLU01f RVJSX1ZDMAkJQklUKDI0KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9M SU5FX1NFUV9FUlJfRFQzCQlCSVQoMjMpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lO VF9NU0swX0xJTkVfU0VRX0VSUl9EVDIJCUJJVCgyMikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJ X0NTSTJfSU5UX01TSzBfTElORV9TRVFfRVJSX0RUMQkJQklUKDIxKQorI2RlZmluZSBTVU44SV9B ODNUX01JUElfQ1NJMl9JTlRfTVNLMF9MSU5FX1NFUV9FUlJfRFQwCQlCSVQoMjApCisjZGVmaW5l IFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0swX0xTX0xFX0VSUl9EVDMJCUJJVCgxOSkKKyNk ZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBfTFNfTEVfRVJSX0RUMgkJQklUKDE4 KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9MU19MRV9FUlJfRFQxCQlC SVQoMTcpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0swX0xTX0xFX0VSUl9E VDAJCUJJVCgxNikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBfQ1JDX0VS Ul9WQzMJCUJJVCgxNSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBfQ1JD X0VSUl9WQzIJCUJJVCgxNCkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBf Q1JDX0VSUl9WQzEJCUJJVCgxMykKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01T SzBfQ1JDX0VSUl9WQzAJCUJJVCgxMikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5U X01TSzBfRlJNX1NFUV9FUlJfVkMzCQlCSVQoMTEpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9D U0kyX0lOVF9NU0swX0ZSTV9TRVFfRVJSX1ZDMgkJQklUKDEwKQorI2RlZmluZSBTVU44SV9BODNU X01JUElfQ1NJMl9JTlRfTVNLMF9GUk1fU0VRX0VSUl9WQzEJCUJJVCg5KQorI2RlZmluZSBTVU44 SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9GUk1fU0VRX0VSUl9WQzAJCUJJVCg4KQorI2RlZmlu ZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9GU19GRV9FUlJfVkMzCQlCSVQoNykKKyNk ZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBfRlNfRkVfRVJSX1ZDMgkJQklUKDYp CisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0swX0ZTX0ZFX0VSUl9WQzEJCUJJ VCg1KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9GU19GRV9FUlJfVkMw CQlCSVQoNCkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBfU09UX1NZTkNf RVJSXzMJCUJJVCgzKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9TT1Rf U1lOQ19FUlJfMgkJQklUKDIpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0sw X1NPVF9TWU5DX0VSUl8xCQlCSVQoMSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5U X01TSzBfU09UX1NZTkNfRVJSXzAJCUJJVCgwKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJ Ml9JTlRfTVNLMV9SRUcJCQkweDJjCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9N U0sxX0RUX0VSUl9WQzMJCUJJVCgxNSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5U X01TSzFfRFRfRVJSX1ZDMgkJQklUKDE0KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9J TlRfTVNLMV9EVF9FUlJfVkMxCQlCSVQoMTMpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0ky X0lOVF9NU0sxX0RUX0VSUl9WQzAJCUJJVCgxMikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NT STJfSU5UX01TSzFfRUNDX0VSUjFfVkMzCQlCSVQoMTEpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQ SV9DU0kyX0lOVF9NU0sxX0VDQ19FUlIxX1ZDMgkJQklUKDEwKQorI2RlZmluZSBTVU44SV9BODNU X01JUElfQ1NJMl9JTlRfTVNLMV9FQ0NfRVJSMV9WQzEJCUJJVCg5KQorI2RlZmluZSBTVU44SV9B ODNUX01JUElfQ1NJMl9JTlRfTVNLMV9FQ0NfRVJSMV9WQzAJCUJJVCg4KQorI2RlZmluZSBTVU44 SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMV9TT1RfRVJSXzMJCQlCSVQoNykKKyNkZWZpbmUgU1VO OElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzFfU09UX0VSUl8yCQkJQklUKDYpCisjZGVmaW5lIFNV TjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0sxX1NPVF9FUlJfMQkJCUJJVCg1KQorI2RlZmluZSBT VU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMV9TT1RfRVJSXzAJCQlCSVQoNCkKKyNkZWZpbmUg U1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzFfRVNDX0VOVFJZX0VSUl8zCQlCSVQoMykKKyNk ZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzFfRVNDX0VOVFJZX0VSUl8yCQlCSVQo MikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzFfRVNDX0VOVFJZX0VSUl8x CQlCSVQoMSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzFfRVNDX0VOVFJZ X0VSUl8wCQlCSVQoMCkKKworI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfUkVHCQkJ CTB4MTAwCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0NGR19JTklUX1ZBTFVFCQkJMHhi OGM2NGYyNAorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfU1lOQ19FTgkJCUJJVCgz MSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ0ZHX0JZUEFTU19FQ0NfRU4JCQlCSVQo MjkpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0NGR19VTlBLVF9FTgkJCUJJVCgyOCkK KyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ0ZHX05PTkVfVU5QS1RfUlhfTU9ERQkJQklU KDI3KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfWUNfU1dBQgkJCUJJVCgyNikK KyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ0ZHX05fQllURQkJCQlCSVQoMjQpCisjZGVm aW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0NGR19TWU5DX0RMWV9DWUNMRSh2KQkJKCgodikgPDwg MTgpICYgXAorCQkJCQkJCQkgR0VOTUFTSygyMiwgMTgpKQorI2RlZmluZSBTVU44SV9BODNUX01J UElfQ1NJMl9DRkdfTl9DSEFOTkVMKHYpCQkJKCgoKHYpIC0gMSkgPDwgMTYpICYgXAorCQkJCQkJ CQkgR0VOTUFTSygxNywgMTYpKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfTl9M QU5FKHYpCQkJKCgoKHYpIC0gMSkgPDwgNCkgJiBcCisJCQkJCQkJCSBHRU5NQVNLKDUsIDQpKQor I2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9WQ0RUMF9SRUcJCQkJMHgxMDQKKyNkZWZpbmUg U1VOOElfQTgzVF9NSVBJX0NTSTJfVkNEVDBfQ0hfVkMoY2gsIHZjKQkJKCgodmMpICYgR0VOTUFT SygxLCAwKSkgPDwgXAorCQkJCQkJCQkgKChjaCkgKiA4ICsgNikpCisjZGVmaW5lIFNVTjhJX0E4 M1RfTUlQSV9DU0kyX1ZDRFQwX0NIX0RUKGNoLCB0KQkJCSgoKHQpICYgR0VOTUFTSyg1LCAwKSkg PDwgXAorCQkJCQkJCQkgKChjaCkgKiA4KSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJf VkNEVDFfUkVHCQkJCTB4MTA4CisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX1ZDRFQxX0NI X1ZDKGNoLCB2YykJCSgoKHZjKSAmIEdFTk1BU0soMSwgMCkpIDw8IFwKKwkJCQkJCQkJICgoKGNo KSAtIDQpICogOCArIDYpKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9WQ0RUMV9DSF9E VChjaCwgdCkJCQkoKCh0KSAmIEdFTk1BU0soNSwgMCkpIDw8IFwKKwkJCQkJCQkJICgoKGNoKSAt IDQpICogOCkpCisKK2VudW0gbWlwaV9jc2kyX2RhdGFfdHlwZSB7CisJTUlQSV9DU0kyX0RBVEFf VFlQRV9SQVc4CT0gMHgyYSwKKwlNSVBJX0NTSTJfREFUQV9UWVBFX1JBVzEwCT0gMHgyYiwKKwlN SVBJX0NTSTJfREFUQV9UWVBFX1JBVzEyCT0gMHgyYywKK307CisKKyNlbmRpZgotLSAKMi4zMi4w CgoKLS0gCmxpbnV4LXBoeSBtYWlsaW5nIGxpc3QKbGludXgtcGh5QGxpc3RzLmluZnJhZGVhZC5v cmcKaHR0cHM6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcGh5 Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-17.1 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3053AC433F5 for ; Fri, 10 Sep 2021 18:50:26 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id E8CA561250 for ; Fri, 10 Sep 2021 18:50:25 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org E8CA561250 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=bootlin.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.infradead.org 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:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=RvvwYgOH+I2iT7ggPIqX7cXlc+yH57ZWv3c6GYELW4Q=; b=dnHBbDUOVePIzs 4tTFvnhBhYK+Kuhip+kl0ZeGlZgrd+Y9jajj0U30C9g0D7UWHtjCcfDo9Xk+JaQPb+ECwNlBkMXpJ S/evMSfXsUe/js8Cf3hIpklRM9ZD1h/RR8+1rtHonBZsSTYL6knqrtrRvsb2q4IvWai8soa1hzDX+ Vz75R484M0VtZnDsOuhiG1sv8AIgSus/jsXoYh7VMXH1Nr2pP2wZaLNo4S6oCQfCcQCGLCEdLM2CE OhNxhYhWx6RDI8VvjEFrUEDWOODnB/XHJkDiNVAVFuHDtLUtxOaw04HxeMobsbCeD6oGq4tb+lMFo dCFQGPmjChu3HCb0vydQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1mOlZ5-00DOku-Je; Fri, 10 Sep 2021 18:47:56 +0000 Received: from relay10.mail.gandi.net ([217.70.178.230]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1mOlTt-00DLzv-Oe; Fri, 10 Sep 2021 18:42:40 +0000 Received: (Authenticated sender: paul.kocialkowski@bootlin.com) by relay10.mail.gandi.net (Postfix) with ESMTPSA id A2243240010; Fri, 10 Sep 2021 18:42:30 +0000 (UTC) From: Paul Kocialkowski To: linux-media@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sunxi@lists.linux.dev, linux-kernel@vger.kernel.org, linux-phy@lists.infradead.org, linux-clk@vger.kernel.org, linux-staging@lists.linux.dev Cc: Yong Deng , Mauro Carvalho Chehab , Rob Herring , Maxime Ripard , Sakari Ailus , Hans Verkuil , Chen-Yu Tsai , Jernej Skrabec , Paul Kocialkowski , Greg Kroah-Hartman , Helen Koike , Laurent Pinchart , Thomas Petazzoni Subject: [PATCH 11/22] media: sunxi: Add support for the A83T MIPI CSI-2 controller Date: Fri, 10 Sep 2021 20:41:36 +0200 Message-Id: <20210910184147.336618-12-paul.kocialkowski@bootlin.com> X-Mailer: git-send-email 2.32.0 In-Reply-To: <20210910184147.336618-1-paul.kocialkowski@bootlin.com> References: <20210910184147.336618-1-paul.kocialkowski@bootlin.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210910_114234_316285_73FF27C2 X-CRM114-Status: GOOD ( 32.17 ) 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 VGhlIEE4M1Qgc3VwcG9ydHMgTUlQSSBDU0ktMiB3aXRoIGEgY29tcG9zaXRlIGNvbnRyb2xsZXIs IGNvdmVyaW5nCmJvdGggdGhlIHByb3RvY29sIGxvZ2ljIGFuZCB0aGUgRC1QSFkgaW1wbGVtZW50 YXRpb24uIFRoaXMgY29udHJvbGxlcgpzZWVtcyB0byBiZSBmb3VuZCBvbiB0aGUgQTgzVCBvbmx5 IGFuZCBwcm9iYWJseSB3YXMgYWJhbmRvbmVkIHNpbmNlLgoKVGhpcyBpbXBsZW1lbnRhdGlvbiBz cGxpdHMgdGhlIHByb3RvY29sIGFuZCBELVBIWSByZWdpc3RlcnMgYW5kCnVzZXMgdGhlIFBIWSBm cmFtZXdvcmsgaW50ZXJuYWxseS4gVGhlIEQtUEhZIGlzIG5vdCByZWdpc3RlcmVkIGFzIGEKc3Rh bmRhbG9uZSBQSFkgZHJpdmVyIHNpbmNlIGl0IGNhbm5vdCBiZSB1c2VkIHdpdGggYW55IG90aGVy CmNvbnRyb2xsZXIuCgpUaGVyZSBhcmUgYSBmZXcgbm90YWJsZSBwb2ludHMgYWJvdXQgdGhlIGNv bnRyb2xsZXI6Ci0gVGhlIGluaXRpYWxpc2F0aW9uIHNlcXVlbmNlIGludm9sZXMgd3JpdGluZyBz cGVjaWZpYyBtYWdpYyBpbml0CiAgdmFsdWVzIHRoYXQgZG8gbm90IHNlZW0gdG8gbWFrZSBhbnkg cGFydGljdWxhciBzZW5zZSBnaXZlbiB0aGUKICBjb25jZXJuZWQgcmVnaXN0ZXIgZmllbGRzOwot IEludGVycnVwdHMgYXBwZWFyIHRvIGJlIGhpdHRpbmcgcmVnYXJkbGVzcyBvZiB0aGUgaW50ZXJy dXB0IG1hc2sKICByZWdpc3RlcnMsIHdoaWNoIGNhbiBjYXVzZSBhIHNlcmlvdXMgZmxvb2Qgd2hl biB0cmFuc21pc3Npb24gZXJyb3JzCiAgb2NjdXIuCgpPbmx5IDgtYml0IGFuZCAxMC1iaXQgQmF5 ZXIgZm9ybWF0cyBhcmUgY3VycmVudGx5IHN1cHBvcnRlZC4KV2hpbGUgdXAgdG8gNCBpbnRlcm5h bCBjaGFubmVscyB0byB0aGUgQ1NJIGNvbnRyb2xsZXIgZXhpc3QsIG9ubHkgb25lCmlzIGN1cnJl bnRseSBzdXBwb3J0ZWQgYnkgdGhpcyBpbXBsZW1lbnRhdGlvbi4KClRoaXMgd29yayBpcyBiYXNl ZCBvbiB0aGUgZmlyc3QgdmVyc2lvbiBvZiB0aGUgZHJpdmVyIHN1Ym1pdHRlZCBieQpLw6l2aW4g TCdow7RwaXRhbCwgd2hpY2ggd2FzIGFkYXB0ZWQgdG8gbWFpbmxpbmUgZnJvbSB0aGUgQWxsd2lu bmVyIEJTUC4KVGhpcyB2ZXJzaW9uIGludGVncmF0ZXMgTUlQSSBDU0ktMiBzdXBwb3J0IGFzIGEg c3RhbmRhbG9uZSBWNEwyIHN1YmRldgppbnN0ZWFkIG9mIG1lcmdpbmcgaXQgaW4gdGhlIHN1bjZp LWNzaSBkcml2ZXIuCgpJdCB3YXMgdGVzdGVkIG9uIGEgQmFuYW5hIFBpIE0zIGJvYXJkIHdpdGgg YW4gT1Y4ODY1IHNlbnNvciBpbiBhIDQtbGFuZQpjb25maWd1cmF0aW9uLgoKU2lnbmVkLW9mZi1i eTogUGF1bCBLb2NpYWxrb3dza2kgPHBhdWwua29jaWFsa293c2tpQGJvb3RsaW4uY29tPgpBY2tl ZC1ieTogTWF4aW1lIFJpcGFyZCA8bXJpcGFyZEBrZXJuZWwub3JnPgotLS0KIGRyaXZlcnMvbWVk aWEvcGxhdGZvcm0vc3VueGkvS2NvbmZpZyAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL21lZGlh L3BsYXRmb3JtL3N1bnhpL01ha2VmaWxlICAgICAgICAgfCAgIDEgKwogLi4uL3N1bnhpL3N1bjhp LWE4M3QtbWlwaS1jc2kyL0tjb25maWcgICAgICAgIHwgIDExICsKIC4uLi9zdW54aS9zdW44aS1h ODN0LW1pcGktY3NpMi9NYWtlZmlsZSAgICAgICB8ICAgNCArCiAuLi4vc3VuOGktYTgzdC1taXBp LWNzaTIvc3VuOGlfYTgzdF9kcGh5LmMgICAgfCAgNzIgKysKIC4uLi9zdW44aS1hODN0LW1pcGkt Y3NpMi9zdW44aV9hODN0X2RwaHkuaCAgICB8ICAzOSArCiAuLi4vc3VuOGlfYTgzdF9taXBpX2Nz aTIuYyAgICAgICAgICAgICAgICAgICAgfCA4MTIgKysrKysrKysrKysrKysrKysrCiAuLi4vc3Vu OGlfYTgzdF9taXBpX2NzaTIuaCAgICAgICAgICAgICAgICAgICAgfCAgNTUgKysKIC4uLi9zdW44 aV9hODN0X21pcGlfY3NpMl9yZWcuaCAgICAgICAgICAgICAgICB8IDE1NyArKysrCiA5IGZpbGVz IGNoYW5nZWQsIDExNTIgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMv bWVkaWEvcGxhdGZvcm0vc3VueGkvc3VuOGktYTgzdC1taXBpLWNzaTIvS2NvbmZpZwogY3JlYXRl IG1vZGUgMTAwNjQ0IGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3VueGkvc3VuOGktYTgzdC1taXBp LWNzaTIvTWFrZWZpbGUKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21lZGlhL3BsYXRmb3Jt L3N1bnhpL3N1bjhpLWE4M3QtbWlwaS1jc2kyL3N1bjhpX2E4M3RfZHBoeS5jCiBjcmVhdGUgbW9k ZSAxMDA2NDQgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3Np Mi9zdW44aV9hODN0X2RwaHkuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbWVkaWEvcGxh dGZvcm0vc3VueGkvc3VuOGktYTgzdC1taXBpLWNzaTIvc3VuOGlfYTgzdF9taXBpX2NzaTIuYwog Y3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3VueGkvc3VuOGktYTgz dC1taXBpLWNzaTIvc3VuOGlfYTgzdF9taXBpX2NzaTIuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGRy aXZlcnMvbWVkaWEvcGxhdGZvcm0vc3VueGkvc3VuOGktYTgzdC1taXBpLWNzaTIvc3VuOGlfYTgz dF9taXBpX2NzaTJfcmVnLmgKCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1 bnhpL0tjb25maWcgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhpL0tjb25maWcKaW5kZXgg OTY4NGUwNzQ1NGFkLi5kYjRjMDdiZTdlNGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcGxh dGZvcm0vc3VueGkvS2NvbmZpZworKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhpL0tj b25maWcKQEAgLTMsMyArMyw0IEBACiBzb3VyY2UgImRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3Vu eGkvc3VuNGktY3NpL0tjb25maWciCiBzb3VyY2UgImRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3Vu eGkvc3VuNmktY3NpL0tjb25maWciCiBzb3VyY2UgImRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3Vu eGkvc3VuNmktbWlwaS1jc2kyL0tjb25maWciCitzb3VyY2UgImRyaXZlcnMvbWVkaWEvcGxhdGZv cm0vc3VueGkvc3VuOGktYTgzdC1taXBpLWNzaTIvS2NvbmZpZyIKZGlmZiAtLWdpdCBhL2RyaXZl cnMvbWVkaWEvcGxhdGZvcm0vc3VueGkvTWFrZWZpbGUgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3Jt L3N1bnhpL01ha2VmaWxlCmluZGV4IDg4N2E3Y2FlOGZjYS4uOWFhMDFjYjAxODgzIDEwMDY0NAot LS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhpL01ha2VmaWxlCisrKyBiL2RyaXZlcnMv bWVkaWEvcGxhdGZvcm0vc3VueGkvTWFrZWZpbGUKQEAgLTMsNSArMyw2IEBACiBvYmoteQkJKz0g c3VuNGktY3NpLwogb2JqLXkJCSs9IHN1bjZpLWNzaS8KIG9iai15CQkrPSBzdW42aS1taXBpLWNz aTIvCitvYmoteQkJKz0gc3VuOGktYTgzdC1taXBpLWNzaTIvCiBvYmoteQkJKz0gc3VuOGktZGkv CiBvYmoteQkJKz0gc3VuOGktcm90YXRlLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9LY29uZmlnIGIvZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9LY29uZmlnCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNjBlN2E5YzQxMDY1Ci0tLSAvZGV2L251bGwKKysr IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9LY29u ZmlnCkBAIC0wLDAgKzEsMTEgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAt b25seQorY29uZmlnIFZJREVPX1NVTjhJX0E4M1RfTUlQSV9DU0kyCisJdHJpc3RhdGUgIkFsbHdp bm5lciBBODNUIE1JUEkgQ1NJLTIgQ29udHJvbGxlciBhbmQgRC1QSFkgRHJpdmVyIgorCWRlcGVu ZHMgb24gQVJDSF9TVU5YSSB8fCBDT01QSUxFX1RFU1QKKwlkZXBlbmRzIG9uIFBNICYmIENPTU1P Tl9DTEsgJiYgVklERU9fVjRMMgorCXNlbGVjdCBSRUdNQVBfTU1JTworCXNlbGVjdCBNRURJQV9D T05UUk9MTEVSCisJc2VsZWN0IFZJREVPX1Y0TDJfU1VCREVWX0FQSQorCXNlbGVjdCBWNEwyX0ZX Tk9ERQorCWhlbHAKKwkgICBTdXBwb3J0IGZvciB0aGUgQWxsd2lubmVyIEE4M1QgTUlQSSBDU0kt MiBDb250cm9sbGVyIGFuZCBELVBIWS4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZv cm0vc3VueGkvc3VuOGktYTgzdC1taXBpLWNzaTIvTWFrZWZpbGUgYi9kcml2ZXJzL21lZGlhL3Bs YXRmb3JtL3N1bnhpL3N1bjhpLWE4M3QtbWlwaS1jc2kyL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMTQyN2QxNWE4NzlhCi0tLSAvZGV2L251bGwKKysr IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9NYWtl ZmlsZQpAQCAtMCwwICsxLDQgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAt b25seQorc3VuOGktYTgzdC1taXBpLWNzaTIteSArPSBzdW44aV9hODN0X21pcGlfY3NpMi5vIHN1 bjhpX2E4M3RfZHBoeS5vCisKK29iai0kKENPTkZJR19WSURFT19TVU44SV9BODNUX01JUElfQ1NJ MikgKz0gc3VuOGktYTgzdC1taXBpLWNzaTIubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9zdW44aV9hODN0X2RwaHkuYyBiL2Ry aXZlcnMvbWVkaWEvcGxhdGZvcm0vc3VueGkvc3VuOGktYTgzdC1taXBpLWNzaTIvc3VuOGlfYTgz dF9kcGh5LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xNWNlYzkx ZWUzOGMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhpL3N1 bjhpLWE4M3QtbWlwaS1jc2kyL3N1bjhpX2E4M3RfZHBoeS5jCkBAIC0wLDAgKzEsNzIgQEAKKy8v IFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKworLyoKKyAqIENvcHlyaWdodCAyMDIw IEJvb3RsaW4KKyAqIEF1dGhvcjogUGF1bCBLb2NpYWxrb3dza2kgPHBhdWwua29jaWFsa293c2tp QGJvb3RsaW4uY29tPgorICovCisKKyNpbmNsdWRlIDxsaW51eC9waHkvcGh5Lmg+CisjaW5jbHVk ZSA8bGludXgvcmVnbWFwLmg+CisKKyNpbmNsdWRlICJzdW44aV9hODN0X2RwaHkuaCIKKyNpbmNs dWRlICJzdW44aV9hODN0X21pcGlfY3NpMi5oIgorCitzdGF0aWMgaW50IHN1bjhpX2E4M3RfZHBo eV9jb25maWd1cmUoc3RydWN0IHBoeSAqZHBoeSwKKwkJCQkgICAgIHVuaW9uIHBoeV9jb25maWd1 cmVfb3B0cyAqb3B0cykKK3sKKwlyZXR1cm4gcGh5X21pcGlfZHBoeV9jb25maWdfdmFsaWRhdGUo Jm9wdHMtPm1pcGlfZHBoeSk7Cit9CisKK3N0YXRpYyBpbnQgc3VuOGlfYTgzdF9kcGh5X3Bvd2Vy X29uKHN0cnVjdCBwaHkgKmRwaHkpCit7CisJc3RydWN0IHN1bjhpX2E4M3RfbWlwaV9jc2kyX2Rl dmljZSAqY3NpMl9kZXYgPSBwaHlfZ2V0X2RydmRhdGEoZHBoeSk7CisJc3RydWN0IHJlZ21hcCAq cmVnbWFwID0gY3NpMl9kZXYtPnJlZ21hcDsKKworCXJlZ21hcF93cml0ZShyZWdtYXAsIFNVTjhJ X0E4M1RfRFBIWV9DVFJMX1JFRywKKwkJICAgICBTVU44SV9BODNUX0RQSFlfQ1RSTF9SRVNFVF9O IHwKKwkJICAgICBTVU44SV9BODNUX0RQSFlfQ1RSTF9TSFVURE9XTl9OKTsKKworCXJlZ21hcF93 cml0ZShyZWdtYXAsIFNVTjhJX0E4M1RfRFBIWV9BTkEwX1JFRywKKwkJICAgICBTVU44SV9BODNU X0RQSFlfQU5BMF9SRVhUX0VOIHwKKwkJICAgICBTVU44SV9BODNUX0RQSFlfQU5BMF9SSU5UKDIp IHwKKwkJICAgICBTVU44SV9BODNUX0RQSFlfQU5BMF9TTksoMikpOworCisJcmV0dXJuIDA7Cit9 OworCitzdGF0aWMgaW50IHN1bjhpX2E4M3RfZHBoeV9wb3dlcl9vZmYoc3RydWN0IHBoeSAqZHBo eSkKK3sKKwlzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJfZGV2aWNlICpjc2kyX2RldiA9IHBo eV9nZXRfZHJ2ZGF0YShkcGh5KTsKKwlzdHJ1Y3QgcmVnbWFwICpyZWdtYXAgPSBjc2kyX2Rldi0+ cmVnbWFwOworCisJcmVnbWFwX3dyaXRlKHJlZ21hcCwgU1VOOElfQTgzVF9EUEhZX0NUUkxfUkVH LCAwKTsKKworCXJldHVybiAwOworfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBwaHlfb3BzIHN1 bjhpX2E4M3RfZHBoeV9vcHMgPSB7CisJLmNvbmZpZ3VyZQk9IHN1bjhpX2E4M3RfZHBoeV9jb25m aWd1cmUsCisJLnBvd2VyX29uCT0gc3VuOGlfYTgzdF9kcGh5X3Bvd2VyX29uLAorCS5wb3dlcl9v ZmYJPSBzdW44aV9hODN0X2RwaHlfcG93ZXJfb2ZmLAorfTsKKworaW50IHN1bjhpX2E4M3RfZHBo eV9yZWdpc3RlcihzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJfZGV2aWNlICpjc2kyX2RldikK K3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBjc2kyX2Rldi0+ZGV2OworCXN0cnVjdCBwaHlfcHJv dmlkZXIgKnBoeV9wcm92aWRlcjsKKworCWNzaTJfZGV2LT5kcGh5ID0gZGV2bV9waHlfY3JlYXRl KGRldiwgTlVMTCwgJnN1bjhpX2E4M3RfZHBoeV9vcHMpOworCWlmIChJU19FUlIoY3NpMl9kZXYt PmRwaHkpKSB7CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGNyZWF0ZSBELVBIWVxuIik7CisJ CXJldHVybiBQVFJfRVJSKGNzaTJfZGV2LT5kcGh5KTsKKwl9CisKKwlwaHlfc2V0X2RydmRhdGEo Y3NpMl9kZXYtPmRwaHksIGNzaTJfZGV2KTsKKworCXBoeV9wcm92aWRlciA9IGRldm1fb2ZfcGh5 X3Byb3ZpZGVyX3JlZ2lzdGVyKGRldiwgb2ZfcGh5X3NpbXBsZV94bGF0ZSk7CisJaWYgKElTX0VS UihwaHlfcHJvdmlkZXIpKSB7CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIHJlZ2lzdGVyIEQt UEhZIHByb3ZpZGVyXG4iKTsKKwkJcmV0dXJuIFBUUl9FUlIocGh5X3Byb3ZpZGVyKTsKKwl9CisK KwlyZXR1cm4gMDsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3VueGkv c3VuOGktYTgzdC1taXBpLWNzaTIvc3VuOGlfYTgzdF9kcGh5LmggYi9kcml2ZXJzL21lZGlhL3Bs YXRmb3JtL3N1bnhpL3N1bjhpLWE4M3QtbWlwaS1jc2kyL3N1bjhpX2E4M3RfZHBoeS5oCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMTg3NzkwNjBmZDMyCi0tLSAvZGV2 L251bGwKKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGkt Y3NpMi9zdW44aV9hODN0X2RwaHkuaApAQCAtMCwwICsxLDM5IEBACisvKiBTUERYLUxpY2Vuc2Ut SWRlbnRpZmllcjogR1BMLTIuMCsgKi8KKy8qCisgKiBDb3B5cmlnaHQgMjAyMCBLw6l2aW4gTCdo w7RwaXRhbCA8a2V2aW4ubGhvcGl0YWxAYm9vdGxpbi5jb20+CisgKiBDb3B5cmlnaHQgMjAyMC0y MDIxIEJvb3RsaW4KKyAqIEF1dGhvcjogUGF1bCBLb2NpYWxrb3dza2kgPHBhdWwua29jaWFsa293 c2tpQGJvb3RsaW4uY29tPgorICovCisKKyNpZm5kZWYgX1NVTjhJX0E4M1RfRFBIWV9IXworI2Rl ZmluZSBfU1VOOElfQTgzVF9EUEhZX0hfCisKKyNpbmNsdWRlICJzdW44aV9hODN0X21pcGlfY3Np Mi5oIgorCisjZGVmaW5lIFNVTjhJX0E4M1RfRFBIWV9DVFJMX1JFRwkJMHgxMAorI2RlZmluZSBT VU44SV9BODNUX0RQSFlfQ1RSTF9JTklUX1ZBTFVFCQkweGI4ZGY2OThlCisjZGVmaW5lIFNVTjhJ X0E4M1RfRFBIWV9DVFJMX1JFU0VUX04JCUJJVCgzMSkKKyNkZWZpbmUgU1VOOElfQTgzVF9EUEhZ X0NUUkxfU0hVVERPV05fTgkJQklUKDE1KQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlfQ1RSTF9E RUJVRwkJQklUKDgpCisjZGVmaW5lIFNVTjhJX0E4M1RfRFBIWV9TVEFUVVNfUkVHCQkweDE0Cisj ZGVmaW5lIFNVTjhJX0E4M1RfRFBIWV9TVEFUVVNfQ0xLX1NUT1AJCUJJVCgxMCkKKyNkZWZpbmUg U1VOOElfQTgzVF9EUEhZX1NUQVRVU19DTEtfVUxQUwkJQklUKDkpCisjZGVmaW5lIFNVTjhJX0E4 M1RfRFBIWV9TVEFUVVNfSFNDTEsJCUJJVCg4KQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlfU1RB VFVTX0QzX1NUT1AJCUJJVCg3KQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlfU1RBVFVTX0QyX1NU T1AJCUJJVCg2KQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlfU1RBVFVTX0QxX1NUT1AJCUJJVCg1 KQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlfU1RBVFVTX0QwX1NUT1AJCUJJVCg0KQorI2RlZmlu ZSBTVU44SV9BODNUX0RQSFlfU1RBVFVTX0QzX1VMUFMJCUJJVCgzKQorI2RlZmluZSBTVU44SV9B ODNUX0RQSFlfU1RBVFVTX0QyX1VMUFMJCUJJVCgyKQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlf U1RBVFVTX0QxX1VMUFMJCUJJVCgxKQorI2RlZmluZSBTVU44SV9BODNUX0RQSFlfU1RBVFVTX0Qw X1VMUFMJCUJJVCgwKQorCisjZGVmaW5lIFNVTjhJX0E4M1RfRFBIWV9BTkEwX1JFRwkJMHgzMAor I2RlZmluZSBTVU44SV9BODNUX0RQSFlfQU5BMF9SRVhUX0VOCQlCSVQoMzEpCisjZGVmaW5lIFNV TjhJX0E4M1RfRFBIWV9BTkEwX1JFWFQJCUJJVCgzMCkKKyNkZWZpbmUgU1VOOElfQTgzVF9EUEhZ X0FOQTBfUklOVCh2KQkJKCgodikgPDwgMjgpICYgR0VOTUFTSygyOSwgMjgpKQorI2RlZmluZSBT VU44SV9BODNUX0RQSFlfQU5BMF9TTksodikJCSgoKHYpIDw8IDIwKSAmIEdFTk1BU0soMjIsIDIw KSkKKworaW50IHN1bjhpX2E4M3RfZHBoeV9yZWdpc3RlcihzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBp X2NzaTJfZGV2aWNlICpjc2kyX2Rldik7CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9t ZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9zdW44aV9hODN0X21pcGlf Y3NpMi5jIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3Np Mi9zdW44aV9hODN0X21pcGlfY3NpMi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMC4uNmIwMTBlNzRmMDU3Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9zdW44aV9hODN0X21pcGlfY3NpMi5j CkBAIC0wLDAgKzEsODEyIEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsK Ky8qCisgKiBDb3B5cmlnaHQgMjAyMCBLw6l2aW4gTCdow7RwaXRhbCA8a2V2aW4ubGhvcGl0YWxA Ym9vdGxpbi5jb20+CisgKiBDb3B5cmlnaHQgMjAyMC0yMDIxIEJvb3RsaW4KKyAqIEF1dGhvcjog UGF1bCBLb2NpYWxrb3dza2kgPHBhdWwua29jaWFsa293c2tpQGJvb3RsaW4uY29tPgorICovCisK KyNpbmNsdWRlIDxsaW51eC9jbGsuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNs dWRlIDxsaW51eC9vZi5oPgorI2luY2x1ZGUgPGxpbnV4L29mX2RldmljZS5oPgorI2luY2x1ZGUg PGxpbnV4L3BoeS9waHkuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNp bmNsdWRlIDxsaW51eC9wbV9ydW50aW1lLmg+CisjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+Cisj aW5jbHVkZSA8bGludXgvcmVzZXQuaD4KKyNpbmNsdWRlIDxtZWRpYS92NGwyLWN0cmxzLmg+Cisj aW5jbHVkZSA8bWVkaWEvdjRsMi1kZXZpY2UuaD4KKyNpbmNsdWRlIDxtZWRpYS92NGwyLWZ3bm9k ZS5oPgorCisjaW5jbHVkZSAic3VuOGlfYTgzdF9kcGh5LmgiCisjaW5jbHVkZSAic3VuOGlfYTgz dF9taXBpX2NzaTIuaCIKKyNpbmNsdWRlICJzdW44aV9hODN0X21pcGlfY3NpMl9yZWcuaCIKKwor LyogRm9ybWF0ICovCisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJf Zm9ybWF0CitzdW44aV9hODN0X21pcGlfY3NpMl9mb3JtYXRzW10gPSB7CisJeworCQkubWJ1c19j b2RlCT0gTUVESUFfQlVTX0ZNVF9TQkdHUjhfMVg4LAorCQkuZGF0YV90eXBlCT0gTUlQSV9DU0ky X0RBVEFfVFlQRV9SQVc4LAorCQkuYnBwCQk9IDgsCisJfSwKKwl7CisJCS5tYnVzX2NvZGUJPSBN RURJQV9CVVNfRk1UX1NHQlJHOF8xWDgsCisJCS5kYXRhX3R5cGUJPSBNSVBJX0NTSTJfREFUQV9U WVBFX1JBVzgsCisJCS5icHAJCT0gOCwKKwl9LAorCXsKKwkJLm1idXNfY29kZQk9IE1FRElBX0JV U19GTVRfU0dSQkc4XzFYOCwKKwkJLmRhdGFfdHlwZQk9IE1JUElfQ1NJMl9EQVRBX1RZUEVfUkFX OCwKKwkJLmJwcAkJPSA4LAorCX0sCisJeworCQkubWJ1c19jb2RlCT0gTUVESUFfQlVTX0ZNVF9T UkdHQjhfMVg4LAorCQkuZGF0YV90eXBlCT0gTUlQSV9DU0kyX0RBVEFfVFlQRV9SQVc4LAorCQku YnBwCQk9IDgsCisJfSwKKwl7CisJCS5tYnVzX2NvZGUJPSBNRURJQV9CVVNfRk1UX1NCR0dSMTBf MVgxMCwKKwkJLmRhdGFfdHlwZQk9IE1JUElfQ1NJMl9EQVRBX1RZUEVfUkFXMTAsCisJCS5icHAJ CT0gMTAsCisJfSwKKwl7CisJCS5tYnVzX2NvZGUJPSBNRURJQV9CVVNfRk1UX1NHQlJHMTBfMVgx MCwKKwkJLmRhdGFfdHlwZQk9IE1JUElfQ1NJMl9EQVRBX1RZUEVfUkFXMTAsCisJCS5icHAJCT0g MTAsCisJfSwKKwl7CisJCS5tYnVzX2NvZGUJPSBNRURJQV9CVVNfRk1UX1NHUkJHMTBfMVgxMCwK KwkJLmRhdGFfdHlwZQk9IE1JUElfQ1NJMl9EQVRBX1RZUEVfUkFXMTAsCisJCS5icHAJCT0gMTAs CisJfSwKKwl7CisJCS5tYnVzX2NvZGUJPSBNRURJQV9CVVNfRk1UX1NSR0dCMTBfMVgxMCwKKwkJ LmRhdGFfdHlwZQk9IE1JUElfQ1NJMl9EQVRBX1RZUEVfUkFXMTAsCisJCS5icHAJCT0gMTAsCisJ fSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJfZm9ybWF0 ICoKK3N1bjhpX2E4M3RfbWlwaV9jc2kyX2Zvcm1hdF9maW5kKHUzMiBtYnVzX2NvZGUpCit7CisJ dW5zaWduZWQgaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShzdW44aV9hODN0 X21pcGlfY3NpMl9mb3JtYXRzKTsgaSsrKQorCQlpZiAoc3VuOGlfYTgzdF9taXBpX2NzaTJfZm9y bWF0c1tpXS5tYnVzX2NvZGUgPT0gbWJ1c19jb2RlKQorCQkJcmV0dXJuICZzdW44aV9hODN0X21p cGlfY3NpMl9mb3JtYXRzW2ldOworCisJcmV0dXJuIE5VTEw7Cit9CisKKy8qIENvbnRyb2xsZXIg Ki8KKworc3RhdGljIHZvaWQKK3N1bjhpX2E4M3RfbWlwaV9jc2kyX2luaXQoc3RydWN0IHN1bjhp X2E4M3RfbWlwaV9jc2kyX2RldmljZSAqY3NpMl9kZXYpCit7CisJc3RydWN0IHJlZ21hcCAqcmVn bWFwID0gY3NpMl9kZXYtPnJlZ21hcDsKKworCS8qCisJICogVGhlIEFsbHdpbm5lciBCU1Agc2V0 cyB2YXJpb3VzIG1hZ2ljIHZhbHVlcyBvbiBhIGJ1bmNoIG9mIHJlZ2lzdGVycy4KKwkgKiBUaGlz IGlzIGFwcGFyZW50bHkgYSBuZWNlc3NhcnkgaW5pdGlhbGl6YXRpb24gcHJvY2VzcyB0aGF0IHdp bGwgY2F1c2UKKwkgKiB0aGUgY2FwdHVyZSB0byBmYWlsIHdpdGggdW5zb2xpY2l0ZWQgaW50ZXJy dXB0cyBoaXR0aW5nIGlmIHNraXBwZWQuCisJICoKKwkgKiBNb3N0IG9mIHRoZSByZWdpc3RlcnMg YXJlIHNldCB0byBwcm9wZXIgdmFsdWVzIGxhdGVyLCBleGNlcHQgZm9yIHRoZQorCSAqIHR3byBy ZXNlcnZlZCByZWdpc3RlcnMuIFRoZXkgYXJlIHNhaWQgdG8gaG9sZCBhICJoYXJkd2FyZSBsb2Nr IgorCSAqIHZhbHVlLCB3aXRob3V0IG1vcmUgaW5mb3JtYXRpb24gYXZhaWxhYmxlLgorCSAqLwor CisJcmVnbWFwX3dyaXRlKHJlZ21hcCwgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ1RSTF9SRUcsIDAp OworCXJlZ21hcF93cml0ZShyZWdtYXAsIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0NUUkxfUkVHLAor CQkgICAgIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0NUUkxfSU5JVF9WQUxVRSk7CisKKwlyZWdtYXBf d3JpdGUocmVnbWFwLCBTVU44SV9BODNUX01JUElfQ1NJMl9SWF9QS1RfTlVNX1JFRywgMCk7CisJ cmVnbWFwX3dyaXRlKHJlZ21hcCwgU1VOOElfQTgzVF9NSVBJX0NTSTJfUlhfUEtUX05VTV9SRUcs CisJCSAgICAgU1VOOElfQTgzVF9NSVBJX0NTSTJfUlhfUEtUX05VTV9JTklUX1ZBTFVFKTsKKwor CXJlZ21hcF93cml0ZShyZWdtYXAsIFNVTjhJX0E4M1RfRFBIWV9DVFJMX1JFRywgMCk7CisJcmVn bWFwX3dyaXRlKHJlZ21hcCwgU1VOOElfQTgzVF9EUEhZX0NUUkxfUkVHLAorCQkgICAgIFNVTjhJ X0E4M1RfRFBIWV9DVFJMX0lOSVRfVkFMVUUpOworCisJcmVnbWFwX3dyaXRlKHJlZ21hcCwgU1VO OElfQTgzVF9NSVBJX0NTSTJfUlNWRDFfUkVHLCAwKTsKKwlyZWdtYXBfd3JpdGUocmVnbWFwLCBT VU44SV9BODNUX01JUElfQ1NJMl9SU1ZEMV9SRUcsCisJCSAgICAgU1VOOElfQTgzVF9NSVBJX0NT STJfUlNWRDFfSFdfTE9DS19WQUxVRSk7CisKKwlyZWdtYXBfd3JpdGUocmVnbWFwLCBTVU44SV9B ODNUX01JUElfQ1NJMl9SU1ZEMl9SRUcsIDApOworCXJlZ21hcF93cml0ZShyZWdtYXAsIFNVTjhJ X0E4M1RfTUlQSV9DU0kyX1JTVkQyX1JFRywKKwkJICAgICBTVU44SV9BODNUX01JUElfQ1NJMl9S U1ZEMl9IV19MT0NLX1ZBTFVFKTsKKworCXJlZ21hcF93cml0ZShyZWdtYXAsIFNVTjhJX0E4M1Rf TUlQSV9DU0kyX0NGR19SRUcsIDApOworCXJlZ21hcF93cml0ZShyZWdtYXAsIFNVTjhJX0E4M1Rf TUlQSV9DU0kyX0NGR19SRUcsCisJCSAgICAgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ0ZHX0lOSVRf VkFMVUUpOworfQorCitzdGF0aWMgdm9pZAorc3VuOGlfYTgzdF9taXBpX2NzaTJfZW5hYmxlKHN0 cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZpY2UgKmNzaTJfZGV2KQoreworCXN0cnVjdCBy ZWdtYXAgKnJlZ21hcCA9IGNzaTJfZGV2LT5yZWdtYXA7CisKKwlyZWdtYXBfdXBkYXRlX2JpdHMo cmVnbWFwLCBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfUkVHLAorCQkJICAgU1VOOElfQTgzVF9N SVBJX0NTSTJfQ0ZHX1NZTkNfRU4sCisJCQkgICBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfU1lO Q19FTik7Cit9CisKK3N0YXRpYyB2b2lkCitzdW44aV9hODN0X21pcGlfY3NpMl9kaXNhYmxlKHN0 cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZpY2UgKmNzaTJfZGV2KQoreworCXN0cnVjdCBy ZWdtYXAgKnJlZ21hcCA9IGNzaTJfZGV2LT5yZWdtYXA7CisKKwlyZWdtYXBfdXBkYXRlX2JpdHMo cmVnbWFwLCBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfUkVHLAorCQkJICAgU1VOOElfQTgzVF9N SVBJX0NTSTJfQ0ZHX1NZTkNfRU4sIDApOworCisJcmVnbWFwX3dyaXRlKHJlZ21hcCwgU1VOOElf QTgzVF9NSVBJX0NTSTJfQ1RSTF9SRUcsIDApOworfQorCitzdGF0aWMgdm9pZAorc3VuOGlfYTgz dF9taXBpX2NzaTJfY29uZmlndXJlKHN0cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZpY2Ug KmNzaTJfZGV2KQoreworCXN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IGNzaTJfZGV2LT5yZWdtYXA7 CisJdW5zaWduZWQgaW50IGxhbmVzX2NvdW50ID0KKwkJY3NpMl9kZXYtPmJyaWRnZS5lbmRwb2lu dC5idXMubWlwaV9jc2kyLm51bV9kYXRhX2xhbmVzOworCXN0cnVjdCB2NGwyX21idXNfZnJhbWVm bXQgKm1idXNfZm9ybWF0ID0gJmNzaTJfZGV2LT5icmlkZ2UubWJ1c19mb3JtYXQ7CisJY29uc3Qg c3RydWN0IHN1bjhpX2E4M3RfbWlwaV9jc2kyX2Zvcm1hdCAqZm9ybWF0OworCXN0cnVjdCBkZXZp Y2UgKmRldiA9IGNzaTJfZGV2LT5kZXY7CisJdTMyIHZlcnNpb24gPSAwOworCisJZm9ybWF0ID0g c3VuOGlfYTgzdF9taXBpX2NzaTJfZm9ybWF0X2ZpbmQobWJ1c19mb3JtYXQtPmNvZGUpOworCWlm IChXQVJOX09OKCFmb3JtYXQpKQorCQlyZXR1cm47CisKKwlyZWdtYXBfd3JpdGUocmVnbWFwLCBT VU44SV9BODNUX01JUElfQ1NJMl9DVFJMX1JFRywKKwkJICAgICBTVU44SV9BODNUX01JUElfQ1NJ Ml9DVFJMX1JFU0VUX04pOworCisJcmVnbWFwX3JlYWQocmVnbWFwLCBTVU44SV9BODNUX01JUElf Q1NJMl9WRVJTSU9OX1JFRywgJnZlcnNpb24pOworCisJZGV2X2RiZyhkZXYsICJBODNUIE1JUEkg Q1NJLTIgdmVyc2lvbjogJTA0eFxuIiwgdmVyc2lvbik7CisKKwlyZWdtYXBfd3JpdGUocmVnbWFw LCBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfUkVHLAorCQkgICAgIFNVTjhJX0E4M1RfTUlQSV9D U0kyX0NGR19VTlBLVF9FTiB8CisJCSAgICAgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ0ZHX1NZTkNf RExZX0NZQ0xFKDgpIHwKKwkJICAgICBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfTl9DSEFOTkVM KDEpIHwKKwkJICAgICBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfTl9MQU5FKGxhbmVzX2NvdW50 KSk7CisKKwkvKgorCSAqIE9ubHkgYSBzaW5nbGUgdmlydHVhbCBjaGFubmVsIChpbmRleCAwKSBp cyBjdXJyZW50bHkgc3VwcG9ydGVkLgorCSAqIFdoaWxlIHRoZSByZWdpc3RlcnMgZG8gbWVudGlv biBtdWx0aXBsZSBwaHlzaWNhbCBjaGFubmVscyBiZWluZworCSAqIGF2YWlsYWJsZSAod2hpY2gg Y2FuIGJlIGNvbmZpZ3VyZWQgdG8gbWF0Y2ggYSBzcGVjaWZpYyB2aXJ0dWFsCisJICogY2hhbm5l bCBvciBkYXRhIHR5cGUpLCBpdCdzIHVuY2xlYXIgd2hldGhlciBjaGFubmVscyA+IDAgYXJlIGFj dHVhbGx5CisJICogY29ubmVjdGVkIGFuZCBhdmFpbGFibGUgYW5kIHRoZSByZWZlcmVuY2Ugc291 cmNlIGNvZGUgb25seSBtYWtlcyB1c2UKKwkgKiBvZiBjaGFubmVsIDAuCisJICoKKwkgKiBVc2lu ZyBleHRyYSBjaGFubmVscyB3b3VsZCBhbHNvIHJlcXVpcmUgbWF0Y2hpbmcgY2hhbm5lbHMgdG8g YmUKKwkgKiBhdmFpbGFibGUgb24gdGhlIENTSSAoYW5kIElTUCkgc2lkZSwgd2hpY2ggaXMgYWxz byB1bnN1cmUgYWx0aG91Z2gKKwkgKiBzb21lIENTSSBpbXBsZW1lbnRhdGlvbnMgYXJlIHNhaWQg dG8gc3VwcG9ydCBtdWx0aXBsZSBjaGFubmVscyBmb3IKKwkgKiBCVDY1NiB0aW1lLXNoYXJpbmcu CisJICoKKwkgKiBXZSBzdGlsbCBjb25maWd1cmUgdmlydHVhbCBjaGFubmVsIG51bWJlcnMgdG8g ZW5zdXJlIHRoYXQgdmlydHVhbAorCSAqIGNoYW5uZWwgMCBvbmx5IGdvZXMgdG8gY2hhbm5lbCAw LgorCSAqLworCisJcmVnbWFwX3dyaXRlKHJlZ21hcCwgU1VOOElfQTgzVF9NSVBJX0NTSTJfVkNE VDBfUkVHLAorCQkgICAgIFNVTjhJX0E4M1RfTUlQSV9DU0kyX1ZDRFQwX0NIX1ZDKDMsIDMpIHwK KwkJICAgICBTVU44SV9BODNUX01JUElfQ1NJMl9WQ0RUMF9DSF9WQygyLCAyKSB8CisJCSAgICAg U1VOOElfQTgzVF9NSVBJX0NTSTJfVkNEVDBfQ0hfVkMoMSwgMSkgfAorCQkgICAgIFNVTjhJX0E4 M1RfTUlQSV9DU0kyX1ZDRFQwX0NIX1ZDKDAsIDApIHwKKwkJICAgICBTVU44SV9BODNUX01JUElf Q1NJMl9WQ0RUMF9DSF9EVCgwLCBmb3JtYXQtPmRhdGFfdHlwZSkpOworfQorCisvKiBWNEwyIFN1 YmRldiAqLworCitzdGF0aWMgaW50IHN1bjhpX2E4M3RfbWlwaV9jc2kyX3Nfc3RyZWFtKHN0cnVj dCB2NGwyX3N1YmRldiAqc3ViZGV2LCBpbnQgb24pCit7CisJc3RydWN0IHN1bjhpX2E4M3RfbWlw aV9jc2kyX2RldmljZSAqY3NpMl9kZXYgPQorCQl2NGwyX2dldF9zdWJkZXZkYXRhKHN1YmRldik7 CisJc3RydWN0IHY0bDJfc3ViZGV2ICpzb3VyY2Vfc3ViZGV2ID0gY3NpMl9kZXYtPmJyaWRnZS5z b3VyY2Vfc3ViZGV2OworCXVuaW9uIHBoeV9jb25maWd1cmVfb3B0cyBkcGh5X29wdHMgPSB7IDAg fTsKKwlzdHJ1Y3QgcGh5X2NvbmZpZ3VyZV9vcHRzX21pcGlfZHBoeSAqZHBoeV9jZmcgPSAmZHBo eV9vcHRzLm1pcGlfZHBoeTsKKwlzdHJ1Y3QgdjRsMl9tYnVzX2ZyYW1lZm10ICptYnVzX2Zvcm1h dCA9ICZjc2kyX2Rldi0+YnJpZGdlLm1idXNfZm9ybWF0OworCWNvbnN0IHN0cnVjdCBzdW44aV9h ODN0X21pcGlfY3NpMl9mb3JtYXQgKmZvcm1hdDsKKwlzdHJ1Y3QgcGh5ICpkcGh5ID0gY3NpMl9k ZXYtPmRwaHk7CisJc3RydWN0IGRldmljZSAqZGV2ID0gY3NpMl9kZXYtPmRldjsKKwlzdHJ1Y3Qg djRsMl9jdHJsICpjdHJsOworCXVuc2lnbmVkIGludCBsYW5lc19jb3VudCA9CisJCWNzaTJfZGV2 LT5icmlkZ2UuZW5kcG9pbnQuYnVzLm1pcGlfY3NpMi5udW1fZGF0YV9sYW5lczsKKwl1bnNpZ25l ZCBsb25nIHBpeGVsX3JhdGU7CisJLyogSW5pdGlhbGl6ZSB0byAwIHRvIHVzZSBib3RoIGluIGRp c2FibGUgbGFiZWwgKHJldCAhPSAwKSBhbmQgb2ZmLiAqLworCWludCByZXQgPSAwOworCisJaWYg KCFzb3VyY2Vfc3ViZGV2KQorCQlyZXR1cm4gLUVOT0RFVjsKKworCWlmICghb24pIHsKKwkJdjRs Ml9zdWJkZXZfY2FsbChzb3VyY2Vfc3ViZGV2LCB2aWRlbywgc19zdHJlYW0sIDApOworCQlnb3Rv IGRpc2FibGU7CisJfQorCisJLyogUnVudGltZSBQTSAqLworCisJcmV0ID0gcG1fcnVudGltZV9y ZXN1bWVfYW5kX2dldChkZXYpOworCWlmIChyZXQgPCAwKQorCQlyZXR1cm4gcmV0OworCisJLyog U2Vuc29yIHBpeGVsIHJhdGUgKi8KKworCWN0cmwgPSB2NGwyX2N0cmxfZmluZChzb3VyY2Vfc3Vi ZGV2LT5jdHJsX2hhbmRsZXIsIFY0TDJfQ0lEX1BJWEVMX1JBVEUpOworCWlmICghY3RybCkgewor CQlkZXZfZXJyKGRldiwgIm1pc3Npbmcgc2Vuc29yIHBpeGVsIHJhdGVcbiIpOworCQlyZXQgPSAt RU5PREVWOworCQlnb3RvIGVycm9yX3BtOworCX0KKworCXBpeGVsX3JhdGUgPSAodW5zaWduZWQg bG9uZyl2NGwyX2N0cmxfZ19jdHJsX2ludDY0KGN0cmwpOworCWlmICghcGl4ZWxfcmF0ZSkgewor CQlkZXZfZXJyKGRldiwgIm1pc3NpbmcgKHplcm8pIHNlbnNvciBwaXhlbCByYXRlXG4iKTsKKwkJ cmV0ID0gLUVOT0RFVjsKKwkJZ290byBlcnJvcl9wbTsKKwl9CisKKwkvKiBELVBIWSAqLworCisJ aWYgKCFsYW5lc19jb3VudCkgeworCQlkZXZfZXJyKGRldiwgIm1pc3NpbmcgKHplcm8pIE1JUEkg Q1NJLTIgbGFuZXMgY291bnRcbiIpOworCQlyZXQgPSAtRU5PREVWOworCQlnb3RvIGVycm9yX3Bt OworCX0KKworCWZvcm1hdCA9IHN1bjhpX2E4M3RfbWlwaV9jc2kyX2Zvcm1hdF9maW5kKG1idXNf Zm9ybWF0LT5jb2RlKTsKKwlpZiAoV0FSTl9PTighZm9ybWF0KSkgeworCQlyZXQgPSAtRU5PREVW OworCQlnb3RvIGVycm9yX3BtOworCX0KKworCXBoeV9taXBpX2RwaHlfZ2V0X2RlZmF1bHRfY29u ZmlnKHBpeGVsX3JhdGUsIGZvcm1hdC0+YnBwLCBsYW5lc19jb3VudCwKKwkJCQkJIGRwaHlfY2Zn KTsKKworCS8qCisJICogTm90ZSB0aGF0IG91ciBoYXJkd2FyZSBpcyB1c2luZyBERFIsIHdoaWNo IGlzIG5vdCB0YWtlbiBpbiBhY2NvdW50IGJ5CisJICogcGh5X21pcGlfZHBoeV9nZXRfZGVmYXVs dF9jb25maWcgd2hlbiBjYWxjdWxhdGluZyBoc19jbGtfcmF0ZSBmcm9tCisJICogdGhlIHBpeGVs IHJhdGUsIGxhbmVzIGNvdW50IGFuZCBicHAuCisJICoKKwkgKiBUaGUgcmVzdWx0aW5nIGNsb2Nr IHJhdGUgaXMgYmFzaWNhbGx5IHRoZSBzeW1ib2wgcmF0ZSBvdmVyIHRoZSB3aG9sZQorCSAqIGxp bmsuIFRoZSBhY3R1YWwgY2xvY2sgcmF0ZSBpcyBjYWxjdWxhdGVkIHdpdGggZGl2aXNpb24gYnkg dHdvIHNpbmNlCisJICogRERSIHNhbXBsZXMgYm90aCBvbiByaXNpbmcgYW5kIGZhbGxpbmcgZWRn ZXMuCisJICovCisKKwlkZXZfZGJnKGRldiwgIkE4M1QgTUlQSSBDU0ktMiBjb25maWc6XG4iKTsK KwlkZXZfZGJnKGRldiwgIiVsZCBwaXhlbHMvcywgJXUgYml0cy9waXhlbCwgJXUgbGFuZXMsICVs dSBIeiBjbG9ja1xuIiwKKwkJcGl4ZWxfcmF0ZSwgZm9ybWF0LT5icHAsIGxhbmVzX2NvdW50LAor CQlkcGh5X2NmZy0+aHNfY2xrX3JhdGUgLyAyKTsKKworCXJldCA9IHBoeV9yZXNldChkcGh5KTsK KwlpZiAocmV0KSB7CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIHJlc2V0IE1JUEkgRC1QSFlc biIpOworCQlnb3RvIGVycm9yX3BtOworCX0KKworCXJldCA9IHBoeV9jb25maWd1cmUoZHBoeSwg JmRwaHlfb3B0cyk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBjb25m aWd1cmUgTUlQSSBELVBIWVxuIik7CisJCWdvdG8gZXJyb3JfcG07CisJfQorCisJLyogQ29udHJv bGxlciAqLworCisJc3VuOGlfYTgzdF9taXBpX2NzaTJfY29uZmlndXJlKGNzaTJfZGV2KTsKKwlz dW44aV9hODN0X21pcGlfY3NpMl9lbmFibGUoY3NpMl9kZXYpOworCisJLyogRC1QSFkgKi8KKwor CXJldCA9IHBoeV9wb3dlcl9vbihkcGh5KTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIoZGV2LCAi ZmFpbGVkIHRvIHBvd2VyIG9uIE1JUEkgRC1QSFlcbiIpOworCQlnb3RvIGVycm9yX3BtOworCX0K KworCS8qIFNvdXJjZSAqLworCisJcmV0ID0gdjRsMl9zdWJkZXZfY2FsbChzb3VyY2Vfc3ViZGV2 LCB2aWRlbywgc19zdHJlYW0sIDEpOworCWlmIChyZXQgJiYgcmV0ICE9IC1FTk9JT0NUTENNRCkK KwkJZ290byBkaXNhYmxlOworCisJcmV0dXJuIDA7CisKK2Rpc2FibGU6CisJcGh5X3Bvd2VyX29m ZihkcGh5KTsKKwlzdW44aV9hODN0X21pcGlfY3NpMl9kaXNhYmxlKGNzaTJfZGV2KTsKKworZXJy b3JfcG06CisJcG1fcnVudGltZV9wdXQoZGV2KTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRp YyBjb25zdCBzdHJ1Y3QgdjRsMl9zdWJkZXZfdmlkZW9fb3BzCitzdW44aV9hODN0X21pcGlfY3Np Ml92aWRlb19vcHMgPSB7CisJLnNfc3RyZWFtCT0gc3VuOGlfYTgzdF9taXBpX2NzaTJfc19zdHJl YW0sCit9OworCitzdGF0aWMgdm9pZAorc3VuOGlfYTgzdF9taXBpX2NzaTJfbWJ1c19mb3JtYXRf cHJlcGFyZShzdHJ1Y3QgdjRsMl9tYnVzX2ZyYW1lZm10ICptYnVzX2Zvcm1hdCkKK3sKKwlpZiAo IXN1bjhpX2E4M3RfbWlwaV9jc2kyX2Zvcm1hdF9maW5kKG1idXNfZm9ybWF0LT5jb2RlKSkKKwkJ bWJ1c19mb3JtYXQtPmNvZGUgPSBzdW44aV9hODN0X21pcGlfY3NpMl9mb3JtYXRzWzBdLm1idXNf Y29kZTsKKworCW1idXNfZm9ybWF0LT5maWVsZCA9IFY0TDJfRklFTERfTk9ORTsKKwltYnVzX2Zv cm1hdC0+Y29sb3JzcGFjZSA9IFY0TDJfQ09MT1JTUEFDRV9SQVc7CisJbWJ1c19mb3JtYXQtPnF1 YW50aXphdGlvbiA9IFY0TDJfUVVBTlRJWkFUSU9OX0RFRkFVTFQ7CisJbWJ1c19mb3JtYXQtPnhm ZXJfZnVuYyA9IFY0TDJfWEZFUl9GVU5DX0RFRkFVTFQ7Cit9CisKK3N0YXRpYyBpbnQgc3VuOGlf YTgzdF9taXBpX2NzaTJfaW5pdF9jZmcoc3RydWN0IHY0bDJfc3ViZGV2ICpzdWJkZXYsCisJCQkJ CSBzdHJ1Y3QgdjRsMl9zdWJkZXZfc3RhdGUgKnN0YXRlKQoreworCXVuc2lnbmVkIGludCBwYWQg PSBTVU44SV9BODNUX01JUElfQ1NJMl9QQURfU0lOSzsKKwlzdHJ1Y3QgdjRsMl9tYnVzX2ZyYW1l Zm10ICptYnVzX2Zvcm1hdCA9CisJCXY0bDJfc3ViZGV2X2dldF90cnlfZm9ybWF0KHN1YmRldiwg c3RhdGUsIHBhZCk7CisKKwltYnVzX2Zvcm1hdC0+Y29kZSA9IHN1bjhpX2E4M3RfbWlwaV9jc2ky X2Zvcm1hdHNbMF0ubWJ1c19jb2RlOworCW1idXNfZm9ybWF0LT53aWR0aCA9IDY0MDsKKwltYnVz X2Zvcm1hdC0+aGVpZ2h0ID0gNDgwOworCisJc3VuOGlfYTgzdF9taXBpX2NzaTJfbWJ1c19mb3Jt YXRfcHJlcGFyZShtYnVzX2Zvcm1hdCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludAor c3VuOGlfYTgzdF9taXBpX2NzaTJfZW51bV9tYnVzX2NvZGUoc3RydWN0IHY0bDJfc3ViZGV2ICpz dWJkZXYsCisJCQkJICAgIHN0cnVjdCB2NGwyX3N1YmRldl9zdGF0ZSAqc3RhdGUsCisJCQkJICAg IHN0cnVjdCB2NGwyX3N1YmRldl9tYnVzX2NvZGVfZW51bSAqY29kZV9lbnVtKQoreworCWlmIChj b2RlX2VudW0tPmluZGV4ID49IEFSUkFZX1NJWkUoc3VuOGlfYTgzdF9taXBpX2NzaTJfZm9ybWF0 cykpCisJCXJldHVybiAtRUlOVkFMOworCisJY29kZV9lbnVtLT5jb2RlID0KKwkJc3VuOGlfYTgz dF9taXBpX2NzaTJfZm9ybWF0c1tjb2RlX2VudW0tPmluZGV4XS5tYnVzX2NvZGU7CisKKwlyZXR1 cm4gMDsKK30KKworc3RhdGljIGludCBzdW44aV9hODN0X21pcGlfY3NpMl9nZXRfZm10KHN0cnVj dCB2NGwyX3N1YmRldiAqc3ViZGV2LAorCQkJCQlzdHJ1Y3QgdjRsMl9zdWJkZXZfc3RhdGUgKnN0 YXRlLAorCQkJCQlzdHJ1Y3QgdjRsMl9zdWJkZXZfZm9ybWF0ICpmb3JtYXQpCit7CisJc3RydWN0 IHN1bjhpX2E4M3RfbWlwaV9jc2kyX2RldmljZSAqY3NpMl9kZXYgPQorCQl2NGwyX2dldF9zdWJk ZXZkYXRhKHN1YmRldik7CisJc3RydWN0IHY0bDJfbWJ1c19mcmFtZWZtdCAqbWJ1c19mb3JtYXQg PSAmZm9ybWF0LT5mb3JtYXQ7CisKKwlpZiAoZm9ybWF0LT53aGljaCA9PSBWNEwyX1NVQkRFVl9G T1JNQVRfVFJZKQorCQkqbWJ1c19mb3JtYXQgPSAqdjRsMl9zdWJkZXZfZ2V0X3RyeV9mb3JtYXQo c3ViZGV2LCBzdGF0ZSwKKwkJCQkJCQkgICBmb3JtYXQtPnBhZCk7CisJZWxzZQorCQkqbWJ1c19m b3JtYXQgPSBjc2kyX2Rldi0+YnJpZGdlLm1idXNfZm9ybWF0OworCisJcmV0dXJuIDA7Cit9CisK K3N0YXRpYyBpbnQgc3VuOGlfYTgzdF9taXBpX2NzaTJfc2V0X2ZtdChzdHJ1Y3QgdjRsMl9zdWJk ZXYgKnN1YmRldiwKKwkJCQkJc3RydWN0IHY0bDJfc3ViZGV2X3N0YXRlICpzdGF0ZSwKKwkJCQkJ c3RydWN0IHY0bDJfc3ViZGV2X2Zvcm1hdCAqZm9ybWF0KQoreworCXN0cnVjdCBzdW44aV9hODN0 X21pcGlfY3NpMl9kZXZpY2UgKmNzaTJfZGV2ID0KKwkJdjRsMl9nZXRfc3ViZGV2ZGF0YShzdWJk ZXYpOworCXN0cnVjdCB2NGwyX21idXNfZnJhbWVmbXQgKm1idXNfZm9ybWF0ID0gJmZvcm1hdC0+ Zm9ybWF0OworCisJc3VuOGlfYTgzdF9taXBpX2NzaTJfbWJ1c19mb3JtYXRfcHJlcGFyZShtYnVz X2Zvcm1hdCk7CisKKwlpZiAoZm9ybWF0LT53aGljaCA9PSBWNEwyX1NVQkRFVl9GT1JNQVRfVFJZ KQorCQkqdjRsMl9zdWJkZXZfZ2V0X3RyeV9mb3JtYXQoc3ViZGV2LCBzdGF0ZSwgZm9ybWF0LT5w YWQpID0KKwkJCSptYnVzX2Zvcm1hdDsKKwllbHNlCisJCWNzaTJfZGV2LT5icmlkZ2UubWJ1c19m b3JtYXQgPSAqbWJ1c19mb3JtYXQ7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0 cnVjdCB2NGwyX3N1YmRldl9wYWRfb3BzIHN1bjhpX2E4M3RfbWlwaV9jc2kyX3BhZF9vcHMgPSB7 CisJLmluaXRfY2ZnCT0gc3VuOGlfYTgzdF9taXBpX2NzaTJfaW5pdF9jZmcsCisJLmVudW1fbWJ1 c19jb2RlCT0gc3VuOGlfYTgzdF9taXBpX2NzaTJfZW51bV9tYnVzX2NvZGUsCisJLmdldF9mbXQJ PSBzdW44aV9hODN0X21pcGlfY3NpMl9nZXRfZm10LAorCS5zZXRfZm10CT0gc3VuOGlfYTgzdF9t aXBpX2NzaTJfc2V0X2ZtdCwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgdjRsMl9zdWJkZXZf b3BzIHN1bjhpX2E4M3RfbWlwaV9jc2kyX3N1YmRldl9vcHMgPSB7CisJLnZpZGVvCT0gJnN1bjhp X2E4M3RfbWlwaV9jc2kyX3ZpZGVvX29wcywKKwkucGFkCT0gJnN1bjhpX2E4M3RfbWlwaV9jc2ky X3BhZF9vcHMsCit9OworCisvKiBNZWRpYSBFbnRpdHkgKi8KKworc3RhdGljIGNvbnN0IHN0cnVj dCBtZWRpYV9lbnRpdHlfb3BlcmF0aW9ucyBzdW44aV9hODN0X21pcGlfY3NpMl9lbnRpdHlfb3Bz ID0geworCS5saW5rX3ZhbGlkYXRlCT0gdjRsMl9zdWJkZXZfbGlua192YWxpZGF0ZSwKK307CisK Ky8qIFY0TDIgQXN5bmMgKi8KKworc3RhdGljIGludAorc3VuOGlfYTgzdF9taXBpX2NzaTJfbm90 aWZpZXJfYm91bmQoc3RydWN0IHY0bDJfYXN5bmNfbm90aWZpZXIgKm5vdGlmaWVyLAorCQkJCSAg ICBzdHJ1Y3QgdjRsMl9zdWJkZXYgKnJlbW90ZV9zdWJkZXYsCisJCQkJICAgIHN0cnVjdCB2NGwy X2FzeW5jX3N1YmRldiAqYXN5bmNfc3ViZGV2KQoreworCXN0cnVjdCB2NGwyX3N1YmRldiAqc3Vi ZGV2ID0gbm90aWZpZXItPnNkOworCXN0cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZpY2Ug KmNzaTJfZGV2ID0KKwkJY29udGFpbmVyX29mKG5vdGlmaWVyLCBzdHJ1Y3Qgc3VuOGlfYTgzdF9t aXBpX2NzaTJfZGV2aWNlLAorCQkJICAgICBicmlkZ2Uubm90aWZpZXIpOworCXN0cnVjdCBtZWRp YV9lbnRpdHkgKnNpbmtfZW50aXR5ID0gJnN1YmRldi0+ZW50aXR5OworCXN0cnVjdCBtZWRpYV9l bnRpdHkgKnNvdXJjZV9lbnRpdHkgPSAmcmVtb3RlX3N1YmRldi0+ZW50aXR5OworCXN0cnVjdCBk ZXZpY2UgKmRldiA9IGNzaTJfZGV2LT5kZXY7CisJaW50IHNpbmtfcGFkX2luZGV4ID0gMDsKKwlp bnQgc291cmNlX3BhZF9pbmRleDsKKwlpbnQgcmV0OworCisJcmV0ID0gbWVkaWFfZW50aXR5X2dl dF9md25vZGVfcGFkKHNvdXJjZV9lbnRpdHksIHJlbW90ZV9zdWJkZXYtPmZ3bm9kZSwKKwkJCQkJ ICBNRURJQV9QQURfRkxfU09VUkNFKTsKKwlpZiAocmV0IDwgMCkgeworCQlkZXZfZXJyKGRldiwg Im1pc3Npbmcgc291cmNlIHBhZCBpbiBleHRlcm5hbCBlbnRpdHkgJXNcbiIsCisJCQlzb3VyY2Vf ZW50aXR5LT5uYW1lKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJc291cmNlX3BhZF9pbmRl eCA9IHJldDsKKworCWRldl9kYmcoZGV2LCAiY3JlYXRpbmcgJXM6JXUgLT4gJXM6JXUgbGlua1xu Iiwgc291cmNlX2VudGl0eS0+bmFtZSwKKwkJc291cmNlX3BhZF9pbmRleCwgc2lua19lbnRpdHkt Pm5hbWUsIHNpbmtfcGFkX2luZGV4KTsKKworCXJldCA9IG1lZGlhX2NyZWF0ZV9wYWRfbGluayhz b3VyY2VfZW50aXR5LCBzb3VyY2VfcGFkX2luZGV4LAorCQkJCSAgICBzaW5rX2VudGl0eSwgc2lu a19wYWRfaW5kZXgsCisJCQkJICAgIE1FRElBX0xOS19GTF9FTkFCTEVEIHwKKwkJCQkgICAgTUVE SUFfTE5LX0ZMX0lNTVVUQUJMRSk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgImZhaWxl ZCB0byBjcmVhdGUgJXM6JXUgLT4gJXM6JXUgbGlua1xuIiwKKwkJCXNvdXJjZV9lbnRpdHktPm5h bWUsIHNvdXJjZV9wYWRfaW5kZXgsCisJCQlzaW5rX2VudGl0eS0+bmFtZSwgc2lua19wYWRfaW5k ZXgpOworCQlyZXR1cm4gcmV0OworCX0KKworCWNzaTJfZGV2LT5icmlkZ2Uuc291cmNlX3N1YmRl diA9IHJlbW90ZV9zdWJkZXY7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVj dCB2NGwyX2FzeW5jX25vdGlmaWVyX29wZXJhdGlvbnMKK3N1bjhpX2E4M3RfbWlwaV9jc2kyX25v dGlmaWVyX29wcyA9IHsKKwkuYm91bmQJPSBzdW44aV9hODN0X21pcGlfY3NpMl9ub3RpZmllcl9i b3VuZCwKK307CisKKy8qIEJyaWRnZSAqLworCitzdGF0aWMgaW50CitzdW44aV9hODN0X21pcGlf Y3NpMl9icmlkZ2Vfc291cmNlX3NldHVwKHN0cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZp Y2UgKmNzaTJfZGV2KQoreworCXN0cnVjdCB2NGwyX2FzeW5jX25vdGlmaWVyICpub3RpZmllciA9 ICZjc2kyX2Rldi0+YnJpZGdlLm5vdGlmaWVyOworCXN0cnVjdCB2NGwyX2Z3bm9kZV9lbmRwb2lu dCAqZW5kcG9pbnQgPSAmY3NpMl9kZXYtPmJyaWRnZS5lbmRwb2ludDsKKwlzdHJ1Y3QgdjRsMl9h c3luY19zdWJkZXYgKnN1YmRldl9hc3luYzsKKwlzdHJ1Y3QgZndub2RlX2hhbmRsZSAqaGFuZGxl OworCXN0cnVjdCBkZXZpY2UgKmRldiA9IGNzaTJfZGV2LT5kZXY7CisJaW50IHJldDsKKworCWhh bmRsZSA9IGZ3bm9kZV9ncmFwaF9nZXRfZW5kcG9pbnRfYnlfaWQoZGV2X2Z3bm9kZShkZXYpLCAw LCAwLAorCQkJCQkJIEZXTk9ERV9HUkFQSF9FTkRQT0lOVF9ORVhUKTsKKwlpZiAoIWhhbmRsZSkK KwkJcmV0dXJuIC1FTk9ERVY7CisKKwllbmRwb2ludC0+YnVzX3R5cGUgPSBWNEwyX01CVVNfQ1NJ Ml9EUEhZOworCisJcmV0ID0gdjRsMl9md25vZGVfZW5kcG9pbnRfcGFyc2UoaGFuZGxlLCBlbmRw b2ludCk7CisJaWYgKHJldCkKKwkJZ290byBjb21wbGV0ZTsKKworCXN1YmRldl9hc3luYyA9IHY0 bDJfYXN5bmNfbm90aWZpZXJfYWRkX2Z3bm9kZV9yZW1vdGVfc3ViZGV2KG5vdGlmaWVyLAorCQlo YW5kbGUsIHN0cnVjdCB2NGwyX2FzeW5jX3N1YmRldik7CisJaWYgKElTX0VSUihzdWJkZXZfYXN5 bmMpKQorCQlyZXQgPSBQVFJfRVJSKHN1YmRldl9hc3luYyk7CisKK2NvbXBsZXRlOgorCWZ3bm9k ZV9oYW5kbGVfcHV0KGhhbmRsZSk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50Citz dW44aV9hODN0X21pcGlfY3NpMl9icmlkZ2Vfc2V0dXAoc3RydWN0IHN1bjhpX2E4M3RfbWlwaV9j c2kyX2RldmljZSAqY3NpMl9kZXYpCit7CisJc3RydWN0IHY0bDJfc3ViZGV2ICpzdWJkZXYgPSAm Y3NpMl9kZXYtPmJyaWRnZS5zdWJkZXY7CisJc3RydWN0IHY0bDJfYXN5bmNfbm90aWZpZXIgKm5v dGlmaWVyID0gJmNzaTJfZGV2LT5icmlkZ2Uubm90aWZpZXI7CisJc3RydWN0IG1lZGlhX3BhZCAq cGFkcyA9IGNzaTJfZGV2LT5icmlkZ2UucGFkczsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBjc2ky X2Rldi0+ZGV2OworCWludCByZXQ7CisKKwkvKiBWNEwyIFN1YmRldiAqLworCisJdjRsMl9zdWJk ZXZfaW5pdChzdWJkZXYsICZzdW44aV9hODN0X21pcGlfY3NpMl9zdWJkZXZfb3BzKTsKKwlzdHJz Y3B5KHN1YmRldi0+bmFtZSwgU1VOOElfQTgzVF9NSVBJX0NTSTJfTkFNRSwgc2l6ZW9mKHN1YmRl di0+bmFtZSkpOworCXN1YmRldi0+ZmxhZ3MgfD0gVjRMMl9TVUJERVZfRkxfSEFTX0RFVk5PREU7 CisJc3ViZGV2LT5vd25lciA9IFRISVNfTU9EVUxFOworCXN1YmRldi0+ZGV2ID0gZGV2OworCisJ djRsMl9zZXRfc3ViZGV2ZGF0YShzdWJkZXYsIGNzaTJfZGV2KTsKKworCS8qIE1lZGlhIEVudGl0 eSAqLworCisJc3ViZGV2LT5lbnRpdHkuZnVuY3Rpb24gPSBNRURJQV9FTlRfRl9WSURfSUZfQlJJ REdFOworCXN1YmRldi0+ZW50aXR5Lm9wcyA9ICZzdW44aV9hODN0X21pcGlfY3NpMl9lbnRpdHlf b3BzOworCisJLyogTWVkaWEgUGFkcyAqLworCisJcGFkc1tTVU44SV9BODNUX01JUElfQ1NJMl9Q QURfU0lOS10uZmxhZ3MgPSBNRURJQV9QQURfRkxfU0lOSzsKKwlwYWRzW1NVTjhJX0E4M1RfTUlQ SV9DU0kyX1BBRF9TT1VSQ0VdLmZsYWdzID0gTUVESUFfUEFEX0ZMX1NPVVJDRTsKKworCXJldCA9 IG1lZGlhX2VudGl0eV9wYWRzX2luaXQoJnN1YmRldi0+ZW50aXR5LAorCQkJCSAgICAgU1VOOElf QTgzVF9NSVBJX0NTSTJfUEFEX0NPVU5ULCBwYWRzKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0 OworCisJLyogVjRMMiBBc3luYyAqLworCisJdjRsMl9hc3luY19ub3RpZmllcl9pbml0KG5vdGlm aWVyKTsKKwlub3RpZmllci0+b3BzID0gJnN1bjhpX2E4M3RfbWlwaV9jc2kyX25vdGlmaWVyX29w czsKKworCXJldCA9IHN1bjhpX2E4M3RfbWlwaV9jc2kyX2JyaWRnZV9zb3VyY2Vfc2V0dXAoY3Np Ml9kZXYpOworCWlmIChyZXQpCisJCWdvdG8gZXJyb3JfdjRsMl9ub3RpZmllcl9jbGVhbnVwOwor CisJcmV0ID0gdjRsMl9hc3luY19zdWJkZXZfbm90aWZpZXJfcmVnaXN0ZXIoc3ViZGV2LCBub3Rp Zmllcik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZXJyb3JfdjRsMl9ub3RpZmllcl9jbGVhbnVw OworCisJLyogVjRMMiBTdWJkZXYgKi8KKworCXJldCA9IHY0bDJfYXN5bmNfcmVnaXN0ZXJfc3Vi ZGV2KHN1YmRldik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gZXJyb3JfdjRsMl9ub3RpZmllcl91 bnJlZ2lzdGVyOworCisJcmV0dXJuIDA7CisKK2Vycm9yX3Y0bDJfbm90aWZpZXJfdW5yZWdpc3Rl cjoKKwl2NGwyX2FzeW5jX25vdGlmaWVyX3VucmVnaXN0ZXIobm90aWZpZXIpOworCitlcnJvcl92 NGwyX25vdGlmaWVyX2NsZWFudXA6CisJdjRsMl9hc3luY19ub3RpZmllcl9jbGVhbnVwKG5vdGlm aWVyKTsKKworCW1lZGlhX2VudGl0eV9jbGVhbnVwKCZzdWJkZXYtPmVudGl0eSk7CisKKwlyZXR1 cm4gcmV0OworfQorCitzdGF0aWMgdm9pZAorc3VuOGlfYTgzdF9taXBpX2NzaTJfYnJpZGdlX2Ns ZWFudXAoc3RydWN0IHN1bjhpX2E4M3RfbWlwaV9jc2kyX2RldmljZSAqY3NpMl9kZXYpCit7CisJ c3RydWN0IHY0bDJfc3ViZGV2ICpzdWJkZXYgPSAmY3NpMl9kZXYtPmJyaWRnZS5zdWJkZXY7CisJ c3RydWN0IHY0bDJfYXN5bmNfbm90aWZpZXIgKm5vdGlmaWVyID0gJmNzaTJfZGV2LT5icmlkZ2Uu bm90aWZpZXI7CisKKwl2NGwyX2FzeW5jX3VucmVnaXN0ZXJfc3ViZGV2KHN1YmRldik7CisJdjRs Ml9hc3luY19ub3RpZmllcl91bnJlZ2lzdGVyKG5vdGlmaWVyKTsKKwl2NGwyX2FzeW5jX25vdGlm aWVyX2NsZWFudXAobm90aWZpZXIpOworCW1lZGlhX2VudGl0eV9jbGVhbnVwKCZzdWJkZXYtPmVu dGl0eSk7Cit9CisKKy8qIFBsYXRmb3JtICovCisKK3N0YXRpYyBpbnQgc3VuOGlfYTgzdF9taXBp X2NzaTJfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHN1bjhpX2E4M3Rf bWlwaV9jc2kyX2RldmljZSAqY3NpMl9kZXYgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKKworCWNs a19kaXNhYmxlX3VucHJlcGFyZShjc2kyX2Rldi0+Y2xrX21pc2MpOworCWNsa19kaXNhYmxlX3Vu cHJlcGFyZShjc2kyX2Rldi0+Y2xrX21pcGkpOworCWNsa19kaXNhYmxlX3VucHJlcGFyZShjc2ky X2Rldi0+Y2xrX21vZCk7CisJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGNzaTJfZGV2LT5jbGtfYnVz KTsKKwlyZXNldF9jb250cm9sX2Fzc2VydChjc2kyX2Rldi0+cmVzZXQpOworCisJcmV0dXJuIDA7 Cit9CisKK3N0YXRpYyBpbnQgc3VuOGlfYTgzdF9taXBpX2NzaTJfcmVzdW1lKHN0cnVjdCBkZXZp Y2UgKmRldikKK3sKKwlzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJfZGV2aWNlICpjc2kyX2Rl diA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCWludCByZXQ7CisKKwlyZXQgPSByZXNldF9jb250 cm9sX2RlYXNzZXJ0KGNzaTJfZGV2LT5yZXNldCk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRl diwgImZhaWxlZCB0byBkZWFzc2VydCByZXNldFxuIik7CisJCXJldHVybiByZXQ7CisJfQorCisJ cmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxlKGNzaTJfZGV2LT5jbGtfYnVzKTsKKwlpZiAocmV0KSB7 CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGVuYWJsZSBidXMgY2xvY2tcbiIpOworCQlnb3Rv IGVycm9yX3Jlc2V0OworCX0KKworCXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShjc2kyX2Rldi0+ Y2xrX21vZCk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBlbmFibGUg bW9kdWxlIGNsb2NrXG4iKTsKKwkJZ290byBlcnJvcl9jbGtfYnVzOworCX0KKworCXJldCA9IGNs a19wcmVwYXJlX2VuYWJsZShjc2kyX2Rldi0+Y2xrX21pcGkpOworCWlmIChyZXQpIHsKKwkJZGV2 X2VycihkZXYsICJmYWlsZWQgdG8gZW5hYmxlIE1JUEkgY2xvY2tcbiIpOworCQlnb3RvIGVycm9y X2Nsa19tb2Q7CisJfQorCisJcmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxlKGNzaTJfZGV2LT5jbGtf bWlzYyk7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBlbmFibGUgQ1NJ IG1pc2MgY2xvY2tcbiIpOworCQlnb3RvIGVycm9yX2Nsa19taXBpOworCX0KKworCXN1bjhpX2E4 M3RfbWlwaV9jc2kyX2luaXQoY3NpMl9kZXYpOworCisJcmV0dXJuIDA7CisKK2Vycm9yX2Nsa19t aXBpOgorCWNsa19kaXNhYmxlX3VucHJlcGFyZShjc2kyX2Rldi0+Y2xrX21pcGkpOworCitlcnJv cl9jbGtfbW9kOgorCWNsa19kaXNhYmxlX3VucHJlcGFyZShjc2kyX2Rldi0+Y2xrX21vZCk7CisK K2Vycm9yX2Nsa19idXM6CisJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGNzaTJfZGV2LT5jbGtfYnVz KTsKKworZXJyb3JfcmVzZXQ6CisJcmVzZXRfY29udHJvbF9hc3NlcnQoY3NpMl9kZXYtPnJlc2V0 KTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZGV2X3BtX29wcyBz dW44aV9hODN0X21pcGlfY3NpMl9wbV9vcHMgPSB7CisJU0VUX1JVTlRJTUVfUE1fT1BTKHN1bjhp X2E4M3RfbWlwaV9jc2kyX3N1c3BlbmQsCisJCQkgICBzdW44aV9hODN0X21pcGlfY3NpMl9yZXN1 bWUsIE5VTEwpCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IHJlZ21hcF9jb25maWcgc3VuOGlf YTgzdF9taXBpX2NzaTJfcmVnbWFwX2NvbmZpZyA9IHsKKwkucmVnX2JpdHMgICAgICAgPSAzMiwK KwkucmVnX3N0cmlkZSAgICAgPSA0LAorCS52YWxfYml0cyAgICAgICA9IDMyLAorCS5tYXhfcmVn aXN0ZXIJPSAweDEyMCwKK307CisKK3N0YXRpYyBpbnQKK3N1bjhpX2E4M3RfbWlwaV9jc2kyX3Jl c291cmNlc19zZXR1cChzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJfZGV2aWNlICpjc2kyX2Rl diwKKwkJCQkgICAgIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBsYXRmb3JtX2RldikKK3sKKwlz dHJ1Y3QgZGV2aWNlICpkZXYgPSBjc2kyX2Rldi0+ZGV2OworCXN0cnVjdCByZXNvdXJjZSAqcmVz OworCXZvaWQgX19pb21lbSAqaW9fYmFzZTsKKwlpbnQgcmV0OworCisJLyogUmVnaXN0ZXJzICov CisKKwlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2UocGxhdGZvcm1fZGV2LCBJT1JFU09VUkNF X01FTSwgMCk7CisJaW9fYmFzZSA9IGRldm1faW9yZW1hcF9yZXNvdXJjZShkZXYsIHJlcyk7CisJ aWYgKElTX0VSUihpb19iYXNlKSkKKwkJcmV0dXJuIFBUUl9FUlIoaW9fYmFzZSk7CisKKwljc2ky X2Rldi0+cmVnbWFwID0KKwkJZGV2bV9yZWdtYXBfaW5pdF9tbWlvKGRldiwgaW9fYmFzZSwKKwkJ CQkgICAgICAmc3VuOGlfYTgzdF9taXBpX2NzaTJfcmVnbWFwX2NvbmZpZyk7CisJaWYgKElTX0VS Uihjc2kyX2Rldi0+cmVnbWFwKSkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBpbml0IHJl Z2lzdGVyIG1hcFxuIik7CisJCXJldHVybiBQVFJfRVJSKGNzaTJfZGV2LT5yZWdtYXApOworCX0K KworCS8qIENsb2NrcyAqLworCisJY3NpMl9kZXYtPmNsa19idXMgPSBkZXZtX2Nsa19nZXQoZGV2 LCAiYnVzIik7CisJaWYgKElTX0VSUihjc2kyX2Rldi0+Y2xrX2J1cykpIHsKKwkJZGV2X2Vycihk ZXYsICJmYWlsZWQgdG8gYWNxdWlyZSBidXMgY2xvY2tcbiIpOworCQlyZXR1cm4gUFRSX0VSUihj c2kyX2Rldi0+Y2xrX2J1cyk7CisJfQorCisJY3NpMl9kZXYtPmNsa19tb2QgPSBkZXZtX2Nsa19n ZXQoZGV2LCAibW9kIik7CisJaWYgKElTX0VSUihjc2kyX2Rldi0+Y2xrX21vZCkpIHsKKwkJZGV2 X2VycihkZXYsICJmYWlsZWQgdG8gYWNxdWlyZSBtb2QgY2xvY2tcbiIpOworCQlyZXR1cm4gUFRS X0VSUihjc2kyX2Rldi0+Y2xrX21vZCk7CisJfQorCisJcmV0ID0gY2xrX3NldF9yYXRlX2V4Y2x1 c2l2ZShjc2kyX2Rldi0+Y2xrX21vZCwgMjk3MDAwMDAwKTsKKwlpZiAocmV0KSB7CisJCWRldl9l cnIoZGV2LCAiZmFpbGVkIHRvIHNldCBtb2QgY2xvY2sgcmF0ZVxuIik7CisJCXJldHVybiByZXQ7 CisJfQorCisJY3NpMl9kZXYtPmNsa19taXBpID0gZGV2bV9jbGtfZ2V0KGRldiwgIm1pcGkiKTsK KwlpZiAoSVNfRVJSKGNzaTJfZGV2LT5jbGtfbWlwaSkpIHsKKwkJZGV2X2VycihkZXYsICJmYWls ZWQgdG8gYWNxdWlyZSBtaXBpIGNsb2NrXG4iKTsKKwkJcmV0dXJuIFBUUl9FUlIoY3NpMl9kZXYt PmNsa19taXBpKTsKKwl9CisKKwljc2kyX2Rldi0+Y2xrX21pc2MgPSBkZXZtX2Nsa19nZXQoZGV2 LCAibWlzYyIpOworCWlmIChJU19FUlIoY3NpMl9kZXYtPmNsa19taXNjKSkgeworCQlkZXZfZXJy KGRldiwgImZhaWxlZCB0byBhY3F1aXJlIG1pc2MgY2xvY2tcbiIpOworCQlyZXR1cm4gUFRSX0VS Uihjc2kyX2Rldi0+Y2xrX21pc2MpOworCX0KKworCS8qIFJlc2V0ICovCisKKwljc2kyX2Rldi0+ cmVzZXQgPSBkZXZtX3Jlc2V0X2NvbnRyb2xfZ2V0X3NoYXJlZChkZXYsIE5VTEwpOworCWlmIChJ U19FUlIoY3NpMl9kZXYtPnJlc2V0KSkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBnZXQg cmVzZXQgY29udHJvbGxlclxuIik7CisJCXJldHVybiBQVFJfRVJSKGNzaTJfZGV2LT5yZXNldCk7 CisJfQorCisJLyogRC1QSFkgKi8KKworCXJldCA9IHN1bjhpX2E4M3RfZHBoeV9yZWdpc3Rlcihj c2kyX2Rldik7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBpbml0aWFs aXplIE1JUEkgRC1QSFlcbiIpOworCQlyZXR1cm4gcmV0OworCX0KKworCS8qIFJ1bnRpbWUgUE0g Ki8KKworCXBtX3J1bnRpbWVfZW5hYmxlKGRldik7CisJcG1fcnVudGltZV9zZXRfc3VzcGVuZGVk KGRldik7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQKK3N1bjhpX2E4M3RfbWlwaV9j c2kyX3Jlc291cmNlc19jbGVhbnVwKHN0cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZpY2Ug KmNzaTJfZGV2KQoreworCXBtX3J1bnRpbWVfZGlzYWJsZShjc2kyX2Rldi0+ZGV2KTsKKwlwaHlf ZXhpdChjc2kyX2Rldi0+ZHBoeSk7CisJY2xrX3JhdGVfZXhjbHVzaXZlX3B1dChjc2kyX2Rldi0+ Y2xrX21vZCk7Cit9CisKK3N0YXRpYyBpbnQgc3VuOGlfYTgzdF9taXBpX2NzaTJfcHJvYmUoc3Ry dWN0IHBsYXRmb3JtX2RldmljZSAqcGxhdGZvcm1fZGV2KQoreworCXN0cnVjdCBzdW44aV9hODN0 X21pcGlfY3NpMl9kZXZpY2UgKmNzaTJfZGV2OworCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZwbGF0 Zm9ybV9kZXYtPmRldjsKKwlpbnQgcmV0OworCisJY3NpMl9kZXYgPSBkZXZtX2t6YWxsb2MoZGV2 LCBzaXplb2YoKmNzaTJfZGV2KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFjc2kyX2RldikKKwkJcmV0 dXJuIC1FTk9NRU07CisKKwljc2kyX2Rldi0+ZGV2ID0gZGV2OworCXBsYXRmb3JtX3NldF9kcnZk YXRhKHBsYXRmb3JtX2RldiwgY3NpMl9kZXYpOworCisJcmV0ID0gc3VuOGlfYTgzdF9taXBpX2Nz aTJfcmVzb3VyY2VzX3NldHVwKGNzaTJfZGV2LCBwbGF0Zm9ybV9kZXYpOworCWlmIChyZXQpCisJ CXJldHVybiByZXQ7CisKKwlyZXQgPSBzdW44aV9hODN0X21pcGlfY3NpMl9icmlkZ2Vfc2V0dXAo Y3NpMl9kZXYpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIGludCBzdW44aV9hODN0X21pcGlfY3NpMl9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGxhdGZvcm1fZGV2KQoreworCXN0cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9kZXZp Y2UgKmNzaTJfZGV2ID0KKwkJcGxhdGZvcm1fZ2V0X2RydmRhdGEocGxhdGZvcm1fZGV2KTsKKwor CXN1bjhpX2E4M3RfbWlwaV9jc2kyX2JyaWRnZV9jbGVhbnVwKGNzaTJfZGV2KTsKKwlzdW44aV9h ODN0X21pcGlfY3NpMl9yZXNvdXJjZXNfY2xlYW51cChjc2kyX2Rldik7CisKKwlyZXR1cm4gMDsK K30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgc3VuOGlfYTgzdF9taXBpX2Nz aTJfb2ZfbWF0Y2hbXSA9IHsKKwl7IC5jb21wYXRpYmxlID0gImFsbHdpbm5lcixzdW44aS1hODN0 LW1pcGktY3NpMiIgfSwKKwl7fSwKK307CitNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBzdW44aV9h ODN0X21pcGlfY3NpMl9vZl9tYXRjaCk7CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVy IHN1bjhpX2E4M3RfbWlwaV9jc2kyX3BsYXRmb3JtX2RyaXZlciA9IHsKKwkucHJvYmUgPSBzdW44 aV9hODN0X21pcGlfY3NpMl9wcm9iZSwKKwkucmVtb3ZlID0gc3VuOGlfYTgzdF9taXBpX2NzaTJf cmVtb3ZlLAorCS5kcml2ZXIgPSB7CisJCS5uYW1lID0gU1VOOElfQTgzVF9NSVBJX0NTSTJfTkFN RSwKKwkJLm9mX21hdGNoX3RhYmxlID0gb2ZfbWF0Y2hfcHRyKHN1bjhpX2E4M3RfbWlwaV9jc2ky X29mX21hdGNoKSwKKwkJLnBtID0gJnN1bjhpX2E4M3RfbWlwaV9jc2kyX3BtX29wcywKKwl9LAor fTsKK21vZHVsZV9wbGF0Zm9ybV9kcml2ZXIoc3VuOGlfYTgzdF9taXBpX2NzaTJfcGxhdGZvcm1f ZHJpdmVyKTsKKworTU9EVUxFX0RFU0NSSVBUSU9OKCJBbGx3aW5uZXIgQTgzVCBNSVBJIENTSS0y IGFuZCBELVBIWSBDb250cm9sbGVyIERyaXZlciIpOworTU9EVUxFX0FVVEhPUigiUGF1bCBLb2Np YWxrb3dza2kgPHBhdWwua29jaWFsa293c2tpQGJvb3RsaW4uY29tPiIpOworTU9EVUxFX0xJQ0VO U0UoIkdQTCIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44 aS1hODN0LW1pcGktY3NpMi9zdW44aV9hODN0X21pcGlfY3NpMi5oIGIvZHJpdmVycy9tZWRpYS9w bGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9zdW44aV9hODN0X21pcGlfY3NpMi5o Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMTgzZjQyMzM5YzU3Ci0t LSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0 LW1pcGktY3NpMi9zdW44aV9hODN0X21pcGlfY3NpMi5oCkBAIC0wLDAgKzEsNTUgQEAKKy8qIFNQ RFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKyAqLworLyoKKyAqIENvcHlyaWdodCAyMDIw IEvDqXZpbiBMJ2jDtHBpdGFsIDxrZXZpbi5saG9waXRhbEBib290bGluLmNvbT4KKyAqIENvcHly aWdodCAyMDIwIEJvb3RsaW4KKyAqIEF1dGhvcjogUGF1bCBLb2NpYWxrb3dza2kgPHBhdWwua29j aWFsa293c2tpQGJvb3RsaW4uY29tPgorICovCisKKyNpZm5kZWYgX1NVTjhJX0E4M1RfTUlQSV9D U0kyX0hfCisjZGVmaW5lIF9TVU44SV9BODNUX01JUElfQ1NJMl9IXworCisjaW5jbHVkZSA8bGlu dXgvcGh5L3BoeS5oPgorI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgorI2luY2x1ZGUgPGxpbnV4 L3Jlc2V0Lmg+CisjaW5jbHVkZSA8bWVkaWEvdjRsMi1kZXZpY2UuaD4KKyNpbmNsdWRlIDxtZWRp YS92NGwyLWZ3bm9kZS5oPgorCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX05BTUUJInN1 bjhpLWE4M3QtbWlwaS1jc2kyIgorCitlbnVtIHN1bjhpX2E4M3RfbWlwaV9jc2kyX3BhZCB7CisJ U1VOOElfQTgzVF9NSVBJX0NTSTJfUEFEX1NJTksJPSAwLAorCVNVTjhJX0E4M1RfTUlQSV9DU0ky X1BBRF9TT1VSQ0UJPSAxLAorCVNVTjhJX0E4M1RfTUlQSV9DU0kyX1BBRF9DT1VOVAk9IDIsCit9 OworCitzdHJ1Y3Qgc3VuOGlfYTgzdF9taXBpX2NzaTJfZm9ybWF0IHsKKwl1MzIJbWJ1c19jb2Rl OworCXU4CWRhdGFfdHlwZTsKKwl1MzIJYnBwOworfTsKKworc3RydWN0IHN1bjhpX2E4M3RfbWlw aV9jc2kyX2JyaWRnZSB7CisJc3RydWN0IHY0bDJfc3ViZGV2CQlzdWJkZXY7CisJc3RydWN0IG1l ZGlhX3BhZAkJcGFkc1tTVU44SV9BODNUX01JUElfQ1NJMl9QQURfQ09VTlRdOworCXN0cnVjdCB2 NGwyX2Z3bm9kZV9lbmRwb2ludAllbmRwb2ludDsKKwlzdHJ1Y3QgdjRsMl9hc3luY19ub3RpZmll cglub3RpZmllcjsKKwlzdHJ1Y3QgdjRsMl9tYnVzX2ZyYW1lZm10CW1idXNfZm9ybWF0OworCisJ c3RydWN0IHY0bDJfc3ViZGV2CQkqc291cmNlX3N1YmRldjsKK307CisKK3N0cnVjdCBzdW44aV9h ODN0X21pcGlfY3NpMl9kZXZpY2UgeworCXN0cnVjdCBkZXZpY2UJCQkJKmRldjsKKworCXN0cnVj dCByZWdtYXAJCQkJKnJlZ21hcDsKKwlzdHJ1Y3QgY2xrCQkJCSpjbGtfYnVzOworCXN0cnVjdCBj bGsJCQkJKmNsa19tb2Q7CisJc3RydWN0IGNsawkJCQkqY2xrX21pcGk7CisJc3RydWN0IGNsawkJ CQkqY2xrX21pc2M7CisJc3RydWN0IHJlc2V0X2NvbnRyb2wJCQkqcmVzZXQ7CisJc3RydWN0IHBo eQkJCQkqZHBoeTsKKworCXN0cnVjdCBzdW44aV9hODN0X21pcGlfY3NpMl9icmlkZ2UJYnJpZGdl OworfTsKKworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhp L3N1bjhpLWE4M3QtbWlwaS1jc2kyL3N1bjhpX2E4M3RfbWlwaV9jc2kyX3JlZy5oIGIvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW44aS1hODN0LW1pcGktY3NpMi9zdW44aV9hODN0X21p cGlfY3NpMl9yZWcuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmYz MzE3YmQ4YWQyNAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3Vu eGkvc3VuOGktYTgzdC1taXBpLWNzaTIvc3VuOGlfYTgzdF9taXBpX2NzaTJfcmVnLmgKQEAgLTAs MCArMSwxNTcgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKyAqLworLyoK KyAqIENvcHlyaWdodCAyMDIwIEvDqXZpbiBMJ2jDtHBpdGFsIDxrZXZpbi5saG9waXRhbEBib290 bGluLmNvbT4KKyAqIENvcHlyaWdodCAyMDIwLTIwMjEgQm9vdGxpbgorICogQXV0aG9yOiBQYXVs IEtvY2lhbGtvd3NraSA8cGF1bC5rb2NpYWxrb3dza2lAYm9vdGxpbi5jb20+CisgKi8KKworI2lm bmRlZiBfU1VOOElfQTgzVF9NSVBJX0NTSTJfUkVHX0hfCisjZGVmaW5lIF9TVU44SV9BODNUX01J UElfQ1NJMl9SRUdfSF8KKworI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9WRVJTSU9OX1JF RwkJCTB4MAorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9DVFJMX1JFRwkJCQkweDQKKyNk ZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ1RSTF9JTklUX1ZBTFVFCQkJMHhiOGMzOWJlYwor I2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9DVFJMX1JFU0VUX04JCQlCSVQoMzEpCisjZGVm aW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX1JYX1BLVF9OVU1fUkVHCQkJMHg4CisjZGVmaW5lIFNV TjhJX0E4M1RfTUlQSV9DU0kyX1JYX1BLVF9OVU1fSU5JVF9WQUxVRQkJMHhiOGQyNTdmOAorI2Rl ZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9SU1ZEMF9SRUcJCQkJMHhjCisKKyNkZWZpbmUgU1VO OElfQTgzVF9NSVBJX0NTSTJfUlNWRDFfUkVHCQkJCTB4MTgKKyNkZWZpbmUgU1VOOElfQTgzVF9N SVBJX0NTSTJfUlNWRDFfSFdfTE9DS19WQUxVRQkJMHhiOGM4YTMwYworI2RlZmluZSBTVU44SV9B ODNUX01JUElfQ1NJMl9SU1ZEMl9SRUcJCQkJMHgxYworI2RlZmluZSBTVU44SV9BODNUX01JUElf Q1NJMl9SU1ZEMl9IV19MT0NLX1ZBTFVFCQkweGI4ZGY4YWQ3CisjZGVmaW5lIFNVTjhJX0E4M1Rf TUlQSV9DU0kyX0lOVF9TVEEwX1JFRwkJCTB4MjAKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NT STJfSU5UX1NUQTBfRUNDX0VSUl9EQkwJCUJJVCgyOCkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJ X0NTSTJfSU5UX1NUQTBfTElORV9DS1NNX0VSUl9WQzMJCUJJVCgyNykKKyNkZWZpbmUgU1VOOElf QTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfTElORV9DS1NNX0VSUl9WQzIJCUJJVCgyNikKKyNkZWZp bmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfTElORV9DS1NNX0VSUl9WQzEJCUJJVCgy NSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfTElORV9DS1NNX0VSUl9W QzAJCUJJVCgyNCkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfTElORV9T RVFfRVJSX0RUMwkJQklUKDIzKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RB MF9MSU5FX1NFUV9FUlJfRFQyCQlCSVQoMjIpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0ky X0lOVF9TVEEwX0xJTkVfU0VRX0VSUl9EVDEJCUJJVCgyMSkKKyNkZWZpbmUgU1VOOElfQTgzVF9N SVBJX0NTSTJfSU5UX1NUQTBfTElORV9TRVFfRVJSX0RUMAkJQklUKDIwKQorI2RlZmluZSBTVU44 SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMF9MU19MRV9FUlJfRFQzCQlCSVQoMTkpCisjZGVmaW5l IFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX0xTX0xFX0VSUl9EVDIJCUJJVCgxOCkKKyNk ZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfTFNfTEVfRVJSX0RUMQkJQklUKDE3 KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMF9MU19MRV9FUlJfRFQwCQlC SVQoMTYpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX0NSQ19FUlJfVkMz CQlCSVQoMTUpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX0NSQ19FUlJf VkMyCQlCSVQoMTQpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX0NSQ19F UlJfVkMxCQlCSVQoMTMpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX0NS Q19FUlJfVkMwCQlCSVQoMTIpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEw X0ZSTV9TRVFfRVJSX1ZDMwkJQklUKDExKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9J TlRfU1RBMF9GUk1fU0VRX0VSUl9WQzIJCUJJVCgxMCkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJ X0NTSTJfSU5UX1NUQTBfRlJNX1NFUV9FUlJfVkMxCQlCSVQoOSkKKyNkZWZpbmUgU1VOOElfQTgz VF9NSVBJX0NTSTJfSU5UX1NUQTBfRlJNX1NFUV9FUlJfVkMwCQlCSVQoOCkKKyNkZWZpbmUgU1VO OElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfRlNfRkVfRVJSX1ZDMwkJQklUKDcpCisjZGVmaW5l IFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX0ZTX0ZFX0VSUl9WQzIJCUJJVCg2KQorI2Rl ZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMF9GU19GRV9FUlJfVkMxCQlCSVQoNSkK KyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfRlNfRkVfRVJSX1ZDMAkJQklU KDQpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEwX1NPVF9TWU5DX0VSUl8z CQlCSVQoMykKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTBfU09UX1NZTkNf RVJSXzIJCUJJVCgyKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMF9TT1Rf U1lOQ19FUlJfMQkJQklUKDEpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEEw X1NPVF9TWU5DX0VSUl8wCQlCSVQoMCkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5U X1NUQTFfUkVHCQkJMHgyNAorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMV9M SU5FX1NFUV9FUlJfRFQ3CQlCSVQoMjMpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lO VF9TVEExX0xJTkVfU0VRX0VSUl9EVDYJCUJJVCgyMikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJ X0NTSTJfSU5UX1NUQTFfTElORV9TRVFfRVJSX0RUNQkJQklUKDIxKQorI2RlZmluZSBTVU44SV9B ODNUX01JUElfQ1NJMl9JTlRfU1RBMV9MSU5FX1NFUV9FUlJfRFQ0CQlCSVQoMjApCisjZGVmaW5l IFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEExX0xTX0xFX0VSUl9EVDcJCUJJVCgxOSkKKyNk ZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTFfTFNfTEVfRVJSX0RUNgkJQklUKDE4 KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMV9MU19MRV9FUlJfRFQ1CQlC SVQoMTcpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEExX0xTX0xFX0VSUl9E VDQJCUJJVCgxNikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTFfRFRfRVJS X1ZDMwkJQklUKDE1KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMV9EVF9F UlJfVkMyCQlCSVQoMTQpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9TVEExX0RU X0VSUl9WQzEJCUJJVCgxMykKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX1NUQTFf RFRfRVJSX1ZDMAkJQklUKDEyKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RB MV9FQ0NfRVJSMV9WQzMJCUJJVCgxMSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5U X1NUQTFfRUNDX0VSUjFfVkMyCQlCSVQoMTApCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0ky X0lOVF9TVEExX0VDQ19FUlIxX1ZDMQkJQklUKDkpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9D U0kyX0lOVF9TVEExX0VDQ19FUlIxX1ZDMAkJQklUKDgpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQ SV9DU0kyX0lOVF9TVEExX1NPVF9FUlJfMwkJCUJJVCg3KQorI2RlZmluZSBTVU44SV9BODNUX01J UElfQ1NJMl9JTlRfU1RBMV9TT1RfRVJSXzIJCQlCSVQoNikKKyNkZWZpbmUgU1VOOElfQTgzVF9N SVBJX0NTSTJfSU5UX1NUQTFfU09UX0VSUl8xCQkJQklUKDUpCisjZGVmaW5lIFNVTjhJX0E4M1Rf TUlQSV9DU0kyX0lOVF9TVEExX1NPVF9FUlJfMAkJCUJJVCg0KQorI2RlZmluZSBTVU44SV9BODNU X01JUElfQ1NJMl9JTlRfU1RBMV9FU0NfRU5UUllfRVJSXzMJCUJJVCgzKQorI2RlZmluZSBTVU44 SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMV9FU0NfRU5UUllfRVJSXzIJCUJJVCgyKQorI2RlZmlu ZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMV9FU0NfRU5UUllfRVJSXzEJCUJJVCgxKQor I2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfU1RBMV9FU0NfRU5UUllfRVJSXzAJCUJJ VCgwKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9SRUcJCQkweDI4Cisj ZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0swX0VDQ19FUlJfREJMCQlCSVQoMjgp CisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0swX0NLU01fRVJSX1ZDMwkJQklU KDI3KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9DS1NNX0VSUl9WQzIJ CUJJVCgyNikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBfQ0tTTV9FUlJf VkMxCQlCSVQoMjUpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0swX0NLU01f RVJSX1ZDMAkJQklUKDI0KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9M SU5FX1NFUV9FUlJfRFQzCQlCSVQoMjMpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lO VF9NU0swX0xJTkVfU0VRX0VSUl9EVDIJCUJJVCgyMikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJ X0NTSTJfSU5UX01TSzBfTElORV9TRVFfRVJSX0RUMQkJQklUKDIxKQorI2RlZmluZSBTVU44SV9B ODNUX01JUElfQ1NJMl9JTlRfTVNLMF9MSU5FX1NFUV9FUlJfRFQwCQlCSVQoMjApCisjZGVmaW5l IFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0swX0xTX0xFX0VSUl9EVDMJCUJJVCgxOSkKKyNk ZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBfTFNfTEVfRVJSX0RUMgkJQklUKDE4 KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9MU19MRV9FUlJfRFQxCQlC SVQoMTcpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0swX0xTX0xFX0VSUl9E VDAJCUJJVCgxNikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBfQ1JDX0VS Ul9WQzMJCUJJVCgxNSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBfQ1JD X0VSUl9WQzIJCUJJVCgxNCkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBf Q1JDX0VSUl9WQzEJCUJJVCgxMykKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01T SzBfQ1JDX0VSUl9WQzAJCUJJVCgxMikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5U X01TSzBfRlJNX1NFUV9FUlJfVkMzCQlCSVQoMTEpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9D U0kyX0lOVF9NU0swX0ZSTV9TRVFfRVJSX1ZDMgkJQklUKDEwKQorI2RlZmluZSBTVU44SV9BODNU X01JUElfQ1NJMl9JTlRfTVNLMF9GUk1fU0VRX0VSUl9WQzEJCUJJVCg5KQorI2RlZmluZSBTVU44 SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9GUk1fU0VRX0VSUl9WQzAJCUJJVCg4KQorI2RlZmlu ZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9GU19GRV9FUlJfVkMzCQlCSVQoNykKKyNk ZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBfRlNfRkVfRVJSX1ZDMgkJQklUKDYp CisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0swX0ZTX0ZFX0VSUl9WQzEJCUJJ VCg1KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9GU19GRV9FUlJfVkMw CQlCSVQoNCkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzBfU09UX1NZTkNf RVJSXzMJCUJJVCgzKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMF9TT1Rf U1lOQ19FUlJfMgkJQklUKDIpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0sw X1NPVF9TWU5DX0VSUl8xCQlCSVQoMSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5U X01TSzBfU09UX1NZTkNfRVJSXzAJCUJJVCgwKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJ Ml9JTlRfTVNLMV9SRUcJCQkweDJjCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9N U0sxX0RUX0VSUl9WQzMJCUJJVCgxNSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5U X01TSzFfRFRfRVJSX1ZDMgkJQklUKDE0KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9J TlRfTVNLMV9EVF9FUlJfVkMxCQlCSVQoMTMpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0ky X0lOVF9NU0sxX0RUX0VSUl9WQzAJCUJJVCgxMikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NT STJfSU5UX01TSzFfRUNDX0VSUjFfVkMzCQlCSVQoMTEpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQ SV9DU0kyX0lOVF9NU0sxX0VDQ19FUlIxX1ZDMgkJQklUKDEwKQorI2RlZmluZSBTVU44SV9BODNU X01JUElfQ1NJMl9JTlRfTVNLMV9FQ0NfRVJSMV9WQzEJCUJJVCg5KQorI2RlZmluZSBTVU44SV9B ODNUX01JUElfQ1NJMl9JTlRfTVNLMV9FQ0NfRVJSMV9WQzAJCUJJVCg4KQorI2RlZmluZSBTVU44 SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMV9TT1RfRVJSXzMJCQlCSVQoNykKKyNkZWZpbmUgU1VO OElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzFfU09UX0VSUl8yCQkJQklUKDYpCisjZGVmaW5lIFNV TjhJX0E4M1RfTUlQSV9DU0kyX0lOVF9NU0sxX1NPVF9FUlJfMQkJCUJJVCg1KQorI2RlZmluZSBT VU44SV9BODNUX01JUElfQ1NJMl9JTlRfTVNLMV9TT1RfRVJSXzAJCQlCSVQoNCkKKyNkZWZpbmUg U1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzFfRVNDX0VOVFJZX0VSUl8zCQlCSVQoMykKKyNk ZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzFfRVNDX0VOVFJZX0VSUl8yCQlCSVQo MikKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzFfRVNDX0VOVFJZX0VSUl8x CQlCSVQoMSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfSU5UX01TSzFfRVNDX0VOVFJZ X0VSUl8wCQlCSVQoMCkKKworI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfUkVHCQkJ CTB4MTAwCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0NGR19JTklUX1ZBTFVFCQkJMHhi OGM2NGYyNAorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfU1lOQ19FTgkJCUJJVCgz MSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ0ZHX0JZUEFTU19FQ0NfRU4JCQlCSVQo MjkpCisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0NGR19VTlBLVF9FTgkJCUJJVCgyOCkK KyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ0ZHX05PTkVfVU5QS1RfUlhfTU9ERQkJQklU KDI3KQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfWUNfU1dBQgkJCUJJVCgyNikK KyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJfQ0ZHX05fQllURQkJCQlCSVQoMjQpCisjZGVm aW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX0NGR19TWU5DX0RMWV9DWUNMRSh2KQkJKCgodikgPDwg MTgpICYgXAorCQkJCQkJCQkgR0VOTUFTSygyMiwgMTgpKQorI2RlZmluZSBTVU44SV9BODNUX01J UElfQ1NJMl9DRkdfTl9DSEFOTkVMKHYpCQkJKCgoKHYpIC0gMSkgPDwgMTYpICYgXAorCQkJCQkJ CQkgR0VOTUFTSygxNywgMTYpKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9DRkdfTl9M QU5FKHYpCQkJKCgoKHYpIC0gMSkgPDwgNCkgJiBcCisJCQkJCQkJCSBHRU5NQVNLKDUsIDQpKQor I2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9WQ0RUMF9SRUcJCQkJMHgxMDQKKyNkZWZpbmUg U1VOOElfQTgzVF9NSVBJX0NTSTJfVkNEVDBfQ0hfVkMoY2gsIHZjKQkJKCgodmMpICYgR0VOTUFT SygxLCAwKSkgPDwgXAorCQkJCQkJCQkgKChjaCkgKiA4ICsgNikpCisjZGVmaW5lIFNVTjhJX0E4 M1RfTUlQSV9DU0kyX1ZDRFQwX0NIX0RUKGNoLCB0KQkJCSgoKHQpICYgR0VOTUFTSyg1LCAwKSkg PDwgXAorCQkJCQkJCQkgKChjaCkgKiA4KSkKKyNkZWZpbmUgU1VOOElfQTgzVF9NSVBJX0NTSTJf VkNEVDFfUkVHCQkJCTB4MTA4CisjZGVmaW5lIFNVTjhJX0E4M1RfTUlQSV9DU0kyX1ZDRFQxX0NI X1ZDKGNoLCB2YykJCSgoKHZjKSAmIEdFTk1BU0soMSwgMCkpIDw8IFwKKwkJCQkJCQkJICgoKGNo KSAtIDQpICogOCArIDYpKQorI2RlZmluZSBTVU44SV9BODNUX01JUElfQ1NJMl9WQ0RUMV9DSF9E VChjaCwgdCkJCQkoKCh0KSAmIEdFTk1BU0soNSwgMCkpIDw8IFwKKwkJCQkJCQkJICgoKGNoKSAt IDQpICogOCkpCisKK2VudW0gbWlwaV9jc2kyX2RhdGFfdHlwZSB7CisJTUlQSV9DU0kyX0RBVEFf VFlQRV9SQVc4CT0gMHgyYSwKKwlNSVBJX0NTSTJfREFUQV9UWVBFX1JBVzEwCT0gMHgyYiwKKwlN SVBJX0NTSTJfREFUQV9UWVBFX1JBVzEyCT0gMHgyYywKK307CisKKyNlbmRpZgotLSAKMi4zMi4w CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgt YXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQu b3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJt LWtlcm5lbAo=