From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Return-Path: Date: Tue, 30 Aug 2016 13:34:53 +0100 From: Lee Jones Subject: Re: [PATCH v8 01/18] remoteproc: st_slim_rproc: add a slimcore rproc driver Message-ID: <20160830123453.GG10121@dell> References: <1472223413-7254-1-git-send-email-peter.griffin@linaro.org> <1472223413-7254-2-git-send-email-peter.griffin@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1472223413-7254-2-git-send-email-peter.griffin@linaro.org> To: Peter Griffin Cc: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, kernel@stlinux.com, vinod.koul@intel.com, patrice.chotard@st.com, dan.j.williams@intel.com, airlied@linux.ie, kraxel@redhat.com, ohad@wizery.com, bjorn.andersson@linaro.org, dmaengine@vger.kernel.org, devicetree@vger.kernel.org, dri-devel@lists.freedesktop.org, virtualization@lists.linux-foundation.org, linux-remoteproc@vger.kernel.org List-ID: On Fri, 26 Aug 2016, Peter Griffin wrote: > slim core is used as a basis for many IPs in the STi > chipsets such as fdma and demux. To avoid duplicating > the elf loading code in each device driver a slim > rproc driver has been created. > > This driver is designed to be used by other device drivers > such as fdma, or demux whose IP is based around a slim core. > The device driver can call slim_rproc_alloc() to allocate > a slim rproc and slim_rproc_put() when finished. > > This driver takes care of ioremapping the slim > registers (dmem, imem, slimcore, peripherals), whose offsets > and sizes can change between IP's. It also obtains and enables > any clocks used by the device. This approach avoids having > a double mapping of the registers as slim_rproc does not register > its own platform device. It also maps well to device tree > abstraction as it allows us to have one dt node for the whole > device. > > All of the generic rproc elf loading code can be reused, and > we provide start() stop() hooks to start and stop the slim > core once the firmware has been loaded. This has been tested > successfully with fdma driver. Nit. It would be good to use a constant line-wrap. 'M-x post-mode' will help with this. > Signed-off-by: Peter Griffin > --- > drivers/remoteproc/Kconfig | 8 + > drivers/remoteproc/Makefile | 1 + > drivers/remoteproc/st_slim_rproc.c | 364 +++++++++++++++++++++++++++++++ > include/linux/remoteproc/st_slim_rproc.h | 53 +++++ > 4 files changed, 426 insertions(+) > create mode 100644 drivers/remoteproc/st_slim_rproc.c > create mode 100644 include/linux/remoteproc/st_slim_rproc.h > > diff --git a/drivers/remoteproc/Kconfig b/drivers/remoteproc/Kconfig > index 1a8bf76a..06765e0 100644 > --- a/drivers/remoteproc/Kconfig > +++ b/drivers/remoteproc/Kconfig > @@ -100,4 +100,12 @@ config ST_REMOTEPROC > processor framework. > This can be either built-in or a loadable module. > > +config ST_SLIM_REMOTEPROC > + tristate "ST Slim remoteproc support" > + select REMOTEPROC > + help > + Say y here to support firmware loading on IP based around > + the Slim core. > + If unsure say N. > + > endmenu > diff --git a/drivers/remoteproc/Makefile b/drivers/remoteproc/Makefile > index 92d3758..db1dae7 100644 > --- a/drivers/remoteproc/Makefile > +++ b/drivers/remoteproc/Makefile > @@ -14,3 +14,4 @@ obj-$(CONFIG_DA8XX_REMOTEPROC) += da8xx_remoteproc.o > obj-$(CONFIG_QCOM_MDT_LOADER) += qcom_mdt_loader.o > obj-$(CONFIG_QCOM_Q6V5_PIL) += qcom_q6v5_pil.o > obj-$(CONFIG_ST_REMOTEPROC) += st_remoteproc.o > +obj-$(CONFIG_ST_SLIM_REMOTEPROC) += st_slim_rproc.o > diff --git a/drivers/remoteproc/st_slim_rproc.c b/drivers/remoteproc/st_slim_rproc.c > new file mode 100644 > index 0000000..f4bf2d7 > --- /dev/null > +++ b/drivers/remoteproc/st_slim_rproc.c > @@ -0,0 +1,364 @@ > +/* > + * st_slim_rproc.c These serve no purpose and have a habit of becoming out-of-date. Please remove it and replace with a nice succinct description instead. > + * Copyright (C) 2016 STMicroelectronics Nit: '\n' here. > + * Author: Peter Griffin Nit: '\n' here. > + * License terms: GNU General Public License (GPL), version 2 Are you sure ST are okay with the shortened version of the GPL? > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include "remoteproc_internal.h" > + > +/* slimcore registers */ What's it called? slimcore, slim core, ST Slim? Please be consistent. Use the name from the datasheet. > +#define SLIM_ID_OFST 0x0 > +#define SLIM_VER_OFST 0x4 > + > +#define SLIM_EN_OFST 0x8 > +#define SLIM_EN_RUN BIT(0) > + > +#define SLIM_CLK_GATE_OFST 0xC > +#define SLIM_CLK_GATE_DIS BIT(0) > +#define SLIM_CLK_GATE_RESET BIT(2) > + > +#define SLIM_SLIM_PC_OFST 0x20 > + > +/* dmem registers */ > +#define SLIM_REV_ID_OFST 0x0 > +#define SLIM_REV_ID_MIN_MASK GENMASK(15, 8) > +#define SLIM_REV_ID_MIN(id) ((id & SLIM_REV_ID_MIN_MASK) >> 8) > +#define SLIM_REV_ID_MAJ_MASK GENMASK(23, 16) > +#define SLIM_REV_ID_MAJ(id) ((id & SLIM_REV_ID_MAJ_MASK) >> 16) > + > + > +/* peripherals registers */ > +#define SLIM_STBUS_SYNC_OFST 0xF88 > +#define SLIM_STBUS_SYNC_DIS BIT(0) > + > +#define SLIM_INT_SET_OFST 0xFD4 > +#define SLIM_INT_CLR_OFST 0xFD8 > +#define SLIM_INT_MASK_OFST 0xFDC > + > +#define SLIM_CMD_CLR_OFST 0xFC8 > +#define SLIM_CMD_MASK_OFST 0xFCC > + > +static const char *mem_names[ST_SLIM_MEM_MAX] = { > + [ST_SLIM_DMEM] = "dmem", > + [ST_SLIM_IMEM] = "imem", > +}; > + > +static int slim_clk_get(struct st_slim_rproc *slim_rproc, struct device *dev) > +{ > + int clk, err; > + > + for (clk = 0; clk < ST_SLIM_MAX_CLK; clk++) { > + slim_rproc->clks[clk] = of_clk_get(dev->of_node, clk); > + if (IS_ERR(slim_rproc->clks[clk])) { > + err = PTR_ERR(slim_rproc->clks[clk]); > + if (err == -EPROBE_DEFER) > + goto err_put_clks; > + slim_rproc->clks[clk] = NULL; > + break; > + } > + } > + > + return 0; > + > +err_put_clks: > + while (--clk >= 0) > + clk_put(slim_rproc->clks[clk]); > + > + return err; > +} > + > +static void slim_clk_disable(struct st_slim_rproc *slim_rproc) > +{ > + int clk; > + > + for (clk = 0; clk < ST_SLIM_MAX_CLK && slim_rproc->clks[clk]; clk++) > + clk_disable_unprepare(slim_rproc->clks[clk]); > +} > + > +static int slim_clk_enable(struct st_slim_rproc *slim_rproc) > +{ > + int clk, ret; > + > + for (clk = 0; clk < ST_SLIM_MAX_CLK && slim_rproc->clks[clk]; clk++) { > + ret = clk_prepare_enable(slim_rproc->clks[clk]); > + if (ret) > + goto err_disable_clks; > + } > + > + return 0; > + > +err_disable_clks: > + while (--clk >= 0) > + clk_disable_unprepare(slim_rproc->clks[clk]); > + > + return ret; > +} > + > +/** > + * Remoteproc slim specific device handlers > + */ I suggest not using kernel-doc format for this type of comment. > +static int slim_rproc_start(struct rproc *rproc) > +{ > + struct device *dev = &rproc->dev; > + struct st_slim_rproc *slim_rproc = rproc->priv; > + unsigned long hw_id, hw_ver, fw_rev; > + u32 val; > + int ret; > + > + ret = slim_clk_enable(slim_rproc); > + if (ret) { > + dev_err(dev, "Failed to enable clocks\n"); > + return ret; > + } > + > + /* disable CPU pipeline clock & reset cpu pipeline */ Be consistent. Is it 'cpu' or 'CPU'. Personally I find using 'correct English' to be the most consistent way of formatting comments i.e. Capitals for names, acronyms and at the start of a sentence. > + val = SLIM_CLK_GATE_DIS | SLIM_CLK_GATE_RESET; > + writel(val, slim_rproc->slimcore + SLIM_CLK_GATE_OFST); > + > + /* disable SLIM core STBus sync */ > + writel(SLIM_STBUS_SYNC_DIS, slim_rproc->peri + SLIM_STBUS_SYNC_OFST); > + > + /* enable cpu pipeline clock */ > + writel(!SLIM_CLK_GATE_DIS, > + slim_rproc->slimcore + SLIM_CLK_GATE_OFST); > + > + /* clear int & cmd mailbox */ > + writel(~0U, slim_rproc->peri + SLIM_INT_CLR_OFST); > + writel(~0U, slim_rproc->peri + SLIM_CMD_CLR_OFST); > + > + /* enable all channels cmd & int */ > + writel(~0U, slim_rproc->peri + SLIM_INT_MASK_OFST); > + writel(~0U, slim_rproc->peri + SLIM_CMD_MASK_OFST); > + > + /* enable cpu */ > + writel(SLIM_EN_RUN, slim_rproc->slimcore + SLIM_EN_OFST); > + > + hw_id = readl_relaxed(slim_rproc->slimcore + SLIM_ID_OFST); > + hw_ver = readl_relaxed(slim_rproc->slimcore + SLIM_VER_OFST); > + > + fw_rev = readl(slim_rproc->mem[ST_SLIM_DMEM].cpu_addr + > + SLIM_REV_ID_OFST); > + > + dev_info(dev, "fw rev:%ld.%ld on SLIM %ld.%ld\n", > + SLIM_REV_ID_MAJ(fw_rev), SLIM_REV_ID_MIN(fw_rev), > + hw_id, hw_ver); > + > + return 0; > +} > + > +static int slim_rproc_stop(struct rproc *rproc) > +{ > + struct st_slim_rproc *slim_rproc = rproc->priv; > + u32 val; > + > + /* mask all (cmd & int) channels */ > + writel(0UL, slim_rproc->peri + SLIM_INT_MASK_OFST); > + writel(0UL, slim_rproc->peri + SLIM_CMD_MASK_OFST); > + > + /* disable cpu pipeline clock */ > + writel(SLIM_CLK_GATE_DIS, slim_rproc->slimcore + SLIM_CLK_GATE_OFST); > + > + writel(!SLIM_EN_RUN, slim_rproc->slimcore + SLIM_EN_OFST); > + > + val = readl(slim_rproc->slimcore + SLIM_EN_OFST); > + if (val & SLIM_EN_RUN) > + dev_warn(&rproc->dev, "Failed to disable SLIM"); > + > + slim_clk_disable(slim_rproc); > + > + dev_dbg(&rproc->dev, "slim stopped\n"); > + > + return 0; > +} > + > +static void *slim_rproc_da_to_va(struct rproc *rproc, u64 da, int len) > +{ > + struct st_slim_rproc *slim_rproc = rproc->priv; > + void *va = NULL; > + int i; > + > + for (i = 0; i < ST_SLIM_MEM_MAX; i++) { > + if (da != slim_rproc->mem[i].bus_addr) > + continue; > + > + if (len <= slim_rproc->mem[i].size) { > + /* __force to make sparse happy with type conversion */ > + va = (__force void *)slim_rproc->mem[i].cpu_addr; > + break; > + } > + } > + > + dev_dbg(&rproc->dev, "%s: da = 0x%llx len = 0x%x va = 0x%p\n", > + __func__, da, len, va); Non-consistent with other debug prints. I suggest dropping the _func_. It's a nice to have during initial debugging, but I don't usually find them useful upstream. > + return va; > +} > + > +static struct rproc_ops slim_rproc_ops = { > + .start = slim_rproc_start, > + .stop = slim_rproc_stop, > + .da_to_va = slim_rproc_da_to_va, > +}; > + > +/** > + * Firmware handler operations: sanity, boot address, load ... > + */ Don't use kernel-doc for these. > +static struct resource_table empty_rsc_tbl = { > + .ver = 1, > + .num = 0, > +}; This should go away soon. Be prepared to remove this once the code lands. > +static struct resource_table *slim_rproc_find_rsc_table(struct rproc *rproc, > + const struct firmware *fw, > + int *tablesz) > +{ > + *tablesz = sizeof(empty_rsc_tbl); > + return &empty_rsc_tbl; > +} > + > +static struct rproc_fw_ops slim_rproc_fw_ops = { > + .find_rsc_table = slim_rproc_find_rsc_table, > +}; > + > +/** > + * st_slim_rproc_alloc() - allocate and initialise slim rproc > + * @pdev: Pointer to the platform_device struct > + * @fw_name: Name of firmware for rproc to use > + * > + * Function for allocating and initialising a slim rproc for use by > + * device drivers whose IP is based around the slim slim core. It "slim slim"? Do you mean "really slim"? ;) > + * obtains and enables any clocks required by the slim core and also > + * ioremaps the various IO. > + * > + * Returns st_slim_rproc pointer or PTR_ERR() on error. > + */ > + > +struct st_slim_rproc *st_slim_rproc_alloc(struct platform_device *pdev, > + char *fw_name) > +{ > + struct device *dev = &pdev->dev; > + struct st_slim_rproc *slim_rproc; > + struct device_node *np = dev->of_node; > + struct rproc *rproc; > + struct resource *res; > + int err, i; > + const struct rproc_fw_ops *elf_ops; > + > + if (WARN_ON(!np || !fw_name)) > + return ERR_PTR(-EINVAL); !np should not happen, ever. You can remove the check. > + if (!of_device_is_compatible(np, "st,slim-rproc")) > + return ERR_PTR(-EINVAL); > + > + rproc = rproc_alloc(dev, np->name, &slim_rproc_ops, > + fw_name, sizeof(*slim_rproc)); > + if (!rproc) > + return ERR_PTR(-ENOMEM); > + > + rproc->has_iommu = false; > + > + slim_rproc = rproc->priv; > + slim_rproc->rproc = rproc; > + > + elf_ops = rproc->fw_ops; > + /* Use some generic elf ops */ > + slim_rproc_fw_ops.load = elf_ops->load; > + slim_rproc_fw_ops.sanity_check = elf_ops->sanity_check; > + > + rproc->fw_ops = &slim_rproc_fw_ops; > + > + /* get imem and dmem */ > + for (i = 0; i < ARRAY_SIZE(mem_names); i++) { > + Superfluous '\n'. > + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, > + mem_names[i]); > + > + slim_rproc->mem[i].cpu_addr = devm_ioremap_resource(dev, res); > + if (IS_ERR(slim_rproc->mem[i].cpu_addr)) { > + dev_err(&pdev->dev, "devm_ioremap_resource failed\n"); > + err = PTR_ERR(slim_rproc->mem[i].cpu_addr); > + goto err; > + } > + slim_rproc->mem[i].bus_addr = res->start; > + slim_rproc->mem[i].size = resource_size(res); > + } > + > + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "slimcore"); Superfluous '\n'. > + slim_rproc->slimcore = devm_ioremap_resource(dev, res); > + if (IS_ERR(slim_rproc->slimcore)) { > + dev_err(&pdev->dev, > + "devm_ioremap_resource failed for slimcore\n"); Best not to quote function names. Instead write the description in plain English; "failed to remap 'slimcore' IO", or similar. > + err = PTR_ERR(slim_rproc->slimcore); > + goto err; > + } > + > + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "peripherals"); > + Superfluous '\n'. > + slim_rproc->peri = devm_ioremap_resource(dev, res); > + if (IS_ERR(slim_rproc->peri)) { > + dev_err(&pdev->dev, "devm_ioremap_resource failed for peri\n"); As above. > + err = PTR_ERR(slim_rproc->peri); > + goto err; > + } > + > + err = slim_clk_get(slim_rproc, dev); > + if (err) > + goto err; > + > + /* Register as a remoteproc device */ > + err = rproc_add(rproc); > + if (err) { > + dev_err(dev, "registration of slim remoteproc failed\n"); > + goto err_clk; > + } > + > + return slim_rproc; > + > +err_clk: > + for (i = 0; i < ST_SLIM_MAX_CLK && slim_rproc->clks[i]; i++) > + clk_put(slim_rproc->clks[i]); > +err: > + rproc_put(rproc); > + return ERR_PTR(err); > +} > +EXPORT_SYMBOL(st_slim_rproc_alloc); > + > +/** > + * st_slim_rproc_put() - put slim rproc resources > + * @slim_rproc: Pointer to the st_slim_rproc struct > + * > + * Function for calling respective _put() functions on Early line wrap <--------|---------|---------|---------|---------|---------|---------|---------> > + * slim_rproc resources. > + * Superfluous '\n'. > + */ > +void st_slim_rproc_put(struct st_slim_rproc *slim_rproc) > +{ > + int clk; > + > + if (!slim_rproc) > + return; > + > + for (clk = 0; clk < ST_SLIM_MAX_CLK && slim_rproc->clks[clk]; clk++) > + clk_put(slim_rproc->clks[clk]); > + > + rproc_del(slim_rproc->rproc); > + rproc_put(slim_rproc->rproc); > +} > +EXPORT_SYMBOL(st_slim_rproc_put); > + > +MODULE_AUTHOR("Peter Griffin"); Email. > +MODULE_DESCRIPTION("STMicroelectronics SLIM rproc driver"); Now it's "SLIM"? Make up your mind. > +MODULE_LICENSE("GPL v2"); > diff --git a/include/linux/remoteproc/st_slim_rproc.h b/include/linux/remoteproc/st_slim_rproc.h > new file mode 100644 > index 0000000..64a2c5b > --- /dev/null > +++ b/include/linux/remoteproc/st_slim_rproc.h > @@ -0,0 +1,53 @@ > +/* > + * st_slim_rproc.h As above. > + * Copyright (C) 2016 STMicroelectronics > + * Author: Peter Griffin > + * License terms: GNU General Public License (GPL), version 2 > + */ Same for the *.c header. > +#ifndef _ST_SLIM_H > +#define _ST_SLIM_H Best to mention the subsystem too. > +#define ST_SLIM_MEM_MAX 2 > +#define ST_SLIM_MAX_CLK 4 > + > +enum { > + ST_SLIM_DMEM, > + ST_SLIM_IMEM, > +}; > + > +/** > + * struct st_slim_mem - slim internal memory structure > + * @cpu_addr: MPU virtual address of the memory region > + * @bus_addr: Bus address used to access the memory region > + * @size: Size of the memory region > + */ > +struct st_slim_mem { > + void __iomem *cpu_addr; > + phys_addr_t bus_addr; > + size_t size; > +}; > + > +/** > + * struct st_slim_rproc - SLIM slim core > + * @rproc: rproc handle > + * @mem: slim memory information > + * @slimcore: slim slimcore regs > + * @peri: slim peripheral regs > + * @clks: slim clocks > + */ > +struct st_slim_rproc { > + struct rproc *rproc; > + struct st_slim_mem mem[ST_SLIM_MEM_MAX]; > + void __iomem *slimcore; > + void __iomem *peri; > + > + /* st_slim_rproc private */ > + struct clk *clks[ST_SLIM_MAX_CLK]; > +}; > + > +struct st_slim_rproc *st_slim_rproc_alloc(struct platform_device *pdev, > + char *fw_name); > +void st_slim_rproc_put(struct st_slim_rproc *slim_rproc); > + > +#endif -- Lee Jones Linaro STMicroelectronics Landing Team Lead Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog From mboxrd@z Thu Jan 1 00:00:00 1970 From: lee.jones@linaro.org (Lee Jones) Date: Tue, 30 Aug 2016 13:34:53 +0100 Subject: [PATCH v8 01/18] remoteproc: st_slim_rproc: add a slimcore rproc driver In-Reply-To: <1472223413-7254-2-git-send-email-peter.griffin@linaro.org> References: <1472223413-7254-1-git-send-email-peter.griffin@linaro.org> <1472223413-7254-2-git-send-email-peter.griffin@linaro.org> Message-ID: <20160830123453.GG10121@dell> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On Fri, 26 Aug 2016, Peter Griffin wrote: > slim core is used as a basis for many IPs in the STi > chipsets such as fdma and demux. To avoid duplicating > the elf loading code in each device driver a slim > rproc driver has been created. > > This driver is designed to be used by other device drivers > such as fdma, or demux whose IP is based around a slim core. > The device driver can call slim_rproc_alloc() to allocate > a slim rproc and slim_rproc_put() when finished. > > This driver takes care of ioremapping the slim > registers (dmem, imem, slimcore, peripherals), whose offsets > and sizes can change between IP's. It also obtains and enables > any clocks used by the device. This approach avoids having > a double mapping of the registers as slim_rproc does not register > its own platform device. It also maps well to device tree > abstraction as it allows us to have one dt node for the whole > device. > > All of the generic rproc elf loading code can be reused, and > we provide start() stop() hooks to start and stop the slim > core once the firmware has been loaded. This has been tested > successfully with fdma driver. Nit. It would be good to use a constant line-wrap. 'M-x post-mode' will help with this. > Signed-off-by: Peter Griffin > --- > drivers/remoteproc/Kconfig | 8 + > drivers/remoteproc/Makefile | 1 + > drivers/remoteproc/st_slim_rproc.c | 364 +++++++++++++++++++++++++++++++ > include/linux/remoteproc/st_slim_rproc.h | 53 +++++ > 4 files changed, 426 insertions(+) > create mode 100644 drivers/remoteproc/st_slim_rproc.c > create mode 100644 include/linux/remoteproc/st_slim_rproc.h > > diff --git a/drivers/remoteproc/Kconfig b/drivers/remoteproc/Kconfig > index 1a8bf76a..06765e0 100644 > --- a/drivers/remoteproc/Kconfig > +++ b/drivers/remoteproc/Kconfig > @@ -100,4 +100,12 @@ config ST_REMOTEPROC > processor framework. > This can be either built-in or a loadable module. > > +config ST_SLIM_REMOTEPROC > + tristate "ST Slim remoteproc support" > + select REMOTEPROC > + help > + Say y here to support firmware loading on IP based around > + the Slim core. > + If unsure say N. > + > endmenu > diff --git a/drivers/remoteproc/Makefile b/drivers/remoteproc/Makefile > index 92d3758..db1dae7 100644 > --- a/drivers/remoteproc/Makefile > +++ b/drivers/remoteproc/Makefile > @@ -14,3 +14,4 @@ obj-$(CONFIG_DA8XX_REMOTEPROC) += da8xx_remoteproc.o > obj-$(CONFIG_QCOM_MDT_LOADER) += qcom_mdt_loader.o > obj-$(CONFIG_QCOM_Q6V5_PIL) += qcom_q6v5_pil.o > obj-$(CONFIG_ST_REMOTEPROC) += st_remoteproc.o > +obj-$(CONFIG_ST_SLIM_REMOTEPROC) += st_slim_rproc.o > diff --git a/drivers/remoteproc/st_slim_rproc.c b/drivers/remoteproc/st_slim_rproc.c > new file mode 100644 > index 0000000..f4bf2d7 > --- /dev/null > +++ b/drivers/remoteproc/st_slim_rproc.c > @@ -0,0 +1,364 @@ > +/* > + * st_slim_rproc.c These serve no purpose and have a habit of becoming out-of-date. Please remove it and replace with a nice succinct description instead. > + * Copyright (C) 2016 STMicroelectronics Nit: '\n' here. > + * Author: Peter Griffin Nit: '\n' here. > + * License terms: GNU General Public License (GPL), version 2 Are you sure ST are okay with the shortened version of the GPL? > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include "remoteproc_internal.h" > + > +/* slimcore registers */ What's it called? slimcore, slim core, ST Slim? Please be consistent. Use the name from the datasheet. > +#define SLIM_ID_OFST 0x0 > +#define SLIM_VER_OFST 0x4 > + > +#define SLIM_EN_OFST 0x8 > +#define SLIM_EN_RUN BIT(0) > + > +#define SLIM_CLK_GATE_OFST 0xC > +#define SLIM_CLK_GATE_DIS BIT(0) > +#define SLIM_CLK_GATE_RESET BIT(2) > + > +#define SLIM_SLIM_PC_OFST 0x20 > + > +/* dmem registers */ > +#define SLIM_REV_ID_OFST 0x0 > +#define SLIM_REV_ID_MIN_MASK GENMASK(15, 8) > +#define SLIM_REV_ID_MIN(id) ((id & SLIM_REV_ID_MIN_MASK) >> 8) > +#define SLIM_REV_ID_MAJ_MASK GENMASK(23, 16) > +#define SLIM_REV_ID_MAJ(id) ((id & SLIM_REV_ID_MAJ_MASK) >> 16) > + > + > +/* peripherals registers */ > +#define SLIM_STBUS_SYNC_OFST 0xF88 > +#define SLIM_STBUS_SYNC_DIS BIT(0) > + > +#define SLIM_INT_SET_OFST 0xFD4 > +#define SLIM_INT_CLR_OFST 0xFD8 > +#define SLIM_INT_MASK_OFST 0xFDC > + > +#define SLIM_CMD_CLR_OFST 0xFC8 > +#define SLIM_CMD_MASK_OFST 0xFCC > + > +static const char *mem_names[ST_SLIM_MEM_MAX] = { > + [ST_SLIM_DMEM] = "dmem", > + [ST_SLIM_IMEM] = "imem", > +}; > + > +static int slim_clk_get(struct st_slim_rproc *slim_rproc, struct device *dev) > +{ > + int clk, err; > + > + for (clk = 0; clk < ST_SLIM_MAX_CLK; clk++) { > + slim_rproc->clks[clk] = of_clk_get(dev->of_node, clk); > + if (IS_ERR(slim_rproc->clks[clk])) { > + err = PTR_ERR(slim_rproc->clks[clk]); > + if (err == -EPROBE_DEFER) > + goto err_put_clks; > + slim_rproc->clks[clk] = NULL; > + break; > + } > + } > + > + return 0; > + > +err_put_clks: > + while (--clk >= 0) > + clk_put(slim_rproc->clks[clk]); > + > + return err; > +} > + > +static void slim_clk_disable(struct st_slim_rproc *slim_rproc) > +{ > + int clk; > + > + for (clk = 0; clk < ST_SLIM_MAX_CLK && slim_rproc->clks[clk]; clk++) > + clk_disable_unprepare(slim_rproc->clks[clk]); > +} > + > +static int slim_clk_enable(struct st_slim_rproc *slim_rproc) > +{ > + int clk, ret; > + > + for (clk = 0; clk < ST_SLIM_MAX_CLK && slim_rproc->clks[clk]; clk++) { > + ret = clk_prepare_enable(slim_rproc->clks[clk]); > + if (ret) > + goto err_disable_clks; > + } > + > + return 0; > + > +err_disable_clks: > + while (--clk >= 0) > + clk_disable_unprepare(slim_rproc->clks[clk]); > + > + return ret; > +} > + > +/** > + * Remoteproc slim specific device handlers > + */ I suggest not using kernel-doc format for this type of comment. > +static int slim_rproc_start(struct rproc *rproc) > +{ > + struct device *dev = &rproc->dev; > + struct st_slim_rproc *slim_rproc = rproc->priv; > + unsigned long hw_id, hw_ver, fw_rev; > + u32 val; > + int ret; > + > + ret = slim_clk_enable(slim_rproc); > + if (ret) { > + dev_err(dev, "Failed to enable clocks\n"); > + return ret; > + } > + > + /* disable CPU pipeline clock & reset cpu pipeline */ Be consistent. Is it 'cpu' or 'CPU'. Personally I find using 'correct English' to be the most consistent way of formatting comments i.e. Capitals for names, acronyms and at the start of a sentence. > + val = SLIM_CLK_GATE_DIS | SLIM_CLK_GATE_RESET; > + writel(val, slim_rproc->slimcore + SLIM_CLK_GATE_OFST); > + > + /* disable SLIM core STBus sync */ > + writel(SLIM_STBUS_SYNC_DIS, slim_rproc->peri + SLIM_STBUS_SYNC_OFST); > + > + /* enable cpu pipeline clock */ > + writel(!SLIM_CLK_GATE_DIS, > + slim_rproc->slimcore + SLIM_CLK_GATE_OFST); > + > + /* clear int & cmd mailbox */ > + writel(~0U, slim_rproc->peri + SLIM_INT_CLR_OFST); > + writel(~0U, slim_rproc->peri + SLIM_CMD_CLR_OFST); > + > + /* enable all channels cmd & int */ > + writel(~0U, slim_rproc->peri + SLIM_INT_MASK_OFST); > + writel(~0U, slim_rproc->peri + SLIM_CMD_MASK_OFST); > + > + /* enable cpu */ > + writel(SLIM_EN_RUN, slim_rproc->slimcore + SLIM_EN_OFST); > + > + hw_id = readl_relaxed(slim_rproc->slimcore + SLIM_ID_OFST); > + hw_ver = readl_relaxed(slim_rproc->slimcore + SLIM_VER_OFST); > + > + fw_rev = readl(slim_rproc->mem[ST_SLIM_DMEM].cpu_addr + > + SLIM_REV_ID_OFST); > + > + dev_info(dev, "fw rev:%ld.%ld on SLIM %ld.%ld\n", > + SLIM_REV_ID_MAJ(fw_rev), SLIM_REV_ID_MIN(fw_rev), > + hw_id, hw_ver); > + > + return 0; > +} > + > +static int slim_rproc_stop(struct rproc *rproc) > +{ > + struct st_slim_rproc *slim_rproc = rproc->priv; > + u32 val; > + > + /* mask all (cmd & int) channels */ > + writel(0UL, slim_rproc->peri + SLIM_INT_MASK_OFST); > + writel(0UL, slim_rproc->peri + SLIM_CMD_MASK_OFST); > + > + /* disable cpu pipeline clock */ > + writel(SLIM_CLK_GATE_DIS, slim_rproc->slimcore + SLIM_CLK_GATE_OFST); > + > + writel(!SLIM_EN_RUN, slim_rproc->slimcore + SLIM_EN_OFST); > + > + val = readl(slim_rproc->slimcore + SLIM_EN_OFST); > + if (val & SLIM_EN_RUN) > + dev_warn(&rproc->dev, "Failed to disable SLIM"); > + > + slim_clk_disable(slim_rproc); > + > + dev_dbg(&rproc->dev, "slim stopped\n"); > + > + return 0; > +} > + > +static void *slim_rproc_da_to_va(struct rproc *rproc, u64 da, int len) > +{ > + struct st_slim_rproc *slim_rproc = rproc->priv; > + void *va = NULL; > + int i; > + > + for (i = 0; i < ST_SLIM_MEM_MAX; i++) { > + if (da != slim_rproc->mem[i].bus_addr) > + continue; > + > + if (len <= slim_rproc->mem[i].size) { > + /* __force to make sparse happy with type conversion */ > + va = (__force void *)slim_rproc->mem[i].cpu_addr; > + break; > + } > + } > + > + dev_dbg(&rproc->dev, "%s: da = 0x%llx len = 0x%x va = 0x%p\n", > + __func__, da, len, va); Non-consistent with other debug prints. I suggest dropping the _func_. It's a nice to have during initial debugging, but I don't usually find them useful upstream. > + return va; > +} > + > +static struct rproc_ops slim_rproc_ops = { > + .start = slim_rproc_start, > + .stop = slim_rproc_stop, > + .da_to_va = slim_rproc_da_to_va, > +}; > + > +/** > + * Firmware handler operations: sanity, boot address, load ... > + */ Don't use kernel-doc for these. > +static struct resource_table empty_rsc_tbl = { > + .ver = 1, > + .num = 0, > +}; This should go away soon. Be prepared to remove this once the code lands. > +static struct resource_table *slim_rproc_find_rsc_table(struct rproc *rproc, > + const struct firmware *fw, > + int *tablesz) > +{ > + *tablesz = sizeof(empty_rsc_tbl); > + return &empty_rsc_tbl; > +} > + > +static struct rproc_fw_ops slim_rproc_fw_ops = { > + .find_rsc_table = slim_rproc_find_rsc_table, > +}; > + > +/** > + * st_slim_rproc_alloc() - allocate and initialise slim rproc > + * @pdev: Pointer to the platform_device struct > + * @fw_name: Name of firmware for rproc to use > + * > + * Function for allocating and initialising a slim rproc for use by > + * device drivers whose IP is based around the slim slim core. It "slim slim"? Do you mean "really slim"? ;) > + * obtains and enables any clocks required by the slim core and also > + * ioremaps the various IO. > + * > + * Returns st_slim_rproc pointer or PTR_ERR() on error. > + */ > + > +struct st_slim_rproc *st_slim_rproc_alloc(struct platform_device *pdev, > + char *fw_name) > +{ > + struct device *dev = &pdev->dev; > + struct st_slim_rproc *slim_rproc; > + struct device_node *np = dev->of_node; > + struct rproc *rproc; > + struct resource *res; > + int err, i; > + const struct rproc_fw_ops *elf_ops; > + > + if (WARN_ON(!np || !fw_name)) > + return ERR_PTR(-EINVAL); !np should not happen, ever. You can remove the check. > + if (!of_device_is_compatible(np, "st,slim-rproc")) > + return ERR_PTR(-EINVAL); > + > + rproc = rproc_alloc(dev, np->name, &slim_rproc_ops, > + fw_name, sizeof(*slim_rproc)); > + if (!rproc) > + return ERR_PTR(-ENOMEM); > + > + rproc->has_iommu = false; > + > + slim_rproc = rproc->priv; > + slim_rproc->rproc = rproc; > + > + elf_ops = rproc->fw_ops; > + /* Use some generic elf ops */ > + slim_rproc_fw_ops.load = elf_ops->load; > + slim_rproc_fw_ops.sanity_check = elf_ops->sanity_check; > + > + rproc->fw_ops = &slim_rproc_fw_ops; > + > + /* get imem and dmem */ > + for (i = 0; i < ARRAY_SIZE(mem_names); i++) { > + Superfluous '\n'. > + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, > + mem_names[i]); > + > + slim_rproc->mem[i].cpu_addr = devm_ioremap_resource(dev, res); > + if (IS_ERR(slim_rproc->mem[i].cpu_addr)) { > + dev_err(&pdev->dev, "devm_ioremap_resource failed\n"); > + err = PTR_ERR(slim_rproc->mem[i].cpu_addr); > + goto err; > + } > + slim_rproc->mem[i].bus_addr = res->start; > + slim_rproc->mem[i].size = resource_size(res); > + } > + > + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "slimcore"); Superfluous '\n'. > + slim_rproc->slimcore = devm_ioremap_resource(dev, res); > + if (IS_ERR(slim_rproc->slimcore)) { > + dev_err(&pdev->dev, > + "devm_ioremap_resource failed for slimcore\n"); Best not to quote function names. Instead write the description in plain English; "failed to remap 'slimcore' IO", or similar. > + err = PTR_ERR(slim_rproc->slimcore); > + goto err; > + } > + > + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "peripherals"); > + Superfluous '\n'. > + slim_rproc->peri = devm_ioremap_resource(dev, res); > + if (IS_ERR(slim_rproc->peri)) { > + dev_err(&pdev->dev, "devm_ioremap_resource failed for peri\n"); As above. > + err = PTR_ERR(slim_rproc->peri); > + goto err; > + } > + > + err = slim_clk_get(slim_rproc, dev); > + if (err) > + goto err; > + > + /* Register as a remoteproc device */ > + err = rproc_add(rproc); > + if (err) { > + dev_err(dev, "registration of slim remoteproc failed\n"); > + goto err_clk; > + } > + > + return slim_rproc; > + > +err_clk: > + for (i = 0; i < ST_SLIM_MAX_CLK && slim_rproc->clks[i]; i++) > + clk_put(slim_rproc->clks[i]); > +err: > + rproc_put(rproc); > + return ERR_PTR(err); > +} > +EXPORT_SYMBOL(st_slim_rproc_alloc); > + > +/** > + * st_slim_rproc_put() - put slim rproc resources > + * @slim_rproc: Pointer to the st_slim_rproc struct > + * > + * Function for calling respective _put() functions on Early line wrap <--------|---------|---------|---------|---------|---------|---------|---------> > + * slim_rproc resources. > + * Superfluous '\n'. > + */ > +void st_slim_rproc_put(struct st_slim_rproc *slim_rproc) > +{ > + int clk; > + > + if (!slim_rproc) > + return; > + > + for (clk = 0; clk < ST_SLIM_MAX_CLK && slim_rproc->clks[clk]; clk++) > + clk_put(slim_rproc->clks[clk]); > + > + rproc_del(slim_rproc->rproc); > + rproc_put(slim_rproc->rproc); > +} > +EXPORT_SYMBOL(st_slim_rproc_put); > + > +MODULE_AUTHOR("Peter Griffin"); Email. > +MODULE_DESCRIPTION("STMicroelectronics SLIM rproc driver"); Now it's "SLIM"? Make up your mind. > +MODULE_LICENSE("GPL v2"); > diff --git a/include/linux/remoteproc/st_slim_rproc.h b/include/linux/remoteproc/st_slim_rproc.h > new file mode 100644 > index 0000000..64a2c5b > --- /dev/null > +++ b/include/linux/remoteproc/st_slim_rproc.h > @@ -0,0 +1,53 @@ > +/* > + * st_slim_rproc.h As above. > + * Copyright (C) 2016 STMicroelectronics > + * Author: Peter Griffin > + * License terms: GNU General Public License (GPL), version 2 > + */ Same for the *.c header. > +#ifndef _ST_SLIM_H > +#define _ST_SLIM_H Best to mention the subsystem too. > +#define ST_SLIM_MEM_MAX 2 > +#define ST_SLIM_MAX_CLK 4 > + > +enum { > + ST_SLIM_DMEM, > + ST_SLIM_IMEM, > +}; > + > +/** > + * struct st_slim_mem - slim internal memory structure > + * @cpu_addr: MPU virtual address of the memory region > + * @bus_addr: Bus address used to access the memory region > + * @size: Size of the memory region > + */ > +struct st_slim_mem { > + void __iomem *cpu_addr; > + phys_addr_t bus_addr; > + size_t size; > +}; > + > +/** > + * struct st_slim_rproc - SLIM slim core > + * @rproc: rproc handle > + * @mem: slim memory information > + * @slimcore: slim slimcore regs > + * @peri: slim peripheral regs > + * @clks: slim clocks > + */ > +struct st_slim_rproc { > + struct rproc *rproc; > + struct st_slim_mem mem[ST_SLIM_MEM_MAX]; > + void __iomem *slimcore; > + void __iomem *peri; > + > + /* st_slim_rproc private */ > + struct clk *clks[ST_SLIM_MAX_CLK]; > +}; > + > +struct st_slim_rproc *st_slim_rproc_alloc(struct platform_device *pdev, > + char *fw_name); > +void st_slim_rproc_put(struct st_slim_rproc *slim_rproc); > + > +#endif -- Lee Jones Linaro STMicroelectronics Landing Team Lead Linaro.org ? Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lee Jones Subject: Re: [PATCH v8 01/18] remoteproc: st_slim_rproc: add a slimcore rproc driver Date: Tue, 30 Aug 2016 13:34:53 +0100 Message-ID: <20160830123453.GG10121@dell> References: <1472223413-7254-1-git-send-email-peter.griffin@linaro.org> <1472223413-7254-2-git-send-email-peter.griffin@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <1472223413-7254-2-git-send-email-peter.griffin@linaro.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Peter Griffin Cc: ohad@wizery.com, devicetree@vger.kernel.org, kernel@stlinux.com, vinod.koul@intel.com, linux-remoteproc@vger.kernel.org, patrice.chotard@st.com, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, kraxel@redhat.com, dmaengine@vger.kernel.org, dan.j.williams@intel.com, bjorn.andersson@linaro.org, virtualization@lists.linux-foundation.org, linux-arm-kernel@lists.infradead.org List-Id: devicetree@vger.kernel.org T24gRnJpLCAyNiBBdWcgMjAxNiwgUGV0ZXIgR3JpZmZpbiB3cm90ZToKCj4gc2xpbSBjb3JlIGlz IHVzZWQgYXMgYSBiYXNpcyBmb3IgbWFueSBJUHMgaW4gdGhlIFNUaQo+IGNoaXBzZXRzIHN1Y2gg YXMgZmRtYSBhbmQgZGVtdXguIFRvIGF2b2lkIGR1cGxpY2F0aW5nCj4gdGhlIGVsZiBsb2FkaW5n IGNvZGUgaW4gZWFjaCBkZXZpY2UgZHJpdmVyIGEgc2xpbQo+IHJwcm9jIGRyaXZlciBoYXMgYmVl biBjcmVhdGVkLgo+IAo+IFRoaXMgZHJpdmVyIGlzIGRlc2lnbmVkIHRvIGJlIHVzZWQgYnkgb3Ro ZXIgZGV2aWNlIGRyaXZlcnMKPiBzdWNoIGFzIGZkbWEsIG9yIGRlbXV4IHdob3NlIElQIGlzIGJh c2VkIGFyb3VuZCBhIHNsaW0gY29yZS4KPiBUaGUgZGV2aWNlIGRyaXZlciBjYW4gY2FsbCBzbGlt X3Jwcm9jX2FsbG9jKCkgdG8gYWxsb2NhdGUKPiBhIHNsaW0gcnByb2MgYW5kIHNsaW1fcnByb2Nf cHV0KCkgd2hlbiBmaW5pc2hlZC4KPiAKPiBUaGlzIGRyaXZlciB0YWtlcyBjYXJlIG9mIGlvcmVt YXBwaW5nIHRoZSBzbGltCj4gcmVnaXN0ZXJzIChkbWVtLCBpbWVtLCBzbGltY29yZSwgcGVyaXBo ZXJhbHMpLCB3aG9zZSBvZmZzZXRzCj4gYW5kIHNpemVzIGNhbiBjaGFuZ2UgYmV0d2VlbiBJUCdz LiBJdCBhbHNvIG9idGFpbnMgYW5kIGVuYWJsZXMKPiBhbnkgY2xvY2tzIHVzZWQgYnkgdGhlIGRl dmljZS4gVGhpcyBhcHByb2FjaCBhdm9pZHMgaGF2aW5nCj4gYSBkb3VibGUgbWFwcGluZyBvZiB0 aGUgcmVnaXN0ZXJzIGFzIHNsaW1fcnByb2MgZG9lcyBub3QgcmVnaXN0ZXIKPiBpdHMgb3duIHBs YXRmb3JtIGRldmljZS4gSXQgYWxzbyBtYXBzIHdlbGwgdG8gZGV2aWNlIHRyZWUKPiBhYnN0cmFj dGlvbiBhcyBpdCBhbGxvd3MgdXMgdG8gaGF2ZSBvbmUgZHQgbm9kZSBmb3IgdGhlIHdob2xlCj4g ZGV2aWNlLgo+IAo+IEFsbCBvZiB0aGUgZ2VuZXJpYyBycHJvYyBlbGYgbG9hZGluZyBjb2RlIGNh biBiZSByZXVzZWQsIGFuZAo+IHdlIHByb3ZpZGUgc3RhcnQoKSBzdG9wKCkgaG9va3MgdG8gc3Rh cnQgYW5kIHN0b3AgdGhlIHNsaW0KPiBjb3JlIG9uY2UgdGhlIGZpcm13YXJlIGhhcyBiZWVuIGxv YWRlZC4gVGhpcyBoYXMgYmVlbiB0ZXN0ZWQKPiBzdWNjZXNzZnVsbHkgd2l0aCBmZG1hIGRyaXZl ci4KCk5pdC4gIEl0IHdvdWxkIGJlIGdvb2QgdG8gdXNlIGEgY29uc3RhbnQgbGluZS13cmFwLgoK J00teCBwb3N0LW1vZGUnIHdpbGwgaGVscCB3aXRoIHRoaXMuCgo+IFNpZ25lZC1vZmYtYnk6IFBl dGVyIEdyaWZmaW4gPHBldGVyLmdyaWZmaW5AbGluYXJvLm9yZz4KPiAtLS0KPiAgZHJpdmVycy9y ZW1vdGVwcm9jL0tjb25maWcgICAgICAgICAgICAgICB8ICAgOCArCj4gIGRyaXZlcnMvcmVtb3Rl cHJvYy9NYWtlZmlsZSAgICAgICAgICAgICAgfCAgIDEgKwo+ICBkcml2ZXJzL3JlbW90ZXByb2Mv c3Rfc2xpbV9ycHJvYy5jICAgICAgIHwgMzY0ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysKPiAgaW5jbHVkZS9saW51eC9yZW1vdGVwcm9jL3N0X3NsaW1fcnByb2MuaCB8ICA1MyArKysr Kwo+ICA0IGZpbGVzIGNoYW5nZWQsIDQyNiBpbnNlcnRpb25zKCspCj4gIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL3JlbW90ZXByb2Mvc3Rfc2xpbV9ycHJvYy5jCj4gIGNyZWF0ZSBtb2RlIDEw MDY0NCBpbmNsdWRlL2xpbnV4L3JlbW90ZXByb2Mvc3Rfc2xpbV9ycHJvYy5oCj4gCj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvcmVtb3RlcHJvYy9LY29uZmlnIGIvZHJpdmVycy9yZW1vdGVwcm9jL0tj b25maWcKPiBpbmRleCAxYThiZjc2YS4uMDY3NjVlMCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3Jl bW90ZXByb2MvS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvcmVtb3RlcHJvYy9LY29uZmlnCj4gQEAg LTEwMCw0ICsxMDAsMTIgQEAgY29uZmlnIFNUX1JFTU9URVBST0MKPiAgCSAgcHJvY2Vzc29yIGZy YW1ld29yay4KPiAgCSAgVGhpcyBjYW4gYmUgZWl0aGVyIGJ1aWx0LWluIG9yIGEgbG9hZGFibGUg bW9kdWxlLgo+ICAKPiArY29uZmlnIFNUX1NMSU1fUkVNT1RFUFJPQwo+ICsJdHJpc3RhdGUgIlNU IFNsaW0gcmVtb3RlcHJvYyBzdXBwb3J0Igo+ICsJc2VsZWN0IFJFTU9URVBST0MKPiArCWhlbHAK PiArCSAgU2F5IHkgaGVyZSB0byBzdXBwb3J0IGZpcm13YXJlIGxvYWRpbmcgb24gSVAgYmFzZWQg YXJvdW5kCj4gKwkgIHRoZSBTbGltIGNvcmUuCj4gKwkgIElmIHVuc3VyZSBzYXkgTi4KPiArCj4g IGVuZG1lbnUKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9yZW1vdGVwcm9jL01ha2VmaWxlIGIvZHJp dmVycy9yZW1vdGVwcm9jL01ha2VmaWxlCj4gaW5kZXggOTJkMzc1OC4uZGIxZGFlNyAxMDA2NDQK PiAtLS0gYS9kcml2ZXJzL3JlbW90ZXByb2MvTWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL3JlbW90 ZXByb2MvTWFrZWZpbGUKPiBAQCAtMTQsMyArMTQsNCBAQCBvYmotJChDT05GSUdfREE4WFhfUkVN T1RFUFJPQykJCSs9IGRhOHh4X3JlbW90ZXByb2Mubwo+ICBvYmotJChDT05GSUdfUUNPTV9NRFRf TE9BREVSKQkJKz0gcWNvbV9tZHRfbG9hZGVyLm8KPiAgb2JqLSQoQ09ORklHX1FDT01fUTZWNV9Q SUwpCQkrPSBxY29tX3E2djVfcGlsLm8KPiAgb2JqLSQoQ09ORklHX1NUX1JFTU9URVBST0MpCQkr PSBzdF9yZW1vdGVwcm9jLm8KPiArb2JqLSQoQ09ORklHX1NUX1NMSU1fUkVNT1RFUFJPQykJKz0g c3Rfc2xpbV9ycHJvYy5vCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvcmVtb3RlcHJvYy9zdF9zbGlt X3Jwcm9jLmMgYi9kcml2ZXJzL3JlbW90ZXByb2Mvc3Rfc2xpbV9ycHJvYy5jCj4gbmV3IGZpbGUg bW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwLi5mNGJmMmQ3Cj4gLS0tIC9kZXYvbnVsbAo+ICsr KyBiL2RyaXZlcnMvcmVtb3RlcHJvYy9zdF9zbGltX3Jwcm9jLmMKPiBAQCAtMCwwICsxLDM2NCBA QAo+ICsvKgo+ICsgKiBzdF9zbGltX3Jwcm9jLmMKClRoZXNlIHNlcnZlIG5vIHB1cnBvc2UgYW5k IGhhdmUgYSBoYWJpdCBvZiBiZWNvbWluZyBvdXQtb2YtZGF0ZS4KUGxlYXNlIHJlbW92ZSBpdCBh bmQgcmVwbGFjZSB3aXRoIGEgbmljZSBzdWNjaW5jdCBkZXNjcmlwdGlvbgppbnN0ZWFkLgoKPiAr ICogQ29weXJpZ2h0IChDKSAyMDE2IFNUTWljcm9lbGVjdHJvbmljcwoKTml0OiAnXG4nIGhlcmUu Cgo+ICsgKiBBdXRob3I6IFBldGVyIEdyaWZmaW4gPHBldGVyLmdyaWZmaW5AbGluYXJvLm9yZz4K Ck5pdDogJ1xuJyBoZXJlLgoKPiArICogTGljZW5zZSB0ZXJtczogIEdOVSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIChHUEwpLCB2ZXJzaW9uIDIKCkFyZSB5b3Ugc3VyZSBTVCBhcmUgb2theSB3aXRo IHRoZSBzaG9ydGVuZWQgdmVyc2lvbiBvZiB0aGUgR1BMPwoKPiArICovCj4gKwo+ICsjaW5jbHVk ZSA8bGludXgvY2xrLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KPiArI2luY2x1ZGUgPGxp bnV4L2tlcm5lbC5oPgo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9vZi5oPgo+ICsjaW5jbHVkZSA8bGludXgvb2ZfZGV2aWNlLmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3JlbW90ZXByb2MuaD4K PiArI2luY2x1ZGUgPGxpbnV4L3JlbW90ZXByb2Mvc3Rfc2xpbV9ycHJvYy5oPgo+ICsjaW5jbHVk ZSAicmVtb3RlcHJvY19pbnRlcm5hbC5oIgo+ICsKPiArLyogc2xpbWNvcmUgcmVnaXN0ZXJzICov CgpXaGF0J3MgaXQgY2FsbGVkPyBzbGltY29yZSwgc2xpbSBjb3JlLCBTVCBTbGltPwoKUGxlYXNl IGJlIGNvbnNpc3RlbnQuICBVc2UgdGhlIG5hbWUgZnJvbSB0aGUgZGF0YXNoZWV0LgoKPiArI2Rl ZmluZSBTTElNX0lEX09GU1QJCTB4MAo+ICsjZGVmaW5lIFNMSU1fVkVSX09GU1QJCTB4NAo+ICsK PiArI2RlZmluZSBTTElNX0VOX09GU1QJCTB4OAo+ICsjZGVmaW5lIFNMSU1fRU5fUlVOCQkJQklU KDApCj4gKwo+ICsjZGVmaW5lIFNMSU1fQ0xLX0dBVEVfT0ZTVAkweEMKPiArI2RlZmluZSBTTElN X0NMS19HQVRFX0RJUwkJQklUKDApCj4gKyNkZWZpbmUgU0xJTV9DTEtfR0FURV9SRVNFVAkJQklU KDIpCj4gKwo+ICsjZGVmaW5lIFNMSU1fU0xJTV9QQ19PRlNUCTB4MjAKPiArCj4gKy8qIGRtZW0g cmVnaXN0ZXJzICovCj4gKyNkZWZpbmUgU0xJTV9SRVZfSURfT0ZTVAkweDAKPiArI2RlZmluZSBT TElNX1JFVl9JRF9NSU5fTUFTSwkJR0VOTUFTSygxNSwgOCkKPiArI2RlZmluZSBTTElNX1JFVl9J RF9NSU4oaWQpCQkoKGlkICYgU0xJTV9SRVZfSURfTUlOX01BU0spID4+IDgpCj4gKyNkZWZpbmUg U0xJTV9SRVZfSURfTUFKX01BU0sJCUdFTk1BU0soMjMsIDE2KQo+ICsjZGVmaW5lIFNMSU1fUkVW X0lEX01BSihpZCkJCSgoaWQgJiBTTElNX1JFVl9JRF9NQUpfTUFTSykgPj4gMTYpCj4gKwo+ICsK PiArLyogcGVyaXBoZXJhbHMgcmVnaXN0ZXJzICovCj4gKyNkZWZpbmUgU0xJTV9TVEJVU19TWU5D X09GU1QJMHhGODgKPiArI2RlZmluZSBTTElNX1NUQlVTX1NZTkNfRElTCQlCSVQoMCkKPiArCj4g KyNkZWZpbmUgU0xJTV9JTlRfU0VUX09GU1QJMHhGRDQKPiArI2RlZmluZSBTTElNX0lOVF9DTFJf T0ZTVAkweEZEOAo+ICsjZGVmaW5lIFNMSU1fSU5UX01BU0tfT0ZTVAkweEZEQwo+ICsKPiArI2Rl ZmluZSBTTElNX0NNRF9DTFJfT0ZTVAkweEZDOAo+ICsjZGVmaW5lIFNMSU1fQ01EX01BU0tfT0ZT VAkweEZDQwo+ICsKPiArc3RhdGljIGNvbnN0IGNoYXIgKm1lbV9uYW1lc1tTVF9TTElNX01FTV9N QVhdID0gewo+ICsJW1NUX1NMSU1fRE1FTV0JPSAiZG1lbSIsCj4gKwlbU1RfU0xJTV9JTUVNXQk9 ICJpbWVtIiwKPiArfTsKPiArCj4gK3N0YXRpYyBpbnQgc2xpbV9jbGtfZ2V0KHN0cnVjdCBzdF9z bGltX3Jwcm9jICpzbGltX3Jwcm9jLCBzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCWludCBj bGssIGVycjsKPiArCj4gKwlmb3IgKGNsayA9IDA7IGNsayA8IFNUX1NMSU1fTUFYX0NMSzsgY2xr KyspIHsKPiArCQlzbGltX3Jwcm9jLT5jbGtzW2Nsa10gPSBvZl9jbGtfZ2V0KGRldi0+b2Zfbm9k ZSwgY2xrKTsKPiArCQlpZiAoSVNfRVJSKHNsaW1fcnByb2MtPmNsa3NbY2xrXSkpIHsKPiArCQkJ ZXJyID0gUFRSX0VSUihzbGltX3Jwcm9jLT5jbGtzW2Nsa10pOwo+ICsJCQlpZiAoZXJyID09IC1F UFJPQkVfREVGRVIpCj4gKwkJCQlnb3RvIGVycl9wdXRfY2xrczsKPiArCQkJc2xpbV9ycHJvYy0+ Y2xrc1tjbGtdID0gTlVMTDsKPiArCQkJYnJlYWs7Cj4gKwkJfQo+ICsJfQo+ICsKPiArCXJldHVy biAwOwo+ICsKPiArZXJyX3B1dF9jbGtzOgo+ICsJd2hpbGUgKC0tY2xrID49IDApCj4gKwkJY2xr X3B1dChzbGltX3Jwcm9jLT5jbGtzW2Nsa10pOwo+ICsKPiArCXJldHVybiBlcnI7Cj4gK30KPiAr Cj4gK3N0YXRpYyB2b2lkIHNsaW1fY2xrX2Rpc2FibGUoc3RydWN0IHN0X3NsaW1fcnByb2MgKnNs aW1fcnByb2MpCj4gK3sKPiArCWludCBjbGs7Cj4gKwo+ICsJZm9yIChjbGsgPSAwOyBjbGsgPCBT VF9TTElNX01BWF9DTEsgJiYgc2xpbV9ycHJvYy0+Y2xrc1tjbGtdOyBjbGsrKykKPiArCQljbGtf ZGlzYWJsZV91bnByZXBhcmUoc2xpbV9ycHJvYy0+Y2xrc1tjbGtdKTsKPiArfQo+ICsKPiArc3Rh dGljIGludCBzbGltX2Nsa19lbmFibGUoc3RydWN0IHN0X3NsaW1fcnByb2MgKnNsaW1fcnByb2Mp Cj4gK3sKPiArCWludCBjbGssIHJldDsKPiArCj4gKwlmb3IgKGNsayA9IDA7IGNsayA8IFNUX1NM SU1fTUFYX0NMSyAmJiBzbGltX3Jwcm9jLT5jbGtzW2Nsa107IGNsaysrKSB7Cj4gKwkJcmV0ID0g Y2xrX3ByZXBhcmVfZW5hYmxlKHNsaW1fcnByb2MtPmNsa3NbY2xrXSk7Cj4gKwkJaWYgKHJldCkK PiArCQkJZ290byBlcnJfZGlzYWJsZV9jbGtzOwo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICsK PiArZXJyX2Rpc2FibGVfY2xrczoKPiArCXdoaWxlICgtLWNsayA+PSAwKQo+ICsJCWNsa19kaXNh YmxlX3VucHJlcGFyZShzbGltX3Jwcm9jLT5jbGtzW2Nsa10pOwo+ICsKPiArCXJldHVybiByZXQ7 Cj4gK30KPiArCj4gKy8qKgo+ICsgKiBSZW1vdGVwcm9jIHNsaW0gc3BlY2lmaWMgZGV2aWNlIGhh bmRsZXJzCj4gKyAqLwoKSSBzdWdnZXN0IG5vdCB1c2luZyBrZXJuZWwtZG9jIGZvcm1hdCBmb3Ig dGhpcyB0eXBlIG9mIGNvbW1lbnQuCgo+ICtzdGF0aWMgaW50IHNsaW1fcnByb2Nfc3RhcnQoc3Ry dWN0IHJwcm9jICpycHJvYykKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gJnJwcm9jLT5k ZXY7Cj4gKwlzdHJ1Y3Qgc3Rfc2xpbV9ycHJvYyAqc2xpbV9ycHJvYyA9IHJwcm9jLT5wcml2Owo+ ICsJdW5zaWduZWQgbG9uZyBod19pZCwgaHdfdmVyLCBmd19yZXY7Cj4gKwl1MzIgdmFsOwo+ICsJ aW50IHJldDsKPiArCj4gKwlyZXQgPSBzbGltX2Nsa19lbmFibGUoc2xpbV9ycHJvYyk7Cj4gKwlp ZiAocmV0KSB7Cj4gKwkJZGV2X2VycihkZXYsICJGYWlsZWQgdG8gZW5hYmxlIGNsb2Nrc1xuIik7 Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0KPiArCj4gKwkvKiBkaXNhYmxlIENQVSBwaXBlbGluZSBj bG9jayAmIHJlc2V0IGNwdSBwaXBlbGluZSAqLwoKQmUgY29uc2lzdGVudC4gIElzIGl0ICdjcHUn IG9yICdDUFUnLiAgUGVyc29uYWxseSBJIGZpbmQgdXNpbmcKJ2NvcnJlY3QgRW5nbGlzaCcgdG8g YmUgdGhlIG1vc3QgY29uc2lzdGVudCB3YXkgb2YgZm9ybWF0dGluZwpjb21tZW50cyBpLmUuIENh cGl0YWxzIGZvciBuYW1lcywgYWNyb255bXMgYW5kIGF0IHRoZSBzdGFydCBvZiBhCnNlbnRlbmNl LgoKPiArCXZhbCA9IFNMSU1fQ0xLX0dBVEVfRElTIHwgU0xJTV9DTEtfR0FURV9SRVNFVDsKPiAr CXdyaXRlbCh2YWwsIHNsaW1fcnByb2MtPnNsaW1jb3JlICsgU0xJTV9DTEtfR0FURV9PRlNUKTsK PiArCj4gKwkvKiBkaXNhYmxlIFNMSU0gY29yZSBTVEJ1cyBzeW5jICovCj4gKwl3cml0ZWwoU0xJ TV9TVEJVU19TWU5DX0RJUywgc2xpbV9ycHJvYy0+cGVyaSArIFNMSU1fU1RCVVNfU1lOQ19PRlNU KTsKPiArCj4gKwkvKiBlbmFibGUgY3B1IHBpcGVsaW5lIGNsb2NrICovCj4gKwl3cml0ZWwoIVNM SU1fQ0xLX0dBVEVfRElTLAo+ICsJCXNsaW1fcnByb2MtPnNsaW1jb3JlICsgU0xJTV9DTEtfR0FU RV9PRlNUKTsKPiArCj4gKwkvKiBjbGVhciBpbnQgJiBjbWQgbWFpbGJveCAqLwo+ICsJd3JpdGVs KH4wVSwgc2xpbV9ycHJvYy0+cGVyaSArIFNMSU1fSU5UX0NMUl9PRlNUKTsKPiArCXdyaXRlbCh+ MFUsIHNsaW1fcnByb2MtPnBlcmkgKyBTTElNX0NNRF9DTFJfT0ZTVCk7Cj4gKwo+ICsJLyogZW5h YmxlIGFsbCBjaGFubmVscyBjbWQgJiBpbnQgKi8KPiArCXdyaXRlbCh+MFUsIHNsaW1fcnByb2Mt PnBlcmkgKyBTTElNX0lOVF9NQVNLX09GU1QpOwo+ICsJd3JpdGVsKH4wVSwgc2xpbV9ycHJvYy0+ cGVyaSArIFNMSU1fQ01EX01BU0tfT0ZTVCk7Cj4gKwo+ICsJLyogZW5hYmxlIGNwdSAqLwo+ICsJ d3JpdGVsKFNMSU1fRU5fUlVOLCBzbGltX3Jwcm9jLT5zbGltY29yZSArIFNMSU1fRU5fT0ZTVCk7 Cj4gKwo+ICsJaHdfaWQgPSByZWFkbF9yZWxheGVkKHNsaW1fcnByb2MtPnNsaW1jb3JlICsgU0xJ TV9JRF9PRlNUKTsKPiArCWh3X3ZlciA9IHJlYWRsX3JlbGF4ZWQoc2xpbV9ycHJvYy0+c2xpbWNv cmUgKyBTTElNX1ZFUl9PRlNUKTsKPiArCj4gKwlmd19yZXYgPSByZWFkbChzbGltX3Jwcm9jLT5t ZW1bU1RfU0xJTV9ETUVNXS5jcHVfYWRkciArCj4gKwkJCVNMSU1fUkVWX0lEX09GU1QpOwo+ICsK PiArCWRldl9pbmZvKGRldiwgImZ3IHJldjolbGQuJWxkIG9uIFNMSU0gJWxkLiVsZFxuIiwKPiAr CQkgU0xJTV9SRVZfSURfTUFKKGZ3X3JldiksIFNMSU1fUkVWX0lEX01JTihmd19yZXYpLAo+ICsJ CSBod19pZCwgaHdfdmVyKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGlu dCBzbGltX3Jwcm9jX3N0b3Aoc3RydWN0IHJwcm9jICpycHJvYykKPiArewo+ICsJc3RydWN0IHN0 X3NsaW1fcnByb2MgKnNsaW1fcnByb2MgPSBycHJvYy0+cHJpdjsKPiArCXUzMiB2YWw7Cj4gKwo+ ICsJLyogbWFzayBhbGwgKGNtZCAmIGludCkgY2hhbm5lbHMgKi8KPiArCXdyaXRlbCgwVUwsIHNs aW1fcnByb2MtPnBlcmkgKyBTTElNX0lOVF9NQVNLX09GU1QpOwo+ICsJd3JpdGVsKDBVTCwgc2xp bV9ycHJvYy0+cGVyaSArIFNMSU1fQ01EX01BU0tfT0ZTVCk7Cj4gKwo+ICsJLyogZGlzYWJsZSBj cHUgcGlwZWxpbmUgY2xvY2sgKi8KPiArCXdyaXRlbChTTElNX0NMS19HQVRFX0RJUywgc2xpbV9y cHJvYy0+c2xpbWNvcmUgKyBTTElNX0NMS19HQVRFX09GU1QpOwo+ICsKPiArCXdyaXRlbCghU0xJ TV9FTl9SVU4sIHNsaW1fcnByb2MtPnNsaW1jb3JlICsgU0xJTV9FTl9PRlNUKTsKPiArCj4gKwl2 YWwgPSByZWFkbChzbGltX3Jwcm9jLT5zbGltY29yZSArIFNMSU1fRU5fT0ZTVCk7Cj4gKwlpZiAo dmFsICYgU0xJTV9FTl9SVU4pCj4gKwkJZGV2X3dhcm4oJnJwcm9jLT5kZXYsICJGYWlsZWQgdG8g ZGlzYWJsZSBTTElNIik7Cj4gKwo+ICsJc2xpbV9jbGtfZGlzYWJsZShzbGltX3Jwcm9jKTsKPiAr Cj4gKwlkZXZfZGJnKCZycHJvYy0+ZGV2LCAic2xpbSBzdG9wcGVkXG4iKTsKPiArCj4gKwlyZXR1 cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgKnNsaW1fcnByb2NfZGFfdG9fdmEoc3RydWN0 IHJwcm9jICpycHJvYywgdTY0IGRhLCBpbnQgbGVuKQo+ICt7Cj4gKwlzdHJ1Y3Qgc3Rfc2xpbV9y cHJvYyAqc2xpbV9ycHJvYyA9IHJwcm9jLT5wcml2Owo+ICsJdm9pZCAqdmEgPSBOVUxMOwo+ICsJ aW50IGk7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IFNUX1NMSU1fTUVNX01BWDsgaSsrKSB7Cj4g KwkJaWYgKGRhICE9IHNsaW1fcnByb2MtPm1lbVtpXS5idXNfYWRkcikKPiArCQkJY29udGludWU7 Cj4gKwo+ICsJCWlmIChsZW4gPD0gc2xpbV9ycHJvYy0+bWVtW2ldLnNpemUpIHsKPiArCQkJLyog X19mb3JjZSB0byBtYWtlIHNwYXJzZSBoYXBweSB3aXRoIHR5cGUgY29udmVyc2lvbiAqLwo+ICsJ CQl2YSA9IChfX2ZvcmNlIHZvaWQgKilzbGltX3Jwcm9jLT5tZW1baV0uY3B1X2FkZHI7Cj4gKwkJ CWJyZWFrOwo+ICsJCX0KPiArCX0KPiArCj4gKwlkZXZfZGJnKCZycHJvYy0+ZGV2LCAiJXM6IGRh ID0gMHglbGx4IGxlbiA9IDB4JXggdmEgPSAweCVwXG4iLAo+ICsJCV9fZnVuY19fLCBkYSwgbGVu LCB2YSk7CgpOb24tY29uc2lzdGVudCB3aXRoIG90aGVyIGRlYnVnIHByaW50cy4gIEkgc3VnZ2Vz dCBkcm9wcGluZyB0aGUKX2Z1bmNfLiAgSXQncyBhIG5pY2UgdG8gaGF2ZSBkdXJpbmcgaW5pdGlh bCBkZWJ1Z2dpbmcsIGJ1dCBJIGRvbid0CnVzdWFsbHkgZmluZCB0aGVtIHVzZWZ1bCB1cHN0cmVh bS4KCj4gKwlyZXR1cm4gdmE7Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgcnByb2Nfb3BzIHNs aW1fcnByb2Nfb3BzID0gewo+ICsJLnN0YXJ0CQk9IHNsaW1fcnByb2Nfc3RhcnQsCj4gKwkuc3Rv cAkJPSBzbGltX3Jwcm9jX3N0b3AsCj4gKwkuZGFfdG9fdmEgICAgICAgPSBzbGltX3Jwcm9jX2Rh X3RvX3ZhLAo+ICt9Owo+ICsKPiArLyoqCj4gKyAqIEZpcm13YXJlIGhhbmRsZXIgb3BlcmF0aW9u czogc2FuaXR5LCBib290IGFkZHJlc3MsIGxvYWQgLi4uCj4gKyAqLwoKRG9uJ3QgdXNlIGtlcm5l bC1kb2MgZm9yIHRoZXNlLgoKPiArc3RhdGljIHN0cnVjdCByZXNvdXJjZV90YWJsZSBlbXB0eV9y c2NfdGJsID0gewo+ICsJLnZlciA9IDEsCj4gKwkubnVtID0gMCwKPiArfTsKClRoaXMgc2hvdWxk IGdvIGF3YXkgc29vbi4KCkJlIHByZXBhcmVkIHRvIHJlbW92ZSB0aGlzIG9uY2UgdGhlIGNvZGUg bGFuZHMuCgo+ICtzdGF0aWMgc3RydWN0IHJlc291cmNlX3RhYmxlICpzbGltX3Jwcm9jX2ZpbmRf cnNjX3RhYmxlKHN0cnVjdCBycHJvYyAqcnByb2MsCj4gKwkJCQkJICAgICAgIGNvbnN0IHN0cnVj dCBmaXJtd2FyZSAqZncsCj4gKwkJCQkJICAgICAgIGludCAqdGFibGVzeikKPiArewo+ICsJKnRh Ymxlc3ogPSBzaXplb2YoZW1wdHlfcnNjX3RibCk7Cj4gKwlyZXR1cm4gJmVtcHR5X3JzY190Ymw7 Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgcnByb2NfZndfb3BzIHNsaW1fcnByb2NfZndfb3Bz ID0gewo+ICsJLmZpbmRfcnNjX3RhYmxlID0gc2xpbV9ycHJvY19maW5kX3JzY190YWJsZSwKPiAr fTsKPiArCj4gKy8qKgo+ICsgKiBzdF9zbGltX3Jwcm9jX2FsbG9jKCkgLSBhbGxvY2F0ZSBhbmQg aW5pdGlhbGlzZSBzbGltIHJwcm9jCj4gKyAqIEBwZGV2OiBQb2ludGVyIHRvIHRoZSBwbGF0Zm9y bV9kZXZpY2Ugc3RydWN0Cj4gKyAqIEBmd19uYW1lOiBOYW1lIG9mIGZpcm13YXJlIGZvciBycHJv YyB0byB1c2UKPiArICoKPiArICogRnVuY3Rpb24gZm9yIGFsbG9jYXRpbmcgYW5kIGluaXRpYWxp c2luZyBhIHNsaW0gcnByb2MgZm9yIHVzZSBieQo+ICsgKiBkZXZpY2UgZHJpdmVycyB3aG9zZSBJ UCBpcyBiYXNlZCBhcm91bmQgdGhlIHNsaW0gc2xpbSBjb3JlLiBJdAoKInNsaW0gc2xpbSI/ICBE byB5b3UgbWVhbiAicmVhbGx5IHNsaW0iPyA7KQoKPiArICogb2J0YWlucyBhbmQgZW5hYmxlcyBh bnkgY2xvY2tzIHJlcXVpcmVkIGJ5IHRoZSBzbGltIGNvcmUgYW5kIGFsc28KPiArICogaW9yZW1h cHMgdGhlIHZhcmlvdXMgSU8uCj4gKyAqCj4gKyAqIFJldHVybnMgc3Rfc2xpbV9ycHJvYyBwb2lu dGVyIG9yIFBUUl9FUlIoKSBvbiBlcnJvci4KPiArICovCj4gKwo+ICtzdHJ1Y3Qgc3Rfc2xpbV9y cHJvYyAqc3Rfc2xpbV9ycHJvY19hbGxvYyhzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LAo+ ICsJCQkJY2hhciAqZndfbmFtZSkKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYt PmRldjsKPiArCXN0cnVjdCBzdF9zbGltX3Jwcm9jICpzbGltX3Jwcm9jOwo+ICsJc3RydWN0IGRl dmljZV9ub2RlICpucCA9IGRldi0+b2Zfbm9kZTsKPiArCXN0cnVjdCBycHJvYyAqcnByb2M7Cj4g KwlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKPiArCWludCBlcnIsIGk7Cj4gKwljb25zdCBzdHJ1Y3Qg cnByb2NfZndfb3BzICplbGZfb3BzOwo+ICsKPiArCWlmIChXQVJOX09OKCFucCB8fCAhZndfbmFt ZSkpCj4gKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CgohbnAgc2hvdWxkIG5vdCBoYXBwZW4s IGV2ZXIuICBZb3UgY2FuIHJlbW92ZSB0aGUgY2hlY2suCgo+ICsJaWYgKCFvZl9kZXZpY2VfaXNf Y29tcGF0aWJsZShucCwgInN0LHNsaW0tcnByb2MiKSkKPiArCQlyZXR1cm4gRVJSX1BUUigtRUlO VkFMKTsKPiArCj4gKwlycHJvYyA9IHJwcm9jX2FsbG9jKGRldiwgbnAtPm5hbWUsICZzbGltX3Jw cm9jX29wcywKPiArCQkJZndfbmFtZSwgc2l6ZW9mKCpzbGltX3Jwcm9jKSk7Cj4gKwlpZiAoIXJw cm9jKQo+ICsJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwo+ICsKPiArCXJwcm9jLT5oYXNfaW9t bXUgPSBmYWxzZTsKPiArCj4gKwlzbGltX3Jwcm9jID0gcnByb2MtPnByaXY7Cj4gKwlzbGltX3Jw cm9jLT5ycHJvYyA9IHJwcm9jOwo+ICsKPiArCWVsZl9vcHMgPSBycHJvYy0+Zndfb3BzOwo+ICsJ LyogVXNlIHNvbWUgZ2VuZXJpYyBlbGYgb3BzICovCj4gKwlzbGltX3Jwcm9jX2Z3X29wcy5sb2Fk ID0gZWxmX29wcy0+bG9hZDsKPiArCXNsaW1fcnByb2NfZndfb3BzLnNhbml0eV9jaGVjayA9IGVs Zl9vcHMtPnNhbml0eV9jaGVjazsKPiArCj4gKwlycHJvYy0+Zndfb3BzID0gJnNsaW1fcnByb2Nf Zndfb3BzOwo+ICsKPiArCS8qIGdldCBpbWVtIGFuZCBkbWVtICovCj4gKwlmb3IgKGkgPSAwOyBp IDwgQVJSQVlfU0laRShtZW1fbmFtZXMpOyBpKyspIHsKPiArCgpTdXBlcmZsdW91cyAnXG4nLgoK PiArCQlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2VfYnluYW1lKHBkZXYsIElPUkVTT1VSQ0Vf TUVNLAo+ICsJCQkJCQltZW1fbmFtZXNbaV0pOwo+ICsKPiArCQlzbGltX3Jwcm9jLT5tZW1baV0u Y3B1X2FkZHIgPSBkZXZtX2lvcmVtYXBfcmVzb3VyY2UoZGV2LCByZXMpOwo+ICsJCWlmIChJU19F UlIoc2xpbV9ycHJvYy0+bWVtW2ldLmNwdV9hZGRyKSkgewo+ICsJCQlkZXZfZXJyKCZwZGV2LT5k ZXYsICJkZXZtX2lvcmVtYXBfcmVzb3VyY2UgZmFpbGVkXG4iKTsKPiArCQkJZXJyID0gUFRSX0VS UihzbGltX3Jwcm9jLT5tZW1baV0uY3B1X2FkZHIpOwo+ICsJCQlnb3RvIGVycjsKPiArCQl9Cj4g KwkJc2xpbV9ycHJvYy0+bWVtW2ldLmJ1c19hZGRyID0gcmVzLT5zdGFydDsKPiArCQlzbGltX3Jw cm9jLT5tZW1baV0uc2l6ZSA9IHJlc291cmNlX3NpemUocmVzKTsKPiArCX0KPiArCj4gKwlyZXMg PSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2VfYnluYW1lKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAic2xp bWNvcmUiKTsKClN1cGVyZmx1b3VzICdcbicuCgo+ICsJc2xpbV9ycHJvYy0+c2xpbWNvcmUgPSBk ZXZtX2lvcmVtYXBfcmVzb3VyY2UoZGV2LCByZXMpOwo+ICsJaWYgKElTX0VSUihzbGltX3Jwcm9j LT5zbGltY29yZSkpIHsKPiArCQlkZXZfZXJyKCZwZGV2LT5kZXYsCj4gKwkJCSJkZXZtX2lvcmVt YXBfcmVzb3VyY2UgZmFpbGVkIGZvciBzbGltY29yZVxuIik7CgpCZXN0IG5vdCB0byBxdW90ZSBm dW5jdGlvbiBuYW1lcy4gIEluc3RlYWQgd3JpdGUgdGhlIGRlc2NyaXB0aW9uIGluCnBsYWluIEVu Z2xpc2g7ICJmYWlsZWQgdG8gcmVtYXAgJ3NsaW1jb3JlJyBJTyIsIG9yIHNpbWlsYXIuIAoKPiAr CQllcnIgPSBQVFJfRVJSKHNsaW1fcnByb2MtPnNsaW1jb3JlKTsKPiArCQlnb3RvIGVycjsKPiAr CX0KPiArCj4gKwlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3VyY2VfYnluYW1lKHBkZXYsIElPUkVT T1VSQ0VfTUVNLCAicGVyaXBoZXJhbHMiKTsKPiArCgpTdXBlcmZsdW91cyAnXG4nLgoKPiArCXNs aW1fcnByb2MtPnBlcmkgPSBkZXZtX2lvcmVtYXBfcmVzb3VyY2UoZGV2LCByZXMpOwo+ICsJaWYg KElTX0VSUihzbGltX3Jwcm9jLT5wZXJpKSkgewo+ICsJCWRldl9lcnIoJnBkZXYtPmRldiwgImRl dm1faW9yZW1hcF9yZXNvdXJjZSBmYWlsZWQgZm9yIHBlcmlcbiIpOwoKQXMgYWJvdmUuCgo+ICsJ CWVyciA9IFBUUl9FUlIoc2xpbV9ycHJvYy0+cGVyaSk7Cj4gKwkJZ290byBlcnI7Cj4gKwl9Cj4g Kwo+ICsJZXJyID0gc2xpbV9jbGtfZ2V0KHNsaW1fcnByb2MsIGRldik7Cj4gKwlpZiAoZXJyKQo+ ICsJCWdvdG8gZXJyOwo+ICsKPiArCS8qIFJlZ2lzdGVyIGFzIGEgcmVtb3RlcHJvYyBkZXZpY2Ug Ki8KPiArCWVyciA9IHJwcm9jX2FkZChycHJvYyk7Cj4gKwlpZiAoZXJyKSB7Cj4gKwkJZGV2X2Vy cihkZXYsICJyZWdpc3RyYXRpb24gb2Ygc2xpbSByZW1vdGVwcm9jIGZhaWxlZFxuIik7Cj4gKwkJ Z290byBlcnJfY2xrOwo+ICsJfQo+ICsKPiArCXJldHVybiBzbGltX3Jwcm9jOwo+ICsKPiArZXJy X2NsazoKPiArCWZvciAoaSA9IDA7IGkgPCBTVF9TTElNX01BWF9DTEsgJiYgc2xpbV9ycHJvYy0+ Y2xrc1tpXTsgaSsrKQo+ICsJCWNsa19wdXQoc2xpbV9ycHJvYy0+Y2xrc1tpXSk7Cj4gK2VycjoK PiArCXJwcm9jX3B1dChycHJvYyk7Cj4gKwlyZXR1cm4gRVJSX1BUUihlcnIpOwo+ICt9Cj4gK0VY UE9SVF9TWU1CT0woc3Rfc2xpbV9ycHJvY19hbGxvYyk7Cj4gKwo+ICsvKioKPiArICAqIHN0X3Ns aW1fcnByb2NfcHV0KCkgLSBwdXQgc2xpbSBycHJvYyByZXNvdXJjZXMKPiArICAqIEBzbGltX3Jw cm9jOiBQb2ludGVyIHRvIHRoZSBzdF9zbGltX3Jwcm9jIHN0cnVjdAo+ICsgICoKPiArICAqIEZ1 bmN0aW9uIGZvciBjYWxsaW5nIHJlc3BlY3RpdmUgX3B1dCgpIGZ1bmN0aW9ucyBvbgoKRWFybHkg bGluZSB3cmFwCgogICA8LS0tLS0tLS18LS0tLS0tLS0tfC0tLS0tLS0tLXwtLS0tLS0tLS18LS0t LS0tLS0tfC0tLS0tLS0tLXwtLS0tLS0tLS18LS0tLS0tLS0tPgogICAKPiArICAqIHNsaW1fcnBy b2MgcmVzb3VyY2VzLgo+ICsgICoKClN1cGVyZmx1b3VzICdcbicuCgo+ICsgICovCj4gK3ZvaWQg c3Rfc2xpbV9ycHJvY19wdXQoc3RydWN0IHN0X3NsaW1fcnByb2MgKnNsaW1fcnByb2MpCj4gK3sK PiArCWludCBjbGs7Cj4gKwo+ICsJaWYgKCFzbGltX3Jwcm9jKQo+ICsJCXJldHVybjsKPiArCj4g Kwlmb3IgKGNsayA9IDA7IGNsayA8IFNUX1NMSU1fTUFYX0NMSyAmJiBzbGltX3Jwcm9jLT5jbGtz W2Nsa107IGNsaysrKQo+ICsJCWNsa19wdXQoc2xpbV9ycHJvYy0+Y2xrc1tjbGtdKTsKPiArCj4g KwlycHJvY19kZWwoc2xpbV9ycHJvYy0+cnByb2MpOwo+ICsJcnByb2NfcHV0KHNsaW1fcnByb2Mt PnJwcm9jKTsKPiArfQo+ICtFWFBPUlRfU1lNQk9MKHN0X3NsaW1fcnByb2NfcHV0KTsKPiArCj4g K01PRFVMRV9BVVRIT1IoIlBldGVyIEdyaWZmaW4iKTsKCkVtYWlsLgoKPiArTU9EVUxFX0RFU0NS SVBUSU9OKCJTVE1pY3JvZWxlY3Ryb25pY3MgU0xJTSBycHJvYyBkcml2ZXIiKTsKCk5vdyBpdCdz ICJTTElNIj8gIE1ha2UgdXAgeW91ciBtaW5kLgoKPiArTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIp Owo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3JlbW90ZXByb2Mvc3Rfc2xpbV9ycHJvYy5o IGIvaW5jbHVkZS9saW51eC9yZW1vdGVwcm9jL3N0X3NsaW1fcnByb2MuaAo+IG5ldyBmaWxlIG1v ZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uNjRhMmM1Ygo+IC0tLSAvZGV2L251bGwKPiArKysg Yi9pbmNsdWRlL2xpbnV4L3JlbW90ZXByb2Mvc3Rfc2xpbV9ycHJvYy5oCj4gQEAgLTAsMCArMSw1 MyBAQAo+ICsvKgo+ICsgKiBzdF9zbGltX3Jwcm9jLmgKCkFzIGFib3ZlLgoKPiArICogQ29weXJp Z2h0IChDKSAyMDE2IFNUTWljcm9lbGVjdHJvbmljcwo+ICsgKiBBdXRob3I6IFBldGVyIEdyaWZm aW4gPHBldGVyLmdyaWZmaW5AbGluYXJvLm9yZz4KPiArICogTGljZW5zZSB0ZXJtczogIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpLCB2ZXJzaW9uIDIKPiArICovCgpTYW1lIGZvciB0 aGUgKi5jIGhlYWRlci4KCj4gKyNpZm5kZWYgX1NUX1NMSU1fSAo+ICsjZGVmaW5lIF9TVF9TTElN X0gKCkJlc3QgdG8gbWVudGlvbiB0aGUgc3Vic3lzdGVtIHRvby4KCj4gKyNkZWZpbmUgU1RfU0xJ TV9NRU1fTUFYIDIKPiArI2RlZmluZSBTVF9TTElNX01BWF9DTEsgNAo+ICsKPiArZW51bSB7Cj4g KwlTVF9TTElNX0RNRU0sCj4gKwlTVF9TTElNX0lNRU0sCj4gK307Cj4gKwo+ICsvKioKPiArICog c3RydWN0IHN0X3NsaW1fbWVtIC0gc2xpbSBpbnRlcm5hbCBtZW1vcnkgc3RydWN0dXJlCj4gKyAq IEBjcHVfYWRkcjogTVBVIHZpcnR1YWwgYWRkcmVzcyBvZiB0aGUgbWVtb3J5IHJlZ2lvbgo+ICsg KiBAYnVzX2FkZHI6IEJ1cyBhZGRyZXNzIHVzZWQgdG8gYWNjZXNzIHRoZSBtZW1vcnkgcmVnaW9u Cj4gKyAqIEBzaXplOiBTaXplIG9mIHRoZSBtZW1vcnkgcmVnaW9uCj4gKyAqLwo+ICtzdHJ1Y3Qg c3Rfc2xpbV9tZW0gewo+ICsJdm9pZCBfX2lvbWVtICpjcHVfYWRkcjsKPiArCXBoeXNfYWRkcl90 IGJ1c19hZGRyOwo+ICsJc2l6ZV90IHNpemU7Cj4gK307Cj4gKwo+ICsvKioKPiArICogc3RydWN0 IHN0X3NsaW1fcnByb2MgLSBTTElNIHNsaW0gY29yZQo+ICsgKiBAcnByb2M6IHJwcm9jIGhhbmRs ZQo+ICsgKiBAbWVtOiBzbGltIG1lbW9yeSBpbmZvcm1hdGlvbgo+ICsgKiBAc2xpbWNvcmU6IHNs aW0gc2xpbWNvcmUgcmVncwo+ICsgKiBAcGVyaTogc2xpbSBwZXJpcGhlcmFsIHJlZ3MKPiArICog QGNsa3M6IHNsaW0gY2xvY2tzCj4gKyAqLwo+ICtzdHJ1Y3Qgc3Rfc2xpbV9ycHJvYyB7Cj4gKwlz dHJ1Y3QgcnByb2MgKnJwcm9jOwo+ICsJc3RydWN0IHN0X3NsaW1fbWVtIG1lbVtTVF9TTElNX01F TV9NQVhdOwo+ICsJdm9pZCBfX2lvbWVtICpzbGltY29yZTsKPiArCXZvaWQgX19pb21lbSAqcGVy aTsKPiArCj4gKwkvKiBzdF9zbGltX3Jwcm9jIHByaXZhdGUgKi8KPiArCXN0cnVjdCBjbGsgKmNs a3NbU1RfU0xJTV9NQVhfQ0xLXTsKPiArfTsKPiArCj4gK3N0cnVjdCBzdF9zbGltX3Jwcm9jICpz dF9zbGltX3Jwcm9jX2FsbG9jKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsCj4gKwkJCQkJ Y2hhciAqZndfbmFtZSk7Cj4gK3ZvaWQgc3Rfc2xpbV9ycHJvY19wdXQoc3RydWN0IHN0X3NsaW1f cnByb2MgKnNsaW1fcnByb2MpOwo+ICsKPiArI2VuZGlmCgotLSAKTGVlIEpvbmVzCkxpbmFybyBT VE1pY3JvZWxlY3Ryb25pY3MgTGFuZGluZyBUZWFtIExlYWQKTGluYXJvLm9yZyDilIIgT3BlbiBz b3VyY2Ugc29mdHdhcmUgZm9yIEFSTSBTb0NzCkZvbGxvdyBMaW5hcm86IEZhY2Vib29rIHwgVHdp dHRlciB8IEJsb2cKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3Jn Cmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs Cg==