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 34D5EC433ED for ; Tue, 4 May 2021 09:48:11 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 06B75610FC for ; Tue, 4 May 2021 09:48:10 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230126AbhEDJtD (ORCPT ); Tue, 4 May 2021 05:49:03 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:52226 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229953AbhEDJsk (ORCPT ); Tue, 4 May 2021 05:48:40 -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 A83C0C061574 for ; Tue, 4 May 2021 02:47:45 -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 1ldreS-0003Qr-1i; Tue, 04 May 2021 11:47:36 +0200 Message-ID: <6997abd422ffa1fa384a048552109aec1095abc3.camel@pengutronix.de> Subject: Re: [PATCH V2 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, Peng Fan Date: Tue, 04 May 2021 11:47:32 +0200 In-Reply-To: <20210430052746.10815-4-peng.fan@oss.nxp.com> References: <20210430052746.10815-1-peng.fan@oss.nxp.com> <20210430052746.10815-4-peng.fan@oss.nxp.com> Content-Type: text/plain; charset="UTF-8" User-Agent: Evolution 3.38.4 (3.38.4-1.fc33) 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 Am Freitag, dem 30.04.2021 um 13:27 +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 | 303 ++++++++++++++++++++++++++++++++++++++ >  drivers/soc/imx/blk-ctl.h | 76 ++++++++++ >  3 files changed, 380 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..1f764dfd308d > --- /dev/null > +++ b/drivers/soc/imx/blk-ctl.c > @@ -0,0 +1,303 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Copyright 2021 NXP. > + */ > + > +#include > +#include > +#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, pd); > +} > + > +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); > + > + ret = regmap_update_bits(regmap, hw->offset, hw->mask, hw->mask); > + > + /* Wait for handshake */ > + udelay(5); > + > + return ret; > +} > + > +int imx_blk_ctl_power_off(struct generic_pm_domain *domain) > +{ > + struct imx_blk_ctl_domain *pd; > + struct imx_blk_ctl *blk_ctl; > + const struct imx_blk_ctl_hw *hw; > + struct regmap *regmap; > + int ret; > + > + pd = to_imx_blk_ctl_pd(domain); > + blk_ctl = pd->blk_ctl; > + regmap = blk_ctl->regmap; > + hw = &blk_ctl->dev_data->pds[pd->id]; > + > + ret = clk_bulk_prepare_enable(blk_ctl->num_clks, blk_ctl->clks); > + if (ret) > + return ret; This looks a bit strange to me. Does that mean that you keep all the CCM clocks going into the blkctl enabled as long as one of the blkctl virtual power domains is up? I would have expected each virtual PD to have a list of clock names that need to be enabled, to make this more selective. I haven't completely thought it through if this is a problem, but I could see some CCM PLLs running without a reason if all CCM clocks are kept enabled. This surely is something we want to avoid from a pwoer consumption PoV. > + > + ret = regmap_update_bits(regmap, hw->offset, hw->mask, 0); > + if (ret) > + goto hsk_fail; > + > + if (hw->flags & IMX_BLK_CTL_PD_RESET) > + ret = regmap_update_bits(regmap, hw->rst_offset, hw->rst_mask, 0); > + > + if (atomic_dec_and_test(&blk_ctl->power_count)) { > + ret = imx_blk_ctl_enable_hsk(blk_ctl->dev); > + if (ret) { > + dev_err(blk_ctl->dev, "Hankshake fail\n"); > + goto hsk_fail; > + } > + } > + > +hsk_fail: > + clk_bulk_disable_unprepare(blk_ctl->num_clks, blk_ctl->clks); > + > + return ret; > +} > + > +int imx_blk_ctl_power_on(struct generic_pm_domain *domain) > +{ > + struct imx_blk_ctl_domain *pd; > + struct regmap *regmap; > + const struct imx_blk_ctl_hw *hw; > + int ret; > + struct imx_blk_ctl *blk_ctl; > + > + pd = to_imx_blk_ctl_pd(domain); > + blk_ctl = pd->blk_ctl; > + regmap = blk_ctl->regmap; > + hw = &blk_ctl->dev_data->pds[pd->id]; > + > + ret = clk_bulk_prepare_enable(blk_ctl->num_clks, blk_ctl->clks); > + if (ret) > + return ret; > + > + if ((atomic_read(&blk_ctl->power_count) == 0)) { > + ret = imx_blk_ctl_enable_hsk(blk_ctl->dev); > + if (ret) { > + dev_err(blk_ctl->dev, "Hankshake fail\n"); > + goto disable_clk; > + } > + } This is bogus. The variable isn't used as a atomic, if at all this should use atomic_inc_return, but I think even that isn't correct in that case. imx_blk_ctl_enable_hsk() includes a wait time, so if two paths call this function at the same time, the second caller would be able to overtake the first one, which is still waiting for the handshake to complete, effectively skipping the handshake. This needs a proper lock, as this function isn't called from a performance critical path it makes no sense to try to optimize this with an atomic counter, rather than going with a mutex. > + > + if (hw->flags & IMX_BLK_CTL_PD_RESET) > + ret = regmap_update_bits(regmap, hw->rst_offset, hw->rst_mask, 0); > + > + /* Wait for reset propagate */ > + udelay(5); > + > + if (hw->flags & IMX_BLK_CTL_PD_RESET) > + ret = regmap_update_bits(regmap, hw->rst_offset, hw->rst_mask, hw->rst_mask); > + > + ret = regmap_update_bits(regmap, hw->offset, hw->mask, hw->mask); > + if (ret) > + goto disable_clk; > + > + atomic_inc(&blk_ctl->power_count); > + > +disable_clk: > + clk_bulk_disable_unprepare(blk_ctl->num_clks, blk_ctl->clks); > + > + return ret; > +} > + > +static int imx_blk_ctl_attach_pd(struct device *dev, struct device **devs, char **pd_names, > + u32 num_pds) > +{ > + int i, ret; > + > + if (!pd_names) > + return 0; > + > + if (dev->pm_domain) { > + devs[0] = dev; > + pm_runtime_enable(dev); > + return 0; > + } > + > + for (i = 0; i < num_pds; i++) { > + devs[i] = dev_pm_domain_attach_by_name(dev, pd_names[i]); > + if (IS_ERR_OR_NULL(devs[i])) { > + ret = PTR_ERR(devs[i]) ? : -ENODATA; > + goto detach_pm; > + } > + } > + > + return 0; > + > +detach_pm: > + for (i--; i >= 0; i--) > + dev_pm_domain_detach(devs[i], false); > + > + return ret; > +} > + > +static int imx_blk_ctl_register_pd(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; > + int i, ret; > + > + blk_ctl->onecell_data.num_domains = num; > + 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 = devm_kzalloc(dev, sizeof(*domain), GFP_KERNEL); > + if (!domain) { > + ret = -ENOMEM; > + goto remove_genpd; > + } > + domain->pd.name = dev_data->pds[i].name; > + domain->pd.power_off = imx_blk_ctl_power_off; > + domain->pd.power_on = imx_blk_ctl_power_on; > + domain->blk_ctl = blk_ctl; > + domain->id = i; > + > + ret = pm_genpd_init(&domain->pd, NULL, true); > + if (ret) > + return ret; > + > + blk_ctl->onecell_data.domains[i] = &domain->pd; > + } > + > + return 0; > + > +remove_genpd: > + for (i = i - 1; i >= 0; i--) > + pm_genpd_remove(blk_ctl->onecell_data.domains[i]); > + > + return ret; > +} > + > +static int imx_blk_ctl_hook_pd(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; > + const struct imx_blk_ctl_hw *pds = dev_data->pds; > + int num_active_pd = dev_data->num_active_pd; > + int num = dev_data->pds_num; > + struct generic_pm_domain *genpd, *child_genpd; > + int ret; > + int i, j; > + > + blk_ctl->active_pds = devm_kcalloc(dev, num_active_pd, sizeof(struct device *), GFP_KERNEL); > + if (!blk_ctl->active_pds) > + return -ENOMEM; > + > + ret = imx_blk_ctl_attach_pd(dev, blk_ctl->active_pds, dev_data->active_pd_names, > + num_active_pd); > + if (ret) { > + if (ret == -EPROBE_DEFER) > + return ret; > + dev_err(dev, "Failed to attach active pd: %d\n", ret); > + return ret; > + } > + > + for (i = 0; i < num; i++) { > + for (j = 0; j < num_active_pd; j++) { > + genpd = pd_to_genpd(blk_ctl->active_pds[j]->pm_domain); > + if (!strcmp(genpd->name, pds[i].parent_name)) > + break; > + } > + > + child_genpd = blk_ctl->onecell_data.domains[i]; > + if (pm_genpd_add_subdomain(genpd, child_genpd)) > + pr_warn("failed to add subdomain:\n"); > + } > + > + return 0; > +} > + > +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; > + int i, ret; > + > + if (!blk_ctl) > + return -ENODEV; > + > + ret = imx_blk_ctl_register_pd(dev); > + if (ret) > + return ret; > + > + ret = imx_blk_ctl_hook_pd(dev); > + if (ret) > + goto unregister_pd; > + > + ret = of_genpd_add_provider_onecell(dev->of_node, &blk_ctl->onecell_data); > + if (ret) > + goto detach_pd; > + > + pm_runtime_get_noresume(dev); > + pm_runtime_set_active(dev); > + pm_runtime_enable(dev); > + > + pm_runtime_put(dev); > + > + return 0; > + > +detach_pd: > + for (i = blk_ctl->dev_data->num_active_pd; i >= 0; i--) > + dev_pm_domain_detach(blk_ctl->active_pds[i], false); > +unregister_pd: > + for (i = num - 1; i >= 0; i--) > + pm_genpd_remove(blk_ctl->onecell_data.domains[i]); > + > + return ret; > +} > +EXPORT_SYMBOL_GPL(imx_blk_ctl_register); > + > +static int __maybe_unused imx_blk_ctl_runtime_suspend(struct device *dev) > +{ > + return 0; > +} > + > +static int __maybe_unused imx_blk_ctl_runtime_resume(struct device *dev) > +{ > + return 0; > +} Why those empty stubs? If you don't need to do anything for suspend/resume, just don't add the functions. > + > +const struct dev_pm_ops imx_blk_ctl_pm_ops = { > + SET_RUNTIME_PM_OPS(imx_blk_ctl_runtime_suspend, > + imx_blk_ctl_runtime_resume, NULL) > + SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, > + pm_runtime_force_resume) > +}; > +EXPORT_SYMBOL_GPL(imx_blk_ctl_pm_ops); > diff --git a/drivers/soc/imx/blk-ctl.h b/drivers/soc/imx/blk-ctl.h > new file mode 100644 > index 000000000000..e736369406a1 > --- /dev/null > +++ b/drivers/soc/imx/blk-ctl.h > @@ -0,0 +1,76 @@ > +/* 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; > + char *name; > + char *parent_name; > + u32 offset; > + u32 mask; > + u32 flags; > + u32 id; > + u32 rst_offset; > + u32 rst_mask; > +}; > + > +struct imx_blk_ctl_domain { > + struct generic_pm_domain pd; > + struct imx_blk_ctl *blk_ctl; > + u32 id; > +}; > + > +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; > + char **active_pd_names; > + u32 num_active_pd; > +}; > + > +struct imx_blk_ctl { > + struct device *dev; > + struct regmap *regmap; > + struct device **active_pds; > + u32 pds_num; > + u32 active_pd_count; > + struct genpd_onecell_data onecell_data; > + const struct imx_blk_ctl_dev_data *dev_data; > + struct clk_bulk_data *clks; > + u32 num_clks; > + > + atomic_t power_count; > +}; > + > +#define IMX_BLK_CTL(_type, _name, _parent_name, _id, _offset, _mask, _rst_offset, _rst_mask, \ > + _flags) \ > + { \ > + .type = _type, \ > + .name = _name, \ > + .parent_name = _parent_name, \ > + .id = _id, \ > + .offset = _offset, \ > + .mask = _mask, \ > + .flags = _flags, \ > + .rst_offset = _rst_offset, \ > + .rst_mask = _rst_mask, \ > + } > + > +#define IMX_BLK_CTL_PD(_name, _parent_name, _id, _offset, _mask, _rst_offset, _rst_mask, _flags) \ > + IMX_BLK_CTL(BLK_CTL_PD, _name, _parent_name, _id, _offset, _mask, _rst_offset, \ > + _rst_mask, _flags) > + > +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=-14.4 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 6A639C43461 for ; Tue, 4 May 2021 09:49:56 +0000 (UTC) Received: from desiato.infradead.org (desiato.infradead.org [90.155.92.199]) (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 AC7FF613B3 for ; Tue, 4 May 2021 09:49:55 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org AC7FF613B3 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=desiato.20200630; 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=r5cD7RjUP2WC1Koj2gK9dEz75XmONWkPosu2BsZzi7Q=; b=O8YCUUVWdcBqKtmb6J5xrSaiL yOB/r3d5J0XR65Cg0qRwg8CqYdQH48AS+S1BYJkfHNMrwINX0BGEtUIvd2TLF8IHP5o8kPgrOR8XA DMtSPj+35Rro69yCLJGG9g7Nn/IonSGNHUL1TvhjGKWYB2MFPRmskngW1iE+GQhHZMSy2vqiuLvsW B1EFK0wAhEeHd+HIWj01ysIuZq+aOjx2SDhlkc+27Mee2434kz3GD1GLnypNJ91vsqY4elXUhKjpi zPQTj3S43jni3CcFh9ZlZLSuhK3EUCbnlQeGn0MZPCHAg2SYBiDCyYxxOXYNvYwdNUzOH8mc7Btcr 13aj6mvHQ==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1ldrej-00FuPI-AX; Tue, 04 May 2021 09:47:53 +0000 Received: from bombadil.infradead.org ([2607:7c80:54:e::133]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1ldree-00FuOv-1L for linux-arm-kernel@desiato.infradead.org; Tue, 04 May 2021 09:47:48 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Content-Transfer-Encoding: MIME-Version:Content-Type:References:In-Reply-To:Date:Cc:To:From:Subject: Message-ID:Sender:Reply-To:Content-ID:Content-Description; bh=+0WI07YoGFqKReE7FC1xRPK+TlqYCLuWmR/lhQin370=; b=Wb3lrNOmwV9wen2mwj/7gQoYwk 2T2kOyWidbeNzgErm0oU0LgYUyeVn8kZBddTe96r4Y7FTbg8U98OJI3f/HSktTJ2aUfwhCaYpXllj xSRlQWtOGZ9DHb/RiC6XVy93zyj8JkSd3uegSm/mAcM2NWS36gmixugSd/PGI/M5Tlu4ffGZJ7Ir0 TcCA5Rh/XR+bvBnFTuh8ItOPkz6/9ZJXnuVxmUW1DuHSBh0TyznvNX0S8PJLNzjTWw7FfRsT0v2bY CrsnK1rJFm8kTE+QAbQMYrtlFmzlpJXliVfduvrJmtAXMwwkzBdMsiP6BzzlLzA4wkW94rfH7Cu85 VbhkMP0w==; Received: from metis.ext.pengutronix.de ([2001:67c:670:201:290:27ff:fe1d:cc33]) by bombadil.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1ldrea-003rsD-Dg for linux-arm-kernel@lists.infradead.org; Tue, 04 May 2021 09:47:46 +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 1ldreS-0003Qr-1i; Tue, 04 May 2021 11:47:36 +0200 Message-ID: <6997abd422ffa1fa384a048552109aec1095abc3.camel@pengutronix.de> Subject: Re: [PATCH V2 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, Peng Fan Date: Tue, 04 May 2021 11:47:32 +0200 In-Reply-To: <20210430052746.10815-4-peng.fan@oss.nxp.com> References: <20210430052746.10815-1-peng.fan@oss.nxp.com> <20210430052746.10815-4-peng.fan@oss.nxp.com> User-Agent: Evolution 3.38.4 (3.38.4-1.fc33) 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-20210504_024744_814761_B15B1FE1 X-CRM114-Status: GOOD ( 39.56 ) 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 QW0gRnJlaXRhZywgZGVtIDMwLjA0LjIwMjEgdW0gMTM6MjcgKzA4MDAgc2NocmllYiBQZW5nIEZh biAoT1NTKToKPiBGcm9tOiBQZW5nIEZhbiA8cGVuZy5mYW5AbnhwLmNvbT4KPiAKPiBUaGUgaS5N WDhNTSBpbnRyb2R1Y2VzIGFuIElQIG5hbWVkIEJMS19DVEwgYW5kIHVzdWFsbHkgaXMgY29tcHJp c2VkIG9mCj4gc29tZSBHUFJzLgo+IAo+IFRoZSBHUFJzIGhhcyBzb21lIGNsb2NrIGJpdHMgYW5k IHJlc2V0IGJpdHMsIGJ1dCBoZXJlIHdlIHRha2UgaXQKPiBhcyB2aXJ0dWFsIFBEcywgYmVjYXVz ZSBvZiB0aGUgY2xvY2sgYW5kIHBvd2VyIGRvbWFpbiBBL0IgbG9jayBpc3N1ZQo+IHdoZW4gdGFr aW5nIGl0IGFzIGEgY2xvY2sgY29udHJvbGxlci4KPiAKPiBGb3Igc29tZSBiaXRzLCBpdCBtaWdo dCBiZSBnb29kIHRvIGFsc28gbWFrZSBpdCBhcyBhIHJlc2V0IGNvbnRyb2xsZXIsCj4gYnV0IHRv IGkuTVg4TU0sIHdlIG5vdCBhZGQgdGhhdCBzdXBwb3J0IGZvciBub3cuCj4gCj4gU2lnbmVkLW9m Zi1ieTogUGVuZyBGYW4gPHBlbmcuZmFuQG54cC5jb20+Cj4gLS0tCj4gwqBkcml2ZXJzL3NvYy9p bXgvTWFrZWZpbGUgIHwgICAyICstCj4gwqBkcml2ZXJzL3NvYy9pbXgvYmxrLWN0bC5jIHwgMzAz ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gwqBkcml2ZXJzL3NvYy9p bXgvYmxrLWN0bC5oIHwgIDc2ICsrKysrKysrKysKPiDCoDMgZmlsZXMgY2hhbmdlZCwgMzgwIGlu c2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKPiDCoGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJz L3NvYy9pbXgvYmxrLWN0bC5jCj4gwqBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9zb2MvaW14 L2Jsay1jdGwuaAo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3NvYy9pbXgvTWFrZWZpbGUgYi9k cml2ZXJzL3NvYy9pbXgvTWFrZWZpbGUKPiBpbmRleCAwNzhkYzkxOGY0ZjMuLmQzZDJiNDlhMzg2 YyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3NvYy9pbXgvTWFrZWZpbGUKPiArKysgYi9kcml2ZXJz L3NvYy9pbXgvTWFrZWZpbGUKPiBAQCAtNCw0ICs0LDQgQEAgb2JqLSQoQ09ORklHX0FSQ0hfTVhD KSArPSBzb2MtaW14Lm8KPiDCoGVuZGlmCj4gwqBvYmotJChDT05GSUdfSEFWRV9JTVhfR1BDKSAr PSBncGMubwo+IMKgb2JqLSQoQ09ORklHX0lNWF9HUENWMl9QTV9ET01BSU5TKSArPSBncGN2Mi5v Cj4gLW9iai0kKENPTkZJR19TT0NfSU1YOE0pICs9IHNvYy1pbXg4bS5vCj4gK29iai0kKENPTkZJ R19TT0NfSU1YOE0pICs9IHNvYy1pbXg4bS5vIGJsay1jdGwubwo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL3NvYy9pbXgvYmxrLWN0bC5jIGIvZHJpdmVycy9zb2MvaW14L2Jsay1jdGwuYwo+IG5ldyBm aWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi4xZjc2NGRmZDMwOGQKPiAtLS0g L2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9zb2MvaW14L2Jsay1jdGwuYwo+IEBAIC0wLDAgKzEs MzAzIEBACj4gKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCj4gKy8qCj4gKyAq IENvcHlyaWdodCAyMDIxIE5YUC4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvY2xrLmg+ Cj4gKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2lvLmg+Cj4gKyNp bmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L29mLmg+Cj4gKyNpbmNs dWRlIDxsaW51eC9vZl9hZGRyZXNzLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9vZl9kZXZpY2UuaD4K PiArI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgo+ICsjaW5jbHVkZSA8bGludXgv cG1fcnVudGltZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9zbGFiLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KPiArI2luY2x1ZGUgPGxp bnV4L3R5cGVzLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9wbV9kb21haW4uaD4KPiArI2luY2x1ZGUg PGxpbnV4L3Jlc2V0LWNvbnRyb2xsZXIuaD4KPiArCj4gKyNpbmNsdWRlICJibGstY3RsLmgiCj4g Kwo+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBpbXhfYmxrX2N0bF9kb21haW4gKnRvX2lteF9ibGtf Y3RsX3BkKHN0cnVjdCBnZW5lcmljX3BtX2RvbWFpbiAqZ2VucGQpCj4gK3sKPiArCXJldHVybiBj b250YWluZXJfb2YoZ2VucGQsIHN0cnVjdCBpbXhfYmxrX2N0bF9kb21haW4sIHBkKTsKPiArfQo+ ICsKPiArc3RhdGljIGludCBpbXhfYmxrX2N0bF9lbmFibGVfaHNrKHN0cnVjdCBkZXZpY2UgKmRl dikKPiArewo+ICsJc3RydWN0IGlteF9ibGtfY3RsICpibGtfY3RsID0gZGV2X2dldF9kcnZkYXRh KGRldik7Cj4gKwljb25zdCBzdHJ1Y3QgaW14X2Jsa19jdGxfaHcgKmh3ID0gJmJsa19jdGwtPmRl dl9kYXRhLT5od19oc2s7Cj4gKwlzdHJ1Y3QgcmVnbWFwICpyZWdtYXAgPSBibGtfY3RsLT5yZWdt YXA7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCj4gKwlpZiAoaHctPmZsYWdzICYgSU1YX0JMS19DVExf UERfUkVTRVQpCj4gKwkJcmV0ID0gcmVnbWFwX3VwZGF0ZV9iaXRzKHJlZ21hcCwgaHctPnJzdF9v ZmZzZXQsIGh3LT5yc3RfbWFzaywgaHctPnJzdF9tYXNrKTsKPiArCj4gKwlyZXQgPSByZWdtYXBf dXBkYXRlX2JpdHMocmVnbWFwLCBody0+b2Zmc2V0LCBody0+bWFzaywgaHctPm1hc2spOwo+ICsK PiArCS8qIFdhaXQgZm9yIGhhbmRzaGFrZSAqLwo+ICsJdWRlbGF5KDUpOwo+ICsKPiArCXJldHVy biByZXQ7Cj4gK30KPiArCj4gK2ludCBpbXhfYmxrX2N0bF9wb3dlcl9vZmYoc3RydWN0IGdlbmVy aWNfcG1fZG9tYWluICpkb21haW4pCj4gK3sKPiArCXN0cnVjdCBpbXhfYmxrX2N0bF9kb21haW4g KnBkOwo+ICsJc3RydWN0IGlteF9ibGtfY3RsICpibGtfY3RsOwo+ICsJY29uc3Qgc3RydWN0IGlt eF9ibGtfY3RsX2h3ICpodzsKPiArCXN0cnVjdCByZWdtYXAgKnJlZ21hcDsKPiArCWludCByZXQ7 Cj4gKwo+ICsJcGQgPSB0b19pbXhfYmxrX2N0bF9wZChkb21haW4pOwo+ICsJYmxrX2N0bCA9IHBk LT5ibGtfY3RsOwo+ICsJcmVnbWFwID0gYmxrX2N0bC0+cmVnbWFwOwo+ICsJaHcgPSAmYmxrX2N0 bC0+ZGV2X2RhdGEtPnBkc1twZC0+aWRdOwo+ICsKPiArCXJldCA9IGNsa19idWxrX3ByZXBhcmVf ZW5hYmxlKGJsa19jdGwtPm51bV9jbGtzLCBibGtfY3RsLT5jbGtzKTsKPiArCWlmIChyZXQpCj4g KwkJcmV0dXJuIHJldDsKClRoaXMgbG9va3MgYSBiaXQgc3RyYW5nZSB0byBtZS4gRG9lcyB0aGF0 IG1lYW4gdGhhdCB5b3Uga2VlcCBhbGwgdGhlCkNDTSBjbG9ja3MgZ29pbmcgaW50byB0aGUgYmxr Y3RsIGVuYWJsZWQgYXMgbG9uZyBhcyBvbmUgb2YgdGhlIGJsa2N0bAp2aXJ0dWFsIHBvd2VyIGRv bWFpbnMgaXMgdXA/IEkgd291bGQgaGF2ZSBleHBlY3RlZCBlYWNoIHZpcnR1YWwgUEQgdG8KaGF2 ZSBhIGxpc3Qgb2YgY2xvY2sgbmFtZXMgdGhhdCBuZWVkIHRvIGJlIGVuYWJsZWQsIHRvIG1ha2Ug dGhpcyBtb3JlCnNlbGVjdGl2ZS4KCkkgaGF2ZW4ndCBjb21wbGV0ZWx5IHRob3VnaHQgaXQgdGhy b3VnaCBpZiB0aGlzIGlzIGEgcHJvYmxlbSwgYnV0IEkKY291bGQgc2VlIHNvbWUgQ0NNIFBMTHMg cnVubmluZyB3aXRob3V0IGEgcmVhc29uIGlmIGFsbCBDQ00gY2xvY2tzIGFyZQprZXB0IGVuYWJs ZWQuIFRoaXMgc3VyZWx5IGlzIHNvbWV0aGluZyB3ZSB3YW50IHRvIGF2b2lkIGZyb20gYSBwd29l cgpjb25zdW1wdGlvbiBQb1YuCgo+ICsKPiArCXJldCA9IHJlZ21hcF91cGRhdGVfYml0cyhyZWdt YXAsIGh3LT5vZmZzZXQsIGh3LT5tYXNrLCAwKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBoc2tf ZmFpbDsKPiArCj4gKwlpZiAoaHctPmZsYWdzICYgSU1YX0JMS19DVExfUERfUkVTRVQpCj4gKwkJ cmV0ID0gcmVnbWFwX3VwZGF0ZV9iaXRzKHJlZ21hcCwgaHctPnJzdF9vZmZzZXQsIGh3LT5yc3Rf bWFzaywgMCk7Cj4gKwo+ICsJaWYgKGF0b21pY19kZWNfYW5kX3Rlc3QoJmJsa19jdGwtPnBvd2Vy X2NvdW50KSkgewo+ICsJCXJldCA9IGlteF9ibGtfY3RsX2VuYWJsZV9oc2soYmxrX2N0bC0+ZGV2 KTsKPiArCQlpZiAocmV0KSB7Cj4gKwkJCWRldl9lcnIoYmxrX2N0bC0+ZGV2LCAiSGFua3NoYWtl IGZhaWxcbiIpOwo+ICsJCQlnb3RvIGhza19mYWlsOwo+ICsJCX0KPiArCX0KPiArCj4gK2hza19m YWlsOgo+ICsJY2xrX2J1bGtfZGlzYWJsZV91bnByZXBhcmUoYmxrX2N0bC0+bnVtX2Nsa3MsIGJs a19jdGwtPmNsa3MpOwo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK2ludCBpbXhfYmxr X2N0bF9wb3dlcl9vbihzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW4gKmRvbWFpbikKPiArewo+ICsJ c3RydWN0IGlteF9ibGtfY3RsX2RvbWFpbiAqcGQ7Cj4gKwlzdHJ1Y3QgcmVnbWFwICpyZWdtYXA7 Cj4gKwljb25zdCBzdHJ1Y3QgaW14X2Jsa19jdGxfaHcgKmh3Owo+ICsJaW50IHJldDsKPiArCXN0 cnVjdCBpbXhfYmxrX2N0bCAqYmxrX2N0bDsKPiArCj4gKwlwZCA9IHRvX2lteF9ibGtfY3RsX3Bk KGRvbWFpbik7Cj4gKwlibGtfY3RsID0gcGQtPmJsa19jdGw7Cj4gKwlyZWdtYXAgPSBibGtfY3Rs LT5yZWdtYXA7Cj4gKwlodyA9ICZibGtfY3RsLT5kZXZfZGF0YS0+cGRzW3BkLT5pZF07Cj4gKwo+ ICsJcmV0ID0gY2xrX2J1bGtfcHJlcGFyZV9lbmFibGUoYmxrX2N0bC0+bnVtX2Nsa3MsIGJsa19j dGwtPmNsa3MpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCWlmICgoYXRv bWljX3JlYWQoJmJsa19jdGwtPnBvd2VyX2NvdW50KSA9PSAwKSkgewo+ICsJCXJldCA9IGlteF9i bGtfY3RsX2VuYWJsZV9oc2soYmxrX2N0bC0+ZGV2KTsKPiArCQlpZiAocmV0KSB7Cj4gKwkJCWRl dl9lcnIoYmxrX2N0bC0+ZGV2LCAiSGFua3NoYWtlIGZhaWxcbiIpOwo+ICsJCQlnb3RvIGRpc2Fi bGVfY2xrOwo+ICsJCX0KPiArCX0KClRoaXMgaXMgYm9ndXMuIFRoZSB2YXJpYWJsZSBpc24ndCB1 c2VkIGFzIGEgYXRvbWljLCBpZiBhdCBhbGwgdGhpcwpzaG91bGQgdXNlIGF0b21pY19pbmNfcmV0 dXJuLCBidXQgSSB0aGluayBldmVuIHRoYXQgaXNuJ3QgY29ycmVjdCBpbgp0aGF0IGNhc2UuIGlt eF9ibGtfY3RsX2VuYWJsZV9oc2soKSBpbmNsdWRlcyBhIHdhaXQgdGltZSwgc28gaWYgdHdvCnBh dGhzIGNhbGwgdGhpcyBmdW5jdGlvbiBhdCB0aGUgc2FtZSB0aW1lLCB0aGUgc2Vjb25kIGNhbGxl ciB3b3VsZCBiZQphYmxlIHRvIG92ZXJ0YWtlIHRoZSBmaXJzdCBvbmUsIHdoaWNoIGlzIHN0aWxs IHdhaXRpbmcgZm9yIHRoZQpoYW5kc2hha2UgdG8gY29tcGxldGUsIGVmZmVjdGl2ZWx5IHNraXBw aW5nIHRoZSBoYW5kc2hha2UuIFRoaXMgbmVlZHMgYQpwcm9wZXIgbG9jaywgYXMgdGhpcyBmdW5j dGlvbiBpc24ndCBjYWxsZWQgZnJvbSBhIHBlcmZvcm1hbmNlIGNyaXRpY2FsCnBhdGggaXQgbWFr ZXMgbm8gc2Vuc2UgdG8gdHJ5IHRvIG9wdGltaXplIHRoaXMgd2l0aCBhbiBhdG9taWMgY291bnRl ciwKcmF0aGVyIHRoYW4gZ29pbmcgd2l0aCBhIG11dGV4LgoKPiArCj4gKwlpZiAoaHctPmZsYWdz ICYgSU1YX0JMS19DVExfUERfUkVTRVQpCj4gKwkJcmV0ID0gcmVnbWFwX3VwZGF0ZV9iaXRzKHJl Z21hcCwgaHctPnJzdF9vZmZzZXQsIGh3LT5yc3RfbWFzaywgMCk7Cj4gKwo+ICsJLyogV2FpdCBm b3IgcmVzZXQgcHJvcGFnYXRlICovCj4gKwl1ZGVsYXkoNSk7Cj4gKwo+ICsJaWYgKGh3LT5mbGFn cyAmIElNWF9CTEtfQ1RMX1BEX1JFU0VUKQo+ICsJCXJldCA9IHJlZ21hcF91cGRhdGVfYml0cyhy ZWdtYXAsIGh3LT5yc3Rfb2Zmc2V0LCBody0+cnN0X21hc2ssIGh3LT5yc3RfbWFzayk7Cj4gKwo+ ICsJcmV0ID0gcmVnbWFwX3VwZGF0ZV9iaXRzKHJlZ21hcCwgaHctPm9mZnNldCwgaHctPm1hc2ss IGh3LT5tYXNrKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBkaXNhYmxlX2NsazsKPiArCj4gKwlh dG9taWNfaW5jKCZibGtfY3RsLT5wb3dlcl9jb3VudCk7Cj4gKwo+ICtkaXNhYmxlX2NsazoKPiAr CWNsa19idWxrX2Rpc2FibGVfdW5wcmVwYXJlKGJsa19jdGwtPm51bV9jbGtzLCBibGtfY3RsLT5j bGtzKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGlteF9ibGtf Y3RsX2F0dGFjaF9wZChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2UgKipkZXZzLCBj aGFyICoqcGRfbmFtZXMsCj4gKwkJCQkgdTMyIG51bV9wZHMpCj4gK3sKPiArCWludCBpLCByZXQ7 Cj4gKwo+ICsJaWYgKCFwZF9uYW1lcykKPiArCQlyZXR1cm4gMDsKPiArCj4gKwlpZiAoZGV2LT5w bV9kb21haW4pIHsKPiArCQlkZXZzWzBdID0gZGV2Owo+ICsJCXBtX3J1bnRpbWVfZW5hYmxlKGRl dik7Cj4gKwkJcmV0dXJuIDA7Cj4gKwl9Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IG51bV9wZHM7 IGkrKykgewo+ICsJCWRldnNbaV0gPSBkZXZfcG1fZG9tYWluX2F0dGFjaF9ieV9uYW1lKGRldiwg cGRfbmFtZXNbaV0pOwo+ICsJCWlmIChJU19FUlJfT1JfTlVMTChkZXZzW2ldKSkgewo+ICsJCQly ZXQgPSBQVFJfRVJSKGRldnNbaV0pID8gOiAtRU5PREFUQTsKPiArCQkJZ290byBkZXRhY2hfcG07 Cj4gKwkJfQo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICsKPiArZGV0YWNoX3BtOgo+ICsJZm9y IChpLS07IGkgPj0gMDsgaS0tKQo+ICsJCWRldl9wbV9kb21haW5fZGV0YWNoKGRldnNbaV0sIGZh bHNlKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGlteF9ibGtf Y3RsX3JlZ2lzdGVyX3BkKHN0cnVjdCBkZXZpY2UgKmRldikKPiArewo+ICsJc3RydWN0IGlteF9i bGtfY3RsICpibGtfY3RsID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gKwljb25zdCBzdHJ1Y3Qg aW14X2Jsa19jdGxfZGV2X2RhdGEgKmRldl9kYXRhID0gYmxrX2N0bC0+ZGV2X2RhdGE7Cj4gKwlp bnQgbnVtID0gZGV2X2RhdGEtPnBkc19udW07Cj4gKwlzdHJ1Y3QgaW14X2Jsa19jdGxfZG9tYWlu ICpkb21haW47Cj4gKwlpbnQgaSwgcmV0Owo+ICsKPiArCWJsa19jdGwtPm9uZWNlbGxfZGF0YS5u dW1fZG9tYWlucyA9IG51bTsKPiArCWJsa19jdGwtPm9uZWNlbGxfZGF0YS5kb21haW5zID0gZGV2 bV9rY2FsbG9jKGRldiwgbnVtLAo+ICsJCQkJCQkgICAgIHNpemVvZihzdHJ1Y3QgZ2VuZXJpY19w bV9kb21haW4gKiksCj4gKwkJCQkJCSAgICAgR0ZQX0tFUk5FTCk7Cj4gKwo+ICsJaWYgKCFibGtf Y3RsLT5vbmVjZWxsX2RhdGEuZG9tYWlucykKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKwlm b3IgKGkgPSAwOyBpIDwgbnVtOyBpKyspIHsKPiArCQlkb21haW4gPSBkZXZtX2t6YWxsb2MoZGV2 LCBzaXplb2YoKmRvbWFpbiksIEdGUF9LRVJORUwpOwo+ICsJCWlmICghZG9tYWluKSB7Cj4gKwkJ CXJldCA9IC1FTk9NRU07Cj4gKwkJCWdvdG8gcmVtb3ZlX2dlbnBkOwo+ICsJCX0KPiArCQlkb21h aW4tPnBkLm5hbWUgPSBkZXZfZGF0YS0+cGRzW2ldLm5hbWU7Cj4gKwkJZG9tYWluLT5wZC5wb3dl cl9vZmYgPSBpbXhfYmxrX2N0bF9wb3dlcl9vZmY7Cj4gKwkJZG9tYWluLT5wZC5wb3dlcl9vbiA9 IGlteF9ibGtfY3RsX3Bvd2VyX29uOwo+ICsJCWRvbWFpbi0+YmxrX2N0bCA9IGJsa19jdGw7Cj4g KwkJZG9tYWluLT5pZCA9IGk7Cj4gKwo+ICsJCXJldCA9IHBtX2dlbnBkX2luaXQoJmRvbWFpbi0+ cGQsIE5VTEwsIHRydWUpOwo+ICsJCWlmIChyZXQpCj4gKwkJCXJldHVybiByZXQ7Cj4gKwo+ICsJ CWJsa19jdGwtPm9uZWNlbGxfZGF0YS5kb21haW5zW2ldID0gJmRvbWFpbi0+cGQ7Cj4gKwl9Cj4g Kwo+ICsJcmV0dXJuIDA7Cj4gKwo+ICtyZW1vdmVfZ2VucGQ6Cj4gKwlmb3IgKGkgPSBpIC0gMTsg aSA+PSAwOyBpLS0pCj4gKwkJcG1fZ2VucGRfcmVtb3ZlKGJsa19jdGwtPm9uZWNlbGxfZGF0YS5k b21haW5zW2ldKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGlt eF9ibGtfY3RsX2hvb2tfcGQoc3RydWN0IGRldmljZSAqZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgaW14 X2Jsa19jdGwgKmJsa19jdGwgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCWNvbnN0IHN0cnVj dCBpbXhfYmxrX2N0bF9kZXZfZGF0YSAqZGV2X2RhdGEgPSBibGtfY3RsLT5kZXZfZGF0YTsKPiAr CWNvbnN0IHN0cnVjdCBpbXhfYmxrX2N0bF9odyAqcGRzID0gZGV2X2RhdGEtPnBkczsKPiArCWlu dCBudW1fYWN0aXZlX3BkID0gZGV2X2RhdGEtPm51bV9hY3RpdmVfcGQ7Cj4gKwlpbnQgbnVtID0g ZGV2X2RhdGEtPnBkc19udW07Cj4gKwlzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW4gKmdlbnBkLCAq Y2hpbGRfZ2VucGQ7Cj4gKwlpbnQgcmV0Owo+ICsJaW50IGksIGo7Cj4gKwo+ICsJYmxrX2N0bC0+ YWN0aXZlX3BkcyA9IGRldm1fa2NhbGxvYyhkZXYsIG51bV9hY3RpdmVfcGQsIHNpemVvZihzdHJ1 Y3QgZGV2aWNlICopLCBHRlBfS0VSTkVMKTsKPiArCWlmICghYmxrX2N0bC0+YWN0aXZlX3BkcykK PiArCQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKwlyZXQgPSBpbXhfYmxrX2N0bF9hdHRhY2hfcGQo ZGV2LCBibGtfY3RsLT5hY3RpdmVfcGRzLCBkZXZfZGF0YS0+YWN0aXZlX3BkX25hbWVzLAo+ICsJ CQkJICAgIG51bV9hY3RpdmVfcGQpOwo+ICsJaWYgKHJldCkgewo+ICsJCWlmIChyZXQgPT0gLUVQ Uk9CRV9ERUZFUikKPiArCQkJcmV0dXJuIHJldDsKPiArCQlkZXZfZXJyKGRldiwgIkZhaWxlZCB0 byBhdHRhY2ggYWN0aXZlIHBkOiAlZFxuIiwgcmV0KTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ ICsKPiArCWZvciAoaSA9IDA7IGkgPCBudW07IGkrKykgewo+ICsJCWZvciAoaiA9IDA7IGogPCBu dW1fYWN0aXZlX3BkOyBqKyspIHsKPiArCQkJZ2VucGQgPSBwZF90b19nZW5wZChibGtfY3RsLT5h Y3RpdmVfcGRzW2pdLT5wbV9kb21haW4pOwo+ICsJCQlpZiAoIXN0cmNtcChnZW5wZC0+bmFtZSwg cGRzW2ldLnBhcmVudF9uYW1lKSkKPiArCQkJCWJyZWFrOwo+ICsJCX0KPiArCj4gKwkJY2hpbGRf Z2VucGQgPSBibGtfY3RsLT5vbmVjZWxsX2RhdGEuZG9tYWluc1tpXTsKPiArCQlpZiAocG1fZ2Vu cGRfYWRkX3N1YmRvbWFpbihnZW5wZCwgY2hpbGRfZ2VucGQpKQo+ICsJCQlwcl93YXJuKCJmYWls ZWQgdG8gYWRkIHN1YmRvbWFpbjpcbiIpOwo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4g Kwo+ICtpbnQgaW14X2Jsa19jdGxfcmVnaXN0ZXIoc3RydWN0IGRldmljZSAqZGV2KQo+ICt7Cj4g KwlzdHJ1Y3QgaW14X2Jsa19jdGwgKmJsa19jdGwgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiAr CWNvbnN0IHN0cnVjdCBpbXhfYmxrX2N0bF9kZXZfZGF0YSAqZGV2X2RhdGEgPSBibGtfY3RsLT5k ZXZfZGF0YTsKPiArCWludCBudW0gPSBkZXZfZGF0YS0+cGRzX251bTsKPiArCWludCBpLCByZXQ7 Cj4gKwo+ICsJaWYgKCFibGtfY3RsKQo+ICsJCXJldHVybiAtRU5PREVWOwo+ICsKPiArCXJldCA9 IGlteF9ibGtfY3RsX3JlZ2lzdGVyX3BkKGRldik7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiBy ZXQ7Cj4gKwo+ICsJcmV0ID0gaW14X2Jsa19jdGxfaG9va19wZChkZXYpOwo+ICsJaWYgKHJldCkK PiArCQlnb3RvIHVucmVnaXN0ZXJfcGQ7Cj4gKwo+ICsJcmV0ID0gb2ZfZ2VucGRfYWRkX3Byb3Zp ZGVyX29uZWNlbGwoZGV2LT5vZl9ub2RlLCAmYmxrX2N0bC0+b25lY2VsbF9kYXRhKTsKPiArCWlm IChyZXQpCj4gKwkJZ290byBkZXRhY2hfcGQ7Cj4gKwo+ICsJcG1fcnVudGltZV9nZXRfbm9yZXN1 bWUoZGV2KTsKPiArCXBtX3J1bnRpbWVfc2V0X2FjdGl2ZShkZXYpOwo+ICsJcG1fcnVudGltZV9l bmFibGUoZGV2KTsKPiArCj4gKwlwbV9ydW50aW1lX3B1dChkZXYpOwo+ICsKPiArCXJldHVybiAw Owo+ICsKPiArZGV0YWNoX3BkOgo+ICsJZm9yIChpID0gYmxrX2N0bC0+ZGV2X2RhdGEtPm51bV9h Y3RpdmVfcGQ7IGkgPj0gMDsgaS0tKQo+ICsJCWRldl9wbV9kb21haW5fZGV0YWNoKGJsa19jdGwt PmFjdGl2ZV9wZHNbaV0sIGZhbHNlKTsKPiArdW5yZWdpc3Rlcl9wZDoKPiArCWZvciAoaSA9IG51 bSAtIDE7IGkgPj0gMDsgaS0tKQo+ICsJCXBtX2dlbnBkX3JlbW92ZShibGtfY3RsLT5vbmVjZWxs X2RhdGEuZG9tYWluc1tpXSk7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICtFWFBPUlRfU1lN Qk9MX0dQTChpbXhfYmxrX2N0bF9yZWdpc3Rlcik7Cj4gKwo+ICtzdGF0aWMgaW50IF9fbWF5YmVf dW51c2VkIGlteF9ibGtfY3RsX3J1bnRpbWVfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCj4g K3sKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IF9fbWF5YmVfdW51c2VkIGlt eF9ibGtfY3RsX3J1bnRpbWVfcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRldikKPiArewo+ICsJcmV0 dXJuIDA7Cj4gK30KCldoeSB0aG9zZSBlbXB0eSBzdHVicz8gSWYgeW91IGRvbid0IG5lZWQgdG8g ZG8gYW55dGhpbmcgZm9yCnN1c3BlbmQvcmVzdW1lLCBqdXN0IGRvbid0IGFkZCB0aGUgZnVuY3Rp b25zLgoKPiArCj4gK2NvbnN0IHN0cnVjdCBkZXZfcG1fb3BzIGlteF9ibGtfY3RsX3BtX29wcyA9 IHsKPiArCVNFVF9SVU5USU1FX1BNX09QUyhpbXhfYmxrX2N0bF9ydW50aW1lX3N1c3BlbmQsCj4g KwkJCSAgIGlteF9ibGtfY3RsX3J1bnRpbWVfcmVzdW1lLCBOVUxMKQo+ICsJU0VUX1NZU1RFTV9T TEVFUF9QTV9PUFMocG1fcnVudGltZV9mb3JjZV9zdXNwZW5kLAo+ICsJCQkgICBwbV9ydW50aW1l X2ZvcmNlX3Jlc3VtZSkKPiArfTsKPiArRVhQT1JUX1NZTUJPTF9HUEwoaW14X2Jsa19jdGxfcG1f b3BzKTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9zb2MvaW14L2Jsay1jdGwuaCBiL2RyaXZlcnMv c29jL2lteC9ibGstY3RsLmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAw MDAwMC4uZTczNjM2OTQwNmExCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvc29jL2lt eC9ibGstY3RsLmgKPiBAQCAtMCwwICsxLDc2IEBACj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlm aWVyOiBHUEwtMi4wICovCj4gKyNpZm5kZWYgX19TT0NfSU1YX0JMS19DVExfSAo+ICsjZGVmaW5l IF9fU09DX0lNWF9CTEtfQ1RMX0gKPiArCj4gK2VudW0gaW14X2Jsa19jdGxfcGRfdHlwZSB7Cj4g KwlCTEtfQ1RMX1BELAo+ICt9Owo+ICsKPiArc3RydWN0IGlteF9ibGtfY3RsX2h3IHsKPiArCWlu dCB0eXBlOwo+ICsJY2hhciAqbmFtZTsKPiArCWNoYXIgKnBhcmVudF9uYW1lOwo+ICsJdTMyIG9m ZnNldDsKPiArCXUzMiBtYXNrOwo+ICsJdTMyIGZsYWdzOwo+ICsJdTMyIGlkOwo+ICsJdTMyIHJz dF9vZmZzZXQ7Cj4gKwl1MzIgcnN0X21hc2s7Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgaW14X2Jsa19j dGxfZG9tYWluIHsKPiArCXN0cnVjdCBnZW5lcmljX3BtX2RvbWFpbiBwZDsKPiArCXN0cnVjdCBp bXhfYmxrX2N0bCAqYmxrX2N0bDsKPiArCXUzMiBpZDsKPiArfTsKPiArCj4gK3N0cnVjdCBpbXhf YmxrX2N0bF9kZXZfZGF0YSB7Cj4gKwlzdHJ1Y3QgcmVnbWFwX2NvbmZpZyBjb25maWc7Cj4gKwlz dHJ1Y3QgaW14X2Jsa19jdGxfaHcgKnBkczsKPiArCXN0cnVjdCBpbXhfYmxrX2N0bF9odyBod19o c2s7Cj4gKwl1MzIgcGRzX251bTsKPiArCWNoYXIgKiphY3RpdmVfcGRfbmFtZXM7Cj4gKwl1MzIg bnVtX2FjdGl2ZV9wZDsKPiArfTsKPiArCj4gK3N0cnVjdCBpbXhfYmxrX2N0bCB7Cj4gKwlzdHJ1 Y3QgZGV2aWNlICpkZXY7Cj4gKwlzdHJ1Y3QgcmVnbWFwICpyZWdtYXA7Cj4gKwlzdHJ1Y3QgZGV2 aWNlICoqYWN0aXZlX3BkczsKPiArCXUzMiBwZHNfbnVtOwo+ICsJdTMyIGFjdGl2ZV9wZF9jb3Vu dDsKPiArCXN0cnVjdCBnZW5wZF9vbmVjZWxsX2RhdGEgb25lY2VsbF9kYXRhOwo+ICsJY29uc3Qg c3RydWN0IGlteF9ibGtfY3RsX2Rldl9kYXRhICpkZXZfZGF0YTsKPiArCXN0cnVjdCBjbGtfYnVs a19kYXRhICpjbGtzOwo+ICsJdTMyIG51bV9jbGtzOwo+ICsKPiArCWF0b21pY190IHBvd2VyX2Nv dW50Owo+ICt9Owo+ICsKPiArI2RlZmluZSBJTVhfQkxLX0NUTChfdHlwZSwgX25hbWUsIF9wYXJl bnRfbmFtZSwgX2lkLCBfb2Zmc2V0LCBfbWFzaywgX3JzdF9vZmZzZXQsIF9yc3RfbWFzaywJXAo+ ICsJCSAgICBfZmxhZ3MpCQkJCQkJCQlcCj4gKwl7CQkJCQkJCQkJCVwKPiArCQkudHlwZSA9IF90 eXBlLAkJCQkJCQkJXAo+ICsJCS5uYW1lID0gX25hbWUsCQkJCQkJCQlcCj4gKwkJLnBhcmVudF9u YW1lID0gX3BhcmVudF9uYW1lLAkJCQkJCVwKPiArCQkuaWQgPSBfaWQsCQkJCQkJCQlcCj4gKwkJ Lm9mZnNldCA9IF9vZmZzZXQsCQkJCQkJCVwKPiArCQkubWFzayA9IF9tYXNrLAkJCQkJCQkJXAo+ ICsJCS5mbGFncyA9IF9mbGFncywJCQkJCQkJXAo+ICsJCS5yc3Rfb2Zmc2V0ID0gX3JzdF9vZmZz ZXQsCQkJCQkJXAo+ICsJCS5yc3RfbWFzayA9IF9yc3RfbWFzaywJCQkJCQkJXAo+ICsJfQo+ICsK PiArI2RlZmluZSBJTVhfQkxLX0NUTF9QRChfbmFtZSwgX3BhcmVudF9uYW1lLCBfaWQsIF9vZmZz ZXQsIF9tYXNrLCBfcnN0X29mZnNldCwgX3JzdF9tYXNrLCBfZmxhZ3MpIFwKPiArCUlNWF9CTEtf Q1RMKEJMS19DVExfUEQsIF9uYW1lLCBfcGFyZW50X25hbWUsIF9pZCwgX29mZnNldCwgX21hc2ss IF9yc3Rfb2Zmc2V0LAkJXAo+ICsJCSAgICBfcnN0X21hc2ssIF9mbGFncykKPiArCj4gK2ludCBp bXhfYmxrX2N0bF9yZWdpc3RlcihzdHJ1Y3QgZGV2aWNlICpkZXYpOwo+ICsKPiArI2RlZmluZSBJ TVhfQkxLX0NUTF9QRF9IQU5EU0hBS0UJQklUKDApCj4gKyNkZWZpbmUgSU1YX0JMS19DVExfUERf UkVTRVQJCUJJVCgxKQo+ICsjZGVmaW5lIElNWF9CTEtfQ1RMX1BEX0JVUwkJQklUKDIpCj4gKwo+ ICtjb25zdCBleHRlcm4gc3RydWN0IGRldl9wbV9vcHMgaW14X2Jsa19jdGxfcG1fb3BzOwo+ICsK PiArI2VuZGlmCgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMu aW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZv L2xpbnV4LWFybS1rZXJuZWwK