From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 44EEAC433FE for ; Wed, 13 Apr 2022 08:32:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229744AbiDMIeu (ORCPT ); Wed, 13 Apr 2022 04:34:50 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38710 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233833AbiDMIet (ORCPT ); Wed, 13 Apr 2022 04:34:49 -0400 Received: from mail-wr1-x433.google.com (mail-wr1-x433.google.com [IPv6:2a00:1450:4864:20::433]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B4E2B4AE0B for ; Wed, 13 Apr 2022 01:32:26 -0700 (PDT) Received: by mail-wr1-x433.google.com with SMTP id q3so870981wrj.7 for ; Wed, 13 Apr 2022 01:32:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to; bh=43L4Fo1VTg4iHrSwnBG558ytJYsFKrb6ExWD6ZDsMak=; b=KG6a9NYqPhTPLeRQWj7HFdFz0SVMQgvtCq9jhHPw0ijLyeLHMPpL6P66acaHSk1da1 WQ7MbIycSEDhN0RdU8Lc/7jCq0LD5g76SIPX49y48OYMupEz5UgFBI2RcrxXLUuhetCs cjAxq3OQ+trQSFj4zI5AHi2Eh+nIfLqDP6jgzHrXG15oObfPNn9KdO9ITMmLFflV5UnR V7s0OqBlRhRfO47q0OVKdLqStMhNFAD0vO99+DVNSLtyG1uFXkaRzah1KU7PC6Rdlami AbzEyOTjmPlkO/ewRJWE8qACRDqzJuhZEDR70Z1dbiYPmIZ9z5kVltilHNvmu8nK4cr9 Ehug== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to; bh=43L4Fo1VTg4iHrSwnBG558ytJYsFKrb6ExWD6ZDsMak=; b=OwyyAUgr/1w+y5ULP9kEhSU07MpxzrhJV3apSpxGNQoGPUO4SomkKwvg4UQJodEAqt cYfYV8b5dyk68zWOcTDbH/QXJaUh5izRJWvdj55DYTI1ITMMQKP6rZIDqK9viaD938PP 9Nx4wHKmYqhQkyszcvT24QA+t06B+z2SYx76urdqxPWRN19h+exzTyUOUdV2l2FNkTQQ eXPtToLrYQBKDf0y0dZFSWW8UFCl2LKcgOXQU6J4l5I49CaIiXgn6j4G/GOMCwBae1yg LEnJnwpQOKRF56f/FuA8a3aS5qZOofdOcs1cRX/sO0b3Ilk9uRmvMTWQmgQ2403FXDnd naIA== X-Gm-Message-State: AOAM531qjYYhQUN8H4RJhSnXVpLNW+SjM6pQoG/j8TtWsTOvZpxnzLn/ 6SPMZ3SdfqFA6BSt2g66LH/GMg== X-Google-Smtp-Source: ABdhPJyb4o/u7q7PWqlOyrGHkM8DDEqRl9AmtylLWkEJrmLmDjLt1mvEGrxMMUOQ6KZKokIhuDpJ5w== X-Received: by 2002:a5d:44d0:0:b0:207:9ac8:2c3b with SMTP id z16-20020a5d44d0000000b002079ac82c3bmr18170538wrr.688.1649838745047; Wed, 13 Apr 2022 01:32:25 -0700 (PDT) Received: from google.com (cpc155339-bagu17-2-0-cust87.1-3.cable.virginm.net. [86.27.177.88]) by smtp.gmail.com with ESMTPSA id f9-20020a05600c154900b0038cb98076d6sm1955228wmg.10.2022.04.13.01.32.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Apr 2022 01:32:24 -0700 (PDT) Date: Wed, 13 Apr 2022 09:32:22 +0100 From: Lee Jones To: Colin Foster Cc: linux-arm-kernel@lists.infradead.org, linux-gpio@vger.kernel.org, linux-phy@lists.infradead.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org, "Rafael J. Wysocki" , Marc Zyngier , Hector Martin , Angela Czubak , Steen Hegelund , Lars Povlsen , Linus Walleij , Vinod Koul , Kishon Vijay Abraham I , Russell King , Heiner Kallweit , Jakub Kicinski , "David S. Miller" , Florian Fainelli , Vivien Didelot , Andrew Lunn , UNGLinuxDriver@microchip.com, Alexandre Belloni , Claudiu Manoil , Vladimir Oltean , katie.morris@in-advantage.com Subject: Re: [RFC v7 net-next 10/13] mfd: ocelot: add support for the vsc7512 chip via spi Message-ID: References: <20220307021208.2406741-1-colin.foster@in-advantage.com> <20220307021208.2406741-11-colin.foster@in-advantage.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20220307021208.2406741-11-colin.foster@in-advantage.com> Precedence: bulk List-ID: X-Mailing-List: linux-gpio@vger.kernel.org On Sun, 06 Mar 2022, Colin Foster wrote: > The VSC7512 is a networking chip that contains several peripherals. Many of > these peripherals are currently supported by the VSC7513 and VSC7514 chips, > but those run on an internal CPU. The VSC7512 lacks this CPU, and must be > controlled externally. > > Utilize the existing drivers by referencing the chip as an MFD. Add support > for the two MDIO buses, the internal phys, pinctrl, serial GPIO, and HSIO. > > Signed-off-by: Colin Foster > --- > drivers/mfd/Kconfig | 24 +++ > drivers/mfd/Makefile | 3 + > drivers/mfd/ocelot-core.c | 189 +++++++++++++++++++++++ > drivers/mfd/ocelot-spi.c | 313 ++++++++++++++++++++++++++++++++++++++ > drivers/mfd/ocelot.h | 42 +++++ > include/soc/mscc/ocelot.h | 5 + > 6 files changed, 576 insertions(+) > create mode 100644 drivers/mfd/ocelot-core.c > create mode 100644 drivers/mfd/ocelot-spi.c > create mode 100644 drivers/mfd/ocelot.h > > diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig > index ba0b3eb131f1..d4312a5252d0 100644 > --- a/drivers/mfd/Kconfig > +++ b/drivers/mfd/Kconfig > @@ -948,6 +948,30 @@ config MFD_MENF21BMC > This driver can also be built as a module. If so the module > will be called menf21bmc. > > +config MFD_OCELOT > + tristate "Microsemi Ocelot External Control Support" > + select MFD_CORE > + help > + Ocelot is a family of networking chips that support multiple ethernet > + and fibre interfaces. In addition to networking, they contain several > + other functions, including pictrl, MDIO, and communication with > + external chips. While some chips have an internal processor capable of > + running an OS, others don't. All chips can be controlled externally > + through different interfaces, including SPI, I2C, and PCIe. > + > + Say yes here to add support for Ocelot chips (VSC7511, VSC7512, > + VSC7513, VSC7514) controlled externally. > + > + If unsure, say N > + > +config MFD_OCELOT_SPI > + tristate "Microsemi Ocelot SPI interface" > + depends on MFD_OCELOT > + depends on SPI_MASTER > + select REGMAP_SPI > + help > + Say yes here to add control to the MFD_OCELOT chips via SPI. > + > config EZX_PCAP > bool "Motorola EZXPCAP Support" > depends on SPI_MASTER > diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile > index df1ecc4a4c95..12513843067a 100644 > --- a/drivers/mfd/Makefile > +++ b/drivers/mfd/Makefile > @@ -120,6 +120,9 @@ obj-$(CONFIG_MFD_MC13XXX_I2C) += mc13xxx-i2c.o > > obj-$(CONFIG_MFD_CORE) += mfd-core.o > > +obj-$(CONFIG_MFD_OCELOT) += ocelot-core.o > +obj-$(CONFIG_MFD_OCELOT_SPI) += ocelot-spi.o > + > obj-$(CONFIG_EZX_PCAP) += ezx-pcap.o > obj-$(CONFIG_MFD_CPCAP) += motorola-cpcap.o > > diff --git a/drivers/mfd/ocelot-core.c b/drivers/mfd/ocelot-core.c > new file mode 100644 > index 000000000000..36e4326a853a > --- /dev/null > +++ b/drivers/mfd/ocelot-core.c > @@ -0,0 +1,189 @@ > +// SPDX-License-Identifier: (GPL-2.0 OR MIT) > +/* > + * MFD core driver for the Ocelot chip family. Please drop all references to 'MFD'. 'Core' is fine, as is 'Parent'. > + * The VSC7511, 7512, 7513, and 7514 can be controlled internally via an > + * on-chip MIPS processor, or externally via SPI, I2C, PCIe. This core driver is > + * intended to be the bus-agnostic glue between, for example, the SPI bus and > + * the MFD children. > + * > + * Copyright 2021 Innovative Advantage Inc. Out of date? > + * Author: Colin Foster > + */ > + > +#include > +#include > +#include > +#include > + > +#include > + > +#include "ocelot.h" > + > +#define GCB_SOFT_RST 0x0008 Tab these out to match the others? > +#define SOFT_CHIP_RST 0x1 > + > +#define VSC7512_GCB_RES_START 0x71070000 > +#define VSC7512_GCB_RES_SIZE 0x14 > + > +#define VSC7512_MIIM0_RES_START 0x7107009c > +#define VSC7512_MIIM0_RES_SIZE 0x24 > + > +#define VSC7512_MIIM1_RES_START 0x710700c0 > +#define VSC7512_MIIM1_RES_SIZE 0x24 > + > +#define VSC7512_PHY_RES_START 0x710700f0 > +#define VSC7512_PHY_RES_SIZE 0x4 > + > +#define VSC7512_HSIO_RES_START 0x710d0000 > +#define VSC7512_HSIO_RES_SIZE 0x10000 > + > +#define VSC7512_GPIO_RES_START 0x71070034 > +#define VSC7512_GPIO_RES_SIZE 0x6c > + > +#define VSC7512_SIO_RES_START 0x710700f8 > +#define VSC7512_SIO_RES_SIZE 0x100 > + > +static const struct resource vsc7512_gcb_resource = > + DEFINE_RES_REG_NAMED(VSC7512_GCB_RES_START, VSC7512_GCB_RES_SIZE, > + "devcpu_gcb_chip_regs"); > + > +static int ocelot_reset(struct ocelot_core *core) > +{ > + int ret; > + > + /* > + * Reset the entire chip here to put it into a completely known state. > + * Other drivers may want to reset their own subsystems. The register > + * self-clears, so one write is all that is needed > + */ > + ret = regmap_write(core->gcb_regmap, GCB_SOFT_RST, SOFT_CHIP_RST); > + if (ret) > + return ret; > + > + msleep(100); > + > + return ret; > +} > + > +static struct regmap *ocelot_devm_regmap_init(struct ocelot_core *core, > + struct device *child, > + const struct resource *res) > +{ > + /* > + * Call directly into ocelot_spi to get a new regmap. This will need to > + * be expanded if additional bus types are to be supported in the > + * future. > + */ > + return ocelot_spi_devm_get_regmap(core, child, res); > +} > + > +struct regmap *ocelot_get_regmap_from_resource(struct device *child, > + const struct resource *res) > +{ > + struct ocelot_core *core = dev_get_drvdata(child->parent); > + > + return ocelot_devm_regmap_init(core, child, res); > +} > +EXPORT_SYMBOL(ocelot_get_regmap_from_resource); What's the reason for having an additional function when one would do? > +static const struct resource vsc7512_miim0_resources[] = { > + DEFINE_RES_REG_NAMED(VSC7512_MIIM0_RES_START, VSC7512_MIIM0_RES_SIZE, > + "gcb_miim0"), > + DEFINE_RES_REG_NAMED(VSC7512_PHY_RES_START, VSC7512_PHY_RES_SIZE, > + "gcb_phy"), > +}; > + > +static const struct resource vsc7512_miim1_resources[] = { > + DEFINE_RES_REG_NAMED(VSC7512_MIIM1_RES_START, VSC7512_MIIM1_RES_SIZE, > + "gcb_miim1"), > +}; > + > +static const struct resource vsc7512_hsio_resources[] = { > + DEFINE_RES_REG_NAMED(VSC7512_HSIO_RES_START, VSC7512_HSIO_RES_SIZE, > + "hsio"), > +}; > + > +static const struct resource vsc7512_pinctrl_resources[] = { > + DEFINE_RES_REG_NAMED(VSC7512_GPIO_RES_START, VSC7512_GPIO_RES_SIZE, > + "gcb_gpio"), > +}; > + > +static const struct resource vsc7512_sgpio_resources[] = { > + DEFINE_RES_REG_NAMED(VSC7512_SIO_RES_START, VSC7512_SIO_RES_SIZE, > + "gcb_sio"), > +}; > + > +static const struct mfd_cell vsc7512_devs[] = { > + { > + .name = "ocelot-pinctrl", > + .of_compatible = "mscc,ocelot-pinctrl", > + .num_resources = ARRAY_SIZE(vsc7512_pinctrl_resources), > + .resources = vsc7512_pinctrl_resources, > + }, { > + .name = "ocelot-sgpio", > + .of_compatible = "mscc,ocelot-sgpio", > + .num_resources = ARRAY_SIZE(vsc7512_sgpio_resources), > + .resources = vsc7512_sgpio_resources, > + }, { > + .name = "ocelot-miim0", > + .of_compatible = "mscc,ocelot-miim", > + .num_resources = ARRAY_SIZE(vsc7512_miim0_resources), > + .resources = vsc7512_miim0_resources, > + }, { > + .name = "ocelot-miim1", > + .of_compatible = "mscc,ocelot-miim", > + .num_resources = ARRAY_SIZE(vsc7512_miim1_resources), > + .resources = vsc7512_miim1_resources, > + }, { > + .name = "ocelot-serdes", > + .of_compatible = "mscc,vsc7514-serdes", > + .num_resources = ARRAY_SIZE(vsc7512_hsio_resources), > + .resources = vsc7512_hsio_resources, > + }, > +}; > + > +int ocelot_core_init(struct ocelot_core *core) > +{ > + struct device *dev = core->dev; > + int ret; > + > + dev_set_drvdata(dev, core); > + > + core->gcb_regmap = ocelot_devm_regmap_init(core, dev, > + &vsc7512_gcb_resource); This just ends up calling ocelot_spi_devm_get_regmap() right? Why not call that from inside ocelot-spi.c where 'core' was allocated? > + if (IS_ERR(core->gcb_regmap)) > + return -ENOMEM; > + > + ret = ocelot_reset(core); > + if (ret) { > + dev_err(dev, "Failed to reset device: %d\n", ret); > + return ret; > + } > + > + /* > + * A chip reset will clear the SPI configuration, so it needs to be done > + * again before we can access any registers > + */ > + ret = ocelot_spi_initialize(core); Not a fan of calling back into the file which called us. And what happens if SPI isn't controlling us? Doesn't the documentation above say this device can also be communicated with via I2C and PCIe? > + if (ret) { > + dev_err(dev, "Failed to initialize SPI interface: %d\n", ret); > + return ret; > + } > + > + ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_AUTO, vsc7512_devs, > + ARRAY_SIZE(vsc7512_devs), NULL, 0, NULL); > + if (ret) { > + dev_err(dev, "Failed to add sub-devices: %d\n", ret); > + return ret; > + } > + > + return 0; > +} > +EXPORT_SYMBOL(ocelot_core_init); > + > +MODULE_DESCRIPTION("Externally Controlled Ocelot Chip Driver"); > +MODULE_AUTHOR("Colin Foster "); > +MODULE_LICENSE("GPL v2"); > diff --git a/drivers/mfd/ocelot-spi.c b/drivers/mfd/ocelot-spi.c > new file mode 100644 > index 000000000000..c788e239c9a7 > --- /dev/null > +++ b/drivers/mfd/ocelot-spi.c > @@ -0,0 +1,313 @@ > +// SPDX-License-Identifier: (GPL-2.0 OR MIT) > +/* > + * SPI core driver for the Ocelot chip family. > + * > + * This driver will handle everything necessary to allow for communication over > + * SPI to the VSC7511, VSC7512, VSC7513 and VSC7514 chips. The main functions > + * are to prepare the chip's SPI interface for a specific bus speed, and a host > + * processor's endianness. This will create and distribute regmaps for any MFD As above, please drop references to MFD. > + * children. > + * > + * Copyright 2021 Innovative Advantage Inc. > + * > + * Author: Colin Foster > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > + > +#include "ocelot.h" > + > +#define DEV_CPUORG_IF_CTRL 0x0000 > +#define DEV_CPUORG_IF_CFGSTAT 0x0004 > + > +#define CFGSTAT_IF_NUM_VCORE (0 << 24) > +#define CFGSTAT_IF_NUM_VRAP (1 << 24) > +#define CFGSTAT_IF_NUM_SI (2 << 24) > +#define CFGSTAT_IF_NUM_MIIM (3 << 24) > + > + > +static const struct resource vsc7512_dev_cpuorg_resource = { > + .start = 0x71000000, > + .end = 0x710002ff, No magic numbers. Please define these addresses. > + .name = "devcpu_org", > +}; > + > +#define VSC7512_BYTE_ORDER_LE 0x00000000 > +#define VSC7512_BYTE_ORDER_BE 0x81818181 > +#define VSC7512_BIT_ORDER_MSB 0x00000000 > +#define VSC7512_BIT_ORDER_LSB 0x42424242 > + > +int ocelot_spi_initialize(struct ocelot_core *core) > +{ > + u32 val, check; > + int err; > + > +#ifdef __LITTLE_ENDIAN > + val = VSC7512_BYTE_ORDER_LE; > +#else > + val = VSC7512_BYTE_ORDER_BE; > +#endif Not a fan of ifdefery in the middle of C files. Please create a macro or define somewhere. > + err = regmap_write(core->cpuorg_regmap, DEV_CPUORG_IF_CTRL, val); > + if (err) > + return err; Comment. > + val = core->spi_padding_bytes; > + err = regmap_write(core->cpuorg_regmap, DEV_CPUORG_IF_CFGSTAT, val); > + if (err) > + return err; Comment. > + /* > + * After we write the interface configuration, read it back here. This > + * will verify several different things. The first is that the number of > + * padding bytes actually got written correctly. These are found in bits > + * 0:3. > + * > + * The second is that bit 16 is cleared. Bit 16 is IF_CFGSTAT:IF_STAT, > + * and will be set if the register access is too fast. This would be in > + * the condition that the number of padding bytes is insufficient for > + * the SPI bus frequency. > + * > + * The last check is for bits 31:24, which define the interface by which > + * the registers are being accessed. Since we're accessing them via the > + * serial interface, it must return IF_NUM_SI. > + */ > + check = val | CFGSTAT_IF_NUM_SI; > + > + err = regmap_read(core->cpuorg_regmap, DEV_CPUORG_IF_CFGSTAT, &val); > + if (err) > + return err; > + > + if (check != val) > + return -ENODEV; > + > + return 0; > +} > +EXPORT_SYMBOL(ocelot_spi_initialize); > + > +/* > + * The SPI protocol for interfacing with the ocelot chips uses 24 bits, while > + * the register locations are defined as 32-bit. The least significant two bits > + * get shifted out, as register accesses must always be word-aligned, leaving > + * bits 21:0 as the 22-bit address. It must always be big-endian, whereas the > + * payload can be optimized for bit / byte order to match whatever architecture > + * the controlling CPU has. > + */ > +static unsigned int ocelot_spi_translate_address(unsigned int reg) > +{ > + return cpu_to_be32((reg & 0xffffff) >> 2); > +} > + > +struct ocelot_spi_regmap_context { > + u32 base; > + struct ocelot_core *core; > +}; > + > +static int ocelot_spi_reg_read(void *context, unsigned int reg, > + unsigned int *val) > +{ > + struct ocelot_spi_regmap_context *regmap_context = context; > + struct ocelot_core *core = regmap_context->core; > + struct spi_transfer tx, padding, rx; > + struct spi_message msg; How big are all of these? We will receive warnings if they occupy too much stack space. > + struct spi_device *spi; > + unsigned int addr; > + u8 *tx_buf; > + > + spi = core->spi; > + > + addr = ocelot_spi_translate_address(reg + regmap_context->base); > + tx_buf = (u8 *)&addr; > + > + spi_message_init(&msg); > + > + memset(&tx, 0, sizeof(tx)); > + > + /* Ignore the first byte for the 24-bit address */ > + tx.tx_buf = &tx_buf[1]; > + tx.len = 3; > + > + spi_message_add_tail(&tx, &msg); > + > + if (core->spi_padding_bytes > 0) { > + u8 dummy_buf[16] = {0}; > + > + memset(&padding, 0, sizeof(padding)); > + > + /* Just toggle the clock for padding bytes */ > + padding.len = core->spi_padding_bytes; > + padding.tx_buf = dummy_buf; > + padding.dummy_data = 1; > + > + spi_message_add_tail(&padding, &msg); > + } > + > + memset(&rx, 0, sizeof(rx)); > + rx.rx_buf = val; > + rx.len = 4; > + > + spi_message_add_tail(&rx, &msg); > + > + return spi_sync(spi, &msg); > +} > + > +static int ocelot_spi_reg_write(void *context, unsigned int reg, > + unsigned int val) > +{ > + struct ocelot_spi_regmap_context *regmap_context = context; > + struct ocelot_core *core = regmap_context->core; > + struct spi_transfer tx[2] = {0}; > + struct spi_message msg; > + struct spi_device *spi; > + unsigned int addr; > + u8 *tx_buf; > + > + spi = core->spi; > + > + addr = ocelot_spi_translate_address(reg + regmap_context->base); > + tx_buf = (u8 *)&addr; > + > + spi_message_init(&msg); > + > + /* Ignore the first byte for the 24-bit address and set the write bit */ > + tx_buf[1] |= BIT(7); > + tx[0].tx_buf = &tx_buf[1]; > + tx[0].len = 3; > + > + spi_message_add_tail(&tx[0], &msg); > + > + memset(&tx[1], 0, sizeof(struct spi_transfer)); > + tx[1].tx_buf = &val; > + tx[1].len = 4; > + > + spi_message_add_tail(&tx[1], &msg); > + > + return spi_sync(spi, &msg); > +} > + > +static const struct regmap_config ocelot_spi_regmap_config = { > + .reg_bits = 24, > + .reg_stride = 4, > + .val_bits = 32, > + > + .reg_read = ocelot_spi_reg_read, > + .reg_write = ocelot_spi_reg_write, > + > + .max_register = 0xffffffff, > + .use_single_write = true, > + .use_single_read = true, > + .can_multi_write = false, > + > + .reg_format_endian = REGMAP_ENDIAN_BIG, > + .val_format_endian = REGMAP_ENDIAN_NATIVE, > +}; > + > +struct regmap * > +ocelot_spi_devm_get_regmap(struct ocelot_core *core, struct device *child, > + const struct resource *res) This seems to always initialise a new Regmap. To me 'get' implies that it could fetch an already existing one. ... and *perhaps* init a new one if none exists.. > +{ > + struct ocelot_spi_regmap_context *context; > + struct regmap_config regmap_config; > + > + context = devm_kzalloc(child, sizeof(*context), GFP_KERNEL); > + if (IS_ERR(context)) > + return ERR_CAST(context); > + > + context->base = res->start; > + context->core = core; > + > + memcpy(®map_config, &ocelot_spi_regmap_config, > + sizeof(ocelot_spi_regmap_config)); > + > + regmap_config.name = res->name; > + regmap_config.max_register = res->end - res->start; > + > + return devm_regmap_init(child, NULL, context, ®map_config); > +} > + > +static int ocelot_spi_probe(struct spi_device *spi) > +{ > + struct device *dev = &spi->dev; > + struct ocelot_core *core; This would be more in keeping with current drivers if you dropped the '_core' part of the struct name and called the variable ddata. > + int err; > + > + core = devm_kzalloc(dev, sizeof(*core), GFP_KERNEL); > + if (!core) > + return -ENOMEM; If you save 'core' (or preferably ddata) here and place it in the device's driver_data slot via dev_set_drvdata(), you can just pass around the 'struct device' which is more in keeping with current implementations. > + if (spi->max_speed_hz <= 500000) { > + core->spi_padding_bytes = 0; > + } else { > + /* > + * Calculation taken from the manual for IF_CFGSTAT:IF_CFG. > + * Register access time is 1us, so we need to configure and send > + * out enough padding bytes between the read request and data > + * transmission that lasts at least 1 microsecond. > + */ > + core->spi_padding_bytes = 1 + > + (spi->max_speed_hz / 1000000 + 2) / 8; > + } > + > + core->spi = spi; > + > + spi->bits_per_word = 8; > + > + err = spi_setup(spi); > + if (err < 0) { > + dev_err(&spi->dev, "Error %d initializing SPI\n", err); > + return err; > + } > + > + core->cpuorg_regmap = > + ocelot_spi_devm_get_regmap(core, dev, > + &vsc7512_dev_cpuorg_resource); > + if (IS_ERR(core->cpuorg_regmap)) > + return -ENOMEM; > + > + core->dev = dev; > + > + /* > + * The chip must be set up for SPI before it gets initialized and reset. > + * This must be done before calling init, and after a chip reset is > + * performed. > + */ > + err = ocelot_spi_initialize(core); > + if (err) { > + dev_err(dev, "Error %d initializing Ocelot SPI bus\n", err); > + return err; > + } > + > + err = ocelot_core_init(core); > + if (err < 0) { > + dev_err(dev, "Error %d initializing Ocelot MFD\n", err); > + return err; > + } > + > + return 0; > +} > + > +const struct of_device_id ocelot_spi_of_match[] = { > + { .compatible = "mscc,vsc7512_mfd_spi" }, > + { }, > +}; > +MODULE_DEVICE_TABLE(of, ocelot_spi_of_match); > + > +static struct spi_driver ocelot_spi_driver = { > + .driver = { > + .name = "ocelot_mfd_spi", > + .of_match_table = of_match_ptr(ocelot_spi_of_match), > + }, > + .probe = ocelot_spi_probe, > +}; > +module_spi_driver(ocelot_spi_driver); > + > +MODULE_DESCRIPTION("SPI Controlled Ocelot Chip Driver"); > +MODULE_AUTHOR("Colin Foster "); > +MODULE_LICENSE("Dual MIT/GPL"); > diff --git a/drivers/mfd/ocelot.h b/drivers/mfd/ocelot.h > new file mode 100644 > index 000000000000..20d3853dd6d2 > --- /dev/null > +++ b/drivers/mfd/ocelot.h > @@ -0,0 +1,42 @@ > +/* SPDX-License-Identifier: GPL-2.0 OR MIT */ > +/* > + * Copyright 2021 Innovative Advantage Inc. > + */ > + > +#include > +#include > + > +struct ocelot_core { > + struct device *dev; > + struct regmap *gcb_regmap; > + struct regmap *cpuorg_regmap; > + > +#if IS_ENABLED(CONFIG_MFD_OCELOT_SPI) I'd drop this personally. > + int spi_padding_bytes; > + struct spi_device *spi; > +#endif > +}; > + > +void ocelot_get_resource_name(char *name, const struct resource *res, > + int size); > +int ocelot_core_init(struct ocelot_core *core); > +int ocelot_remove(struct ocelot_core *core); This doesn't appear to be relevant. > +#if IS_ENABLED(CONFIG_MFD_OCELOT_SPI) > +struct regmap *ocelot_spi_devm_get_regmap(struct ocelot_core *core, > + struct device *child, > + const struct resource *res); > +int ocelot_spi_initialize(struct ocelot_core *core); > +#else > +static inline struct regmap *ocelot_spi_devm_get_regmap( > + struct ocelot_core *core, struct device *child, > + const struct resource *res) > +{ > + return ERR_PTR(-EOPNOTSUPP); > +} > + > +static inline int ocelot_spi_initialize(struct ocelot_core *core) > +{ > + return -EOPNOTSUPP; > +} > +#endif > diff --git a/include/soc/mscc/ocelot.h b/include/soc/mscc/ocelot.h > index 998616511ffb..d9e2710d5646 100644 > --- a/include/soc/mscc/ocelot.h > +++ b/include/soc/mscc/ocelot.h > @@ -1018,11 +1018,16 @@ ocelot_mrp_del_ring_role(struct ocelot *ocelot, int port, > } > #endif > > +#if IS_ENABLED(CONFIG_MFD_OCELOT) > +struct regmap *ocelot_get_regmap_from_resource(struct device *child, > + const struct resource *res); > +#else > static inline struct regmap * > ocelot_get_regmap_from_resource(struct device *child, > const struct resource *res) > { > return ERR_PTR(-EOPNOTSUPP); > } > +#endif > > #endif -- Lee Jones [李琼斯] Principal Technical Lead - Developer Services Linaro.org │ Open source software for Arm SoCs Follow Linaro: Facebook | Twitter | Blog From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 6ADB8C433EF for ; Wed, 13 Apr 2022 08:32:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=64SLWxOrpFMVG3noHJnKwlZMuH9ZHMr7k3YkQovsTj8=; b=FhDsSFDXAJdLY6 BS1nfuBzWuNYpWvAKKJ1VuSGGtdc7U7+gunxdvvzwFc+FIo5ds3KyjeMibWml6LDxU1fAOp03x+Ql khkerlzuwtbdGNzQTMMuWsGIyfVmjSGJ2SvK6qUanWFrFlHWtZAVn80qE1TaIuq16cqE5csvI50EQ W6tr5pRSV5dtA7Ouv0lT070gAPVbCJ2bsaSRDAZCCfyUCmaLjzBesgHve4qXQtr8GSbtahS2hLD1N 2vzDMLAGORpT/iqVC91A+kLPPZwYrtocb/bTZPxiNa+r6zI/8cO/kZE4o9VUm/prWztI3uYlDc9X1 dE2RQiujNV1Z7PDveLrw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1neYQd-0005JT-N4; Wed, 13 Apr 2022 08:32:43 +0000 Received: from mail-wr1-x42b.google.com ([2a00:1450:4864:20::42b]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1neYQN-0005DZ-OP for linux-phy@lists.infradead.org; Wed, 13 Apr 2022 08:32:31 +0000 Received: by mail-wr1-x42b.google.com with SMTP id g18so1486925wrb.10 for ; Wed, 13 Apr 2022 01:32:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to; bh=43L4Fo1VTg4iHrSwnBG558ytJYsFKrb6ExWD6ZDsMak=; b=KG6a9NYqPhTPLeRQWj7HFdFz0SVMQgvtCq9jhHPw0ijLyeLHMPpL6P66acaHSk1da1 WQ7MbIycSEDhN0RdU8Lc/7jCq0LD5g76SIPX49y48OYMupEz5UgFBI2RcrxXLUuhetCs cjAxq3OQ+trQSFj4zI5AHi2Eh+nIfLqDP6jgzHrXG15oObfPNn9KdO9ITMmLFflV5UnR V7s0OqBlRhRfO47q0OVKdLqStMhNFAD0vO99+DVNSLtyG1uFXkaRzah1KU7PC6Rdlami AbzEyOTjmPlkO/ewRJWE8qACRDqzJuhZEDR70Z1dbiYPmIZ9z5kVltilHNvmu8nK4cr9 Ehug== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to; bh=43L4Fo1VTg4iHrSwnBG558ytJYsFKrb6ExWD6ZDsMak=; b=KZKpmbNYPPRf/HH0IlMeEwwp0lHfTZDee0o1w4iM63Ru2+wFjumOOPxASMngMUMCAa fZMgNFQFkQN3K1XdTVspesrkQhHVscMPCJ1e/acZr3vj0RVQO7DPCyD99N8j8C9r+W8R n9ZdRBhfBcga368BBuP1Qop87F89EM5rN22GLuHhe4zKy1VQNG9/23SeNqAZ8p+pf2wh 0NG75GNkxRuVi0g7bZh/uL+uPsweNqOBaA6gLZi5r+M6RhUVem8iU4ON8ES2rl09ekkQ Z+eoIkJtHSi/cuk8oK/Y2pOlpk1vwnMKt3pBsjpo8BvKvRK8rTfugWSGCVXxZcs/nrLK MZ2w== X-Gm-Message-State: AOAM531J8vbwtj3+ZlHlq+jRJnej3eVjeRbuZ0T2tcVwE4L6o3oMJV4Q SJqd9wuuErg1S8P3urCkmCUIrQ== X-Google-Smtp-Source: ABdhPJyb4o/u7q7PWqlOyrGHkM8DDEqRl9AmtylLWkEJrmLmDjLt1mvEGrxMMUOQ6KZKokIhuDpJ5w== X-Received: by 2002:a5d:44d0:0:b0:207:9ac8:2c3b with SMTP id z16-20020a5d44d0000000b002079ac82c3bmr18170538wrr.688.1649838745047; Wed, 13 Apr 2022 01:32:25 -0700 (PDT) Received: from google.com (cpc155339-bagu17-2-0-cust87.1-3.cable.virginm.net. [86.27.177.88]) by smtp.gmail.com with ESMTPSA id f9-20020a05600c154900b0038cb98076d6sm1955228wmg.10.2022.04.13.01.32.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Apr 2022 01:32:24 -0700 (PDT) Date: Wed, 13 Apr 2022 09:32:22 +0100 From: Lee Jones To: Colin Foster Cc: linux-arm-kernel@lists.infradead.org, linux-gpio@vger.kernel.org, linux-phy@lists.infradead.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org, "Rafael J. Wysocki" , Marc Zyngier , Hector Martin , Angela Czubak , Steen Hegelund , Lars Povlsen , Linus Walleij , Vinod Koul , Kishon Vijay Abraham I , Russell King , Heiner Kallweit , Jakub Kicinski , "David S. Miller" , Florian Fainelli , Vivien Didelot , Andrew Lunn , UNGLinuxDriver@microchip.com, Alexandre Belloni , Claudiu Manoil , Vladimir Oltean , katie.morris@in-advantage.com Subject: Re: [RFC v7 net-next 10/13] mfd: ocelot: add support for the vsc7512 chip via spi Message-ID: References: <20220307021208.2406741-1-colin.foster@in-advantage.com> <20220307021208.2406741-11-colin.foster@in-advantage.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20220307021208.2406741-11-colin.foster@in-advantage.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220413_013227_838872_DAAC2FE8 X-CRM114-Status: GOOD ( 42.58 ) 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 T24gU3VuLCAwNiBNYXIgMjAyMiwgQ29saW4gRm9zdGVyIHdyb3RlOgoKPiBUaGUgVlNDNzUxMiBp cyBhIG5ldHdvcmtpbmcgY2hpcCB0aGF0IGNvbnRhaW5zIHNldmVyYWwgcGVyaXBoZXJhbHMuIE1h bnkgb2YKPiB0aGVzZSBwZXJpcGhlcmFscyBhcmUgY3VycmVudGx5IHN1cHBvcnRlZCBieSB0aGUg VlNDNzUxMyBhbmQgVlNDNzUxNCBjaGlwcywKPiBidXQgdGhvc2UgcnVuIG9uIGFuIGludGVybmFs IENQVS4gVGhlIFZTQzc1MTIgbGFja3MgdGhpcyBDUFUsIGFuZCBtdXN0IGJlCj4gY29udHJvbGxl ZCBleHRlcm5hbGx5Lgo+IAo+IFV0aWxpemUgdGhlIGV4aXN0aW5nIGRyaXZlcnMgYnkgcmVmZXJl bmNpbmcgdGhlIGNoaXAgYXMgYW4gTUZELiBBZGQgc3VwcG9ydAo+IGZvciB0aGUgdHdvIE1ESU8g YnVzZXMsIHRoZSBpbnRlcm5hbCBwaHlzLCBwaW5jdHJsLCBzZXJpYWwgR1BJTywgYW5kIEhTSU8u Cj4gCj4gU2lnbmVkLW9mZi1ieTogQ29saW4gRm9zdGVyIDxjb2xpbi5mb3N0ZXJAaW4tYWR2YW50 YWdlLmNvbT4KPiAtLS0KPiAgZHJpdmVycy9tZmQvS2NvbmZpZyAgICAgICB8ICAyNCArKysKPiAg ZHJpdmVycy9tZmQvTWFrZWZpbGUgICAgICB8ICAgMyArCj4gIGRyaXZlcnMvbWZkL29jZWxvdC1j b3JlLmMgfCAxODkgKysrKysrKysrKysrKysrKysrKysrKysKPiAgZHJpdmVycy9tZmQvb2NlbG90 LXNwaS5jICB8IDMxMyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICBk cml2ZXJzL21mZC9vY2Vsb3QuaCAgICAgIHwgIDQyICsrKysrCj4gIGluY2x1ZGUvc29jL21zY2Mv b2NlbG90LmggfCAgIDUgKwo+ICA2IGZpbGVzIGNoYW5nZWQsIDU3NiBpbnNlcnRpb25zKCspCj4g IGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21mZC9vY2Vsb3QtY29yZS5jCj4gIGNyZWF0ZSBt b2RlIDEwMDY0NCBkcml2ZXJzL21mZC9vY2Vsb3Qtc3BpLmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0 IGRyaXZlcnMvbWZkL29jZWxvdC5oCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL0tjb25m aWcgYi9kcml2ZXJzL21mZC9LY29uZmlnCj4gaW5kZXggYmEwYjNlYjEzMWYxLi5kNDMxMmE1MjUy ZDAgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9tZmQvS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvbWZk L0tjb25maWcKPiBAQCAtOTQ4LDYgKzk0OCwzMCBAQCBjb25maWcgTUZEX01FTkYyMUJNQwo+ICAJ ICBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gSWYgc28gdGhlIG1v ZHVsZQo+ICAJICB3aWxsIGJlIGNhbGxlZCBtZW5mMjFibWMuCj4gIAo+ICtjb25maWcgTUZEX09D RUxPVAo+ICsJdHJpc3RhdGUgIk1pY3Jvc2VtaSBPY2Vsb3QgRXh0ZXJuYWwgQ29udHJvbCBTdXBw b3J0Igo+ICsJc2VsZWN0IE1GRF9DT1JFCj4gKwloZWxwCj4gKwkgIE9jZWxvdCBpcyBhIGZhbWls eSBvZiBuZXR3b3JraW5nIGNoaXBzIHRoYXQgc3VwcG9ydCBtdWx0aXBsZSBldGhlcm5ldAo+ICsJ ICBhbmQgZmlicmUgaW50ZXJmYWNlcy4gSW4gYWRkaXRpb24gdG8gbmV0d29ya2luZywgdGhleSBj b250YWluIHNldmVyYWwKPiArCSAgb3RoZXIgZnVuY3Rpb25zLCBpbmNsdWRpbmcgcGljdHJsLCBN RElPLCBhbmQgY29tbXVuaWNhdGlvbiB3aXRoCj4gKwkgIGV4dGVybmFsIGNoaXBzLiBXaGlsZSBz b21lIGNoaXBzIGhhdmUgYW4gaW50ZXJuYWwgcHJvY2Vzc29yIGNhcGFibGUgb2YKPiArCSAgcnVu bmluZyBhbiBPUywgb3RoZXJzIGRvbid0LiBBbGwgY2hpcHMgY2FuIGJlIGNvbnRyb2xsZWQgZXh0 ZXJuYWxseQo+ICsJICB0aHJvdWdoIGRpZmZlcmVudCBpbnRlcmZhY2VzLCBpbmNsdWRpbmcgU1BJ LCBJMkMsIGFuZCBQQ0llLgo+ICsKPiArCSAgU2F5IHllcyBoZXJlIHRvIGFkZCBzdXBwb3J0IGZv ciBPY2Vsb3QgY2hpcHMgKFZTQzc1MTEsIFZTQzc1MTIsCj4gKwkgIFZTQzc1MTMsIFZTQzc1MTQp IGNvbnRyb2xsZWQgZXh0ZXJuYWxseS4KPiArCj4gKwkgIElmIHVuc3VyZSwgc2F5IE4KPiArCj4g K2NvbmZpZyBNRkRfT0NFTE9UX1NQSQo+ICsJdHJpc3RhdGUgIk1pY3Jvc2VtaSBPY2Vsb3QgU1BJ IGludGVyZmFjZSIKPiArCWRlcGVuZHMgb24gTUZEX09DRUxPVAo+ICsJZGVwZW5kcyBvbiBTUElf TUFTVEVSCj4gKwlzZWxlY3QgUkVHTUFQX1NQSQo+ICsJaGVscAo+ICsJICBTYXkgeWVzIGhlcmUg dG8gYWRkIGNvbnRyb2wgdG8gdGhlIE1GRF9PQ0VMT1QgY2hpcHMgdmlhIFNQSS4KPiArCj4gIGNv bmZpZyBFWlhfUENBUAo+ICAJYm9vbCAiTW90b3JvbGEgRVpYUENBUCBTdXBwb3J0Igo+ICAJZGVw ZW5kcyBvbiBTUElfTUFTVEVSCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL01ha2VmaWxlIGIv ZHJpdmVycy9tZmQvTWFrZWZpbGUKPiBpbmRleCBkZjFlY2M0YTRjOTUuLjEyNTEzODQzMDY3YSAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL21mZC9NYWtlZmlsZQo+ICsrKyBiL2RyaXZlcnMvbWZkL01h a2VmaWxlCj4gQEAgLTEyMCw2ICsxMjAsOSBAQCBvYmotJChDT05GSUdfTUZEX01DMTNYWFhfSTJD KQkrPSBtYzEzeHh4LWkyYy5vCj4gIAo+ICBvYmotJChDT05GSUdfTUZEX0NPUkUpCQkrPSBtZmQt Y29yZS5vCj4gIAo+ICtvYmotJChDT05GSUdfTUZEX09DRUxPVCkJKz0gb2NlbG90LWNvcmUubwo+ ICtvYmotJChDT05GSUdfTUZEX09DRUxPVF9TUEkpCSs9IG9jZWxvdC1zcGkubwo+ICsKPiAgb2Jq LSQoQ09ORklHX0VaWF9QQ0FQKQkJKz0gZXp4LXBjYXAubwo+ICBvYmotJChDT05GSUdfTUZEX0NQ Q0FQKQkJKz0gbW90b3JvbGEtY3BjYXAubwo+ICAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQv b2NlbG90LWNvcmUuYyBiL2RyaXZlcnMvbWZkL29jZWxvdC1jb3JlLmMKPiBuZXcgZmlsZSBtb2Rl IDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uMzZlNDMyNmE4NTNhCj4gLS0tIC9kZXYvbnVs bAo+ICsrKyBiL2RyaXZlcnMvbWZkL29jZWxvdC1jb3JlLmMKPiBAQCAtMCwwICsxLDE4OSBAQAo+ ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogKEdQTC0yLjAgT1IgTUlUKQo+ICsvKgo+ICsg KiBNRkQgY29yZSBkcml2ZXIgZm9yIHRoZSBPY2Vsb3QgY2hpcCBmYW1pbHkuCgpQbGVhc2UgZHJv cCBhbGwgcmVmZXJlbmNlcyB0byAnTUZEJy4KCidDb3JlJyBpcyBmaW5lLCBhcyBpcyAnUGFyZW50 Jy4KCj4gKyAqIFRoZSBWU0M3NTExLCA3NTEyLCA3NTEzLCBhbmQgNzUxNCBjYW4gYmUgY29udHJv bGxlZCBpbnRlcm5hbGx5IHZpYSBhbgo+ICsgKiBvbi1jaGlwIE1JUFMgcHJvY2Vzc29yLCBvciBl eHRlcm5hbGx5IHZpYSBTUEksIEkyQywgUENJZS4gVGhpcyBjb3JlIGRyaXZlciBpcwo+ICsgKiBp bnRlbmRlZCB0byBiZSB0aGUgYnVzLWFnbm9zdGljIGdsdWUgYmV0d2VlbiwgZm9yIGV4YW1wbGUs IHRoZSBTUEkgYnVzIGFuZAo+ICsgKiB0aGUgTUZEIGNoaWxkcmVuLgo+ICsgKgo+ICsgKiBDb3B5 cmlnaHQgMjAyMSBJbm5vdmF0aXZlIEFkdmFudGFnZSBJbmMuCgpPdXQgb2YgZGF0ZT8KCj4gKyAq IEF1dGhvcjogQ29saW4gRm9zdGVyIDxjb2xpbi5mb3N0ZXJAaW4tYWR2YW50YWdlLmNvbT4KPiAr ICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvbWZkL2NvcmUuaD4KPiArI2luY2x1ZGUgPGxpbnV4 L21vZHVsZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+Cj4gKyNpbmNsdWRlIDxzb2Mv bXNjYy9vY2Vsb3QuaD4KPiArCj4gKyNpbmNsdWRlIDxhc20vYnl0ZW9yZGVyLmg+Cj4gKwo+ICsj aW5jbHVkZSAib2NlbG90LmgiCj4gKwo+ICsjZGVmaW5lIEdDQl9TT0ZUX1JTVCAweDAwMDgKClRh YiB0aGVzZSBvdXQgdG8gbWF0Y2ggdGhlIG90aGVycz8KCj4gKyNkZWZpbmUgU09GVF9DSElQX1JT VCAweDEKPiArCj4gKyNkZWZpbmUgVlNDNzUxMl9HQ0JfUkVTX1NUQVJUCTB4NzEwNzAwMDAKPiAr I2RlZmluZSBWU0M3NTEyX0dDQl9SRVNfU0laRQkweDE0Cj4gKwo+ICsjZGVmaW5lIFZTQzc1MTJf TUlJTTBfUkVTX1NUQVJUCTB4NzEwNzAwOWMKPiArI2RlZmluZSBWU0M3NTEyX01JSU0wX1JFU19T SVpFCTB4MjQKPiArCj4gKyNkZWZpbmUgVlNDNzUxMl9NSUlNMV9SRVNfU1RBUlQJMHg3MTA3MDBj MAo+ICsjZGVmaW5lIFZTQzc1MTJfTUlJTTFfUkVTX1NJWkUJMHgyNAo+ICsKPiArI2RlZmluZSBW U0M3NTEyX1BIWV9SRVNfU1RBUlQJMHg3MTA3MDBmMAo+ICsjZGVmaW5lIFZTQzc1MTJfUEhZX1JF U19TSVpFCTB4NAo+ICsKPiArI2RlZmluZSBWU0M3NTEyX0hTSU9fUkVTX1NUQVJUCTB4NzEwZDAw MDAKPiArI2RlZmluZSBWU0M3NTEyX0hTSU9fUkVTX1NJWkUJMHgxMDAwMAo+ICsKPiArI2RlZmlu ZSBWU0M3NTEyX0dQSU9fUkVTX1NUQVJUCTB4NzEwNzAwMzQKPiArI2RlZmluZSBWU0M3NTEyX0dQ SU9fUkVTX1NJWkUJMHg2Ywo+ICsKPiArI2RlZmluZSBWU0M3NTEyX1NJT19SRVNfU1RBUlQJMHg3 MTA3MDBmOAo+ICsjZGVmaW5lIFZTQzc1MTJfU0lPX1JFU19TSVpFCTB4MTAwCj4gKwo+ICtzdGF0 aWMgY29uc3Qgc3RydWN0IHJlc291cmNlIHZzYzc1MTJfZ2NiX3Jlc291cmNlID0KPiArCURFRklO RV9SRVNfUkVHX05BTUVEKFZTQzc1MTJfR0NCX1JFU19TVEFSVCwgVlNDNzUxMl9HQ0JfUkVTX1NJ WkUsCj4gKwkJCSAgICAgImRldmNwdV9nY2JfY2hpcF9yZWdzIik7Cj4gKwo+ICtzdGF0aWMgaW50 IG9jZWxvdF9yZXNldChzdHJ1Y3Qgb2NlbG90X2NvcmUgKmNvcmUpCj4gK3sKPiArCWludCByZXQ7 Cj4gKwo+ICsJLyoKPiArCSAqIFJlc2V0IHRoZSBlbnRpcmUgY2hpcCBoZXJlIHRvIHB1dCBpdCBp bnRvIGEgY29tcGxldGVseSBrbm93biBzdGF0ZS4KPiArCSAqIE90aGVyIGRyaXZlcnMgbWF5IHdh bnQgdG8gcmVzZXQgdGhlaXIgb3duIHN1YnN5c3RlbXMuIFRoZSByZWdpc3Rlcgo+ICsJICogc2Vs Zi1jbGVhcnMsIHNvIG9uZSB3cml0ZSBpcyBhbGwgdGhhdCBpcyBuZWVkZWQKPiArCSAqLwo+ICsJ cmV0ID0gcmVnbWFwX3dyaXRlKGNvcmUtPmdjYl9yZWdtYXAsIEdDQl9TT0ZUX1JTVCwgU09GVF9D SElQX1JTVCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJbXNsZWVwKDEw MCk7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCByZWdtYXAg Km9jZWxvdF9kZXZtX3JlZ21hcF9pbml0KHN0cnVjdCBvY2Vsb3RfY29yZSAqY29yZSwKPiArCQkJ CQkgICAgICBzdHJ1Y3QgZGV2aWNlICpjaGlsZCwKPiArCQkJCQkgICAgICBjb25zdCBzdHJ1Y3Qg cmVzb3VyY2UgKnJlcykKPiArewo+ICsJLyoKPiArCSAqIENhbGwgZGlyZWN0bHkgaW50byBvY2Vs b3Rfc3BpIHRvIGdldCBhIG5ldyByZWdtYXAuIFRoaXMgd2lsbCBuZWVkIHRvCj4gKwkgKiBiZSBl eHBhbmRlZCBpZiBhZGRpdGlvbmFsIGJ1cyB0eXBlcyBhcmUgdG8gYmUgc3VwcG9ydGVkIGluIHRo ZQo+ICsJICogZnV0dXJlLgo+ICsJICovCj4gKwlyZXR1cm4gb2NlbG90X3NwaV9kZXZtX2dldF9y ZWdtYXAoY29yZSwgY2hpbGQsIHJlcyk7Cj4gK30KPiArCj4gK3N0cnVjdCByZWdtYXAgKm9jZWxv dF9nZXRfcmVnbWFwX2Zyb21fcmVzb3VyY2Uoc3RydWN0IGRldmljZSAqY2hpbGQsCj4gKwkJCQkJ ICAgICAgIGNvbnN0IHN0cnVjdCByZXNvdXJjZSAqcmVzKQo+ICt7Cj4gKwlzdHJ1Y3Qgb2NlbG90 X2NvcmUgKmNvcmUgPSBkZXZfZ2V0X2RydmRhdGEoY2hpbGQtPnBhcmVudCk7Cj4gKwo+ICsJcmV0 dXJuIG9jZWxvdF9kZXZtX3JlZ21hcF9pbml0KGNvcmUsIGNoaWxkLCByZXMpOwo+ICt9Cj4gK0VY UE9SVF9TWU1CT0wob2NlbG90X2dldF9yZWdtYXBfZnJvbV9yZXNvdXJjZSk7CgpXaGF0J3MgdGhl IHJlYXNvbiBmb3IgaGF2aW5nIGFuIGFkZGl0aW9uYWwgZnVuY3Rpb24gd2hlbiBvbmUgd291bGQg ZG8/Cgo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IHJlc291cmNlIHZzYzc1MTJfbWlpbTBfcmVzb3Vy Y2VzW10gPSB7Cj4gKwlERUZJTkVfUkVTX1JFR19OQU1FRChWU0M3NTEyX01JSU0wX1JFU19TVEFS VCwgVlNDNzUxMl9NSUlNMF9SRVNfU0laRSwKPiArCQkJICAgICAiZ2NiX21paW0wIiksCj4gKwlE RUZJTkVfUkVTX1JFR19OQU1FRChWU0M3NTEyX1BIWV9SRVNfU1RBUlQsIFZTQzc1MTJfUEhZX1JF U19TSVpFLAo+ICsJCQkgICAgICJnY2JfcGh5IiksCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qg c3RydWN0IHJlc291cmNlIHZzYzc1MTJfbWlpbTFfcmVzb3VyY2VzW10gPSB7Cj4gKwlERUZJTkVf UkVTX1JFR19OQU1FRChWU0M3NTEyX01JSU0xX1JFU19TVEFSVCwgVlNDNzUxMl9NSUlNMV9SRVNf U0laRSwKPiArCQkJICAgICAiZ2NiX21paW0xIiksCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qg c3RydWN0IHJlc291cmNlIHZzYzc1MTJfaHNpb19yZXNvdXJjZXNbXSA9IHsKPiArCURFRklORV9S RVNfUkVHX05BTUVEKFZTQzc1MTJfSFNJT19SRVNfU1RBUlQsIFZTQzc1MTJfSFNJT19SRVNfU0la RSwKPiArCQkJICAgICAiaHNpbyIpLAo+ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBy ZXNvdXJjZSB2c2M3NTEyX3BpbmN0cmxfcmVzb3VyY2VzW10gPSB7Cj4gKwlERUZJTkVfUkVTX1JF R19OQU1FRChWU0M3NTEyX0dQSU9fUkVTX1NUQVJULCBWU0M3NTEyX0dQSU9fUkVTX1NJWkUsCj4g KwkJCSAgICAgImdjYl9ncGlvIiksCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IHJl c291cmNlIHZzYzc1MTJfc2dwaW9fcmVzb3VyY2VzW10gPSB7Cj4gKwlERUZJTkVfUkVTX1JFR19O QU1FRChWU0M3NTEyX1NJT19SRVNfU1RBUlQsIFZTQzc1MTJfU0lPX1JFU19TSVpFLAo+ICsJCQkg ICAgICJnY2Jfc2lvIiksCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG1mZF9jZWxs IHZzYzc1MTJfZGV2c1tdID0gewo+ICsJewo+ICsJCS5uYW1lID0gIm9jZWxvdC1waW5jdHJsIiwK PiArCQkub2ZfY29tcGF0aWJsZSA9ICJtc2NjLG9jZWxvdC1waW5jdHJsIiwKPiArCQkubnVtX3Jl c291cmNlcyA9IEFSUkFZX1NJWkUodnNjNzUxMl9waW5jdHJsX3Jlc291cmNlcyksCj4gKwkJLnJl c291cmNlcyA9IHZzYzc1MTJfcGluY3RybF9yZXNvdXJjZXMsCj4gKwl9LCB7Cj4gKwkJLm5hbWUg PSAib2NlbG90LXNncGlvIiwKPiArCQkub2ZfY29tcGF0aWJsZSA9ICJtc2NjLG9jZWxvdC1zZ3Bp byIsCj4gKwkJLm51bV9yZXNvdXJjZXMgPSBBUlJBWV9TSVpFKHZzYzc1MTJfc2dwaW9fcmVzb3Vy Y2VzKSwKPiArCQkucmVzb3VyY2VzID0gdnNjNzUxMl9zZ3Bpb19yZXNvdXJjZXMsCj4gKwl9LCB7 Cj4gKwkJLm5hbWUgPSAib2NlbG90LW1paW0wIiwKPiArCQkub2ZfY29tcGF0aWJsZSA9ICJtc2Nj LG9jZWxvdC1taWltIiwKPiArCQkubnVtX3Jlc291cmNlcyA9IEFSUkFZX1NJWkUodnNjNzUxMl9t aWltMF9yZXNvdXJjZXMpLAo+ICsJCS5yZXNvdXJjZXMgPSB2c2M3NTEyX21paW0wX3Jlc291cmNl cywKPiArCX0sIHsKPiArCQkubmFtZSA9ICJvY2Vsb3QtbWlpbTEiLAo+ICsJCS5vZl9jb21wYXRp YmxlID0gIm1zY2Msb2NlbG90LW1paW0iLAo+ICsJCS5udW1fcmVzb3VyY2VzID0gQVJSQVlfU0la RSh2c2M3NTEyX21paW0xX3Jlc291cmNlcyksCj4gKwkJLnJlc291cmNlcyA9IHZzYzc1MTJfbWlp bTFfcmVzb3VyY2VzLAo+ICsJfSwgewo+ICsJCS5uYW1lID0gIm9jZWxvdC1zZXJkZXMiLAo+ICsJ CS5vZl9jb21wYXRpYmxlID0gIm1zY2MsdnNjNzUxNC1zZXJkZXMiLAo+ICsJCS5udW1fcmVzb3Vy Y2VzID0gQVJSQVlfU0laRSh2c2M3NTEyX2hzaW9fcmVzb3VyY2VzKSwKPiArCQkucmVzb3VyY2Vz ID0gdnNjNzUxMl9oc2lvX3Jlc291cmNlcywKPiArCX0sCj4gK307Cj4gKwo+ICtpbnQgb2NlbG90 X2NvcmVfaW5pdChzdHJ1Y3Qgb2NlbG90X2NvcmUgKmNvcmUpCj4gK3sKPiArCXN0cnVjdCBkZXZp Y2UgKmRldiA9IGNvcmUtPmRldjsKPiArCWludCByZXQ7Cj4gKwo+ICsJZGV2X3NldF9kcnZkYXRh KGRldiwgY29yZSk7Cj4gKwo+ICsJY29yZS0+Z2NiX3JlZ21hcCA9IG9jZWxvdF9kZXZtX3JlZ21h cF9pbml0KGNvcmUsIGRldiwKPiArCQkJCQkJICAgJnZzYzc1MTJfZ2NiX3Jlc291cmNlKTsKClRo aXMganVzdCBlbmRzIHVwIGNhbGxpbmcgb2NlbG90X3NwaV9kZXZtX2dldF9yZWdtYXAoKSByaWdo dD8KCldoeSBub3QgY2FsbCB0aGF0IGZyb20gaW5zaWRlIG9jZWxvdC1zcGkuYyB3aGVyZSAnY29y ZScgd2FzIGFsbG9jYXRlZD8KCj4gKwlpZiAoSVNfRVJSKGNvcmUtPmdjYl9yZWdtYXApKQo+ICsJ CXJldHVybiAtRU5PTUVNOwo+ICsKPiArCXJldCA9IG9jZWxvdF9yZXNldChjb3JlKTsKPiArCWlm IChyZXQpIHsKPiArCQlkZXZfZXJyKGRldiwgIkZhaWxlZCB0byByZXNldCBkZXZpY2U6ICVkXG4i LCByZXQpOwo+ICsJCXJldHVybiByZXQ7Cj4gKwl9Cj4gKwo+ICsJLyoKPiArCSAqIEEgY2hpcCBy ZXNldCB3aWxsIGNsZWFyIHRoZSBTUEkgY29uZmlndXJhdGlvbiwgc28gaXQgbmVlZHMgdG8gYmUg ZG9uZQo+ICsJICogYWdhaW4gYmVmb3JlIHdlIGNhbiBhY2Nlc3MgYW55IHJlZ2lzdGVycwo+ICsJ ICovCj4gKwlyZXQgPSBvY2Vsb3Rfc3BpX2luaXRpYWxpemUoY29yZSk7CgpOb3QgYSBmYW4gb2Yg Y2FsbGluZyBiYWNrIGludG8gdGhlIGZpbGUgd2hpY2ggY2FsbGVkIHVzLgoKQW5kIHdoYXQgaGFw cGVucyBpZiBTUEkgaXNuJ3QgY29udHJvbGxpbmcgdXM/CgpEb2Vzbid0IHRoZSBkb2N1bWVudGF0 aW9uIGFib3ZlIHNheSB0aGlzIGRldmljZSBjYW4gYWxzbyBiZQpjb21tdW5pY2F0ZWQgd2l0aCB2 aWEgSTJDIGFuZCBQQ0llPwoKPiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKGRldiwgIkZhaWxl ZCB0byBpbml0aWFsaXplIFNQSSBpbnRlcmZhY2U6ICVkXG4iLCByZXQpOwo+ICsJCXJldHVybiBy ZXQ7Cj4gKwl9Cj4gKwo+ICsJcmV0ID0gZGV2bV9tZmRfYWRkX2RldmljZXMoZGV2LCBQTEFURk9S TV9ERVZJRF9BVVRPLCB2c2M3NTEyX2RldnMsCj4gKwkJCQkgICBBUlJBWV9TSVpFKHZzYzc1MTJf ZGV2cyksIE5VTEwsIDAsIE5VTEwpOwo+ICsJaWYgKHJldCkgewo+ICsJCWRldl9lcnIoZGV2LCAi RmFpbGVkIHRvIGFkZCBzdWItZGV2aWNlczogJWRcbiIsIHJldCk7Cj4gKwkJcmV0dXJuIHJldDsK PiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICtFWFBPUlRfU1lNQk9MKG9jZWxvdF9jb3Jl X2luaXQpOwo+ICsKPiArTU9EVUxFX0RFU0NSSVBUSU9OKCJFeHRlcm5hbGx5IENvbnRyb2xsZWQg T2NlbG90IENoaXAgRHJpdmVyIik7Cj4gK01PRFVMRV9BVVRIT1IoIkNvbGluIEZvc3RlciA8Y29s aW4uZm9zdGVyQGluLWFkdmFudGFnZS5jb20+Iik7Cj4gK01PRFVMRV9MSUNFTlNFKCJHUEwgdjIi KTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvb2NlbG90LXNwaS5jIGIvZHJpdmVycy9tZmQv b2NlbG90LXNwaS5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAu LmM3ODhlMjM5YzlhNwo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL21mZC9vY2Vsb3Qt c3BpLmMKPiBAQCAtMCwwICsxLDMxMyBAQAo+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog KEdQTC0yLjAgT1IgTUlUKQo+ICsvKgo+ICsgKiBTUEkgY29yZSBkcml2ZXIgZm9yIHRoZSBPY2Vs b3QgY2hpcCBmYW1pbHkuCj4gKyAqCj4gKyAqIFRoaXMgZHJpdmVyIHdpbGwgaGFuZGxlIGV2ZXJ5 dGhpbmcgbmVjZXNzYXJ5IHRvIGFsbG93IGZvciBjb21tdW5pY2F0aW9uIG92ZXIKPiArICogU1BJ IHRvIHRoZSBWU0M3NTExLCBWU0M3NTEyLCBWU0M3NTEzIGFuZCBWU0M3NTE0IGNoaXBzLiBUaGUg bWFpbiBmdW5jdGlvbnMKPiArICogYXJlIHRvIHByZXBhcmUgdGhlIGNoaXAncyBTUEkgaW50ZXJm YWNlIGZvciBhIHNwZWNpZmljIGJ1cyBzcGVlZCwgYW5kIGEgaG9zdAo+ICsgKiBwcm9jZXNzb3In cyBlbmRpYW5uZXNzLiBUaGlzIHdpbGwgY3JlYXRlIGFuZCBkaXN0cmlidXRlIHJlZ21hcHMgZm9y IGFueSBNRkQKCkFzIGFib3ZlLCBwbGVhc2UgZHJvcCByZWZlcmVuY2VzIHRvIE1GRC4KCj4gKyAq IGNoaWxkcmVuLgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgMjAyMSBJbm5vdmF0aXZlIEFkdmFudGFn ZSBJbmMuCj4gKyAqCj4gKyAqIEF1dGhvcjogQ29saW4gRm9zdGVyIDxjb2xpbi5mb3N0ZXJAaW4t YWR2YW50YWdlLmNvbT4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvaW9wb2xsLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9rY29uZmlnLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4K PiArI2luY2x1ZGUgPGxpbnV4L29mLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KPiAr I2luY2x1ZGUgPGxpbnV4L3NwaS9zcGkuaD4KPiArCj4gKyNpbmNsdWRlIDxhc20vYnl0ZW9yZGVy Lmg+Cj4gKwo+ICsjaW5jbHVkZSAib2NlbG90LmgiCj4gKwo+ICsjZGVmaW5lIERFVl9DUFVPUkdf SUZfQ1RSTAkweDAwMDAKPiArI2RlZmluZSBERVZfQ1BVT1JHX0lGX0NGR1NUQVQJMHgwMDA0Cj4g Kwo+ICsjZGVmaW5lIENGR1NUQVRfSUZfTlVNX1ZDT1JFCSgwIDw8IDI0KQo+ICsjZGVmaW5lIENG R1NUQVRfSUZfTlVNX1ZSQVAJKDEgPDwgMjQpCj4gKyNkZWZpbmUgQ0ZHU1RBVF9JRl9OVU1fU0kJ KDIgPDwgMjQpCj4gKyNkZWZpbmUgQ0ZHU1RBVF9JRl9OVU1fTUlJTQkoMyA8PCAyNCkKPiArCj4g Kwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IHJlc291cmNlIHZzYzc1MTJfZGV2X2NwdW9yZ19yZXNv dXJjZSA9IHsKPiArCS5zdGFydAk9IDB4NzEwMDAwMDAsCj4gKwkuZW5kCT0gMHg3MTAwMDJmZiwK Ck5vIG1hZ2ljIG51bWJlcnMuICBQbGVhc2UgZGVmaW5lIHRoZXNlIGFkZHJlc3Nlcy4KCj4gKwku bmFtZQk9ICJkZXZjcHVfb3JnIiwKPiArfTsKPiArCj4gKyNkZWZpbmUgVlNDNzUxMl9CWVRFX09S REVSX0xFIDB4MDAwMDAwMDAKPiArI2RlZmluZSBWU0M3NTEyX0JZVEVfT1JERVJfQkUgMHg4MTgx ODE4MQo+ICsjZGVmaW5lIFZTQzc1MTJfQklUX09SREVSX01TQiAweDAwMDAwMDAwCj4gKyNkZWZp bmUgVlNDNzUxMl9CSVRfT1JERVJfTFNCIDB4NDI0MjQyNDIKPiArCj4gK2ludCBvY2Vsb3Rfc3Bp X2luaXRpYWxpemUoc3RydWN0IG9jZWxvdF9jb3JlICpjb3JlKQo+ICt7Cj4gKwl1MzIgdmFsLCBj aGVjazsKPiArCWludCBlcnI7Cj4gKwo+ICsjaWZkZWYgX19MSVRUTEVfRU5ESUFOCj4gKwl2YWwg PSBWU0M3NTEyX0JZVEVfT1JERVJfTEU7Cj4gKyNlbHNlCj4gKwl2YWwgPSBWU0M3NTEyX0JZVEVf T1JERVJfQkU7Cj4gKyNlbmRpZgoKTm90IGEgZmFuIG9mIGlmZGVmZXJ5IGluIHRoZSBtaWRkbGUg b2YgQyBmaWxlcy4KClBsZWFzZSBjcmVhdGUgYSBtYWNybyBvciBkZWZpbmUgc29tZXdoZXJlLgoK PiArCWVyciA9IHJlZ21hcF93cml0ZShjb3JlLT5jcHVvcmdfcmVnbWFwLCBERVZfQ1BVT1JHX0lG X0NUUkwsIHZhbCk7Cj4gKwlpZiAoZXJyKQo+ICsJCXJldHVybiBlcnI7CgpDb21tZW50LgoKPiAr CXZhbCA9IGNvcmUtPnNwaV9wYWRkaW5nX2J5dGVzOwo+ICsJZXJyID0gcmVnbWFwX3dyaXRlKGNv cmUtPmNwdW9yZ19yZWdtYXAsIERFVl9DUFVPUkdfSUZfQ0ZHU1RBVCwgdmFsKTsKPiArCWlmIChl cnIpCj4gKwkJcmV0dXJuIGVycjsKCkNvbW1lbnQuCgo+ICsJLyoKPiArCSAqIEFmdGVyIHdlIHdy aXRlIHRoZSBpbnRlcmZhY2UgY29uZmlndXJhdGlvbiwgcmVhZCBpdCBiYWNrIGhlcmUuIFRoaXMK PiArCSAqIHdpbGwgdmVyaWZ5IHNldmVyYWwgZGlmZmVyZW50IHRoaW5ncy4gVGhlIGZpcnN0IGlz IHRoYXQgdGhlIG51bWJlciBvZgo+ICsJICogcGFkZGluZyBieXRlcyBhY3R1YWxseSBnb3Qgd3Jp dHRlbiBjb3JyZWN0bHkuIFRoZXNlIGFyZSBmb3VuZCBpbiBiaXRzCj4gKwkgKiAwOjMuCj4gKwkg Kgo+ICsJICogVGhlIHNlY29uZCBpcyB0aGF0IGJpdCAxNiBpcyBjbGVhcmVkLiBCaXQgMTYgaXMg SUZfQ0ZHU1RBVDpJRl9TVEFULAo+ICsJICogYW5kIHdpbGwgYmUgc2V0IGlmIHRoZSByZWdpc3Rl ciBhY2Nlc3MgaXMgdG9vIGZhc3QuIFRoaXMgd291bGQgYmUgaW4KPiArCSAqIHRoZSBjb25kaXRp b24gdGhhdCB0aGUgbnVtYmVyIG9mIHBhZGRpbmcgYnl0ZXMgaXMgaW5zdWZmaWNpZW50IGZvcgo+ ICsJICogdGhlIFNQSSBidXMgZnJlcXVlbmN5Lgo+ICsJICoKPiArCSAqIFRoZSBsYXN0IGNoZWNr IGlzIGZvciBiaXRzIDMxOjI0LCB3aGljaCBkZWZpbmUgdGhlIGludGVyZmFjZSBieSB3aGljaAo+ ICsJICogdGhlIHJlZ2lzdGVycyBhcmUgYmVpbmcgYWNjZXNzZWQuIFNpbmNlIHdlJ3JlIGFjY2Vz c2luZyB0aGVtIHZpYSB0aGUKPiArCSAqIHNlcmlhbCBpbnRlcmZhY2UsIGl0IG11c3QgcmV0dXJu IElGX05VTV9TSS4KPiArCSAqLwo+ICsJY2hlY2sgPSB2YWwgfCBDRkdTVEFUX0lGX05VTV9TSTsK PiArCj4gKwllcnIgPSByZWdtYXBfcmVhZChjb3JlLT5jcHVvcmdfcmVnbWFwLCBERVZfQ1BVT1JH X0lGX0NGR1NUQVQsICZ2YWwpOwo+ICsJaWYgKGVycikKPiArCQlyZXR1cm4gZXJyOwo+ICsKPiAr CWlmIChjaGVjayAhPSB2YWwpCj4gKwkJcmV0dXJuIC1FTk9ERVY7Cj4gKwo+ICsJcmV0dXJuIDA7 Cj4gK30KPiArRVhQT1JUX1NZTUJPTChvY2Vsb3Rfc3BpX2luaXRpYWxpemUpOwo+ICsKPiArLyoK PiArICogVGhlIFNQSSBwcm90b2NvbCBmb3IgaW50ZXJmYWNpbmcgd2l0aCB0aGUgb2NlbG90IGNo aXBzIHVzZXMgMjQgYml0cywgd2hpbGUKPiArICogdGhlIHJlZ2lzdGVyIGxvY2F0aW9ucyBhcmUg ZGVmaW5lZCBhcyAzMi1iaXQuIFRoZSBsZWFzdCBzaWduaWZpY2FudCB0d28gYml0cwo+ICsgKiBn ZXQgc2hpZnRlZCBvdXQsIGFzIHJlZ2lzdGVyIGFjY2Vzc2VzIG11c3QgYWx3YXlzIGJlIHdvcmQt YWxpZ25lZCwgbGVhdmluZwo+ICsgKiBiaXRzIDIxOjAgYXMgdGhlIDIyLWJpdCBhZGRyZXNzLiBJ dCBtdXN0IGFsd2F5cyBiZSBiaWctZW5kaWFuLCB3aGVyZWFzIHRoZQo+ICsgKiBwYXlsb2FkIGNh biBiZSBvcHRpbWl6ZWQgZm9yIGJpdCAvIGJ5dGUgb3JkZXIgdG8gbWF0Y2ggd2hhdGV2ZXIgYXJj aGl0ZWN0dXJlCj4gKyAqIHRoZSBjb250cm9sbGluZyBDUFUgaGFzLgo+ICsgKi8KPiArc3RhdGlj IHVuc2lnbmVkIGludCBvY2Vsb3Rfc3BpX3RyYW5zbGF0ZV9hZGRyZXNzKHVuc2lnbmVkIGludCBy ZWcpCj4gK3sKPiArCXJldHVybiBjcHVfdG9fYmUzMigocmVnICYgMHhmZmZmZmYpID4+IDIpOwo+ ICt9Cj4gKwo+ICtzdHJ1Y3Qgb2NlbG90X3NwaV9yZWdtYXBfY29udGV4dCB7Cj4gKwl1MzIgYmFz ZTsKPiArCXN0cnVjdCBvY2Vsb3RfY29yZSAqY29yZTsKPiArfTsKPiArCj4gK3N0YXRpYyBpbnQg b2NlbG90X3NwaV9yZWdfcmVhZCh2b2lkICpjb250ZXh0LCB1bnNpZ25lZCBpbnQgcmVnLAo+ICsJ CQkgICAgICAgdW5zaWduZWQgaW50ICp2YWwpCj4gK3sKPiArCXN0cnVjdCBvY2Vsb3Rfc3BpX3Jl Z21hcF9jb250ZXh0ICpyZWdtYXBfY29udGV4dCA9IGNvbnRleHQ7Cj4gKwlzdHJ1Y3Qgb2NlbG90 X2NvcmUgKmNvcmUgPSByZWdtYXBfY29udGV4dC0+Y29yZTsKPiArCXN0cnVjdCBzcGlfdHJhbnNm ZXIgdHgsIHBhZGRpbmcsIHJ4Owo+ICsJc3RydWN0IHNwaV9tZXNzYWdlIG1zZzsKCkhvdyBiaWcg YXJlIGFsbCBvZiB0aGVzZT8KCldlIHdpbGwgcmVjZWl2ZSB3YXJuaW5ncyBpZiB0aGV5IG9jY3Vw eSB0b28gbXVjaCBzdGFjayBzcGFjZS4KCj4gKwlzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpOwo+ICsJ dW5zaWduZWQgaW50IGFkZHI7Cj4gKwl1OCAqdHhfYnVmOwo+ICsKPiArCXNwaSA9IGNvcmUtPnNw aTsKPiArCj4gKwlhZGRyID0gb2NlbG90X3NwaV90cmFuc2xhdGVfYWRkcmVzcyhyZWcgKyByZWdt YXBfY29udGV4dC0+YmFzZSk7Cj4gKwl0eF9idWYgPSAodTggKikmYWRkcjsKPiArCj4gKwlzcGlf bWVzc2FnZV9pbml0KCZtc2cpOwo+ICsKPiArCW1lbXNldCgmdHgsIDAsIHNpemVvZih0eCkpOwo+ ICsKPiArCS8qIElnbm9yZSB0aGUgZmlyc3QgYnl0ZSBmb3IgdGhlIDI0LWJpdCBhZGRyZXNzICov Cj4gKwl0eC50eF9idWYgPSAmdHhfYnVmWzFdOwo+ICsJdHgubGVuID0gMzsKPiArCj4gKwlzcGlf bWVzc2FnZV9hZGRfdGFpbCgmdHgsICZtc2cpOwo+ICsKPiArCWlmIChjb3JlLT5zcGlfcGFkZGlu Z19ieXRlcyA+IDApIHsKPiArCQl1OCBkdW1teV9idWZbMTZdID0gezB9Owo+ICsKPiArCQltZW1z ZXQoJnBhZGRpbmcsIDAsIHNpemVvZihwYWRkaW5nKSk7Cj4gKwo+ICsJCS8qIEp1c3QgdG9nZ2xl IHRoZSBjbG9jayBmb3IgcGFkZGluZyBieXRlcyAqLwo+ICsJCXBhZGRpbmcubGVuID0gY29yZS0+ c3BpX3BhZGRpbmdfYnl0ZXM7Cj4gKwkJcGFkZGluZy50eF9idWYgPSBkdW1teV9idWY7Cj4gKwkJ cGFkZGluZy5kdW1teV9kYXRhID0gMTsKPiArCj4gKwkJc3BpX21lc3NhZ2VfYWRkX3RhaWwoJnBh ZGRpbmcsICZtc2cpOwo+ICsJfQo+ICsKPiArCW1lbXNldCgmcngsIDAsIHNpemVvZihyeCkpOwo+ ICsJcngucnhfYnVmID0gdmFsOwo+ICsJcngubGVuID0gNDsKPiArCj4gKwlzcGlfbWVzc2FnZV9h ZGRfdGFpbCgmcngsICZtc2cpOwo+ICsKPiArCXJldHVybiBzcGlfc3luYyhzcGksICZtc2cpOwo+ ICt9Cj4gKwo+ICtzdGF0aWMgaW50IG9jZWxvdF9zcGlfcmVnX3dyaXRlKHZvaWQgKmNvbnRleHQs IHVuc2lnbmVkIGludCByZWcsCj4gKwkJCQl1bnNpZ25lZCBpbnQgdmFsKQo+ICt7Cj4gKwlzdHJ1 Y3Qgb2NlbG90X3NwaV9yZWdtYXBfY29udGV4dCAqcmVnbWFwX2NvbnRleHQgPSBjb250ZXh0Owo+ ICsJc3RydWN0IG9jZWxvdF9jb3JlICpjb3JlID0gcmVnbWFwX2NvbnRleHQtPmNvcmU7Cj4gKwlz dHJ1Y3Qgc3BpX3RyYW5zZmVyIHR4WzJdID0gezB9Owo+ICsJc3RydWN0IHNwaV9tZXNzYWdlIG1z ZzsKPiArCXN0cnVjdCBzcGlfZGV2aWNlICpzcGk7Cj4gKwl1bnNpZ25lZCBpbnQgYWRkcjsKPiAr CXU4ICp0eF9idWY7Cj4gKwo+ICsJc3BpID0gY29yZS0+c3BpOwo+ICsKPiArCWFkZHIgPSBvY2Vs b3Rfc3BpX3RyYW5zbGF0ZV9hZGRyZXNzKHJlZyArIHJlZ21hcF9jb250ZXh0LT5iYXNlKTsKPiAr CXR4X2J1ZiA9ICh1OCAqKSZhZGRyOwo+ICsKPiArCXNwaV9tZXNzYWdlX2luaXQoJm1zZyk7Cj4g Kwo+ICsJLyogSWdub3JlIHRoZSBmaXJzdCBieXRlIGZvciB0aGUgMjQtYml0IGFkZHJlc3MgYW5k IHNldCB0aGUgd3JpdGUgYml0ICovCj4gKwl0eF9idWZbMV0gfD0gQklUKDcpOwo+ICsJdHhbMF0u dHhfYnVmID0gJnR4X2J1ZlsxXTsKPiArCXR4WzBdLmxlbiA9IDM7Cj4gKwo+ICsJc3BpX21lc3Nh Z2VfYWRkX3RhaWwoJnR4WzBdLCAmbXNnKTsKPiArCj4gKwltZW1zZXQoJnR4WzFdLCAwLCBzaXpl b2Yoc3RydWN0IHNwaV90cmFuc2ZlcikpOwo+ICsJdHhbMV0udHhfYnVmID0gJnZhbDsKPiArCXR4 WzFdLmxlbiA9IDQ7Cj4gKwo+ICsJc3BpX21lc3NhZ2VfYWRkX3RhaWwoJnR4WzFdLCAmbXNnKTsK PiArCj4gKwlyZXR1cm4gc3BpX3N5bmMoc3BpLCAmbXNnKTsKPiArfQo+ICsKPiArc3RhdGljIGNv bnN0IHN0cnVjdCByZWdtYXBfY29uZmlnIG9jZWxvdF9zcGlfcmVnbWFwX2NvbmZpZyA9IHsKPiAr CS5yZWdfYml0cyA9IDI0LAo+ICsJLnJlZ19zdHJpZGUgPSA0LAo+ICsJLnZhbF9iaXRzID0gMzIs Cj4gKwo+ICsJLnJlZ19yZWFkID0gb2NlbG90X3NwaV9yZWdfcmVhZCwKPiArCS5yZWdfd3JpdGUg PSBvY2Vsb3Rfc3BpX3JlZ193cml0ZSwKPiArCj4gKwkubWF4X3JlZ2lzdGVyID0gMHhmZmZmZmZm ZiwKPiArCS51c2Vfc2luZ2xlX3dyaXRlID0gdHJ1ZSwKPiArCS51c2Vfc2luZ2xlX3JlYWQgPSB0 cnVlLAo+ICsJLmNhbl9tdWx0aV93cml0ZSA9IGZhbHNlLAo+ICsKPiArCS5yZWdfZm9ybWF0X2Vu ZGlhbiA9IFJFR01BUF9FTkRJQU5fQklHLAo+ICsJLnZhbF9mb3JtYXRfZW5kaWFuID0gUkVHTUFQ X0VORElBTl9OQVRJVkUsCj4gK307Cj4gKwo+ICtzdHJ1Y3QgcmVnbWFwICoKPiArb2NlbG90X3Nw aV9kZXZtX2dldF9yZWdtYXAoc3RydWN0IG9jZWxvdF9jb3JlICpjb3JlLCBzdHJ1Y3QgZGV2aWNl ICpjaGlsZCwKPiArCQkJICAgY29uc3Qgc3RydWN0IHJlc291cmNlICpyZXMpCgpUaGlzIHNlZW1z IHRvIGFsd2F5cyBpbml0aWFsaXNlIGEgbmV3IFJlZ21hcC4KClRvIG1lICdnZXQnIGltcGxpZXMg dGhhdCBpdCBjb3VsZCBmZXRjaCBhbiBhbHJlYWR5IGV4aXN0aW5nIG9uZS4KCi4uLiBhbmQgKnBl cmhhcHMqIGluaXQgYSBuZXcgb25lIGlmIG5vbmUgZXhpc3RzLi4KCj4gK3sKPiArCXN0cnVjdCBv Y2Vsb3Rfc3BpX3JlZ21hcF9jb250ZXh0ICpjb250ZXh0Owo+ICsJc3RydWN0IHJlZ21hcF9jb25m aWcgcmVnbWFwX2NvbmZpZzsKPiArCj4gKwljb250ZXh0ID0gZGV2bV9remFsbG9jKGNoaWxkLCBz aXplb2YoKmNvbnRleHQpLCBHRlBfS0VSTkVMKTsKPiArCWlmIChJU19FUlIoY29udGV4dCkpCj4g KwkJcmV0dXJuIEVSUl9DQVNUKGNvbnRleHQpOwo+ICsKPiArCWNvbnRleHQtPmJhc2UgPSByZXMt PnN0YXJ0Owo+ICsJY29udGV4dC0+Y29yZSA9IGNvcmU7Cj4gKwo+ICsJbWVtY3B5KCZyZWdtYXBf Y29uZmlnLCAmb2NlbG90X3NwaV9yZWdtYXBfY29uZmlnLAo+ICsJICAgICAgIHNpemVvZihvY2Vs b3Rfc3BpX3JlZ21hcF9jb25maWcpKTsKPiArCj4gKwlyZWdtYXBfY29uZmlnLm5hbWUgPSByZXMt Pm5hbWU7Cj4gKwlyZWdtYXBfY29uZmlnLm1heF9yZWdpc3RlciA9IHJlcy0+ZW5kIC0gcmVzLT5z dGFydDsKPiArCj4gKwlyZXR1cm4gZGV2bV9yZWdtYXBfaW5pdChjaGlsZCwgTlVMTCwgY29udGV4 dCwgJnJlZ21hcF9jb25maWcpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IG9jZWxvdF9zcGlfcHJv YmUoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0g JnNwaS0+ZGV2Owo+ICsJc3RydWN0IG9jZWxvdF9jb3JlICpjb3JlOwoKVGhpcyB3b3VsZCBiZSBt b3JlIGluIGtlZXBpbmcgd2l0aCBjdXJyZW50IGRyaXZlcnMgaWYgeW91IGRyb3BwZWQgdGhlCidf Y29yZScgcGFydCBvZiB0aGUgc3RydWN0IG5hbWUgYW5kIGNhbGxlZCB0aGUgdmFyaWFibGUgZGRh dGEuCgo+ICsJaW50IGVycjsKPiArCj4gKwljb3JlID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9m KCpjb3JlKSwgR0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIWNvcmUpCj4gKwkJcmV0dXJuIC1FTk9NRU07 CgpJZiB5b3Ugc2F2ZSAnY29yZScgKG9yIHByZWZlcmFibHkgZGRhdGEpIGhlcmUgYW5kIHBsYWNl IGl0IGluIHRoZQpkZXZpY2UncyBkcml2ZXJfZGF0YSBzbG90IHZpYSBkZXZfc2V0X2RydmRhdGEo KSwgeW91IGNhbiBqdXN0IHBhc3MKYXJvdW5kIHRoZSAnc3RydWN0IGRldmljZScgd2hpY2ggaXMg bW9yZSBpbiBrZWVwaW5nIHdpdGggY3VycmVudAppbXBsZW1lbnRhdGlvbnMuCgo+ICsJaWYgKHNw aS0+bWF4X3NwZWVkX2h6IDw9IDUwMDAwMCkgewo+ICsJCWNvcmUtPnNwaV9wYWRkaW5nX2J5dGVz ID0gMDsKPiArCX0gZWxzZSB7Cj4gKwkJLyoKPiArCQkgKiBDYWxjdWxhdGlvbiB0YWtlbiBmcm9t IHRoZSBtYW51YWwgZm9yIElGX0NGR1NUQVQ6SUZfQ0ZHLgo+ICsJCSAqIFJlZ2lzdGVyIGFjY2Vz cyB0aW1lIGlzIDF1cywgc28gd2UgbmVlZCB0byBjb25maWd1cmUgYW5kIHNlbmQKPiArCQkgKiBv dXQgZW5vdWdoIHBhZGRpbmcgYnl0ZXMgYmV0d2VlbiB0aGUgcmVhZCByZXF1ZXN0IGFuZCBkYXRh Cj4gKwkJICogdHJhbnNtaXNzaW9uIHRoYXQgbGFzdHMgYXQgbGVhc3QgMSBtaWNyb3NlY29uZC4K PiArCQkgKi8KPiArCQljb3JlLT5zcGlfcGFkZGluZ19ieXRlcyA9IDEgKwo+ICsJCQkoc3BpLT5t YXhfc3BlZWRfaHogLyAxMDAwMDAwICsgMikgLyA4Owo+ICsJfQo+ICsKPiArCWNvcmUtPnNwaSA9 IHNwaTsKPiArCj4gKwlzcGktPmJpdHNfcGVyX3dvcmQgPSA4Owo+ICsKPiArCWVyciA9IHNwaV9z ZXR1cChzcGkpOwo+ICsJaWYgKGVyciA8IDApIHsKPiArCQlkZXZfZXJyKCZzcGktPmRldiwgIkVy cm9yICVkIGluaXRpYWxpemluZyBTUElcbiIsIGVycik7Cj4gKwkJcmV0dXJuIGVycjsKPiArCX0K PiArCj4gKwljb3JlLT5jcHVvcmdfcmVnbWFwID0KPiArCQlvY2Vsb3Rfc3BpX2Rldm1fZ2V0X3Jl Z21hcChjb3JlLCBkZXYsCj4gKwkJCQkJICAgJnZzYzc1MTJfZGV2X2NwdW9yZ19yZXNvdXJjZSk7 Cj4gKwlpZiAoSVNfRVJSKGNvcmUtPmNwdW9yZ19yZWdtYXApKQo+ICsJCXJldHVybiAtRU5PTUVN Owo+ICsKPiArCWNvcmUtPmRldiA9IGRldjsKPiArCj4gKwkvKgo+ICsJICogVGhlIGNoaXAgbXVz dCBiZSBzZXQgdXAgZm9yIFNQSSBiZWZvcmUgaXQgZ2V0cyBpbml0aWFsaXplZCBhbmQgcmVzZXQu Cj4gKwkgKiBUaGlzIG11c3QgYmUgZG9uZSBiZWZvcmUgY2FsbGluZyBpbml0LCBhbmQgYWZ0ZXIg YSBjaGlwIHJlc2V0IGlzCj4gKwkgKiBwZXJmb3JtZWQuCj4gKwkgKi8KPiArCWVyciA9IG9jZWxv dF9zcGlfaW5pdGlhbGl6ZShjb3JlKTsKPiArCWlmIChlcnIpIHsKPiArCQlkZXZfZXJyKGRldiwg IkVycm9yICVkIGluaXRpYWxpemluZyBPY2Vsb3QgU1BJIGJ1c1xuIiwgZXJyKTsKPiArCQlyZXR1 cm4gZXJyOwo+ICsJfQo+ICsKPiArCWVyciA9IG9jZWxvdF9jb3JlX2luaXQoY29yZSk7Cj4gKwlp ZiAoZXJyIDwgMCkgewo+ICsJCWRldl9lcnIoZGV2LCAiRXJyb3IgJWQgaW5pdGlhbGl6aW5nIE9j ZWxvdCBNRkRcbiIsIGVycik7Cj4gKwkJcmV0dXJuIGVycjsKPiArCX0KPiArCj4gKwlyZXR1cm4g MDsKPiArfQo+ICsKPiArY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBvY2Vsb3Rfc3BpX29mX21h dGNoW10gPSB7Cj4gKwl7IC5jb21wYXRpYmxlID0gIm1zY2MsdnNjNzUxMl9tZmRfc3BpIiB9LAo+ ICsJeyB9LAo+ICt9Owo+ICtNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBvY2Vsb3Rfc3BpX29mX21h dGNoKTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3Qgc3BpX2RyaXZlciBvY2Vsb3Rfc3BpX2RyaXZlciA9 IHsKPiArCS5kcml2ZXIgPSB7Cj4gKwkJLm5hbWUgPSAib2NlbG90X21mZF9zcGkiLAo+ICsJCS5v Zl9tYXRjaF90YWJsZSA9IG9mX21hdGNoX3B0cihvY2Vsb3Rfc3BpX29mX21hdGNoKSwKPiArCX0s Cj4gKwkucHJvYmUgPSBvY2Vsb3Rfc3BpX3Byb2JlLAo+ICt9Owo+ICttb2R1bGVfc3BpX2RyaXZl cihvY2Vsb3Rfc3BpX2RyaXZlcik7Cj4gKwo+ICtNT0RVTEVfREVTQ1JJUFRJT04oIlNQSSBDb250 cm9sbGVkIE9jZWxvdCBDaGlwIERyaXZlciIpOwo+ICtNT0RVTEVfQVVUSE9SKCJDb2xpbiBGb3N0 ZXIgPGNvbGluLmZvc3RlckBpbi1hZHZhbnRhZ2UuY29tPiIpOwo+ICtNT0RVTEVfTElDRU5TRSgi RHVhbCBNSVQvR1BMIik7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL29jZWxvdC5oIGIvZHJp dmVycy9tZmQvb2NlbG90LmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAw MDAwMC4uMjBkMzg1M2RkNmQyCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvbWZkL29j ZWxvdC5oCj4gQEAgLTAsMCArMSw0MiBAQAo+ICsvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog R1BMLTIuMCBPUiBNSVQgKi8KPiArLyoKPiArICogQ29weXJpZ2h0IDIwMjEgSW5ub3ZhdGl2ZSBB ZHZhbnRhZ2UgSW5jLgo+ICsgKi8KPiArCj4gKyNpbmNsdWRlIDxsaW51eC9rY29uZmlnLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KPiArCj4gK3N0cnVjdCBvY2Vsb3RfY29yZSB7Cj4g KwlzdHJ1Y3QgZGV2aWNlICpkZXY7Cj4gKwlzdHJ1Y3QgcmVnbWFwICpnY2JfcmVnbWFwOwo+ICsJ c3RydWN0IHJlZ21hcCAqY3B1b3JnX3JlZ21hcDsKPiArCj4gKyNpZiBJU19FTkFCTEVEKENPTkZJ R19NRkRfT0NFTE9UX1NQSSkKCkknZCBkcm9wIHRoaXMgcGVyc29uYWxseS4KCj4gKwlpbnQgc3Bp X3BhZGRpbmdfYnl0ZXM7Cj4gKwlzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpOwo+ICsjZW5kaWYKPiAr fTsKPiArCj4gK3ZvaWQgb2NlbG90X2dldF9yZXNvdXJjZV9uYW1lKGNoYXIgKm5hbWUsIGNvbnN0 IHN0cnVjdCByZXNvdXJjZSAqcmVzLAo+ICsJCQkgICAgICBpbnQgc2l6ZSk7Cj4gK2ludCBvY2Vs b3RfY29yZV9pbml0KHN0cnVjdCBvY2Vsb3RfY29yZSAqY29yZSk7Cj4gK2ludCBvY2Vsb3RfcmVt b3ZlKHN0cnVjdCBvY2Vsb3RfY29yZSAqY29yZSk7CgpUaGlzIGRvZXNuJ3QgYXBwZWFyIHRvIGJl IHJlbGV2YW50LgoKPiArI2lmIElTX0VOQUJMRUQoQ09ORklHX01GRF9PQ0VMT1RfU1BJKQo+ICtz dHJ1Y3QgcmVnbWFwICpvY2Vsb3Rfc3BpX2Rldm1fZ2V0X3JlZ21hcChzdHJ1Y3Qgb2NlbG90X2Nv cmUgKmNvcmUsCj4gKwkJCQkJICBzdHJ1Y3QgZGV2aWNlICpjaGlsZCwKPiArCQkJCQkgIGNvbnN0 IHN0cnVjdCByZXNvdXJjZSAqcmVzKTsKPiAraW50IG9jZWxvdF9zcGlfaW5pdGlhbGl6ZShzdHJ1 Y3Qgb2NlbG90X2NvcmUgKmNvcmUpOwo+ICsjZWxzZQo+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBy ZWdtYXAgKm9jZWxvdF9zcGlfZGV2bV9nZXRfcmVnbWFwKAo+ICsJCXN0cnVjdCBvY2Vsb3RfY29y ZSAqY29yZSwgc3RydWN0IGRldmljZSAqY2hpbGQsCj4gKwkJY29uc3Qgc3RydWN0IHJlc291cmNl ICpyZXMpCj4gK3sKPiArCXJldHVybiBFUlJfUFRSKC1FT1BOT1RTVVBQKTsKPiArfQo+ICsKPiAr c3RhdGljIGlubGluZSBpbnQgb2NlbG90X3NwaV9pbml0aWFsaXplKHN0cnVjdCBvY2Vsb3RfY29y ZSAqY29yZSkKPiArewo+ICsJcmV0dXJuIC1FT1BOT1RTVVBQOwo+ICt9Cj4gKyNlbmRpZgo+IGRp ZmYgLS1naXQgYS9pbmNsdWRlL3NvYy9tc2NjL29jZWxvdC5oIGIvaW5jbHVkZS9zb2MvbXNjYy9v Y2Vsb3QuaAo+IGluZGV4IDk5ODYxNjUxMWZmYi4uZDllMjcxMGQ1NjQ2IDEwMDY0NAo+IC0tLSBh L2luY2x1ZGUvc29jL21zY2Mvb2NlbG90LmgKPiArKysgYi9pbmNsdWRlL3NvYy9tc2NjL29jZWxv dC5oCj4gQEAgLTEwMTgsMTEgKzEwMTgsMTYgQEAgb2NlbG90X21ycF9kZWxfcmluZ19yb2xlKHN0 cnVjdCBvY2Vsb3QgKm9jZWxvdCwgaW50IHBvcnQsCj4gIH0KPiAgI2VuZGlmCj4gIAo+ICsjaWYg SVNfRU5BQkxFRChDT05GSUdfTUZEX09DRUxPVCkKPiArc3RydWN0IHJlZ21hcCAqb2NlbG90X2dl dF9yZWdtYXBfZnJvbV9yZXNvdXJjZShzdHJ1Y3QgZGV2aWNlICpjaGlsZCwKPiArCQkJCQkgICAg ICAgY29uc3Qgc3RydWN0IHJlc291cmNlICpyZXMpOwo+ICsjZWxzZQo+ICBzdGF0aWMgaW5saW5l IHN0cnVjdCByZWdtYXAgKgo+ICBvY2Vsb3RfZ2V0X3JlZ21hcF9mcm9tX3Jlc291cmNlKHN0cnVj dCBkZXZpY2UgKmNoaWxkLAo+ICAJCQkJY29uc3Qgc3RydWN0IHJlc291cmNlICpyZXMpCj4gIHsK PiAgCXJldHVybiBFUlJfUFRSKC1FT1BOT1RTVVBQKTsKPiAgfQo+ICsjZW5kaWYKPiAgCj4gICNl bmRpZgoKLS0gCkxlZSBKb25lcyBb5p2O55C85pavXQpQcmluY2lwYWwgVGVjaG5pY2FsIExlYWQg LSBEZXZlbG9wZXIgU2VydmljZXMKTGluYXJvLm9yZyDilIIgT3BlbiBzb3VyY2Ugc29mdHdhcmUg Zm9yIEFybSBTb0NzCkZvbGxvdyBMaW5hcm86IEZhY2Vib29rIHwgVHdpdHRlciB8IEJsb2cKCi0t IApsaW51eC1waHkgbWFpbGluZyBsaXN0CmxpbnV4LXBoeUBsaXN0cy5pbmZyYWRlYWQub3JnCmh0 dHBzOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXBoeQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 46487C433EF for ; Wed, 13 Apr 2022 08:33:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=mYnazWrxrVzRMD7Y9xPGUuoKh6S7SgarKjqjRdG7YWA=; b=ZLQOis+XRjAh/u rQAxmN6T7SwViYsLjq7orSguBiuEzHAFUTjSuPiacZgzk0IbBaGV7gIZiECl0wY+4YN8O4cRWuK2j fo7AwMOSvMlyUUfyGeG6ZmLdG2rHw9aEk6pC7XAz9B1Jy86amjW3wkTWX4X05VnI2uEqU1sBvGTU2 S6uUvIEUOJqSKyAtQZH4lLHFymoaeqi7/eEh/xVUs8nDKYwGFd7nGQeIGCY2om41+0nRSyjGWg7pY 0iXtLyc5HHT7pGLMpeXb4lT2hEJa9FPZ78iKZvyc6G14xOrw5XepkZwSCrNkTrXUg1eQ5XonHQO6B qi5uk1lyw8F+il6Z9geQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1neYQS-0005FZ-8O; Wed, 13 Apr 2022 08:32:32 +0000 Received: from mail-wr1-x431.google.com ([2a00:1450:4864:20::431]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1neYQN-0005DW-6Q for linux-arm-kernel@lists.infradead.org; Wed, 13 Apr 2022 08:32:30 +0000 Received: by mail-wr1-x431.google.com with SMTP id u3so1520995wrg.3 for ; Wed, 13 Apr 2022 01:32:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to; bh=43L4Fo1VTg4iHrSwnBG558ytJYsFKrb6ExWD6ZDsMak=; b=KG6a9NYqPhTPLeRQWj7HFdFz0SVMQgvtCq9jhHPw0ijLyeLHMPpL6P66acaHSk1da1 WQ7MbIycSEDhN0RdU8Lc/7jCq0LD5g76SIPX49y48OYMupEz5UgFBI2RcrxXLUuhetCs cjAxq3OQ+trQSFj4zI5AHi2Eh+nIfLqDP6jgzHrXG15oObfPNn9KdO9ITMmLFflV5UnR V7s0OqBlRhRfO47q0OVKdLqStMhNFAD0vO99+DVNSLtyG1uFXkaRzah1KU7PC6Rdlami AbzEyOTjmPlkO/ewRJWE8qACRDqzJuhZEDR70Z1dbiYPmIZ9z5kVltilHNvmu8nK4cr9 Ehug== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to; bh=43L4Fo1VTg4iHrSwnBG558ytJYsFKrb6ExWD6ZDsMak=; b=aCgOKxW/r7vDCbPBYDekc8ZvCzVTrIgx5QGIHlsyxogL6agpxGgjLwcXJHMxNukioV LjqIu69L0y6rdHx6m12C+AOQs9AyeQnOY9VtC1UjmQvyMCQor25d1k8xrK3V5WPL9qRY vLej6P7co7PhmQYN7qjLLUWjoV6LpmC64GiKF/9jgnWNUNB15D6HKMt4hP/1MG5Oas56 q3I1ucv+JV47FDSFZDI7nN8t07sZ99dtW11I5Hbs3CdtevtVEgveXv26VtQ1HY4mdP1Y /r6g+WD1i9QMQqzPRmpoGb+5wCCvJOkwgbTDfJHLVSa+GYdrQenpvy61cJqnRTspF93a tPDQ== X-Gm-Message-State: AOAM532lrguMCvO5sd8qDF9P3MRTrMcEWh2PWO+sfP0v9V/RW+82pbS1 94QHuIhaYDL7iYm04CXVDNxNtw== X-Google-Smtp-Source: ABdhPJyb4o/u7q7PWqlOyrGHkM8DDEqRl9AmtylLWkEJrmLmDjLt1mvEGrxMMUOQ6KZKokIhuDpJ5w== X-Received: by 2002:a5d:44d0:0:b0:207:9ac8:2c3b with SMTP id z16-20020a5d44d0000000b002079ac82c3bmr18170538wrr.688.1649838745047; Wed, 13 Apr 2022 01:32:25 -0700 (PDT) Received: from google.com (cpc155339-bagu17-2-0-cust87.1-3.cable.virginm.net. [86.27.177.88]) by smtp.gmail.com with ESMTPSA id f9-20020a05600c154900b0038cb98076d6sm1955228wmg.10.2022.04.13.01.32.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Apr 2022 01:32:24 -0700 (PDT) Date: Wed, 13 Apr 2022 09:32:22 +0100 From: Lee Jones To: Colin Foster Cc: linux-arm-kernel@lists.infradead.org, linux-gpio@vger.kernel.org, linux-phy@lists.infradead.org, netdev@vger.kernel.org, linux-kernel@vger.kernel.org, "Rafael J. Wysocki" , Marc Zyngier , Hector Martin , Angela Czubak , Steen Hegelund , Lars Povlsen , Linus Walleij , Vinod Koul , Kishon Vijay Abraham I , Russell King , Heiner Kallweit , Jakub Kicinski , "David S. Miller" , Florian Fainelli , Vivien Didelot , Andrew Lunn , UNGLinuxDriver@microchip.com, Alexandre Belloni , Claudiu Manoil , Vladimir Oltean , katie.morris@in-advantage.com Subject: Re: [RFC v7 net-next 10/13] mfd: ocelot: add support for the vsc7512 chip via spi Message-ID: References: <20220307021208.2406741-1-colin.foster@in-advantage.com> <20220307021208.2406741-11-colin.foster@in-advantage.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20220307021208.2406741-11-colin.foster@in-advantage.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220413_013227_349318_068BC1B4 X-CRM114-Status: GOOD ( 44.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 T24gU3VuLCAwNiBNYXIgMjAyMiwgQ29saW4gRm9zdGVyIHdyb3RlOgoKPiBUaGUgVlNDNzUxMiBp cyBhIG5ldHdvcmtpbmcgY2hpcCB0aGF0IGNvbnRhaW5zIHNldmVyYWwgcGVyaXBoZXJhbHMuIE1h bnkgb2YKPiB0aGVzZSBwZXJpcGhlcmFscyBhcmUgY3VycmVudGx5IHN1cHBvcnRlZCBieSB0aGUg VlNDNzUxMyBhbmQgVlNDNzUxNCBjaGlwcywKPiBidXQgdGhvc2UgcnVuIG9uIGFuIGludGVybmFs IENQVS4gVGhlIFZTQzc1MTIgbGFja3MgdGhpcyBDUFUsIGFuZCBtdXN0IGJlCj4gY29udHJvbGxl ZCBleHRlcm5hbGx5Lgo+IAo+IFV0aWxpemUgdGhlIGV4aXN0aW5nIGRyaXZlcnMgYnkgcmVmZXJl bmNpbmcgdGhlIGNoaXAgYXMgYW4gTUZELiBBZGQgc3VwcG9ydAo+IGZvciB0aGUgdHdvIE1ESU8g YnVzZXMsIHRoZSBpbnRlcm5hbCBwaHlzLCBwaW5jdHJsLCBzZXJpYWwgR1BJTywgYW5kIEhTSU8u Cj4gCj4gU2lnbmVkLW9mZi1ieTogQ29saW4gRm9zdGVyIDxjb2xpbi5mb3N0ZXJAaW4tYWR2YW50 YWdlLmNvbT4KPiAtLS0KPiAgZHJpdmVycy9tZmQvS2NvbmZpZyAgICAgICB8ICAyNCArKysKPiAg ZHJpdmVycy9tZmQvTWFrZWZpbGUgICAgICB8ICAgMyArCj4gIGRyaXZlcnMvbWZkL29jZWxvdC1j b3JlLmMgfCAxODkgKysrKysrKysrKysrKysrKysrKysrKysKPiAgZHJpdmVycy9tZmQvb2NlbG90 LXNwaS5jICB8IDMxMyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICBk cml2ZXJzL21mZC9vY2Vsb3QuaCAgICAgIHwgIDQyICsrKysrCj4gIGluY2x1ZGUvc29jL21zY2Mv b2NlbG90LmggfCAgIDUgKwo+ICA2IGZpbGVzIGNoYW5nZWQsIDU3NiBpbnNlcnRpb25zKCspCj4g IGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21mZC9vY2Vsb3QtY29yZS5jCj4gIGNyZWF0ZSBt b2RlIDEwMDY0NCBkcml2ZXJzL21mZC9vY2Vsb3Qtc3BpLmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0 IGRyaXZlcnMvbWZkL29jZWxvdC5oCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL0tjb25m aWcgYi9kcml2ZXJzL21mZC9LY29uZmlnCj4gaW5kZXggYmEwYjNlYjEzMWYxLi5kNDMxMmE1MjUy ZDAgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9tZmQvS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvbWZk L0tjb25maWcKPiBAQCAtOTQ4LDYgKzk0OCwzMCBAQCBjb25maWcgTUZEX01FTkYyMUJNQwo+ICAJ ICBUaGlzIGRyaXZlciBjYW4gYWxzbyBiZSBidWlsdCBhcyBhIG1vZHVsZS4gSWYgc28gdGhlIG1v ZHVsZQo+ICAJICB3aWxsIGJlIGNhbGxlZCBtZW5mMjFibWMuCj4gIAo+ICtjb25maWcgTUZEX09D RUxPVAo+ICsJdHJpc3RhdGUgIk1pY3Jvc2VtaSBPY2Vsb3QgRXh0ZXJuYWwgQ29udHJvbCBTdXBw b3J0Igo+ICsJc2VsZWN0IE1GRF9DT1JFCj4gKwloZWxwCj4gKwkgIE9jZWxvdCBpcyBhIGZhbWls eSBvZiBuZXR3b3JraW5nIGNoaXBzIHRoYXQgc3VwcG9ydCBtdWx0aXBsZSBldGhlcm5ldAo+ICsJ ICBhbmQgZmlicmUgaW50ZXJmYWNlcy4gSW4gYWRkaXRpb24gdG8gbmV0d29ya2luZywgdGhleSBj b250YWluIHNldmVyYWwKPiArCSAgb3RoZXIgZnVuY3Rpb25zLCBpbmNsdWRpbmcgcGljdHJsLCBN RElPLCBhbmQgY29tbXVuaWNhdGlvbiB3aXRoCj4gKwkgIGV4dGVybmFsIGNoaXBzLiBXaGlsZSBz b21lIGNoaXBzIGhhdmUgYW4gaW50ZXJuYWwgcHJvY2Vzc29yIGNhcGFibGUgb2YKPiArCSAgcnVu bmluZyBhbiBPUywgb3RoZXJzIGRvbid0LiBBbGwgY2hpcHMgY2FuIGJlIGNvbnRyb2xsZWQgZXh0 ZXJuYWxseQo+ICsJICB0aHJvdWdoIGRpZmZlcmVudCBpbnRlcmZhY2VzLCBpbmNsdWRpbmcgU1BJ LCBJMkMsIGFuZCBQQ0llLgo+ICsKPiArCSAgU2F5IHllcyBoZXJlIHRvIGFkZCBzdXBwb3J0IGZv ciBPY2Vsb3QgY2hpcHMgKFZTQzc1MTEsIFZTQzc1MTIsCj4gKwkgIFZTQzc1MTMsIFZTQzc1MTQp IGNvbnRyb2xsZWQgZXh0ZXJuYWxseS4KPiArCj4gKwkgIElmIHVuc3VyZSwgc2F5IE4KPiArCj4g K2NvbmZpZyBNRkRfT0NFTE9UX1NQSQo+ICsJdHJpc3RhdGUgIk1pY3Jvc2VtaSBPY2Vsb3QgU1BJ IGludGVyZmFjZSIKPiArCWRlcGVuZHMgb24gTUZEX09DRUxPVAo+ICsJZGVwZW5kcyBvbiBTUElf TUFTVEVSCj4gKwlzZWxlY3QgUkVHTUFQX1NQSQo+ICsJaGVscAo+ICsJICBTYXkgeWVzIGhlcmUg dG8gYWRkIGNvbnRyb2wgdG8gdGhlIE1GRF9PQ0VMT1QgY2hpcHMgdmlhIFNQSS4KPiArCj4gIGNv bmZpZyBFWlhfUENBUAo+ICAJYm9vbCAiTW90b3JvbGEgRVpYUENBUCBTdXBwb3J0Igo+ICAJZGVw ZW5kcyBvbiBTUElfTUFTVEVSCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL01ha2VmaWxlIGIv ZHJpdmVycy9tZmQvTWFrZWZpbGUKPiBpbmRleCBkZjFlY2M0YTRjOTUuLjEyNTEzODQzMDY3YSAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL21mZC9NYWtlZmlsZQo+ICsrKyBiL2RyaXZlcnMvbWZkL01h a2VmaWxlCj4gQEAgLTEyMCw2ICsxMjAsOSBAQCBvYmotJChDT05GSUdfTUZEX01DMTNYWFhfSTJD KQkrPSBtYzEzeHh4LWkyYy5vCj4gIAo+ICBvYmotJChDT05GSUdfTUZEX0NPUkUpCQkrPSBtZmQt Y29yZS5vCj4gIAo+ICtvYmotJChDT05GSUdfTUZEX09DRUxPVCkJKz0gb2NlbG90LWNvcmUubwo+ ICtvYmotJChDT05GSUdfTUZEX09DRUxPVF9TUEkpCSs9IG9jZWxvdC1zcGkubwo+ICsKPiAgb2Jq LSQoQ09ORklHX0VaWF9QQ0FQKQkJKz0gZXp4LXBjYXAubwo+ICBvYmotJChDT05GSUdfTUZEX0NQ Q0FQKQkJKz0gbW90b3JvbGEtY3BjYXAubwo+ICAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQv b2NlbG90LWNvcmUuYyBiL2RyaXZlcnMvbWZkL29jZWxvdC1jb3JlLmMKPiBuZXcgZmlsZSBtb2Rl IDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uMzZlNDMyNmE4NTNhCj4gLS0tIC9kZXYvbnVs bAo+ICsrKyBiL2RyaXZlcnMvbWZkL29jZWxvdC1jb3JlLmMKPiBAQCAtMCwwICsxLDE4OSBAQAo+ ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogKEdQTC0yLjAgT1IgTUlUKQo+ICsvKgo+ICsg KiBNRkQgY29yZSBkcml2ZXIgZm9yIHRoZSBPY2Vsb3QgY2hpcCBmYW1pbHkuCgpQbGVhc2UgZHJv cCBhbGwgcmVmZXJlbmNlcyB0byAnTUZEJy4KCidDb3JlJyBpcyBmaW5lLCBhcyBpcyAnUGFyZW50 Jy4KCj4gKyAqIFRoZSBWU0M3NTExLCA3NTEyLCA3NTEzLCBhbmQgNzUxNCBjYW4gYmUgY29udHJv bGxlZCBpbnRlcm5hbGx5IHZpYSBhbgo+ICsgKiBvbi1jaGlwIE1JUFMgcHJvY2Vzc29yLCBvciBl eHRlcm5hbGx5IHZpYSBTUEksIEkyQywgUENJZS4gVGhpcyBjb3JlIGRyaXZlciBpcwo+ICsgKiBp bnRlbmRlZCB0byBiZSB0aGUgYnVzLWFnbm9zdGljIGdsdWUgYmV0d2VlbiwgZm9yIGV4YW1wbGUs IHRoZSBTUEkgYnVzIGFuZAo+ICsgKiB0aGUgTUZEIGNoaWxkcmVuLgo+ICsgKgo+ICsgKiBDb3B5 cmlnaHQgMjAyMSBJbm5vdmF0aXZlIEFkdmFudGFnZSBJbmMuCgpPdXQgb2YgZGF0ZT8KCj4gKyAq IEF1dGhvcjogQ29saW4gRm9zdGVyIDxjb2xpbi5mb3N0ZXJAaW4tYWR2YW50YWdlLmNvbT4KPiAr ICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvbWZkL2NvcmUuaD4KPiArI2luY2x1ZGUgPGxpbnV4 L21vZHVsZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+Cj4gKyNpbmNsdWRlIDxzb2Mv bXNjYy9vY2Vsb3QuaD4KPiArCj4gKyNpbmNsdWRlIDxhc20vYnl0ZW9yZGVyLmg+Cj4gKwo+ICsj aW5jbHVkZSAib2NlbG90LmgiCj4gKwo+ICsjZGVmaW5lIEdDQl9TT0ZUX1JTVCAweDAwMDgKClRh YiB0aGVzZSBvdXQgdG8gbWF0Y2ggdGhlIG90aGVycz8KCj4gKyNkZWZpbmUgU09GVF9DSElQX1JT VCAweDEKPiArCj4gKyNkZWZpbmUgVlNDNzUxMl9HQ0JfUkVTX1NUQVJUCTB4NzEwNzAwMDAKPiAr I2RlZmluZSBWU0M3NTEyX0dDQl9SRVNfU0laRQkweDE0Cj4gKwo+ICsjZGVmaW5lIFZTQzc1MTJf TUlJTTBfUkVTX1NUQVJUCTB4NzEwNzAwOWMKPiArI2RlZmluZSBWU0M3NTEyX01JSU0wX1JFU19T SVpFCTB4MjQKPiArCj4gKyNkZWZpbmUgVlNDNzUxMl9NSUlNMV9SRVNfU1RBUlQJMHg3MTA3MDBj MAo+ICsjZGVmaW5lIFZTQzc1MTJfTUlJTTFfUkVTX1NJWkUJMHgyNAo+ICsKPiArI2RlZmluZSBW U0M3NTEyX1BIWV9SRVNfU1RBUlQJMHg3MTA3MDBmMAo+ICsjZGVmaW5lIFZTQzc1MTJfUEhZX1JF U19TSVpFCTB4NAo+ICsKPiArI2RlZmluZSBWU0M3NTEyX0hTSU9fUkVTX1NUQVJUCTB4NzEwZDAw MDAKPiArI2RlZmluZSBWU0M3NTEyX0hTSU9fUkVTX1NJWkUJMHgxMDAwMAo+ICsKPiArI2RlZmlu ZSBWU0M3NTEyX0dQSU9fUkVTX1NUQVJUCTB4NzEwNzAwMzQKPiArI2RlZmluZSBWU0M3NTEyX0dQ SU9fUkVTX1NJWkUJMHg2Ywo+ICsKPiArI2RlZmluZSBWU0M3NTEyX1NJT19SRVNfU1RBUlQJMHg3 MTA3MDBmOAo+ICsjZGVmaW5lIFZTQzc1MTJfU0lPX1JFU19TSVpFCTB4MTAwCj4gKwo+ICtzdGF0 aWMgY29uc3Qgc3RydWN0IHJlc291cmNlIHZzYzc1MTJfZ2NiX3Jlc291cmNlID0KPiArCURFRklO RV9SRVNfUkVHX05BTUVEKFZTQzc1MTJfR0NCX1JFU19TVEFSVCwgVlNDNzUxMl9HQ0JfUkVTX1NJ WkUsCj4gKwkJCSAgICAgImRldmNwdV9nY2JfY2hpcF9yZWdzIik7Cj4gKwo+ICtzdGF0aWMgaW50 IG9jZWxvdF9yZXNldChzdHJ1Y3Qgb2NlbG90X2NvcmUgKmNvcmUpCj4gK3sKPiArCWludCByZXQ7 Cj4gKwo+ICsJLyoKPiArCSAqIFJlc2V0IHRoZSBlbnRpcmUgY2hpcCBoZXJlIHRvIHB1dCBpdCBp bnRvIGEgY29tcGxldGVseSBrbm93biBzdGF0ZS4KPiArCSAqIE90aGVyIGRyaXZlcnMgbWF5IHdh bnQgdG8gcmVzZXQgdGhlaXIgb3duIHN1YnN5c3RlbXMuIFRoZSByZWdpc3Rlcgo+ICsJICogc2Vs Zi1jbGVhcnMsIHNvIG9uZSB3cml0ZSBpcyBhbGwgdGhhdCBpcyBuZWVkZWQKPiArCSAqLwo+ICsJ cmV0ID0gcmVnbWFwX3dyaXRlKGNvcmUtPmdjYl9yZWdtYXAsIEdDQl9TT0ZUX1JTVCwgU09GVF9D SElQX1JTVCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJbXNsZWVwKDEw MCk7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCByZWdtYXAg Km9jZWxvdF9kZXZtX3JlZ21hcF9pbml0KHN0cnVjdCBvY2Vsb3RfY29yZSAqY29yZSwKPiArCQkJ CQkgICAgICBzdHJ1Y3QgZGV2aWNlICpjaGlsZCwKPiArCQkJCQkgICAgICBjb25zdCBzdHJ1Y3Qg cmVzb3VyY2UgKnJlcykKPiArewo+ICsJLyoKPiArCSAqIENhbGwgZGlyZWN0bHkgaW50byBvY2Vs b3Rfc3BpIHRvIGdldCBhIG5ldyByZWdtYXAuIFRoaXMgd2lsbCBuZWVkIHRvCj4gKwkgKiBiZSBl eHBhbmRlZCBpZiBhZGRpdGlvbmFsIGJ1cyB0eXBlcyBhcmUgdG8gYmUgc3VwcG9ydGVkIGluIHRo ZQo+ICsJICogZnV0dXJlLgo+ICsJICovCj4gKwlyZXR1cm4gb2NlbG90X3NwaV9kZXZtX2dldF9y ZWdtYXAoY29yZSwgY2hpbGQsIHJlcyk7Cj4gK30KPiArCj4gK3N0cnVjdCByZWdtYXAgKm9jZWxv dF9nZXRfcmVnbWFwX2Zyb21fcmVzb3VyY2Uoc3RydWN0IGRldmljZSAqY2hpbGQsCj4gKwkJCQkJ ICAgICAgIGNvbnN0IHN0cnVjdCByZXNvdXJjZSAqcmVzKQo+ICt7Cj4gKwlzdHJ1Y3Qgb2NlbG90 X2NvcmUgKmNvcmUgPSBkZXZfZ2V0X2RydmRhdGEoY2hpbGQtPnBhcmVudCk7Cj4gKwo+ICsJcmV0 dXJuIG9jZWxvdF9kZXZtX3JlZ21hcF9pbml0KGNvcmUsIGNoaWxkLCByZXMpOwo+ICt9Cj4gK0VY UE9SVF9TWU1CT0wob2NlbG90X2dldF9yZWdtYXBfZnJvbV9yZXNvdXJjZSk7CgpXaGF0J3MgdGhl IHJlYXNvbiBmb3IgaGF2aW5nIGFuIGFkZGl0aW9uYWwgZnVuY3Rpb24gd2hlbiBvbmUgd291bGQg ZG8/Cgo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IHJlc291cmNlIHZzYzc1MTJfbWlpbTBfcmVzb3Vy Y2VzW10gPSB7Cj4gKwlERUZJTkVfUkVTX1JFR19OQU1FRChWU0M3NTEyX01JSU0wX1JFU19TVEFS VCwgVlNDNzUxMl9NSUlNMF9SRVNfU0laRSwKPiArCQkJICAgICAiZ2NiX21paW0wIiksCj4gKwlE RUZJTkVfUkVTX1JFR19OQU1FRChWU0M3NTEyX1BIWV9SRVNfU1RBUlQsIFZTQzc1MTJfUEhZX1JF U19TSVpFLAo+ICsJCQkgICAgICJnY2JfcGh5IiksCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qg c3RydWN0IHJlc291cmNlIHZzYzc1MTJfbWlpbTFfcmVzb3VyY2VzW10gPSB7Cj4gKwlERUZJTkVf UkVTX1JFR19OQU1FRChWU0M3NTEyX01JSU0xX1JFU19TVEFSVCwgVlNDNzUxMl9NSUlNMV9SRVNf U0laRSwKPiArCQkJICAgICAiZ2NiX21paW0xIiksCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qg c3RydWN0IHJlc291cmNlIHZzYzc1MTJfaHNpb19yZXNvdXJjZXNbXSA9IHsKPiArCURFRklORV9S RVNfUkVHX05BTUVEKFZTQzc1MTJfSFNJT19SRVNfU1RBUlQsIFZTQzc1MTJfSFNJT19SRVNfU0la RSwKPiArCQkJICAgICAiaHNpbyIpLAo+ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBy ZXNvdXJjZSB2c2M3NTEyX3BpbmN0cmxfcmVzb3VyY2VzW10gPSB7Cj4gKwlERUZJTkVfUkVTX1JF R19OQU1FRChWU0M3NTEyX0dQSU9fUkVTX1NUQVJULCBWU0M3NTEyX0dQSU9fUkVTX1NJWkUsCj4g KwkJCSAgICAgImdjYl9ncGlvIiksCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IHJl c291cmNlIHZzYzc1MTJfc2dwaW9fcmVzb3VyY2VzW10gPSB7Cj4gKwlERUZJTkVfUkVTX1JFR19O QU1FRChWU0M3NTEyX1NJT19SRVNfU1RBUlQsIFZTQzc1MTJfU0lPX1JFU19TSVpFLAo+ICsJCQkg ICAgICJnY2Jfc2lvIiksCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG1mZF9jZWxs IHZzYzc1MTJfZGV2c1tdID0gewo+ICsJewo+ICsJCS5uYW1lID0gIm9jZWxvdC1waW5jdHJsIiwK PiArCQkub2ZfY29tcGF0aWJsZSA9ICJtc2NjLG9jZWxvdC1waW5jdHJsIiwKPiArCQkubnVtX3Jl c291cmNlcyA9IEFSUkFZX1NJWkUodnNjNzUxMl9waW5jdHJsX3Jlc291cmNlcyksCj4gKwkJLnJl c291cmNlcyA9IHZzYzc1MTJfcGluY3RybF9yZXNvdXJjZXMsCj4gKwl9LCB7Cj4gKwkJLm5hbWUg PSAib2NlbG90LXNncGlvIiwKPiArCQkub2ZfY29tcGF0aWJsZSA9ICJtc2NjLG9jZWxvdC1zZ3Bp byIsCj4gKwkJLm51bV9yZXNvdXJjZXMgPSBBUlJBWV9TSVpFKHZzYzc1MTJfc2dwaW9fcmVzb3Vy Y2VzKSwKPiArCQkucmVzb3VyY2VzID0gdnNjNzUxMl9zZ3Bpb19yZXNvdXJjZXMsCj4gKwl9LCB7 Cj4gKwkJLm5hbWUgPSAib2NlbG90LW1paW0wIiwKPiArCQkub2ZfY29tcGF0aWJsZSA9ICJtc2Nj LG9jZWxvdC1taWltIiwKPiArCQkubnVtX3Jlc291cmNlcyA9IEFSUkFZX1NJWkUodnNjNzUxMl9t aWltMF9yZXNvdXJjZXMpLAo+ICsJCS5yZXNvdXJjZXMgPSB2c2M3NTEyX21paW0wX3Jlc291cmNl cywKPiArCX0sIHsKPiArCQkubmFtZSA9ICJvY2Vsb3QtbWlpbTEiLAo+ICsJCS5vZl9jb21wYXRp YmxlID0gIm1zY2Msb2NlbG90LW1paW0iLAo+ICsJCS5udW1fcmVzb3VyY2VzID0gQVJSQVlfU0la RSh2c2M3NTEyX21paW0xX3Jlc291cmNlcyksCj4gKwkJLnJlc291cmNlcyA9IHZzYzc1MTJfbWlp bTFfcmVzb3VyY2VzLAo+ICsJfSwgewo+ICsJCS5uYW1lID0gIm9jZWxvdC1zZXJkZXMiLAo+ICsJ CS5vZl9jb21wYXRpYmxlID0gIm1zY2MsdnNjNzUxNC1zZXJkZXMiLAo+ICsJCS5udW1fcmVzb3Vy Y2VzID0gQVJSQVlfU0laRSh2c2M3NTEyX2hzaW9fcmVzb3VyY2VzKSwKPiArCQkucmVzb3VyY2Vz ID0gdnNjNzUxMl9oc2lvX3Jlc291cmNlcywKPiArCX0sCj4gK307Cj4gKwo+ICtpbnQgb2NlbG90 X2NvcmVfaW5pdChzdHJ1Y3Qgb2NlbG90X2NvcmUgKmNvcmUpCj4gK3sKPiArCXN0cnVjdCBkZXZp Y2UgKmRldiA9IGNvcmUtPmRldjsKPiArCWludCByZXQ7Cj4gKwo+ICsJZGV2X3NldF9kcnZkYXRh KGRldiwgY29yZSk7Cj4gKwo+ICsJY29yZS0+Z2NiX3JlZ21hcCA9IG9jZWxvdF9kZXZtX3JlZ21h cF9pbml0KGNvcmUsIGRldiwKPiArCQkJCQkJICAgJnZzYzc1MTJfZ2NiX3Jlc291cmNlKTsKClRo aXMganVzdCBlbmRzIHVwIGNhbGxpbmcgb2NlbG90X3NwaV9kZXZtX2dldF9yZWdtYXAoKSByaWdo dD8KCldoeSBub3QgY2FsbCB0aGF0IGZyb20gaW5zaWRlIG9jZWxvdC1zcGkuYyB3aGVyZSAnY29y ZScgd2FzIGFsbG9jYXRlZD8KCj4gKwlpZiAoSVNfRVJSKGNvcmUtPmdjYl9yZWdtYXApKQo+ICsJ CXJldHVybiAtRU5PTUVNOwo+ICsKPiArCXJldCA9IG9jZWxvdF9yZXNldChjb3JlKTsKPiArCWlm IChyZXQpIHsKPiArCQlkZXZfZXJyKGRldiwgIkZhaWxlZCB0byByZXNldCBkZXZpY2U6ICVkXG4i LCByZXQpOwo+ICsJCXJldHVybiByZXQ7Cj4gKwl9Cj4gKwo+ICsJLyoKPiArCSAqIEEgY2hpcCBy ZXNldCB3aWxsIGNsZWFyIHRoZSBTUEkgY29uZmlndXJhdGlvbiwgc28gaXQgbmVlZHMgdG8gYmUg ZG9uZQo+ICsJICogYWdhaW4gYmVmb3JlIHdlIGNhbiBhY2Nlc3MgYW55IHJlZ2lzdGVycwo+ICsJ ICovCj4gKwlyZXQgPSBvY2Vsb3Rfc3BpX2luaXRpYWxpemUoY29yZSk7CgpOb3QgYSBmYW4gb2Yg Y2FsbGluZyBiYWNrIGludG8gdGhlIGZpbGUgd2hpY2ggY2FsbGVkIHVzLgoKQW5kIHdoYXQgaGFw cGVucyBpZiBTUEkgaXNuJ3QgY29udHJvbGxpbmcgdXM/CgpEb2Vzbid0IHRoZSBkb2N1bWVudGF0 aW9uIGFib3ZlIHNheSB0aGlzIGRldmljZSBjYW4gYWxzbyBiZQpjb21tdW5pY2F0ZWQgd2l0aCB2 aWEgSTJDIGFuZCBQQ0llPwoKPiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKGRldiwgIkZhaWxl ZCB0byBpbml0aWFsaXplIFNQSSBpbnRlcmZhY2U6ICVkXG4iLCByZXQpOwo+ICsJCXJldHVybiBy ZXQ7Cj4gKwl9Cj4gKwo+ICsJcmV0ID0gZGV2bV9tZmRfYWRkX2RldmljZXMoZGV2LCBQTEFURk9S TV9ERVZJRF9BVVRPLCB2c2M3NTEyX2RldnMsCj4gKwkJCQkgICBBUlJBWV9TSVpFKHZzYzc1MTJf ZGV2cyksIE5VTEwsIDAsIE5VTEwpOwo+ICsJaWYgKHJldCkgewo+ICsJCWRldl9lcnIoZGV2LCAi RmFpbGVkIHRvIGFkZCBzdWItZGV2aWNlczogJWRcbiIsIHJldCk7Cj4gKwkJcmV0dXJuIHJldDsK PiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICtFWFBPUlRfU1lNQk9MKG9jZWxvdF9jb3Jl X2luaXQpOwo+ICsKPiArTU9EVUxFX0RFU0NSSVBUSU9OKCJFeHRlcm5hbGx5IENvbnRyb2xsZWQg T2NlbG90IENoaXAgRHJpdmVyIik7Cj4gK01PRFVMRV9BVVRIT1IoIkNvbGluIEZvc3RlciA8Y29s aW4uZm9zdGVyQGluLWFkdmFudGFnZS5jb20+Iik7Cj4gK01PRFVMRV9MSUNFTlNFKCJHUEwgdjIi KTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvb2NlbG90LXNwaS5jIGIvZHJpdmVycy9tZmQv b2NlbG90LXNwaS5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAu LmM3ODhlMjM5YzlhNwo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL21mZC9vY2Vsb3Qt c3BpLmMKPiBAQCAtMCwwICsxLDMxMyBAQAo+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog KEdQTC0yLjAgT1IgTUlUKQo+ICsvKgo+ICsgKiBTUEkgY29yZSBkcml2ZXIgZm9yIHRoZSBPY2Vs b3QgY2hpcCBmYW1pbHkuCj4gKyAqCj4gKyAqIFRoaXMgZHJpdmVyIHdpbGwgaGFuZGxlIGV2ZXJ5 dGhpbmcgbmVjZXNzYXJ5IHRvIGFsbG93IGZvciBjb21tdW5pY2F0aW9uIG92ZXIKPiArICogU1BJ IHRvIHRoZSBWU0M3NTExLCBWU0M3NTEyLCBWU0M3NTEzIGFuZCBWU0M3NTE0IGNoaXBzLiBUaGUg bWFpbiBmdW5jdGlvbnMKPiArICogYXJlIHRvIHByZXBhcmUgdGhlIGNoaXAncyBTUEkgaW50ZXJm YWNlIGZvciBhIHNwZWNpZmljIGJ1cyBzcGVlZCwgYW5kIGEgaG9zdAo+ICsgKiBwcm9jZXNzb3In cyBlbmRpYW5uZXNzLiBUaGlzIHdpbGwgY3JlYXRlIGFuZCBkaXN0cmlidXRlIHJlZ21hcHMgZm9y IGFueSBNRkQKCkFzIGFib3ZlLCBwbGVhc2UgZHJvcCByZWZlcmVuY2VzIHRvIE1GRC4KCj4gKyAq IGNoaWxkcmVuLgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgMjAyMSBJbm5vdmF0aXZlIEFkdmFudGFn ZSBJbmMuCj4gKyAqCj4gKyAqIEF1dGhvcjogQ29saW4gRm9zdGVyIDxjb2xpbi5mb3N0ZXJAaW4t YWR2YW50YWdlLmNvbT4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvaW9wb2xsLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9rY29uZmlnLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4K PiArI2luY2x1ZGUgPGxpbnV4L29mLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KPiAr I2luY2x1ZGUgPGxpbnV4L3NwaS9zcGkuaD4KPiArCj4gKyNpbmNsdWRlIDxhc20vYnl0ZW9yZGVy Lmg+Cj4gKwo+ICsjaW5jbHVkZSAib2NlbG90LmgiCj4gKwo+ICsjZGVmaW5lIERFVl9DUFVPUkdf SUZfQ1RSTAkweDAwMDAKPiArI2RlZmluZSBERVZfQ1BVT1JHX0lGX0NGR1NUQVQJMHgwMDA0Cj4g Kwo+ICsjZGVmaW5lIENGR1NUQVRfSUZfTlVNX1ZDT1JFCSgwIDw8IDI0KQo+ICsjZGVmaW5lIENG R1NUQVRfSUZfTlVNX1ZSQVAJKDEgPDwgMjQpCj4gKyNkZWZpbmUgQ0ZHU1RBVF9JRl9OVU1fU0kJ KDIgPDwgMjQpCj4gKyNkZWZpbmUgQ0ZHU1RBVF9JRl9OVU1fTUlJTQkoMyA8PCAyNCkKPiArCj4g Kwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IHJlc291cmNlIHZzYzc1MTJfZGV2X2NwdW9yZ19yZXNv dXJjZSA9IHsKPiArCS5zdGFydAk9IDB4NzEwMDAwMDAsCj4gKwkuZW5kCT0gMHg3MTAwMDJmZiwK Ck5vIG1hZ2ljIG51bWJlcnMuICBQbGVhc2UgZGVmaW5lIHRoZXNlIGFkZHJlc3Nlcy4KCj4gKwku bmFtZQk9ICJkZXZjcHVfb3JnIiwKPiArfTsKPiArCj4gKyNkZWZpbmUgVlNDNzUxMl9CWVRFX09S REVSX0xFIDB4MDAwMDAwMDAKPiArI2RlZmluZSBWU0M3NTEyX0JZVEVfT1JERVJfQkUgMHg4MTgx ODE4MQo+ICsjZGVmaW5lIFZTQzc1MTJfQklUX09SREVSX01TQiAweDAwMDAwMDAwCj4gKyNkZWZp bmUgVlNDNzUxMl9CSVRfT1JERVJfTFNCIDB4NDI0MjQyNDIKPiArCj4gK2ludCBvY2Vsb3Rfc3Bp X2luaXRpYWxpemUoc3RydWN0IG9jZWxvdF9jb3JlICpjb3JlKQo+ICt7Cj4gKwl1MzIgdmFsLCBj aGVjazsKPiArCWludCBlcnI7Cj4gKwo+ICsjaWZkZWYgX19MSVRUTEVfRU5ESUFOCj4gKwl2YWwg PSBWU0M3NTEyX0JZVEVfT1JERVJfTEU7Cj4gKyNlbHNlCj4gKwl2YWwgPSBWU0M3NTEyX0JZVEVf T1JERVJfQkU7Cj4gKyNlbmRpZgoKTm90IGEgZmFuIG9mIGlmZGVmZXJ5IGluIHRoZSBtaWRkbGUg b2YgQyBmaWxlcy4KClBsZWFzZSBjcmVhdGUgYSBtYWNybyBvciBkZWZpbmUgc29tZXdoZXJlLgoK PiArCWVyciA9IHJlZ21hcF93cml0ZShjb3JlLT5jcHVvcmdfcmVnbWFwLCBERVZfQ1BVT1JHX0lG X0NUUkwsIHZhbCk7Cj4gKwlpZiAoZXJyKQo+ICsJCXJldHVybiBlcnI7CgpDb21tZW50LgoKPiAr CXZhbCA9IGNvcmUtPnNwaV9wYWRkaW5nX2J5dGVzOwo+ICsJZXJyID0gcmVnbWFwX3dyaXRlKGNv cmUtPmNwdW9yZ19yZWdtYXAsIERFVl9DUFVPUkdfSUZfQ0ZHU1RBVCwgdmFsKTsKPiArCWlmIChl cnIpCj4gKwkJcmV0dXJuIGVycjsKCkNvbW1lbnQuCgo+ICsJLyoKPiArCSAqIEFmdGVyIHdlIHdy aXRlIHRoZSBpbnRlcmZhY2UgY29uZmlndXJhdGlvbiwgcmVhZCBpdCBiYWNrIGhlcmUuIFRoaXMK PiArCSAqIHdpbGwgdmVyaWZ5IHNldmVyYWwgZGlmZmVyZW50IHRoaW5ncy4gVGhlIGZpcnN0IGlz IHRoYXQgdGhlIG51bWJlciBvZgo+ICsJICogcGFkZGluZyBieXRlcyBhY3R1YWxseSBnb3Qgd3Jp dHRlbiBjb3JyZWN0bHkuIFRoZXNlIGFyZSBmb3VuZCBpbiBiaXRzCj4gKwkgKiAwOjMuCj4gKwkg Kgo+ICsJICogVGhlIHNlY29uZCBpcyB0aGF0IGJpdCAxNiBpcyBjbGVhcmVkLiBCaXQgMTYgaXMg SUZfQ0ZHU1RBVDpJRl9TVEFULAo+ICsJICogYW5kIHdpbGwgYmUgc2V0IGlmIHRoZSByZWdpc3Rl ciBhY2Nlc3MgaXMgdG9vIGZhc3QuIFRoaXMgd291bGQgYmUgaW4KPiArCSAqIHRoZSBjb25kaXRp b24gdGhhdCB0aGUgbnVtYmVyIG9mIHBhZGRpbmcgYnl0ZXMgaXMgaW5zdWZmaWNpZW50IGZvcgo+ ICsJICogdGhlIFNQSSBidXMgZnJlcXVlbmN5Lgo+ICsJICoKPiArCSAqIFRoZSBsYXN0IGNoZWNr IGlzIGZvciBiaXRzIDMxOjI0LCB3aGljaCBkZWZpbmUgdGhlIGludGVyZmFjZSBieSB3aGljaAo+ ICsJICogdGhlIHJlZ2lzdGVycyBhcmUgYmVpbmcgYWNjZXNzZWQuIFNpbmNlIHdlJ3JlIGFjY2Vz c2luZyB0aGVtIHZpYSB0aGUKPiArCSAqIHNlcmlhbCBpbnRlcmZhY2UsIGl0IG11c3QgcmV0dXJu IElGX05VTV9TSS4KPiArCSAqLwo+ICsJY2hlY2sgPSB2YWwgfCBDRkdTVEFUX0lGX05VTV9TSTsK PiArCj4gKwllcnIgPSByZWdtYXBfcmVhZChjb3JlLT5jcHVvcmdfcmVnbWFwLCBERVZfQ1BVT1JH X0lGX0NGR1NUQVQsICZ2YWwpOwo+ICsJaWYgKGVycikKPiArCQlyZXR1cm4gZXJyOwo+ICsKPiAr CWlmIChjaGVjayAhPSB2YWwpCj4gKwkJcmV0dXJuIC1FTk9ERVY7Cj4gKwo+ICsJcmV0dXJuIDA7 Cj4gK30KPiArRVhQT1JUX1NZTUJPTChvY2Vsb3Rfc3BpX2luaXRpYWxpemUpOwo+ICsKPiArLyoK PiArICogVGhlIFNQSSBwcm90b2NvbCBmb3IgaW50ZXJmYWNpbmcgd2l0aCB0aGUgb2NlbG90IGNo aXBzIHVzZXMgMjQgYml0cywgd2hpbGUKPiArICogdGhlIHJlZ2lzdGVyIGxvY2F0aW9ucyBhcmUg ZGVmaW5lZCBhcyAzMi1iaXQuIFRoZSBsZWFzdCBzaWduaWZpY2FudCB0d28gYml0cwo+ICsgKiBn ZXQgc2hpZnRlZCBvdXQsIGFzIHJlZ2lzdGVyIGFjY2Vzc2VzIG11c3QgYWx3YXlzIGJlIHdvcmQt YWxpZ25lZCwgbGVhdmluZwo+ICsgKiBiaXRzIDIxOjAgYXMgdGhlIDIyLWJpdCBhZGRyZXNzLiBJ dCBtdXN0IGFsd2F5cyBiZSBiaWctZW5kaWFuLCB3aGVyZWFzIHRoZQo+ICsgKiBwYXlsb2FkIGNh biBiZSBvcHRpbWl6ZWQgZm9yIGJpdCAvIGJ5dGUgb3JkZXIgdG8gbWF0Y2ggd2hhdGV2ZXIgYXJj aGl0ZWN0dXJlCj4gKyAqIHRoZSBjb250cm9sbGluZyBDUFUgaGFzLgo+ICsgKi8KPiArc3RhdGlj IHVuc2lnbmVkIGludCBvY2Vsb3Rfc3BpX3RyYW5zbGF0ZV9hZGRyZXNzKHVuc2lnbmVkIGludCBy ZWcpCj4gK3sKPiArCXJldHVybiBjcHVfdG9fYmUzMigocmVnICYgMHhmZmZmZmYpID4+IDIpOwo+ ICt9Cj4gKwo+ICtzdHJ1Y3Qgb2NlbG90X3NwaV9yZWdtYXBfY29udGV4dCB7Cj4gKwl1MzIgYmFz ZTsKPiArCXN0cnVjdCBvY2Vsb3RfY29yZSAqY29yZTsKPiArfTsKPiArCj4gK3N0YXRpYyBpbnQg b2NlbG90X3NwaV9yZWdfcmVhZCh2b2lkICpjb250ZXh0LCB1bnNpZ25lZCBpbnQgcmVnLAo+ICsJ CQkgICAgICAgdW5zaWduZWQgaW50ICp2YWwpCj4gK3sKPiArCXN0cnVjdCBvY2Vsb3Rfc3BpX3Jl Z21hcF9jb250ZXh0ICpyZWdtYXBfY29udGV4dCA9IGNvbnRleHQ7Cj4gKwlzdHJ1Y3Qgb2NlbG90 X2NvcmUgKmNvcmUgPSByZWdtYXBfY29udGV4dC0+Y29yZTsKPiArCXN0cnVjdCBzcGlfdHJhbnNm ZXIgdHgsIHBhZGRpbmcsIHJ4Owo+ICsJc3RydWN0IHNwaV9tZXNzYWdlIG1zZzsKCkhvdyBiaWcg YXJlIGFsbCBvZiB0aGVzZT8KCldlIHdpbGwgcmVjZWl2ZSB3YXJuaW5ncyBpZiB0aGV5IG9jY3Vw eSB0b28gbXVjaCBzdGFjayBzcGFjZS4KCj4gKwlzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpOwo+ICsJ dW5zaWduZWQgaW50IGFkZHI7Cj4gKwl1OCAqdHhfYnVmOwo+ICsKPiArCXNwaSA9IGNvcmUtPnNw aTsKPiArCj4gKwlhZGRyID0gb2NlbG90X3NwaV90cmFuc2xhdGVfYWRkcmVzcyhyZWcgKyByZWdt YXBfY29udGV4dC0+YmFzZSk7Cj4gKwl0eF9idWYgPSAodTggKikmYWRkcjsKPiArCj4gKwlzcGlf bWVzc2FnZV9pbml0KCZtc2cpOwo+ICsKPiArCW1lbXNldCgmdHgsIDAsIHNpemVvZih0eCkpOwo+ ICsKPiArCS8qIElnbm9yZSB0aGUgZmlyc3QgYnl0ZSBmb3IgdGhlIDI0LWJpdCBhZGRyZXNzICov Cj4gKwl0eC50eF9idWYgPSAmdHhfYnVmWzFdOwo+ICsJdHgubGVuID0gMzsKPiArCj4gKwlzcGlf bWVzc2FnZV9hZGRfdGFpbCgmdHgsICZtc2cpOwo+ICsKPiArCWlmIChjb3JlLT5zcGlfcGFkZGlu Z19ieXRlcyA+IDApIHsKPiArCQl1OCBkdW1teV9idWZbMTZdID0gezB9Owo+ICsKPiArCQltZW1z ZXQoJnBhZGRpbmcsIDAsIHNpemVvZihwYWRkaW5nKSk7Cj4gKwo+ICsJCS8qIEp1c3QgdG9nZ2xl IHRoZSBjbG9jayBmb3IgcGFkZGluZyBieXRlcyAqLwo+ICsJCXBhZGRpbmcubGVuID0gY29yZS0+ c3BpX3BhZGRpbmdfYnl0ZXM7Cj4gKwkJcGFkZGluZy50eF9idWYgPSBkdW1teV9idWY7Cj4gKwkJ cGFkZGluZy5kdW1teV9kYXRhID0gMTsKPiArCj4gKwkJc3BpX21lc3NhZ2VfYWRkX3RhaWwoJnBh ZGRpbmcsICZtc2cpOwo+ICsJfQo+ICsKPiArCW1lbXNldCgmcngsIDAsIHNpemVvZihyeCkpOwo+ ICsJcngucnhfYnVmID0gdmFsOwo+ICsJcngubGVuID0gNDsKPiArCj4gKwlzcGlfbWVzc2FnZV9h ZGRfdGFpbCgmcngsICZtc2cpOwo+ICsKPiArCXJldHVybiBzcGlfc3luYyhzcGksICZtc2cpOwo+ ICt9Cj4gKwo+ICtzdGF0aWMgaW50IG9jZWxvdF9zcGlfcmVnX3dyaXRlKHZvaWQgKmNvbnRleHQs IHVuc2lnbmVkIGludCByZWcsCj4gKwkJCQl1bnNpZ25lZCBpbnQgdmFsKQo+ICt7Cj4gKwlzdHJ1 Y3Qgb2NlbG90X3NwaV9yZWdtYXBfY29udGV4dCAqcmVnbWFwX2NvbnRleHQgPSBjb250ZXh0Owo+ ICsJc3RydWN0IG9jZWxvdF9jb3JlICpjb3JlID0gcmVnbWFwX2NvbnRleHQtPmNvcmU7Cj4gKwlz dHJ1Y3Qgc3BpX3RyYW5zZmVyIHR4WzJdID0gezB9Owo+ICsJc3RydWN0IHNwaV9tZXNzYWdlIG1z ZzsKPiArCXN0cnVjdCBzcGlfZGV2aWNlICpzcGk7Cj4gKwl1bnNpZ25lZCBpbnQgYWRkcjsKPiAr CXU4ICp0eF9idWY7Cj4gKwo+ICsJc3BpID0gY29yZS0+c3BpOwo+ICsKPiArCWFkZHIgPSBvY2Vs b3Rfc3BpX3RyYW5zbGF0ZV9hZGRyZXNzKHJlZyArIHJlZ21hcF9jb250ZXh0LT5iYXNlKTsKPiAr CXR4X2J1ZiA9ICh1OCAqKSZhZGRyOwo+ICsKPiArCXNwaV9tZXNzYWdlX2luaXQoJm1zZyk7Cj4g Kwo+ICsJLyogSWdub3JlIHRoZSBmaXJzdCBieXRlIGZvciB0aGUgMjQtYml0IGFkZHJlc3MgYW5k IHNldCB0aGUgd3JpdGUgYml0ICovCj4gKwl0eF9idWZbMV0gfD0gQklUKDcpOwo+ICsJdHhbMF0u dHhfYnVmID0gJnR4X2J1ZlsxXTsKPiArCXR4WzBdLmxlbiA9IDM7Cj4gKwo+ICsJc3BpX21lc3Nh Z2VfYWRkX3RhaWwoJnR4WzBdLCAmbXNnKTsKPiArCj4gKwltZW1zZXQoJnR4WzFdLCAwLCBzaXpl b2Yoc3RydWN0IHNwaV90cmFuc2ZlcikpOwo+ICsJdHhbMV0udHhfYnVmID0gJnZhbDsKPiArCXR4 WzFdLmxlbiA9IDQ7Cj4gKwo+ICsJc3BpX21lc3NhZ2VfYWRkX3RhaWwoJnR4WzFdLCAmbXNnKTsK PiArCj4gKwlyZXR1cm4gc3BpX3N5bmMoc3BpLCAmbXNnKTsKPiArfQo+ICsKPiArc3RhdGljIGNv bnN0IHN0cnVjdCByZWdtYXBfY29uZmlnIG9jZWxvdF9zcGlfcmVnbWFwX2NvbmZpZyA9IHsKPiAr CS5yZWdfYml0cyA9IDI0LAo+ICsJLnJlZ19zdHJpZGUgPSA0LAo+ICsJLnZhbF9iaXRzID0gMzIs Cj4gKwo+ICsJLnJlZ19yZWFkID0gb2NlbG90X3NwaV9yZWdfcmVhZCwKPiArCS5yZWdfd3JpdGUg PSBvY2Vsb3Rfc3BpX3JlZ193cml0ZSwKPiArCj4gKwkubWF4X3JlZ2lzdGVyID0gMHhmZmZmZmZm ZiwKPiArCS51c2Vfc2luZ2xlX3dyaXRlID0gdHJ1ZSwKPiArCS51c2Vfc2luZ2xlX3JlYWQgPSB0 cnVlLAo+ICsJLmNhbl9tdWx0aV93cml0ZSA9IGZhbHNlLAo+ICsKPiArCS5yZWdfZm9ybWF0X2Vu ZGlhbiA9IFJFR01BUF9FTkRJQU5fQklHLAo+ICsJLnZhbF9mb3JtYXRfZW5kaWFuID0gUkVHTUFQ X0VORElBTl9OQVRJVkUsCj4gK307Cj4gKwo+ICtzdHJ1Y3QgcmVnbWFwICoKPiArb2NlbG90X3Nw aV9kZXZtX2dldF9yZWdtYXAoc3RydWN0IG9jZWxvdF9jb3JlICpjb3JlLCBzdHJ1Y3QgZGV2aWNl ICpjaGlsZCwKPiArCQkJICAgY29uc3Qgc3RydWN0IHJlc291cmNlICpyZXMpCgpUaGlzIHNlZW1z IHRvIGFsd2F5cyBpbml0aWFsaXNlIGEgbmV3IFJlZ21hcC4KClRvIG1lICdnZXQnIGltcGxpZXMg dGhhdCBpdCBjb3VsZCBmZXRjaCBhbiBhbHJlYWR5IGV4aXN0aW5nIG9uZS4KCi4uLiBhbmQgKnBl cmhhcHMqIGluaXQgYSBuZXcgb25lIGlmIG5vbmUgZXhpc3RzLi4KCj4gK3sKPiArCXN0cnVjdCBv Y2Vsb3Rfc3BpX3JlZ21hcF9jb250ZXh0ICpjb250ZXh0Owo+ICsJc3RydWN0IHJlZ21hcF9jb25m aWcgcmVnbWFwX2NvbmZpZzsKPiArCj4gKwljb250ZXh0ID0gZGV2bV9remFsbG9jKGNoaWxkLCBz aXplb2YoKmNvbnRleHQpLCBHRlBfS0VSTkVMKTsKPiArCWlmIChJU19FUlIoY29udGV4dCkpCj4g KwkJcmV0dXJuIEVSUl9DQVNUKGNvbnRleHQpOwo+ICsKPiArCWNvbnRleHQtPmJhc2UgPSByZXMt PnN0YXJ0Owo+ICsJY29udGV4dC0+Y29yZSA9IGNvcmU7Cj4gKwo+ICsJbWVtY3B5KCZyZWdtYXBf Y29uZmlnLCAmb2NlbG90X3NwaV9yZWdtYXBfY29uZmlnLAo+ICsJICAgICAgIHNpemVvZihvY2Vs b3Rfc3BpX3JlZ21hcF9jb25maWcpKTsKPiArCj4gKwlyZWdtYXBfY29uZmlnLm5hbWUgPSByZXMt Pm5hbWU7Cj4gKwlyZWdtYXBfY29uZmlnLm1heF9yZWdpc3RlciA9IHJlcy0+ZW5kIC0gcmVzLT5z dGFydDsKPiArCj4gKwlyZXR1cm4gZGV2bV9yZWdtYXBfaW5pdChjaGlsZCwgTlVMTCwgY29udGV4 dCwgJnJlZ21hcF9jb25maWcpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IG9jZWxvdF9zcGlfcHJv YmUoc3RydWN0IHNwaV9kZXZpY2UgKnNwaSkKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0g JnNwaS0+ZGV2Owo+ICsJc3RydWN0IG9jZWxvdF9jb3JlICpjb3JlOwoKVGhpcyB3b3VsZCBiZSBt b3JlIGluIGtlZXBpbmcgd2l0aCBjdXJyZW50IGRyaXZlcnMgaWYgeW91IGRyb3BwZWQgdGhlCidf Y29yZScgcGFydCBvZiB0aGUgc3RydWN0IG5hbWUgYW5kIGNhbGxlZCB0aGUgdmFyaWFibGUgZGRh dGEuCgo+ICsJaW50IGVycjsKPiArCj4gKwljb3JlID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9m KCpjb3JlKSwgR0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIWNvcmUpCj4gKwkJcmV0dXJuIC1FTk9NRU07 CgpJZiB5b3Ugc2F2ZSAnY29yZScgKG9yIHByZWZlcmFibHkgZGRhdGEpIGhlcmUgYW5kIHBsYWNl IGl0IGluIHRoZQpkZXZpY2UncyBkcml2ZXJfZGF0YSBzbG90IHZpYSBkZXZfc2V0X2RydmRhdGEo KSwgeW91IGNhbiBqdXN0IHBhc3MKYXJvdW5kIHRoZSAnc3RydWN0IGRldmljZScgd2hpY2ggaXMg bW9yZSBpbiBrZWVwaW5nIHdpdGggY3VycmVudAppbXBsZW1lbnRhdGlvbnMuCgo+ICsJaWYgKHNw aS0+bWF4X3NwZWVkX2h6IDw9IDUwMDAwMCkgewo+ICsJCWNvcmUtPnNwaV9wYWRkaW5nX2J5dGVz ID0gMDsKPiArCX0gZWxzZSB7Cj4gKwkJLyoKPiArCQkgKiBDYWxjdWxhdGlvbiB0YWtlbiBmcm9t IHRoZSBtYW51YWwgZm9yIElGX0NGR1NUQVQ6SUZfQ0ZHLgo+ICsJCSAqIFJlZ2lzdGVyIGFjY2Vz cyB0aW1lIGlzIDF1cywgc28gd2UgbmVlZCB0byBjb25maWd1cmUgYW5kIHNlbmQKPiArCQkgKiBv dXQgZW5vdWdoIHBhZGRpbmcgYnl0ZXMgYmV0d2VlbiB0aGUgcmVhZCByZXF1ZXN0IGFuZCBkYXRh Cj4gKwkJICogdHJhbnNtaXNzaW9uIHRoYXQgbGFzdHMgYXQgbGVhc3QgMSBtaWNyb3NlY29uZC4K PiArCQkgKi8KPiArCQljb3JlLT5zcGlfcGFkZGluZ19ieXRlcyA9IDEgKwo+ICsJCQkoc3BpLT5t YXhfc3BlZWRfaHogLyAxMDAwMDAwICsgMikgLyA4Owo+ICsJfQo+ICsKPiArCWNvcmUtPnNwaSA9 IHNwaTsKPiArCj4gKwlzcGktPmJpdHNfcGVyX3dvcmQgPSA4Owo+ICsKPiArCWVyciA9IHNwaV9z ZXR1cChzcGkpOwo+ICsJaWYgKGVyciA8IDApIHsKPiArCQlkZXZfZXJyKCZzcGktPmRldiwgIkVy cm9yICVkIGluaXRpYWxpemluZyBTUElcbiIsIGVycik7Cj4gKwkJcmV0dXJuIGVycjsKPiArCX0K PiArCj4gKwljb3JlLT5jcHVvcmdfcmVnbWFwID0KPiArCQlvY2Vsb3Rfc3BpX2Rldm1fZ2V0X3Jl Z21hcChjb3JlLCBkZXYsCj4gKwkJCQkJICAgJnZzYzc1MTJfZGV2X2NwdW9yZ19yZXNvdXJjZSk7 Cj4gKwlpZiAoSVNfRVJSKGNvcmUtPmNwdW9yZ19yZWdtYXApKQo+ICsJCXJldHVybiAtRU5PTUVN Owo+ICsKPiArCWNvcmUtPmRldiA9IGRldjsKPiArCj4gKwkvKgo+ICsJICogVGhlIGNoaXAgbXVz dCBiZSBzZXQgdXAgZm9yIFNQSSBiZWZvcmUgaXQgZ2V0cyBpbml0aWFsaXplZCBhbmQgcmVzZXQu Cj4gKwkgKiBUaGlzIG11c3QgYmUgZG9uZSBiZWZvcmUgY2FsbGluZyBpbml0LCBhbmQgYWZ0ZXIg YSBjaGlwIHJlc2V0IGlzCj4gKwkgKiBwZXJmb3JtZWQuCj4gKwkgKi8KPiArCWVyciA9IG9jZWxv dF9zcGlfaW5pdGlhbGl6ZShjb3JlKTsKPiArCWlmIChlcnIpIHsKPiArCQlkZXZfZXJyKGRldiwg IkVycm9yICVkIGluaXRpYWxpemluZyBPY2Vsb3QgU1BJIGJ1c1xuIiwgZXJyKTsKPiArCQlyZXR1 cm4gZXJyOwo+ICsJfQo+ICsKPiArCWVyciA9IG9jZWxvdF9jb3JlX2luaXQoY29yZSk7Cj4gKwlp ZiAoZXJyIDwgMCkgewo+ICsJCWRldl9lcnIoZGV2LCAiRXJyb3IgJWQgaW5pdGlhbGl6aW5nIE9j ZWxvdCBNRkRcbiIsIGVycik7Cj4gKwkJcmV0dXJuIGVycjsKPiArCX0KPiArCj4gKwlyZXR1cm4g MDsKPiArfQo+ICsKPiArY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBvY2Vsb3Rfc3BpX29mX21h dGNoW10gPSB7Cj4gKwl7IC5jb21wYXRpYmxlID0gIm1zY2MsdnNjNzUxMl9tZmRfc3BpIiB9LAo+ ICsJeyB9LAo+ICt9Owo+ICtNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBvY2Vsb3Rfc3BpX29mX21h dGNoKTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3Qgc3BpX2RyaXZlciBvY2Vsb3Rfc3BpX2RyaXZlciA9 IHsKPiArCS5kcml2ZXIgPSB7Cj4gKwkJLm5hbWUgPSAib2NlbG90X21mZF9zcGkiLAo+ICsJCS5v Zl9tYXRjaF90YWJsZSA9IG9mX21hdGNoX3B0cihvY2Vsb3Rfc3BpX29mX21hdGNoKSwKPiArCX0s Cj4gKwkucHJvYmUgPSBvY2Vsb3Rfc3BpX3Byb2JlLAo+ICt9Owo+ICttb2R1bGVfc3BpX2RyaXZl cihvY2Vsb3Rfc3BpX2RyaXZlcik7Cj4gKwo+ICtNT0RVTEVfREVTQ1JJUFRJT04oIlNQSSBDb250 cm9sbGVkIE9jZWxvdCBDaGlwIERyaXZlciIpOwo+ICtNT0RVTEVfQVVUSE9SKCJDb2xpbiBGb3N0 ZXIgPGNvbGluLmZvc3RlckBpbi1hZHZhbnRhZ2UuY29tPiIpOwo+ICtNT0RVTEVfTElDRU5TRSgi RHVhbCBNSVQvR1BMIik7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL29jZWxvdC5oIGIvZHJp dmVycy9tZmQvb2NlbG90LmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAw MDAwMC4uMjBkMzg1M2RkNmQyCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvbWZkL29j ZWxvdC5oCj4gQEAgLTAsMCArMSw0MiBAQAo+ICsvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog R1BMLTIuMCBPUiBNSVQgKi8KPiArLyoKPiArICogQ29weXJpZ2h0IDIwMjEgSW5ub3ZhdGl2ZSBB ZHZhbnRhZ2UgSW5jLgo+ICsgKi8KPiArCj4gKyNpbmNsdWRlIDxsaW51eC9rY29uZmlnLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KPiArCj4gK3N0cnVjdCBvY2Vsb3RfY29yZSB7Cj4g KwlzdHJ1Y3QgZGV2aWNlICpkZXY7Cj4gKwlzdHJ1Y3QgcmVnbWFwICpnY2JfcmVnbWFwOwo+ICsJ c3RydWN0IHJlZ21hcCAqY3B1b3JnX3JlZ21hcDsKPiArCj4gKyNpZiBJU19FTkFCTEVEKENPTkZJ R19NRkRfT0NFTE9UX1NQSSkKCkknZCBkcm9wIHRoaXMgcGVyc29uYWxseS4KCj4gKwlpbnQgc3Bp X3BhZGRpbmdfYnl0ZXM7Cj4gKwlzdHJ1Y3Qgc3BpX2RldmljZSAqc3BpOwo+ICsjZW5kaWYKPiAr fTsKPiArCj4gK3ZvaWQgb2NlbG90X2dldF9yZXNvdXJjZV9uYW1lKGNoYXIgKm5hbWUsIGNvbnN0 IHN0cnVjdCByZXNvdXJjZSAqcmVzLAo+ICsJCQkgICAgICBpbnQgc2l6ZSk7Cj4gK2ludCBvY2Vs b3RfY29yZV9pbml0KHN0cnVjdCBvY2Vsb3RfY29yZSAqY29yZSk7Cj4gK2ludCBvY2Vsb3RfcmVt b3ZlKHN0cnVjdCBvY2Vsb3RfY29yZSAqY29yZSk7CgpUaGlzIGRvZXNuJ3QgYXBwZWFyIHRvIGJl IHJlbGV2YW50LgoKPiArI2lmIElTX0VOQUJMRUQoQ09ORklHX01GRF9PQ0VMT1RfU1BJKQo+ICtz dHJ1Y3QgcmVnbWFwICpvY2Vsb3Rfc3BpX2Rldm1fZ2V0X3JlZ21hcChzdHJ1Y3Qgb2NlbG90X2Nv cmUgKmNvcmUsCj4gKwkJCQkJICBzdHJ1Y3QgZGV2aWNlICpjaGlsZCwKPiArCQkJCQkgIGNvbnN0 IHN0cnVjdCByZXNvdXJjZSAqcmVzKTsKPiAraW50IG9jZWxvdF9zcGlfaW5pdGlhbGl6ZShzdHJ1 Y3Qgb2NlbG90X2NvcmUgKmNvcmUpOwo+ICsjZWxzZQo+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBy ZWdtYXAgKm9jZWxvdF9zcGlfZGV2bV9nZXRfcmVnbWFwKAo+ICsJCXN0cnVjdCBvY2Vsb3RfY29y ZSAqY29yZSwgc3RydWN0IGRldmljZSAqY2hpbGQsCj4gKwkJY29uc3Qgc3RydWN0IHJlc291cmNl ICpyZXMpCj4gK3sKPiArCXJldHVybiBFUlJfUFRSKC1FT1BOT1RTVVBQKTsKPiArfQo+ICsKPiAr c3RhdGljIGlubGluZSBpbnQgb2NlbG90X3NwaV9pbml0aWFsaXplKHN0cnVjdCBvY2Vsb3RfY29y ZSAqY29yZSkKPiArewo+ICsJcmV0dXJuIC1FT1BOT1RTVVBQOwo+ICt9Cj4gKyNlbmRpZgo+IGRp ZmYgLS1naXQgYS9pbmNsdWRlL3NvYy9tc2NjL29jZWxvdC5oIGIvaW5jbHVkZS9zb2MvbXNjYy9v Y2Vsb3QuaAo+IGluZGV4IDk5ODYxNjUxMWZmYi4uZDllMjcxMGQ1NjQ2IDEwMDY0NAo+IC0tLSBh L2luY2x1ZGUvc29jL21zY2Mvb2NlbG90LmgKPiArKysgYi9pbmNsdWRlL3NvYy9tc2NjL29jZWxv dC5oCj4gQEAgLTEwMTgsMTEgKzEwMTgsMTYgQEAgb2NlbG90X21ycF9kZWxfcmluZ19yb2xlKHN0 cnVjdCBvY2Vsb3QgKm9jZWxvdCwgaW50IHBvcnQsCj4gIH0KPiAgI2VuZGlmCj4gIAo+ICsjaWYg SVNfRU5BQkxFRChDT05GSUdfTUZEX09DRUxPVCkKPiArc3RydWN0IHJlZ21hcCAqb2NlbG90X2dl dF9yZWdtYXBfZnJvbV9yZXNvdXJjZShzdHJ1Y3QgZGV2aWNlICpjaGlsZCwKPiArCQkJCQkgICAg ICAgY29uc3Qgc3RydWN0IHJlc291cmNlICpyZXMpOwo+ICsjZWxzZQo+ICBzdGF0aWMgaW5saW5l IHN0cnVjdCByZWdtYXAgKgo+ICBvY2Vsb3RfZ2V0X3JlZ21hcF9mcm9tX3Jlc291cmNlKHN0cnVj dCBkZXZpY2UgKmNoaWxkLAo+ICAJCQkJY29uc3Qgc3RydWN0IHJlc291cmNlICpyZXMpCj4gIHsK PiAgCXJldHVybiBFUlJfUFRSKC1FT1BOT1RTVVBQKTsKPiAgfQo+ICsjZW5kaWYKPiAgCj4gICNl bmRpZgoKLS0gCkxlZSBKb25lcyBb5p2O55C85pavXQpQcmluY2lwYWwgVGVjaG5pY2FsIExlYWQg LSBEZXZlbG9wZXIgU2VydmljZXMKTGluYXJvLm9yZyDilIIgT3BlbiBzb3VyY2Ugc29mdHdhcmUg Zm9yIEFybSBTb0NzCkZvbGxvdyBMaW5hcm86IEZhY2Vib29rIHwgVHdpdHRlciB8IEJsb2cKCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1r ZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpo dHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJu ZWwK