From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 86D5BC07E99 for ; Mon, 5 Jul 2021 14:55:37 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 68ED061955 for ; Mon, 5 Jul 2021 14:55:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231643AbhGEO6M (ORCPT ); Mon, 5 Jul 2021 10:58:12 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58808 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231594AbhGEO6I (ORCPT ); Mon, 5 Jul 2021 10:58:08 -0400 Received: from metis.ext.pengutronix.de (metis.ext.pengutronix.de [IPv6:2001:67c:670:201:290:27ff:fe1d:cc33]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 11AF6C061574 for ; Mon, 5 Jul 2021 07:55:31 -0700 (PDT) Received: from gallifrey.ext.pengutronix.de ([2001:67c:670:201:5054:ff:fe8d:eefb] helo=[IPv6:::1]) by metis.ext.pengutronix.de with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1m0Q0G-0007rp-4w; Mon, 05 Jul 2021 16:55:20 +0200 Message-ID: <0fc1f5043eeedb0c40ae9f76e245c648e0c88cde.camel@pengutronix.de> Subject: Re: [PATCH V8 3/4] soc: imx: Add generic blk-ctl driver From: Lucas Stach To: "Peng Fan (OSS)" , robh+dt@kernel.org, shawnguo@kernel.org, s.hauer@pengutronix.de Cc: kernel@pengutronix.de, festevam@gmail.com, linux-imx@nxp.com, p.zabel@pengutronix.de, krzk@kernel.org, agx@sigxcpu.org, marex@denx.de, andrew.smirnov@gmail.com, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, ping.bai@nxp.com, frieder.schrempf@kontron.de, aford173@gmail.com, abel.vesa@nxp.com, jagan@amarulasolutions.com, Peng Fan Date: Mon, 05 Jul 2021 16:55:17 +0200 In-Reply-To: <20210629072941.7980-4-peng.fan@oss.nxp.com> References: <20210629072941.7980-1-peng.fan@oss.nxp.com> <20210629072941.7980-4-peng.fan@oss.nxp.com> Content-Type: text/plain; charset="UTF-8" User-Agent: Evolution 3.40.1 (3.40.1-1.fc34) MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-SA-Exim-Connect-IP: 2001:67c:670:201:5054:ff:fe8d:eefb X-SA-Exim-Mail-From: l.stach@pengutronix.de X-SA-Exim-Scanned: No (on metis.ext.pengutronix.de); SAEximRunCond expanded to false X-PTX-Original-Recipient: linux-kernel@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi Peng, Am Dienstag, dem 29.06.2021 um 15:29 +0800 schrieb Peng Fan (OSS): > From: Peng Fan > > The i.MX8MM introduces an IP named BLK_CTL and usually is comprised of > some GPRs. > > The GPRs has some clock bits and reset bits, but here we take it > as virtual PDs, because of the clock and power domain A/B lock issue > when taking it as a clock controller. > > For some bits, it might be good to also make it as a reset controller, > but to i.MX8MM, we not add that support for now. > > Signed-off-by: Peng Fan > --- > drivers/soc/imx/Makefile | 2 +- > drivers/soc/imx/blk-ctl.c | 324 ++++++++++++++++++++++++++++++++++++++ > drivers/soc/imx/blk-ctl.h | 85 ++++++++++ > 3 files changed, 410 insertions(+), 1 deletion(-) > create mode 100644 drivers/soc/imx/blk-ctl.c > create mode 100644 drivers/soc/imx/blk-ctl.h > > diff --git a/drivers/soc/imx/Makefile b/drivers/soc/imx/Makefile > index 078dc918f4f3..d3d2b49a386c 100644 > --- a/drivers/soc/imx/Makefile > +++ b/drivers/soc/imx/Makefile > @@ -4,4 +4,4 @@ obj-$(CONFIG_ARCH_MXC) += soc-imx.o > endif > obj-$(CONFIG_HAVE_IMX_GPC) += gpc.o > obj-$(CONFIG_IMX_GPCV2_PM_DOMAINS) += gpcv2.o > -obj-$(CONFIG_SOC_IMX8M) += soc-imx8m.o > +obj-$(CONFIG_SOC_IMX8M) += soc-imx8m.o blk-ctl.o > diff --git a/drivers/soc/imx/blk-ctl.c b/drivers/soc/imx/blk-ctl.c > new file mode 100644 > index 000000000000..cec1884202e0 > --- /dev/null > +++ b/drivers/soc/imx/blk-ctl.c > @@ -0,0 +1,324 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Copyright 2021 NXP. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "blk-ctl.h" > + > +static inline struct imx_blk_ctl_domain *to_imx_blk_ctl_pd(struct generic_pm_domain *genpd) > +{ > + return container_of(genpd, struct imx_blk_ctl_domain, genpd); > +} > + > +static int imx_blk_ctl_enable_hsk(struct device *dev) > +{ > + struct imx_blk_ctl *blk_ctl = dev_get_drvdata(dev); > + const struct imx_blk_ctl_hw *hw = blk_ctl->dev_data->hw_hsk; > + struct regmap *regmap = blk_ctl->regmap; > + int ret; > + > + if (hw->flags & IMX_BLK_CTL_PD_RESET) { > + ret = regmap_update_bits(regmap, hw->rst_offset, hw->rst_mask, hw->rst_mask); > + if (ret) > + return ret; > + } > + > + ret = regmap_update_bits(regmap, hw->offset, hw->mask, hw->mask); > + > + /* Wait for handshake */ > + udelay(5); > + > + return ret; > +} > + > +static int imx_blk_ctl_power_on(struct generic_pm_domain *domain) > +{ > + struct imx_blk_ctl_domain *pd = to_imx_blk_ctl_pd(domain); > + struct imx_blk_ctl *blk_ctl = pd->blk_ctl; > + struct regmap *regmap = blk_ctl->regmap; > + const struct imx_blk_ctl_hw *hw = &blk_ctl->dev_data->pds[pd->id]; > + int ret; > + > + mutex_lock(&blk_ctl->lock); > + > + ret = clk_bulk_prepare_enable(blk_ctl->num_clks, blk_ctl->clks); I'm still not a fan of enabling all the clocks going into the blk-ctl to power up/down one specific domain. It's not really a problem with clocks, where the parents are always on, as the clock gate/ungate is pretty cheap, but as soon as you get to something like the display pixel clock, where the parent PLL may be shut down, the clock enable may easily be the most costly operation of this whole function, even if this specific clock isn't even needed for the domain in question. > + if (ret) { > + mutex_unlock(&blk_ctl->lock); > + return ret; > + } > + > + if (hw->flags & IMX_BLK_CTL_PD_HANDSHAKE) { > + ret = imx_blk_ctl_enable_hsk(blk_ctl->dev); > + if (ret) > + dev_err(blk_ctl->dev, "Handshake failed when power on\n"); > + > + /* Expected, handshake already handle reset*/ > + goto disable_clk; > + } > + > + if (hw->flags & IMX_BLK_CTL_PD_RESET) { > + ret = regmap_clear_bits(regmap, hw->rst_offset, hw->rst_mask); > + if (ret) > + goto disable_clk; > + > + /* Wait for reset propagate */ > + udelay(5); > + > + ret = regmap_update_bits(regmap, hw->rst_offset, hw->rst_mask, hw->rst_mask); > + if (ret) > + goto disable_clk; > + } > + > + ret = regmap_update_bits(regmap, hw->offset, hw->mask, hw->mask); > I find this very hard to follow and reason about. Why do we even need those different paths for domains with or without the handshake? Shouldn't it be enough to just be enough to do the following in all cases: 1. release sft reset 2. enable sft clock 3. wait a little for reset to propagate or ADB to ack power up > +disable_clk: > + clk_bulk_disable_unprepare(blk_ctl->num_clks, blk_ctl->clks); > + > + mutex_unlock(&blk_ctl->lock); > + > + return ret; > +} > + > +static int imx_blk_ctl_power_off(struct generic_pm_domain *domain) > +{ > + struct imx_blk_ctl_domain *pd = to_imx_blk_ctl_pd(domain); > + struct imx_blk_ctl *blk_ctl = pd->blk_ctl; > + struct regmap *regmap = blk_ctl->regmap; > + const struct imx_blk_ctl_hw *hw = &blk_ctl->dev_data->pds[pd->id]; > + int ret = 0; > + > + mutex_lock(&blk_ctl->lock); > + > + ret = clk_bulk_prepare_enable(blk_ctl->num_clks, blk_ctl->clks); > + if (ret) { > + mutex_unlock(&blk_ctl->lock); > + return ret; > + } > + > + if (!(hw->flags & IMX_BLK_CTL_PD_HANDSHAKE)) { > + ret = regmap_clear_bits(regmap, hw->offset, hw->mask); > + if (ret) > + goto disable_clk; > + > + if (hw->flags & IMX_BLK_CTL_PD_RESET) { > + ret = regmap_clear_bits(regmap, hw->rst_offset, hw->rst_mask); > + if (ret) > + goto disable_clk; > + } > + } else { > + ret = imx_blk_ctl_enable_hsk(blk_ctl->dev); Why would we need to enable the handshake again in the power DOWN path? The clock/reset bits should still be set from the power up. The power down should probably just be a no-op for the blk-ctl bus domains, to allow the proper ADB handshake in the PGC domain power-down. > + if (ret) > + dev_err(blk_ctl->dev, "Handshake failed when power off\n"); > + } > + > +disable_clk: > + clk_bulk_disable_unprepare(blk_ctl->num_clks, blk_ctl->clks); > + > + mutex_unlock(&blk_ctl->lock); > + > + return ret; > +} > + > +static int imx_blk_ctl_probe(struct platform_device *pdev) > +{ > + struct imx_blk_ctl_domain *domain = pdev->dev.platform_data; > + struct imx_blk_ctl *blk_ctl = domain->blk_ctl; > + struct generic_pm_domain *parent_genpd; > + struct device *dev = &pdev->dev; > + struct device *active_pd; > + int ret; > + > + pdev->dev.of_node = blk_ctl->dev->of_node; > + > + if (domain->hw->active_pd_name) { > + active_pd = dev_pm_domain_attach_by_name(dev, domain->hw->active_pd_name); > + if (IS_ERR_OR_NULL(active_pd)) { > + ret = PTR_ERR(active_pd) ? : -ENODATA; > + pdev->dev.of_node = NULL; This is extremely ugly. I think we should not even have separate platform drivers for the blk-ctl domains, there is just no reason for it. See below for more comments in that direction. > + return ret; > + } > + > + domain->active_pd = active_pd; > + } else { > + if (!blk_ctl->bus_domain) { > + pdev->dev.of_node = NULL; > + return -EPROBE_DEFER; > + } > + } > + > + if (domain->hw->active_pd_name) > + parent_genpd = pd_to_genpd(active_pd->pm_domain); > + else > + parent_genpd = blk_ctl->bus_domain; > + > + if (pm_genpd_add_subdomain(parent_genpd, &domain->genpd)) { > + dev_warn(dev, "failed to add subdomain: %s\n", domain->genpd.name); I don't see where the dispmix_bus domain and clock is kept enabled. I would guess that the bus domain should be some kind of parent to the lcdif and mipi domains, as I don't think it would be okay to disable the bus clock, while any of the peripherals in the dispmix complex are still active. Am I missing something here? > + } else { > + mutex_lock(&blk_ctl->lock); > + domain->hooked = true; > + mutex_unlock(&blk_ctl->lock); > + } > + > + return 0; > +} > + > +static int imx_blk_ctl_remove(struct platform_device *pdev) > +{ > + struct imx_blk_ctl_domain *domain = pdev->dev.platform_data; > + struct imx_blk_ctl *blk_ctl = domain->blk_ctl; > + struct generic_pm_domain *parent_genpd; > + struct device *active_pd; > + > + if (domain->hw->active_pd_name) > + parent_genpd = pd_to_genpd(active_pd->pm_domain); This has probably never been tested. active_pd is undefined at this point, so will most likely lead to a kernel crash. > + else > + parent_genpd = blk_ctl->bus_domain; > + > + pm_genpd_remove_subdomain(parent_genpd, &domain->genpd); > + > + mutex_lock(&blk_ctl->lock); > + domain->hooked = false; > + mutex_unlock(&blk_ctl->lock); > + > + if (domain->hw->active_pd_name) > + dev_pm_domain_detach(domain->active_pd, false); > + > + return 0; > +} > + > +static const struct platform_device_id imx_blk_ctl_id[] = { > + { "imx-vpumix-blk-ctl", }, > + { "imx-dispmix-blk-ctl", }, > + { }, > +}; > + > +static struct platform_driver imx_blk_ctl_driver = { > + .driver = { > + .name = "imx-blk-ctl", > + }, > + .probe = imx_blk_ctl_probe, > + .remove = imx_blk_ctl_remove, > + .id_table = imx_blk_ctl_id, > +}; > +builtin_platform_driver(imx_blk_ctl_driver) > + > +static struct generic_pm_domain *imx_blk_ctl_genpd_xlate(struct of_phandle_args *genpdspec, > + void *data) > +{ > + struct genpd_onecell_data *genpd_data = data; > + unsigned int idx = genpdspec->args[0]; > + struct imx_blk_ctl_domain *domain; > + struct generic_pm_domain *genpd = ERR_PTR(-EPROBE_DEFER); > + > + if (genpdspec->args_count != 1) > + return ERR_PTR(-EINVAL); > + > + if (idx >= genpd_data->num_domains) > + return ERR_PTR(-EINVAL); > + > + if (!genpd_data->domains[idx]) > + return ERR_PTR(-ENOENT); > + > + domain = to_imx_blk_ctl_pd(genpd_data->domains[idx]); > + > + mutex_lock(&domain->blk_ctl->lock); > + if (domain->hooked) > + genpd = genpd_data->domains[idx]; > + mutex_unlock(&domain->blk_ctl->lock); > + > + return genpd; > +} > + > +int imx_blk_ctl_register(struct device *dev) > +{ > + struct imx_blk_ctl *blk_ctl = dev_get_drvdata(dev); > + const struct imx_blk_ctl_dev_data *dev_data = blk_ctl->dev_data; > + int num = dev_data->pds_num; > + struct imx_blk_ctl_domain *domain; > + struct generic_pm_domain *genpd; > + struct platform_device *pd_pdev; > + int domain_index; > + int i, ret; > + > + blk_ctl->onecell_data.num_domains = num; > + blk_ctl->onecell_data.xlate = imx_blk_ctl_genpd_xlate; > + blk_ctl->onecell_data.domains = devm_kcalloc(dev, num, sizeof(struct generic_pm_domain *), > + GFP_KERNEL); > + if (!blk_ctl->onecell_data.domains) > + return -ENOMEM; > + > + for (i = 0; i < num; i++) { > + domain_index = dev_data->pds[i].id; > + if (domain_index >= num) { > + dev_warn(dev, "Domain index %d is out of bounds\n", domain_index); > + continue; > + } > + > + domain = devm_kzalloc(dev, sizeof(struct imx_blk_ctl_domain), GFP_KERNEL); > + if (!domain) > + goto error; > + > + pd_pdev = platform_device_alloc(dev_data->name, domain_index); > + if (!pd_pdev) { > + dev_err(dev, "Failed to allocate platform device\n"); > + goto error; > + } We don't need a full blow platform device and a driver for the individual domains. The only point where we need the device is to attach the parent PGC power domains and for this we only need a device.  So we could either have a dummy device for this usage in the domain or we could even reuse the device in the genpd, which is initialized in pm_genpd_init. Now while I think about it... genpd_dev_pm_attach_by_name already allocates the virtual dummy device. I don't think we need to do anything here on our own. Just get rid of the platform device and driver. > + > + pd_pdev->dev.platform_data = domain; > + > + domain->blk_ctl = blk_ctl; > + domain->hw = &dev_data->pds[i]; > + domain->id = domain_index; > + domain->genpd.name = dev_data->pds[i].name; > + domain->genpd.power_off = imx_blk_ctl_power_off; > + domain->genpd.power_on = imx_blk_ctl_power_on; > + domain->dev = &pd_pdev->dev; > + domain->hooked = false; > + > + ret = pm_genpd_init(&domain->genpd, NULL, true); > + pd_pdev->dev.parent = dev; > + > + if (domain->hw->flags & IMX_BLK_CTL_PD_HANDSHAKE) > + blk_ctl->bus_domain = &domain->genpd; > + > + ret = platform_device_add(pd_pdev); > + if (ret) { > + platform_device_put(pd_pdev); > + goto error; > + } There is really no need for the complexity with the hooked property (the mutex around the read/write access still doesn't make it properly thread safe) and the blk-ctl domain probe/remove calls. Just handle everything within this loop. This would make the driver a whole lot more easy to follow. > + blk_ctl->onecell_data.domains[i] = &domain->genpd; > + } > + > + return of_genpd_add_provider_onecell(dev->of_node, &blk_ctl->onecell_data); > + > +error: > + for (; i >= 0; i--) { > + genpd = blk_ctl->onecell_data.domains[i]; > + if (!genpd) > + continue; > + domain = to_imx_blk_ctl_pd(genpd); > + if (domain->dev) > + platform_device_put(to_platform_device(domain->dev)); > + } > + return ret; > +} > +EXPORT_SYMBOL_GPL(imx_blk_ctl_register); > + > +const struct dev_pm_ops imx_blk_ctl_pm_ops = { > + SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume) > +}; > +EXPORT_SYMBOL_GPL(imx_blk_ctl_pm_ops); This code is linked into the same module as the platform driver using it. So there is no need to export those symbols and expose them to the whole kernel. > diff --git a/drivers/soc/imx/blk-ctl.h b/drivers/soc/imx/blk-ctl.h > new file mode 100644 > index 000000000000..6780d00ec8c5 > --- /dev/null > +++ b/drivers/soc/imx/blk-ctl.h > @@ -0,0 +1,85 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +#ifndef __SOC_IMX_BLK_CTL_H > +#define __SOC_IMX_BLK_CTL_H > + > +enum imx_blk_ctl_pd_type { > + BLK_CTL_PD, > +}; > + > +struct imx_blk_ctl_hw { > + int type; Initialized, but unused. > + char *name; > + char *active_pd_name; > + u32 offset; > + u32 mask; offset and mask are way too generic names. I had to spend some time reading the driver to find out that those are the clock enable bits. This should be clear from the naming. > + u32 flags; > + u32 id; > + u32 rst_offset; > + u32 rst_mask; > + u32 errata; Unused. > +}; > + > +struct imx_blk_ctl_domain { > + struct generic_pm_domain genpd; > + struct device *active_pd; > + struct imx_blk_ctl *blk_ctl; > + struct imx_blk_ctl_hw *hw; > + struct device *dev; > + bool hooked; > + u32 id; There are already a lot of pointers between the different structures. Why do we need those id properties? You should be able to get to all needed information by chasing pointers, instead of indexing into arrays. Really the only point where a id->domain mapping is done should be the xlate function. > +}; > + > +struct imx_blk_ctl_dev_data { > + struct regmap_config config; > + struct imx_blk_ctl_hw *pds; > + struct imx_blk_ctl_hw *hw_hsk; > + u32 pds_num; > + u32 max_num; > + char *name; > +}; > + > +struct imx_blk_ctl { > + struct device *dev; > + struct regmap *regmap; > + struct genpd_onecell_data onecell_data; > + const struct imx_blk_ctl_dev_data *dev_data; > + struct clk_bulk_data *clks; > + u32 num_clks; > + struct generic_pm_domain *bus_domain; There should be nothing special about the bus domain at all. Right now this permeates through the whole driver that the bus domain is somehow special. It should just be a parent domain of the other domains, or kept alive via some other appropriate means. > + > + struct mutex lock; This mutex is only used in the common blk-ctl code, but is initialized in imx8mm_blk_ctrl_probe. This seems very inconsistent. I would have expected this mutex to be initialized in imx_blk_ctl_register. However, once you get rid of the hooked and bus domain magic, this mutex may as well be per-domain, at which point I think you don't even need the mutex, as the genpd locking should be enough then. > +}; > + > +#define IMX_BLK_CTL(_type, _name, _active_pd, _id, _offset, _mask, _rst_offset, _rst_mask, \ > + _flags, _errata) \ > + { \ > + .type = _type, \ > + .name = _name, \ > + .active_pd_name = _active_pd, \ > + .id = _id, \ > + .offset = _offset, \ > + .mask = _mask, \ > + .flags = _flags, \ > + .rst_offset = _rst_offset, \ > + .rst_mask = _rst_mask, \ > + .errata = _errata, \ > + } > + > +#define IMX_BLK_CTL_PD(_name, _active_pd, _id, _offset, _mask, _rst_offset, _rst_mask, _flags) \ > + IMX_BLK_CTL(BLK_CTL_PD, _name, _active_pd, _id, _offset, _mask, _rst_offset, \ > + _rst_mask, _flags, 0) > + > +#define IMX_BLK_CTL_PD_ERRATA(_name, _active_pd, _id, _offset, _mask, _rst_offset, _rst_mask, \ > + _flags, _errata) \ > + IMX_BLK_CTL(BLK_CTL_PD, _name, _active_pd, _id, _offset, _mask, _rst_offset, \ > + _rst_mask, _flags, _errata) > + > +int imx_blk_ctl_register(struct device *dev); > + > +#define IMX_BLK_CTL_PD_HANDSHAKE BIT(0) > +#define IMX_BLK_CTL_PD_RESET BIT(1) > +#define IMX_BLK_CTL_PD_BUS BIT(2) > + > +const extern struct dev_pm_ops imx_blk_ctl_pm_ops; > + > +#endif From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.2 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7F287C07E99 for ; Mon, 5 Jul 2021 15:02:39 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 42409613AE for ; Mon, 5 Jul 2021 15:02:39 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 42409613AE Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=pengutronix.de Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Date:Cc:To:From:Subject:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=3En0caJQdAUVPfdFQYFGQ1PgYSRAZKYOmqC9Zgqk2lk=; b=q2Jk6lrCYiX/l7 3+bkmmImjwHk9Jwsw9dM+zXLdPbE81EmXUk0caMv1kK5Y1W9Bpf+BvYubgqECld2C7VkOm7rWYaZa CpEX14LU5EdRcg34fvzkLTeQ4Y5r7OmvfMmailWrwwkp+hsbEubQMohyNTy++YTSO2gTPnsRR7vEe cbdKxpzqB4ujE1kQzuXPQ/3WjfjK9UsfTORtOIzw3zfZvjfEK9zQnPtyNDMaPgO8OPAT09kavqWx6 SdrhPnyz6EIPvnFg2u7aM4FKYwpdYzV+d0XQ5rqjW5Hkzwq6GT/Z3N4KzWfnMlVoZV6c9mPQZM7hl X5Ot20Jgz+xWQ/6qX24A==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1m0Q5H-009EL9-04; Mon, 05 Jul 2021 15:00:32 +0000 Received: from metis.ext.pengutronix.de ([2001:67c:670:201:290:27ff:fe1d:cc33]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1m0Q0R-009CBL-In for linux-arm-kernel@lists.infradead.org; Mon, 05 Jul 2021 14:55:34 +0000 Received: from gallifrey.ext.pengutronix.de ([2001:67c:670:201:5054:ff:fe8d:eefb] helo=[IPv6:::1]) by metis.ext.pengutronix.de with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1m0Q0G-0007rp-4w; Mon, 05 Jul 2021 16:55:20 +0200 Message-ID: <0fc1f5043eeedb0c40ae9f76e245c648e0c88cde.camel@pengutronix.de> Subject: Re: [PATCH V8 3/4] soc: imx: Add generic blk-ctl driver From: Lucas Stach To: "Peng Fan (OSS)" , robh+dt@kernel.org, shawnguo@kernel.org, s.hauer@pengutronix.de Cc: kernel@pengutronix.de, festevam@gmail.com, linux-imx@nxp.com, p.zabel@pengutronix.de, krzk@kernel.org, agx@sigxcpu.org, marex@denx.de, andrew.smirnov@gmail.com, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, ping.bai@nxp.com, frieder.schrempf@kontron.de, aford173@gmail.com, abel.vesa@nxp.com, jagan@amarulasolutions.com, Peng Fan Date: Mon, 05 Jul 2021 16:55:17 +0200 In-Reply-To: <20210629072941.7980-4-peng.fan@oss.nxp.com> References: <20210629072941.7980-1-peng.fan@oss.nxp.com> <20210629072941.7980-4-peng.fan@oss.nxp.com> User-Agent: Evolution 3.40.1 (3.40.1-1.fc34) MIME-Version: 1.0 X-SA-Exim-Connect-IP: 2001:67c:670:201:5054:ff:fe8d:eefb X-SA-Exim-Mail-From: l.stach@pengutronix.de X-SA-Exim-Scanned: No (on metis.ext.pengutronix.de); SAEximRunCond expanded to false X-PTX-Original-Recipient: linux-arm-kernel@lists.infradead.org X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210705_075531_999807_1FA1144D X-CRM114-Status: GOOD ( 53.58 ) 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 SGkgUGVuZywKCkFtIERpZW5zdGFnLCBkZW0gMjkuMDYuMjAyMSB1bSAxNToyOSArMDgwMCBzY2hy aWViIFBlbmcgRmFuIChPU1MpOgo+IEZyb206IFBlbmcgRmFuIDxwZW5nLmZhbkBueHAuY29tPgo+ IAo+IFRoZSBpLk1YOE1NIGludHJvZHVjZXMgYW4gSVAgbmFtZWQgQkxLX0NUTCBhbmQgdXN1YWxs eSBpcyBjb21wcmlzZWQgb2YKPiBzb21lIEdQUnMuCj4gCj4gVGhlIEdQUnMgaGFzIHNvbWUgY2xv Y2sgYml0cyBhbmQgcmVzZXQgYml0cywgYnV0IGhlcmUgd2UgdGFrZSBpdAo+IGFzIHZpcnR1YWwg UERzLCBiZWNhdXNlIG9mIHRoZSBjbG9jayBhbmQgcG93ZXIgZG9tYWluIEEvQiBsb2NrIGlzc3Vl Cj4gd2hlbiB0YWtpbmcgaXQgYXMgYSBjbG9jayBjb250cm9sbGVyLgo+IAo+IEZvciBzb21lIGJp dHMsIGl0IG1pZ2h0IGJlIGdvb2QgdG8gYWxzbyBtYWtlIGl0IGFzIGEgcmVzZXQgY29udHJvbGxl ciwKPiBidXQgdG8gaS5NWDhNTSwgd2Ugbm90IGFkZCB0aGF0IHN1cHBvcnQgZm9yIG5vdy4KPiAK PiBTaWduZWQtb2ZmLWJ5OiBQZW5nIEZhbiA8cGVuZy5mYW5AbnhwLmNvbT4KPiAtLS0KPiAgZHJp dmVycy9zb2MvaW14L01ha2VmaWxlICB8ICAgMiArLQo+ICBkcml2ZXJzL3NvYy9pbXgvYmxrLWN0 bC5jIHwgMzI0ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gIGRyaXZl cnMvc29jL2lteC9ibGstY3RsLmggfCAgODUgKysrKysrKysrKwo+ICAzIGZpbGVzIGNoYW5nZWQs IDQxMCBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL3NvYy9pbXgvYmxrLWN0bC5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3Nv Yy9pbXgvYmxrLWN0bC5oCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvc29jL2lteC9NYWtlZmls ZSBiL2RyaXZlcnMvc29jL2lteC9NYWtlZmlsZQo+IGluZGV4IDA3OGRjOTE4ZjRmMy4uZDNkMmI0 OWEzODZjIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvc29jL2lteC9NYWtlZmlsZQo+ICsrKyBiL2Ry aXZlcnMvc29jL2lteC9NYWtlZmlsZQo+IEBAIC00LDQgKzQsNCBAQCBvYmotJChDT05GSUdfQVJD SF9NWEMpICs9IHNvYy1pbXgubwo+ICBlbmRpZgo+ICBvYmotJChDT05GSUdfSEFWRV9JTVhfR1BD KSArPSBncGMubwo+ICBvYmotJChDT05GSUdfSU1YX0dQQ1YyX1BNX0RPTUFJTlMpICs9IGdwY3Yy Lm8KPiAtb2JqLSQoQ09ORklHX1NPQ19JTVg4TSkgKz0gc29jLWlteDhtLm8KPiArb2JqLSQoQ09O RklHX1NPQ19JTVg4TSkgKz0gc29jLWlteDhtLm8gYmxrLWN0bC5vCj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvc29jL2lteC9ibGstY3RsLmMgYi9kcml2ZXJzL3NvYy9pbXgvYmxrLWN0bC5jCj4gbmV3 IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmNlYzE4ODQyMDJlMAo+IC0t LSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL3NvYy9pbXgvYmxrLWN0bC5jCj4gQEAgLTAsMCAr MSwzMjQgQEAKPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiArLyoKPiAr ICogQ29weXJpZ2h0IDIwMjEgTlhQLgo+ICsgKi8KPiArCj4gKyNpbmNsdWRlIDxsaW51eC9jbGsu aD4KPiArI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgo+ICsjaW5jbHVkZSA8bGludXgvaW8uaD4KPiAr I2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KPiAr I2luY2x1ZGUgPGxpbnV4L29mLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9vZl9hZGRyZXNzLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9vZl9kZXZpY2UuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3Jt X2RldmljZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvcG1fcnVudGltZS5oPgo+ICsjaW5jbHVkZSA8 bGludXgvcG1fZG9tYWluLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KPiArI2luY2x1 ZGUgPGxpbnV4L3NsYWIuaD4KPiArCj4gKyNpbmNsdWRlICJibGstY3RsLmgiCj4gKwo+ICtzdGF0 aWMgaW5saW5lIHN0cnVjdCBpbXhfYmxrX2N0bF9kb21haW4gKnRvX2lteF9ibGtfY3RsX3BkKHN0 cnVjdCBnZW5lcmljX3BtX2RvbWFpbiAqZ2VucGQpCj4gK3sKPiArCXJldHVybiBjb250YWluZXJf b2YoZ2VucGQsIHN0cnVjdCBpbXhfYmxrX2N0bF9kb21haW4sIGdlbnBkKTsKPiArfQo+ICsKPiAr c3RhdGljIGludCBpbXhfYmxrX2N0bF9lbmFibGVfaHNrKHN0cnVjdCBkZXZpY2UgKmRldikKPiAr ewo+ICsJc3RydWN0IGlteF9ibGtfY3RsICpibGtfY3RsID0gZGV2X2dldF9kcnZkYXRhKGRldik7 Cj4gKwljb25zdCBzdHJ1Y3QgaW14X2Jsa19jdGxfaHcgKmh3ID0gYmxrX2N0bC0+ZGV2X2RhdGEt Pmh3X2hzazsKPiArCXN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IGJsa19jdGwtPnJlZ21hcDsKPiAr CWludCByZXQ7Cj4gKwo+ICsJaWYgKGh3LT5mbGFncyAmIElNWF9CTEtfQ1RMX1BEX1JFU0VUKSB7 Cj4gKwkJcmV0ID0gcmVnbWFwX3VwZGF0ZV9iaXRzKHJlZ21hcCwgaHctPnJzdF9vZmZzZXQsIGh3 LT5yc3RfbWFzaywgaHctPnJzdF9tYXNrKTsKPiArCQlpZiAocmV0KQo+ICsJCQlyZXR1cm4gcmV0 Owo+ICsJfQo+ICsKPiArCXJldCA9IHJlZ21hcF91cGRhdGVfYml0cyhyZWdtYXAsIGh3LT5vZmZz ZXQsIGh3LT5tYXNrLCBody0+bWFzayk7Cj4gKwo+ICsJLyogV2FpdCBmb3IgaGFuZHNoYWtlICov Cj4gKwl1ZGVsYXkoNSk7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIGlu dCBpbXhfYmxrX2N0bF9wb3dlcl9vbihzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW4gKmRvbWFpbikK PiArewo+ICsJc3RydWN0IGlteF9ibGtfY3RsX2RvbWFpbiAqcGQgPSB0b19pbXhfYmxrX2N0bF9w ZChkb21haW4pOwo+ICsJc3RydWN0IGlteF9ibGtfY3RsICpibGtfY3RsID0gcGQtPmJsa19jdGw7 Cj4gKwlzdHJ1Y3QgcmVnbWFwICpyZWdtYXAgPSBibGtfY3RsLT5yZWdtYXA7Cj4gKwljb25zdCBz dHJ1Y3QgaW14X2Jsa19jdGxfaHcgKmh3ID0gJmJsa19jdGwtPmRldl9kYXRhLT5wZHNbcGQtPmlk XTsKPiArCWludCByZXQ7Cj4gKwo+ICsJbXV0ZXhfbG9jaygmYmxrX2N0bC0+bG9jayk7Cj4gKwo+ ICsJcmV0ID0gY2xrX2J1bGtfcHJlcGFyZV9lbmFibGUoYmxrX2N0bC0+bnVtX2Nsa3MsIGJsa19j dGwtPmNsa3MpOwoKSSdtIHN0aWxsIG5vdCBhIGZhbiBvZiBlbmFibGluZyBhbGwgdGhlIGNsb2Nr cyBnb2luZyBpbnRvIHRoZSBibGstY3RsCnRvIHBvd2VyIHVwL2Rvd24gb25lIHNwZWNpZmljIGRv bWFpbi4gSXQncyBub3QgcmVhbGx5IGEgcHJvYmxlbSB3aXRoCmNsb2Nrcywgd2hlcmUgdGhlIHBh cmVudHMgYXJlIGFsd2F5cyBvbiwgYXMgdGhlIGNsb2NrIGdhdGUvdW5nYXRlIGlzCnByZXR0eSBj aGVhcCwgYnV0IGFzIHNvb24gYXMgeW91IGdldCB0byBzb21ldGhpbmcgbGlrZSB0aGUgZGlzcGxh eQpwaXhlbCBjbG9jaywgd2hlcmUgdGhlIHBhcmVudCBQTEwgbWF5IGJlIHNodXQgZG93biwgdGhl IGNsb2NrIGVuYWJsZQptYXkgZWFzaWx5IGJlIHRoZSBtb3N0IGNvc3RseSBvcGVyYXRpb24gb2Yg dGhpcyB3aG9sZSBmdW5jdGlvbiwgZXZlbiBpZgp0aGlzIHNwZWNpZmljIGNsb2NrIGlzbid0IGV2 ZW4gbmVlZGVkIGZvciB0aGUgZG9tYWluIGluIHF1ZXN0aW9uLgoKPiArCWlmIChyZXQpIHsKPiAr CQltdXRleF91bmxvY2soJmJsa19jdGwtPmxvY2spOwo+ICsJCXJldHVybiByZXQ7Cj4gKwl9Cj4g Kwo+ICsJaWYgKGh3LT5mbGFncyAmIElNWF9CTEtfQ1RMX1BEX0hBTkRTSEFLRSkgewo+ICsJCXJl dCA9IGlteF9ibGtfY3RsX2VuYWJsZV9oc2soYmxrX2N0bC0+ZGV2KTsKPiArCQlpZiAocmV0KQo+ ICsJCQlkZXZfZXJyKGJsa19jdGwtPmRldiwgIkhhbmRzaGFrZSBmYWlsZWQgd2hlbiBwb3dlciBv blxuIik7Cj4gKwo+ICsJCS8qIEV4cGVjdGVkLCBoYW5kc2hha2UgYWxyZWFkeSBoYW5kbGUgcmVz ZXQqLwo+ICsJCWdvdG8gZGlzYWJsZV9jbGs7Cj4gKwl9Cj4gKwo+ICsJaWYgKGh3LT5mbGFncyAm IElNWF9CTEtfQ1RMX1BEX1JFU0VUKSB7Cj4gKwkJcmV0ID0gcmVnbWFwX2NsZWFyX2JpdHMocmVn bWFwLCBody0+cnN0X29mZnNldCwgaHctPnJzdF9tYXNrKTsKPiArCQlpZiAocmV0KQo+ICsJCQln b3RvIGRpc2FibGVfY2xrOwo+ICsKPiArCQkvKiBXYWl0IGZvciByZXNldCBwcm9wYWdhdGUgKi8K PiArCQl1ZGVsYXkoNSk7Cj4gKwo+ICsJCXJldCA9IHJlZ21hcF91cGRhdGVfYml0cyhyZWdtYXAs IGh3LT5yc3Rfb2Zmc2V0LCBody0+cnN0X21hc2ssIGh3LT5yc3RfbWFzayk7Cj4gKwkJaWYgKHJl dCkKPiArCQkJZ290byBkaXNhYmxlX2NsazsKPiArCX0KPiArCj4gKwlyZXQgPSByZWdtYXBfdXBk YXRlX2JpdHMocmVnbWFwLCBody0+b2Zmc2V0LCBody0+bWFzaywgaHctPm1hc2spOwo+IAoKSSBm aW5kIHRoaXMgdmVyeSBoYXJkIHRvIGZvbGxvdyBhbmQgcmVhc29uIGFib3V0LiBXaHkgZG8gd2Ug ZXZlbiBuZWVkCnRob3NlIGRpZmZlcmVudCBwYXRocyBmb3IgZG9tYWlucyB3aXRoIG9yIHdpdGhv dXQgdGhlIGhhbmRzaGFrZT8KClNob3VsZG4ndCBpdCBiZSBlbm91Z2ggdG8ganVzdCBiZSBlbm91 Z2ggdG8gZG8gdGhlIGZvbGxvd2luZyBpbiBhbGwKY2FzZXM6CjEuIHJlbGVhc2Ugc2Z0IHJlc2V0 CjIuIGVuYWJsZSBzZnQgY2xvY2sKMy4gd2FpdCBhIGxpdHRsZSBmb3IgcmVzZXQgdG8gcHJvcGFn YXRlIG9yIEFEQiB0byBhY2sgcG93ZXIgdXAKCj4gK2Rpc2FibGVfY2xrOgo+ICsJY2xrX2J1bGtf ZGlzYWJsZV91bnByZXBhcmUoYmxrX2N0bC0+bnVtX2Nsa3MsIGJsa19jdGwtPmNsa3MpOwo+ICsK PiArCW11dGV4X3VubG9jaygmYmxrX2N0bC0+bG9jayk7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiAr fQo+ICsKPiArc3RhdGljIGludCBpbXhfYmxrX2N0bF9wb3dlcl9vZmYoc3RydWN0IGdlbmVyaWNf cG1fZG9tYWluICpkb21haW4pCj4gK3sKPiArCXN0cnVjdCBpbXhfYmxrX2N0bF9kb21haW4gKnBk ID0gdG9faW14X2Jsa19jdGxfcGQoZG9tYWluKTsKPiArCXN0cnVjdCBpbXhfYmxrX2N0bCAqYmxr X2N0bCA9IHBkLT5ibGtfY3RsOwo+ICsJc3RydWN0IHJlZ21hcCAqcmVnbWFwID0gYmxrX2N0bC0+ cmVnbWFwOwo+ICsJY29uc3Qgc3RydWN0IGlteF9ibGtfY3RsX2h3ICpodyA9ICZibGtfY3RsLT5k ZXZfZGF0YS0+cGRzW3BkLT5pZF07Cj4gKwlpbnQgcmV0ID0gMDsKPiArCj4gKwltdXRleF9sb2Nr KCZibGtfY3RsLT5sb2NrKTsKPiArCj4gKwlyZXQgPSBjbGtfYnVsa19wcmVwYXJlX2VuYWJsZShi bGtfY3RsLT5udW1fY2xrcywgYmxrX2N0bC0+Y2xrcyk7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJbXV0 ZXhfdW5sb2NrKCZibGtfY3RsLT5sb2NrKTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsKPiAr CWlmICghKGh3LT5mbGFncyAmIElNWF9CTEtfQ1RMX1BEX0hBTkRTSEFLRSkpIHsKPiArCQlyZXQg PSByZWdtYXBfY2xlYXJfYml0cyhyZWdtYXAsIGh3LT5vZmZzZXQsIGh3LT5tYXNrKTsKPiArCQlp ZiAocmV0KQo+ICsJCQlnb3RvIGRpc2FibGVfY2xrOwo+ICsKPiArCQlpZiAoaHctPmZsYWdzICYg SU1YX0JMS19DVExfUERfUkVTRVQpIHsKPiArCQkJcmV0ID0gcmVnbWFwX2NsZWFyX2JpdHMocmVn bWFwLCBody0+cnN0X29mZnNldCwgaHctPnJzdF9tYXNrKTsKPiArCQkJaWYgKHJldCkKPiArCQkJ CWdvdG8gZGlzYWJsZV9jbGs7Cj4gKwkJfQo+ICsJfSBlbHNlIHsKPiArCQlyZXQgPSBpbXhfYmxr X2N0bF9lbmFibGVfaHNrKGJsa19jdGwtPmRldik7CgpXaHkgd291bGQgd2UgbmVlZCB0byBlbmFi bGUgdGhlIGhhbmRzaGFrZSBhZ2FpbiBpbiB0aGUgcG93ZXIgRE9XTiBwYXRoPwpUaGUgY2xvY2sv cmVzZXQgYml0cyBzaG91bGQgc3RpbGwgYmUgc2V0IGZyb20gdGhlIHBvd2VyIHVwLiBUaGUgcG93 ZXIKZG93biBzaG91bGQgcHJvYmFibHkganVzdCBiZSBhIG5vLW9wIGZvciB0aGUgYmxrLWN0bCBi dXMgZG9tYWlucywgdG8KYWxsb3cgdGhlIHByb3BlciBBREIgaGFuZHNoYWtlIGluIHRoZSBQR0Mg ZG9tYWluIHBvd2VyLWRvd24uCgo+ICsJCWlmIChyZXQpCj4gKwkJCWRldl9lcnIoYmxrX2N0bC0+ ZGV2LCAiSGFuZHNoYWtlIGZhaWxlZCB3aGVuIHBvd2VyIG9mZlxuIik7Cj4gKwl9Cj4gKwo+ICtk aXNhYmxlX2NsazoKPiArCWNsa19idWxrX2Rpc2FibGVfdW5wcmVwYXJlKGJsa19jdGwtPm51bV9j bGtzLCBibGtfY3RsLT5jbGtzKTsKPiArCj4gKwltdXRleF91bmxvY2soJmJsa19jdGwtPmxvY2sp Owo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgaW14X2Jsa19jdGxf cHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiArewo+ICsJc3RydWN0IGlteF9i bGtfY3RsX2RvbWFpbiAqZG9tYWluID0gcGRldi0+ZGV2LnBsYXRmb3JtX2RhdGE7Cj4gKwlzdHJ1 Y3QgaW14X2Jsa19jdGwgKmJsa19jdGwgPSBkb21haW4tPmJsa19jdGw7Cj4gKwlzdHJ1Y3QgZ2Vu ZXJpY19wbV9kb21haW4gKnBhcmVudF9nZW5wZDsKPiArCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZw ZGV2LT5kZXY7Cj4gKwlzdHJ1Y3QgZGV2aWNlICphY3RpdmVfcGQ7Cj4gKwlpbnQgcmV0Owo+ICsK PiArCXBkZXYtPmRldi5vZl9ub2RlID0gYmxrX2N0bC0+ZGV2LT5vZl9ub2RlOwo+ICsKPiArCWlm IChkb21haW4tPmh3LT5hY3RpdmVfcGRfbmFtZSkgewo+ICsJCWFjdGl2ZV9wZCA9IGRldl9wbV9k b21haW5fYXR0YWNoX2J5X25hbWUoZGV2LCBkb21haW4tPmh3LT5hY3RpdmVfcGRfbmFtZSk7Cj4g KwkJaWYgKElTX0VSUl9PUl9OVUxMKGFjdGl2ZV9wZCkpIHsKPiArCQkJcmV0ID0gUFRSX0VSUihh Y3RpdmVfcGQpID8gOiAtRU5PREFUQTsKPiArCQkJcGRldi0+ZGV2Lm9mX25vZGUgPSBOVUxMOwoK VGhpcyBpcyBleHRyZW1lbHkgdWdseS4gSSB0aGluayB3ZSBzaG91bGQgbm90IGV2ZW4gaGF2ZSBz ZXBhcmF0ZQpwbGF0Zm9ybSBkcml2ZXJzIGZvciB0aGUgYmxrLWN0bCBkb21haW5zLCB0aGVyZSBp cyBqdXN0IG5vIHJlYXNvbiBmb3IKaXQuIFNlZSBiZWxvdyBmb3IgbW9yZSBjb21tZW50cyBpbiB0 aGF0IGRpcmVjdGlvbi4KIAo+ICsJCQlyZXR1cm4gcmV0Owo+ICsJCX0KPiArCj4gKwkJZG9tYWlu LT5hY3RpdmVfcGQgPSBhY3RpdmVfcGQ7Cj4gKwl9IGVsc2Ugewo+ICsJCWlmICghYmxrX2N0bC0+ YnVzX2RvbWFpbikgewo+ICsJCQlwZGV2LT5kZXYub2Zfbm9kZSA9IE5VTEw7Cj4gKwkJCXJldHVy biAtRVBST0JFX0RFRkVSOwo+ICsJCX0KPiArCX0KPiArCj4gKwlpZiAoZG9tYWluLT5ody0+YWN0 aXZlX3BkX25hbWUpCj4gKwkJcGFyZW50X2dlbnBkID0gcGRfdG9fZ2VucGQoYWN0aXZlX3BkLT5w bV9kb21haW4pOwo+ICsJZWxzZQo+ICsJCXBhcmVudF9nZW5wZCA9IGJsa19jdGwtPmJ1c19kb21h aW47Cj4gKwo+ICsJaWYgKHBtX2dlbnBkX2FkZF9zdWJkb21haW4ocGFyZW50X2dlbnBkLCAmZG9t YWluLT5nZW5wZCkpIHsKPiArCQlkZXZfd2FybihkZXYsICJmYWlsZWQgdG8gYWRkIHN1YmRvbWFp bjogJXNcbiIsIGRvbWFpbi0+Z2VucGQubmFtZSk7CgpJIGRvbid0IHNlZSB3aGVyZSB0aGUgZGlz cG1peF9idXMgZG9tYWluIGFuZCBjbG9jayBpcyBrZXB0IGVuYWJsZWQuIEkKd291bGQgZ3Vlc3Mg dGhhdCB0aGUgYnVzIGRvbWFpbiBzaG91bGQgYmUgc29tZSBraW5kIG9mIHBhcmVudCB0byB0aGUK bGNkaWYgYW5kIG1pcGkgZG9tYWlucywgYXMgSSBkb24ndCB0aGluayBpdCB3b3VsZCBiZSBva2F5 IHRvIGRpc2FibGUKdGhlIGJ1cyBjbG9jaywgd2hpbGUgYW55IG9mIHRoZSBwZXJpcGhlcmFscyBp biB0aGUgZGlzcG1peCBjb21wbGV4IGFyZQpzdGlsbCBhY3RpdmUuIEFtIEkgbWlzc2luZyBzb21l dGhpbmcgaGVyZT8KCj4gKwl9IGVsc2Ugewo+ICsJCW11dGV4X2xvY2soJmJsa19jdGwtPmxvY2sp Owo+ICsJCWRvbWFpbi0+aG9va2VkID0gdHJ1ZTsKPiArCQltdXRleF91bmxvY2soJmJsa19jdGwt PmxvY2spOwo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGlt eF9ibGtfY3RsX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICt7Cj4gKwlz dHJ1Y3QgaW14X2Jsa19jdGxfZG9tYWluICpkb21haW4gPSBwZGV2LT5kZXYucGxhdGZvcm1fZGF0 YTsKPiArCXN0cnVjdCBpbXhfYmxrX2N0bCAqYmxrX2N0bCA9IGRvbWFpbi0+YmxrX2N0bDsKPiAr CXN0cnVjdCBnZW5lcmljX3BtX2RvbWFpbiAqcGFyZW50X2dlbnBkOwo+ICsJc3RydWN0IGRldmlj ZSAqYWN0aXZlX3BkOwo+ICsKPiArCWlmIChkb21haW4tPmh3LT5hY3RpdmVfcGRfbmFtZSkKPiAr CQlwYXJlbnRfZ2VucGQgPSBwZF90b19nZW5wZChhY3RpdmVfcGQtPnBtX2RvbWFpbik7CgpUaGlz IGhhcyBwcm9iYWJseSBuZXZlciBiZWVuIHRlc3RlZC4gYWN0aXZlX3BkIGlzIHVuZGVmaW5lZCBh dCB0aGlzCnBvaW50LCBzbyB3aWxsIG1vc3QgbGlrZWx5IGxlYWQgdG8gYSBrZXJuZWwgY3Jhc2gu Cj4gKwllbHNlCj4gKwkJcGFyZW50X2dlbnBkID0gYmxrX2N0bC0+YnVzX2RvbWFpbjsKPiArCj4g KwlwbV9nZW5wZF9yZW1vdmVfc3ViZG9tYWluKHBhcmVudF9nZW5wZCwgJmRvbWFpbi0+Z2VucGQp Owo+ICsKPiArCW11dGV4X2xvY2soJmJsa19jdGwtPmxvY2spOwo+ICsJZG9tYWluLT5ob29rZWQg PSBmYWxzZTsKPiArCW11dGV4X3VubG9jaygmYmxrX2N0bC0+bG9jayk7Cj4gKwo+ICsJaWYgKGRv bWFpbi0+aHctPmFjdGl2ZV9wZF9uYW1lKQo+ICsJCWRldl9wbV9kb21haW5fZGV0YWNoKGRvbWFp bi0+YWN0aXZlX3BkLCBmYWxzZSk7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRp YyBjb25zdCBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlX2lkIGlteF9ibGtfY3RsX2lkW10gPSB7Cj4g Kwl7ICJpbXgtdnB1bWl4LWJsay1jdGwiLCB9LAo+ICsJeyAiaW14LWRpc3BtaXgtYmxrLWN0bCIs IH0sCj4gKwl7IH0sCj4gK307Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBp bXhfYmxrX2N0bF9kcml2ZXIgPSB7Cj4gKwkuZHJpdmVyID0gewo+ICsJCS5uYW1lID0gImlteC1i bGstY3RsIiwKPiArCX0sCj4gKwkucHJvYmUgICAgPSBpbXhfYmxrX2N0bF9wcm9iZSwKPiArCS5y ZW1vdmUgICA9IGlteF9ibGtfY3RsX3JlbW92ZSwKPiArCS5pZF90YWJsZSA9IGlteF9ibGtfY3Rs X2lkLAo+ICt9Owo+ICtidWlsdGluX3BsYXRmb3JtX2RyaXZlcihpbXhfYmxrX2N0bF9kcml2ZXIp Cj4gKwo+ICtzdGF0aWMgc3RydWN0IGdlbmVyaWNfcG1fZG9tYWluICppbXhfYmxrX2N0bF9nZW5w ZF94bGF0ZShzdHJ1Y3Qgb2ZfcGhhbmRsZV9hcmdzICpnZW5wZHNwZWMsCj4gKwkJCQkJCQkgdm9p ZCAqZGF0YSkKPiArewo+ICsJc3RydWN0IGdlbnBkX29uZWNlbGxfZGF0YSAqZ2VucGRfZGF0YSA9 IGRhdGE7Cj4gKwl1bnNpZ25lZCBpbnQgaWR4ID0gZ2VucGRzcGVjLT5hcmdzWzBdOwo+ICsJc3Ry dWN0IGlteF9ibGtfY3RsX2RvbWFpbiAqZG9tYWluOwo+ICsJc3RydWN0IGdlbmVyaWNfcG1fZG9t YWluICpnZW5wZCA9IEVSUl9QVFIoLUVQUk9CRV9ERUZFUik7Cj4gKwo+ICsJaWYgKGdlbnBkc3Bl Yy0+YXJnc19jb3VudCAhPSAxKQo+ICsJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOwo+ICsKPiAr CWlmIChpZHggPj0gZ2VucGRfZGF0YS0+bnVtX2RvbWFpbnMpCj4gKwkJcmV0dXJuIEVSUl9QVFIo LUVJTlZBTCk7Cj4gKwo+ICsJaWYgKCFnZW5wZF9kYXRhLT5kb21haW5zW2lkeF0pCj4gKwkJcmV0 dXJuIEVSUl9QVFIoLUVOT0VOVCk7Cj4gKwo+ICsJZG9tYWluID0gdG9faW14X2Jsa19jdGxfcGQo Z2VucGRfZGF0YS0+ZG9tYWluc1tpZHhdKTsKPiArCj4gKwltdXRleF9sb2NrKCZkb21haW4tPmJs a19jdGwtPmxvY2spOwo+ICsJaWYgKGRvbWFpbi0+aG9va2VkKQo+ICsJCWdlbnBkID0gZ2VucGRf ZGF0YS0+ZG9tYWluc1tpZHhdOwo+ICsJbXV0ZXhfdW5sb2NrKCZkb21haW4tPmJsa19jdGwtPmxv Y2spOwo+ICsKPiArCXJldHVybiBnZW5wZDsKPiArfQo+ICsKPiAraW50IGlteF9ibGtfY3RsX3Jl Z2lzdGVyKHN0cnVjdCBkZXZpY2UgKmRldikKPiArewo+ICsJc3RydWN0IGlteF9ibGtfY3RsICpi bGtfY3RsID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gKwljb25zdCBzdHJ1Y3QgaW14X2Jsa19j dGxfZGV2X2RhdGEgKmRldl9kYXRhID0gYmxrX2N0bC0+ZGV2X2RhdGE7Cj4gKwlpbnQgbnVtID0g ZGV2X2RhdGEtPnBkc19udW07Cj4gKwlzdHJ1Y3QgaW14X2Jsa19jdGxfZG9tYWluICpkb21haW47 Cj4gKwlzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW4gKmdlbnBkOwo+ICsJc3RydWN0IHBsYXRmb3Jt X2RldmljZSAqcGRfcGRldjsKPiArCWludCBkb21haW5faW5kZXg7Cj4gKwlpbnQgaSwgcmV0Owo+ ICsKPiArCWJsa19jdGwtPm9uZWNlbGxfZGF0YS5udW1fZG9tYWlucyA9IG51bTsKPiArCWJsa19j dGwtPm9uZWNlbGxfZGF0YS54bGF0ZSA9IGlteF9ibGtfY3RsX2dlbnBkX3hsYXRlOwo+ICsJYmxr X2N0bC0+b25lY2VsbF9kYXRhLmRvbWFpbnMgPSBkZXZtX2tjYWxsb2MoZGV2LCBudW0sIHNpemVv ZihzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW4gKiksCj4gKwkJCQkJCSAgICAgR0ZQX0tFUk5FTCk7 Cj4gKwlpZiAoIWJsa19jdGwtPm9uZWNlbGxfZGF0YS5kb21haW5zKQo+ICsJCXJldHVybiAtRU5P TUVNOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBudW07IGkrKykgewo+ICsJCWRvbWFpbl9pbmRl eCA9IGRldl9kYXRhLT5wZHNbaV0uaWQ7Cj4gKwkJaWYgKGRvbWFpbl9pbmRleCA+PSBudW0pIHsK PiArCQkJZGV2X3dhcm4oZGV2LCAiRG9tYWluIGluZGV4ICVkIGlzIG91dCBvZiBib3VuZHNcbiIs IGRvbWFpbl9pbmRleCk7Cj4gKwkJCWNvbnRpbnVlOwo+ICsJCX0KPiArCj4gKwkJZG9tYWluID0g ZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKHN0cnVjdCBpbXhfYmxrX2N0bF9kb21haW4pLCBHRlBf S0VSTkVMKTsKPiArCQlpZiAoIWRvbWFpbikKPiArCQkJZ290byBlcnJvcjsKPiArCj4gKwkJcGRf cGRldiA9IHBsYXRmb3JtX2RldmljZV9hbGxvYyhkZXZfZGF0YS0+bmFtZSwgZG9tYWluX2luZGV4 KTsKPiArCQlpZiAoIXBkX3BkZXYpIHsKPiArCQkJZGV2X2VycihkZXYsICJGYWlsZWQgdG8gYWxs b2NhdGUgcGxhdGZvcm0gZGV2aWNlXG4iKTsKPiArCQkJZ290byBlcnJvcjsKPiArCQl9CgpXZSBk b24ndCBuZWVkIGEgZnVsbCBibG93IHBsYXRmb3JtIGRldmljZSBhbmQgYSBkcml2ZXIgZm9yIHRo ZQppbmRpdmlkdWFsIGRvbWFpbnMuIFRoZSBvbmx5IHBvaW50IHdoZXJlIHdlIG5lZWQgdGhlIGRl dmljZSBpcyB0bwphdHRhY2ggdGhlIHBhcmVudCBQR0MgcG93ZXIgZG9tYWlucyBhbmQgZm9yIHRo aXMgd2Ugb25seSBuZWVkIGEKZGV2aWNlLsKgCgpTbyB3ZSBjb3VsZCBlaXRoZXIgaGF2ZSBhIGR1 bW15IGRldmljZSBmb3IgdGhpcyB1c2FnZSBpbiB0aGUgZG9tYWluIG9yCndlIGNvdWxkIGV2ZW4g cmV1c2UgdGhlIGRldmljZSBpbiB0aGUgZ2VucGQsIHdoaWNoIGlzIGluaXRpYWxpemVkIGluCnBt X2dlbnBkX2luaXQuCgpOb3cgd2hpbGUgSSB0aGluayBhYm91dCBpdC4uLiBnZW5wZF9kZXZfcG1f YXR0YWNoX2J5X25hbWUgYWxyZWFkeQphbGxvY2F0ZXMgdGhlIHZpcnR1YWwgZHVtbXkgZGV2aWNl LiBJIGRvbid0IHRoaW5rIHdlIG5lZWQgdG8gZG8KYW55dGhpbmcgaGVyZSBvbiBvdXIgb3duLiBK dXN0IGdldCByaWQgb2YgdGhlIHBsYXRmb3JtIGRldmljZSBhbmQKZHJpdmVyLgoKPiArCj4gKwkJ cGRfcGRldi0+ZGV2LnBsYXRmb3JtX2RhdGEgPSBkb21haW47Cj4gKwo+ICsJCWRvbWFpbi0+Ymxr X2N0bCA9IGJsa19jdGw7Cj4gKwkJZG9tYWluLT5odyA9ICZkZXZfZGF0YS0+cGRzW2ldOwo+ICsJ CWRvbWFpbi0+aWQgPSBkb21haW5faW5kZXg7Cj4gKwkJZG9tYWluLT5nZW5wZC5uYW1lID0gZGV2 X2RhdGEtPnBkc1tpXS5uYW1lOwo+ICsJCWRvbWFpbi0+Z2VucGQucG93ZXJfb2ZmID0gaW14X2Js a19jdGxfcG93ZXJfb2ZmOwo+ICsJCWRvbWFpbi0+Z2VucGQucG93ZXJfb24gPSBpbXhfYmxrX2N0 bF9wb3dlcl9vbjsKPiArCQlkb21haW4tPmRldiA9ICZwZF9wZGV2LT5kZXY7Cj4gKwkJZG9tYWlu LT5ob29rZWQgPSBmYWxzZTsKPiArCj4gKwkJcmV0ID0gcG1fZ2VucGRfaW5pdCgmZG9tYWluLT5n ZW5wZCwgTlVMTCwgdHJ1ZSk7Cj4gKwkJcGRfcGRldi0+ZGV2LnBhcmVudCA9IGRldjsKPiArCj4g KwkJaWYgKGRvbWFpbi0+aHctPmZsYWdzICYgSU1YX0JMS19DVExfUERfSEFORFNIQUtFKQo+ICsJ CQlibGtfY3RsLT5idXNfZG9tYWluID0gJmRvbWFpbi0+Z2VucGQ7Cj4gKwo+ICsJCXJldCA9IHBs YXRmb3JtX2RldmljZV9hZGQocGRfcGRldik7Cj4gKwkJaWYgKHJldCkgewo+ICsJCQlwbGF0Zm9y bV9kZXZpY2VfcHV0KHBkX3BkZXYpOwo+ICsJCQlnb3RvIGVycm9yOwo+ICsJCX0KClRoZXJlIGlz IHJlYWxseSBubyBuZWVkIGZvciB0aGUgY29tcGxleGl0eSB3aXRoIHRoZSBob29rZWQgcHJvcGVy dHkKKHRoZSBtdXRleCBhcm91bmQgdGhlIHJlYWQvd3JpdGUgYWNjZXNzIHN0aWxsIGRvZXNuJ3Qg bWFrZSBpdCBwcm9wZXJseQp0aHJlYWQgc2FmZSkgYW5kIHRoZSBibGstY3RsIGRvbWFpbiBwcm9i ZS9yZW1vdmUgY2FsbHMuIEp1c3QgaGFuZGxlCmV2ZXJ5dGhpbmcgd2l0aGluIHRoaXMgbG9vcC4g VGhpcyB3b3VsZCBtYWtlIHRoZSBkcml2ZXIgYSB3aG9sZSBsb3QKbW9yZSBlYXN5IHRvIGZvbGxv dy4KCj4gKwkJYmxrX2N0bC0+b25lY2VsbF9kYXRhLmRvbWFpbnNbaV0gPSAmZG9tYWluLT5nZW5w ZDsKPiArCX0KPiArCj4gKwlyZXR1cm4gb2ZfZ2VucGRfYWRkX3Byb3ZpZGVyX29uZWNlbGwoZGV2 LT5vZl9ub2RlLCAmYmxrX2N0bC0+b25lY2VsbF9kYXRhKTsKPiArCj4gK2Vycm9yOgo+ICsJZm9y ICg7IGkgPj0gMDsgaS0tKSB7Cj4gKwkJZ2VucGQgPSBibGtfY3RsLT5vbmVjZWxsX2RhdGEuZG9t YWluc1tpXTsKPiArCQlpZiAoIWdlbnBkKQo+ICsJCQljb250aW51ZTsKPiArCQlkb21haW4gPSB0 b19pbXhfYmxrX2N0bF9wZChnZW5wZCk7Cj4gKwkJaWYgKGRvbWFpbi0+ZGV2KQo+ICsJCQlwbGF0 Zm9ybV9kZXZpY2VfcHV0KHRvX3BsYXRmb3JtX2RldmljZShkb21haW4tPmRldikpOwo+ICsJfQo+ ICsJcmV0dXJuIHJldDsKPiArfQo+ICtFWFBPUlRfU1lNQk9MX0dQTChpbXhfYmxrX2N0bF9yZWdp c3Rlcik7Cj4gKwo+ICtjb25zdCBzdHJ1Y3QgZGV2X3BtX29wcyBpbXhfYmxrX2N0bF9wbV9vcHMg PSB7Cj4gKwlTRVRfU1lTVEVNX1NMRUVQX1BNX09QUyhwbV9ydW50aW1lX2ZvcmNlX3N1c3BlbmQs IHBtX3J1bnRpbWVfZm9yY2VfcmVzdW1lKQo+ICt9Owo+ICtFWFBPUlRfU1lNQk9MX0dQTChpbXhf YmxrX2N0bF9wbV9vcHMpOwoKVGhpcyBjb2RlIGlzIGxpbmtlZCBpbnRvIHRoZSBzYW1lIG1vZHVs ZSBhcyB0aGUgcGxhdGZvcm0gZHJpdmVyIHVzaW5nCml0LiBTbyB0aGVyZSBpcyBubyBuZWVkIHRv IGV4cG9ydCB0aG9zZSBzeW1ib2xzIGFuZCBleHBvc2UgdGhlbSB0byB0aGUKd2hvbGUga2VybmVs LgoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9zb2MvaW14L2Jsay1jdGwuaCBiL2RyaXZlcnMvc29j L2lteC9ibGstY3RsLmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAw MC4uNjc4MGQwMGVjOGM1Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvc29jL2lteC9i bGstY3RsLmgKPiBAQCAtMCwwICsxLDg1IEBACj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wICovCj4gKyNpZm5kZWYgX19TT0NfSU1YX0JMS19DVExfSAo+ICsjZGVmaW5lIF9f U09DX0lNWF9CTEtfQ1RMX0gKPiArCj4gK2VudW0gaW14X2Jsa19jdGxfcGRfdHlwZSB7Cj4gKwlC TEtfQ1RMX1BELAo+ICt9Owo+ICsKPiArc3RydWN0IGlteF9ibGtfY3RsX2h3IHsKPiArCWludCB0 eXBlOwoKSW5pdGlhbGl6ZWQsIGJ1dCB1bnVzZWQuCgo+ICsJY2hhciAqbmFtZTsKPiArCWNoYXIg KmFjdGl2ZV9wZF9uYW1lOwo+ICsJdTMyIG9mZnNldDsKPiArCXUzMiBtYXNrOwoKb2Zmc2V0IGFu ZCBtYXNrIGFyZSB3YXkgdG9vIGdlbmVyaWMgbmFtZXMuIEkgaGFkIHRvIHNwZW5kIHNvbWUgdGlt ZQpyZWFkaW5nIHRoZSBkcml2ZXIgdG8gZmluZCBvdXQgdGhhdCB0aG9zZSBhcmUgdGhlIGNsb2Nr IGVuYWJsZSBiaXRzLgpUaGlzIHNob3VsZCBiZSBjbGVhciBmcm9tIHRoZSBuYW1pbmcuCgo+ICsJ dTMyIGZsYWdzOyAKPiArCXUzMiBpZDsKPiArCXUzMiByc3Rfb2Zmc2V0Owo+ICsJdTMyIHJzdF9t YXNrOwo+ICsJdTMyIGVycmF0YTsKClVudXNlZC4KCj4gK307Cj4gKwo+ICtzdHJ1Y3QgaW14X2Js a19jdGxfZG9tYWluIHsKPiArCXN0cnVjdCBnZW5lcmljX3BtX2RvbWFpbiBnZW5wZDsKPiArCXN0 cnVjdCBkZXZpY2UgKmFjdGl2ZV9wZDsKPiArCXN0cnVjdCBpbXhfYmxrX2N0bCAqYmxrX2N0bDsK PiArCXN0cnVjdCBpbXhfYmxrX2N0bF9odyAqaHc7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXY7Cj4g Kwlib29sIGhvb2tlZDsKPiArCXUzMiBpZDsKClRoZXJlIGFyZSBhbHJlYWR5IGEgbG90IG9mIHBv aW50ZXJzIGJldHdlZW4gdGhlIGRpZmZlcmVudCBzdHJ1Y3R1cmVzLgpXaHkgZG8gd2UgbmVlZCB0 aG9zZSBpZCBwcm9wZXJ0aWVzPyBZb3Ugc2hvdWxkIGJlIGFibGUgdG8gZ2V0IHRvIGFsbApuZWVk ZWQgaW5mb3JtYXRpb24gYnkgY2hhc2luZyBwb2ludGVycywgaW5zdGVhZCBvZiAgaW5kZXhpbmcg aW50bwphcnJheXMuIFJlYWxseSB0aGUgb25seSBwb2ludCB3aGVyZSBhIGlkLT5kb21haW4gbWFw cGluZyBpcyBkb25lIHNob3VsZApiZSB0aGUgeGxhdGUgZnVuY3Rpb24uCgo+ICt9Owo+ICsKPiAr c3RydWN0IGlteF9ibGtfY3RsX2Rldl9kYXRhIHsKPiArCXN0cnVjdCByZWdtYXBfY29uZmlnIGNv bmZpZzsKPiArCXN0cnVjdCBpbXhfYmxrX2N0bF9odyAqcGRzOwo+ICsJc3RydWN0IGlteF9ibGtf Y3RsX2h3ICpod19oc2s7Cj4gKwl1MzIgcGRzX251bTsKPiArCXUzMiBtYXhfbnVtOwo+ICsJY2hh ciAqbmFtZTsKPiArfTsKPiArCj4gK3N0cnVjdCBpbXhfYmxrX2N0bCB7Cj4gKwlzdHJ1Y3QgZGV2 aWNlICpkZXY7Cj4gKwlzdHJ1Y3QgcmVnbWFwICpyZWdtYXA7Cj4gKwlzdHJ1Y3QgZ2VucGRfb25l Y2VsbF9kYXRhIG9uZWNlbGxfZGF0YTsKPiArCWNvbnN0IHN0cnVjdCBpbXhfYmxrX2N0bF9kZXZf ZGF0YSAqZGV2X2RhdGE7Cj4gKwlzdHJ1Y3QgY2xrX2J1bGtfZGF0YSAqY2xrczsKPiArCXUzMiBu dW1fY2xrczsKPiArCXN0cnVjdCBnZW5lcmljX3BtX2RvbWFpbiAqYnVzX2RvbWFpbjsKClRoZXJl IHNob3VsZCBiZSBub3RoaW5nIHNwZWNpYWwgYWJvdXQgdGhlIGJ1cyBkb21haW4gYXQgYWxsLiBS aWdodCBub3cKdGhpcyBwZXJtZWF0ZXMgdGhyb3VnaCB0aGUgd2hvbGUgZHJpdmVyIHRoYXQgdGhl IGJ1cyBkb21haW4gaXMgc29tZWhvdwpzcGVjaWFsLiBJdCBzaG91bGQganVzdCBiZSBhIHBhcmVu dCBkb21haW4gb2YgdGhlIG90aGVyIGRvbWFpbnMsIG9yCmtlcHQgYWxpdmUgdmlhIHNvbWUgb3Ro ZXIgYXBwcm9wcmlhdGUgbWVhbnMuCgo+ICsKPiArCXN0cnVjdCBtdXRleCBsb2NrOwoKVGhpcyBt dXRleCBpcyBvbmx5IHVzZWQgaW4gdGhlIGNvbW1vbiBibGstY3RsIGNvZGUsIGJ1dCBpcyBpbml0 aWFsaXplZAppbiBpbXg4bW1fYmxrX2N0cmxfcHJvYmUuIFRoaXMgc2VlbXMgdmVyeSBpbmNvbnNp c3RlbnQuIEkgd291bGQgaGF2ZQpleHBlY3RlZCB0aGlzIG11dGV4IHRvIGJlIGluaXRpYWxpemVk IGluIGlteF9ibGtfY3RsX3JlZ2lzdGVyLiBIb3dldmVyLApvbmNlIHlvdSBnZXQgcmlkIG9mIHRo ZSBob29rZWQgYW5kIGJ1cyBkb21haW4gbWFnaWMsIHRoaXMgbXV0ZXggbWF5IGFzCndlbGwgYmUg cGVyLWRvbWFpbiwgYXQgd2hpY2ggcG9pbnQgSSB0aGluayB5b3UgZG9uJ3QgZXZlbiBuZWVkIHRo ZQptdXRleCwgYXMgdGhlIGdlbnBkIGxvY2tpbmcgc2hvdWxkIGJlIGVub3VnaCB0aGVuLgoKPiAr fTsKPiArCj4gKyNkZWZpbmUgSU1YX0JMS19DVEwoX3R5cGUsIF9uYW1lLCBfYWN0aXZlX3BkLCBf aWQsIF9vZmZzZXQsIF9tYXNrLCBfcnN0X29mZnNldCwgX3JzdF9tYXNrLAlcCj4gKwkJICAgIF9m bGFncywgX2VycmF0YSkJCQkJCQkJCVwKPiArCXsJCQkJCQkJCQkJCVwKPiArCQkudHlwZSA9IF90 eXBlLAkJCQkJCQkJCVwKPiArCQkubmFtZSA9IF9uYW1lLAkJCQkJCQkJCVwKPiArCQkuYWN0aXZl X3BkX25hbWUgPSBfYWN0aXZlX3BkLAkJCQkJCQlcCj4gKwkJLmlkID0gX2lkLAkJCQkJCQkJCVwK PiArCQkub2Zmc2V0ID0gX29mZnNldCwJCQkJCQkJCVwKPiArCQkubWFzayA9IF9tYXNrLAkJCQkJ CQkJCVwKPiArCQkuZmxhZ3MgPSBfZmxhZ3MsCQkJCQkJCQlcCj4gKwkJLnJzdF9vZmZzZXQgPSBf cnN0X29mZnNldCwJCQkJCQkJXAo+ICsJCS5yc3RfbWFzayA9IF9yc3RfbWFzaywJCQkJCQkJCVwK PiArCQkuZXJyYXRhID0gX2VycmF0YSwJCQkJCQkJCVwKPiArCX0KPiArCj4gKyNkZWZpbmUgSU1Y X0JMS19DVExfUEQoX25hbWUsIF9hY3RpdmVfcGQsIF9pZCwgX29mZnNldCwgX21hc2ssIF9yc3Rf b2Zmc2V0LCBfcnN0X21hc2ssIF9mbGFncykJXAo+ICsJSU1YX0JMS19DVEwoQkxLX0NUTF9QRCwg X25hbWUsIF9hY3RpdmVfcGQsIF9pZCwgX29mZnNldCwgX21hc2ssIF9yc3Rfb2Zmc2V0LAkJXAo+ ICsJCSAgICBfcnN0X21hc2ssIF9mbGFncywgMCkKPiArCj4gKyNkZWZpbmUgSU1YX0JMS19DVExf UERfRVJSQVRBKF9uYW1lLCBfYWN0aXZlX3BkLCBfaWQsIF9vZmZzZXQsIF9tYXNrLCBfcnN0X29m ZnNldCwgX3JzdF9tYXNrLAlcCj4gKwkJCSAgICAgIF9mbGFncywgX2VycmF0YSkJCQkJCQkJXAo+ ICsJSU1YX0JMS19DVEwoQkxLX0NUTF9QRCwgX25hbWUsIF9hY3RpdmVfcGQsIF9pZCwgX29mZnNl dCwgX21hc2ssIF9yc3Rfb2Zmc2V0LAkJXAo+ICsJCSAgICBfcnN0X21hc2ssIF9mbGFncywgX2Vy cmF0YSkKPiArCj4gK2ludCBpbXhfYmxrX2N0bF9yZWdpc3RlcihzdHJ1Y3QgZGV2aWNlICpkZXYp Owo+ICsKPiArI2RlZmluZSBJTVhfQkxLX0NUTF9QRF9IQU5EU0hBS0UJQklUKDApCj4gKyNkZWZp bmUgSU1YX0JMS19DVExfUERfUkVTRVQJCUJJVCgxKQo+ICsjZGVmaW5lIElNWF9CTEtfQ1RMX1BE X0JVUwkJQklUKDIpCj4gKwo+ICtjb25zdCBleHRlcm4gc3RydWN0IGRldl9wbV9vcHMgaW14X2Js a19jdGxfcG1fb3BzOwo+ICsKPiArI2VuZGlmCgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4 LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK