From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id E7FBEEE6422 for ; Fri, 15 Sep 2023 06:53:47 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232453AbjIOGxv (ORCPT ); Fri, 15 Sep 2023 02:53:51 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32830 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232435AbjIOGxu (ORCPT ); Fri, 15 Sep 2023 02:53:50 -0400 X-Greylist: delayed 387 seconds by postgrey-1.37 at lindbergh.monkeyblade.net; Thu, 14 Sep 2023 23:53:25 PDT Received: from mail.tkos.co.il (wiki.tkos.co.il [84.110.109.230]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B195D272B; Thu, 14 Sep 2023 23:53:25 -0700 (PDT) Received: from tarshish (unknown [10.0.8.2]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.tkos.co.il (Postfix) with ESMTPS id 64B094402B3; Fri, 15 Sep 2023 09:46:52 +0300 (IDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=tkos.co.il; s=default; t=1694760412; bh=fyZ+SkBRodjYD2mW6Xocvnd5U6+dMtwLSQid+Sw+7bw=; h=References:From:To:Cc:Subject:Date:In-reply-to:From; b=ZarfHsVIuebrXzUZwmPgNGOrYS2VXEyIxce7dm/sT7uE9l282WjenuTzf2cJZbCMl 1KVVVWtyydOw1O0KfOD8i8k1SzE+6CckTYcTEpERu/2vdVeQe48fBhEwLPE5zOaFMy 7B9qNH78ZYYBlO+7hMuVWetJiZAs80XIiksisHYrvZhR4Fgi3gSl6NLcjm5q5dk6ix nWVJbv7e9ad+vHYFaZD+TR9ST9BLK7hMEHQzgRE4MevrANxtlO3WsVqNDQ3Ds7wP7W XB3jyYcR3wOZmL5n3pKWCeARWkwndFwUs1CiOMjo7RHQ1xs4h31BKSZmsAjoZpDhlk JvNM9fYGrJfng== References: <17dd231f496d09ed8502bdd505eaa77bb6637e4b.1644226245.git.baruch@tkos.co.il> <8a331c88-c7d4-3a14-0ec3-fd616ea24a99@quicinc.com> User-agent: mu4e 1.9.21; emacs 29.1 From: Baruch Siach To: Devi Priya Cc: Thierry Reding , Uwe =?utf-8?Q?Kleine-K?= =?utf-8?Q?=C3=B6nig?= , Andy Gross , Bjorn Andersson , Rob Herring , Robert Marko , Kathiravan T , linux-pwm@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-msm@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: Re: [PATCH 1/3] pwm: driver for qualcomm ipq6018 pwm block Date: Fri, 15 Sep 2023 09:36:10 +0300 In-reply-to: <8a331c88-c7d4-3a14-0ec3-fd616ea24a99@quicinc.com> Message-ID: <87wmwsylup.fsf@tarshish> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-arm-msm@vger.kernel.org Hi Devi, [ Dropped/updated codeaurora.org addresses ] On Fri, Sep 15 2023, Devi Priya wrote: > On 2/7/2022 3:00 PM, Baruch Siach wrote: >> From: Baruch Siach >> Driver for the PWM block in Qualcomm IPQ6018 line of SoCs. Based on >> driver from downstream Codeaurora kernel tree. Removed support for older >> (V1) variants because I have no access to that hardware. >> Tested on IPQ6010 based hardware. >> Signed-off-by: Baruch Siach >> --- >> v11: > > Just curious to know if you have plans to post the next revision! I have been waiting for comments from pwm maintainers before sending the next revision. Unfortunately since then I lost access to the hardware, so I can't test suggested implementation changes. The only pending issue in v11 is the trivial change that Nathan Chancellor suggested, which should be safe. If you like to take it from here you are welcome. Thanks, baruch >> Address comment from Uwe Kleine-K=C3=B6nig: >> Drop redundant registers field comments >> Fix period limit check in .apply >> Clarify the comment explaining skip of pre_div > pwm_div values >> Add explicit check for clock rate within limit >> Add comment explaining the selection of initial pre_div >> Use pwm_div division with remainder instead of separate diff calculat= ion >> Round up duty_cycle calculation in .get_state >> v10: >> Restore round up in pwm_div calculation; otherwise diff is always <=3D >> 0, so only bingo match works >> Don't overwrite min_diff on every loop iteration >> v9: >> Address comment from Uwe Kleine-K=C3=B6nig: >> Use period_ns*rate in dividers calculation for better accuracy >> Round down pre_div and pwm_div >> Add a comment explaining why pwm_div can't underflow >> Add a comment explaining why pre_div > pwm_div end the search loop >> Drop 'CFG_' from register macros >> Rename to_ipq_pwm_chip() to ipq_pwm_from_chip() >> Change bare 'unsigned' to 'unsigned int' >> Clarify the comment on separate REG1 write for enable/disable >> Round up the period value in .get_state >> Use direct readl/writel so no need to check for regmap errors >> v7: >> Change 'offset' to 'reg' for the tcsr offset (Rob) >> Drop clock name; there is only one clock (Bjorn) >> Simplify probe failure code path (Bjorn) >> v6: >> Address Uwe Kleine-K=C3=B6nig review comments: >> Drop IPQ_PWM_MAX_DEVICES >> Rely on assigned-clock-rates; drop IPQ_PWM_CLK_SRC_FREQ >> Simplify register offset calculation >> Calculate duty cycle more precisely >> Refuse to set inverted polarity >> Drop redundant IPQ_PWM_REG1_ENABLE bit clear >> Remove x1000 factor in pwm_div calculation, use rate directly, and ro= und >> up >> Choose initial pre_div such that pwm_div < IPQ_PWM_MAX_DIV >> Ensure pre_div <=3D pwm_div >> Rename close_ to best_ >> Explain in comment why effective_div doesn't overflow >> Limit pwm_div to IPQ_PWM_MAX_DIV - 1 to allow 100% duty cycle >> Disable clock only after pwmchip_remove() >> const pwm_ops >> Other changes: >> Add missing linux/bitfield.h header include (kernel test robot) >> Adjust code for PWM device node under TCSR (Rob Herring) >> v5: >> Use &tcsr_q6 syscon to access registers (Bjorn Andersson) >> Address Uwe Kleine-K=C3=B6nig review comments: >> Implement .get_state() >> Add IPQ_PWM_ prefix to local macros >> Use GENMASK/BIT/FIELD_PREP for register fields access >> Make type of config_div_and_duty() parameters consistent >> Derive IPQ_PWM_MIN_PERIOD_NS from IPQ_PWM_CLK_SRC_FREQ >> Integrate enable/disable into config_div_and_duty() to save register >> read, >> and reduce frequency glitch on update >> Use min() instead of min_t() >> Fix comment format >> Use dev_err_probe() to indicate probe step failure >> Add missing clk_disable_unprepare() in .remove >> Don't set .owner >> v4: >> Use div64_u64() to fix link for 32-bit targets ((kernel test robot >> , Uwe Kleine-K=C3=B6nig) >> v3: >> s/qcom,pwm-ipq6018/qcom,ipq6018-pwm/ (Rob Herring) >> Fix integer overflow on 32-bit targets (kernel test robot >> ) >> v2: >> Address Uwe Kleine-K=C3=B6nig review comments: >> Fix period calculation when out of range >> Don't set period larger than requested >> Remove PWM disable on configuration change >> Implement .apply instead of non-atomic .config/.enable/.disable >> Don't modify PWM on .request/.free >> Check pwm_div underflow >> Fix various code and comment formatting issues >> Other changes: >> Use u64 divisor safe division >> Remove now empty .request/.free >> --- >> drivers/pwm/Kconfig | 12 ++ >> drivers/pwm/Makefile | 1 + >> drivers/pwm/pwm-ipq.c | 281 ++++++++++++++++++++++++++++++++++++++++++ >> 3 files changed, 294 insertions(+) >> create mode 100644 drivers/pwm/pwm-ipq.c >> diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig >> index 21e3b05a5153..e39718137ecd 100644 >> --- a/drivers/pwm/Kconfig >> +++ b/drivers/pwm/Kconfig >> @@ -260,6 +260,18 @@ config PWM_INTEL_LGM >> To compile this driver as a module, choose M here: the module >> will be called pwm-intel-lgm. >> +config PWM_IPQ >> + tristate "IPQ PWM support" >> + depends on ARCH_QCOM || COMPILE_TEST >> + depends on HAVE_CLK && HAS_IOMEM >> + help >> + Generic PWM framework driver for IPQ PWM block which supports >> + 4 pwm channels. Each of the these channels can be configured >> + independent of each other. >> + >> + To compile this driver as a module, choose M here: the module >> + will be called pwm-ipq. >> + >> config PWM_IQS620A >> tristate "Azoteq IQS620A PWM support" >> depends on MFD_IQS62X || COMPILE_TEST >> diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile >> index 708840b7fba8..7402feae4b36 100644 >> --- a/drivers/pwm/Makefile >> +++ b/drivers/pwm/Makefile >> @@ -22,6 +22,7 @@ obj-$(CONFIG_PWM_IMX1) +=3D pwm-imx1.o >> obj-$(CONFIG_PWM_IMX27) +=3D pwm-imx27.o >> obj-$(CONFIG_PWM_IMX_TPM) +=3D pwm-imx-tpm.o >> obj-$(CONFIG_PWM_INTEL_LGM) +=3D pwm-intel-lgm.o >> +obj-$(CONFIG_PWM_IPQ) +=3D pwm-ipq.o >> obj-$(CONFIG_PWM_IQS620A) +=3D pwm-iqs620a.o >> obj-$(CONFIG_PWM_JZ4740) +=3D pwm-jz4740.o >> obj-$(CONFIG_PWM_KEEMBAY) +=3D pwm-keembay.o >> diff --git a/drivers/pwm/pwm-ipq.c b/drivers/pwm/pwm-ipq.c >> new file mode 100644 >> index 000000000000..994027290bcb >> --- /dev/null >> +++ b/drivers/pwm/pwm-ipq.c >> @@ -0,0 +1,281 @@ >> +// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 >> +/* >> + * Copyright (c) 2016-2017, 2020 The Linux Foundation. All rights reser= ved. >> + */ >> + >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> + >> +/* The frequency range supported is 1 Hz to clock rate */ >> +#define IPQ_PWM_MAX_PERIOD_NS ((u64)NSEC_PER_SEC) >> + >> +/* >> + * The max value specified for each field is based on the number of bits >> + * in the pwm control register for that field >> + */ >> +#define IPQ_PWM_MAX_DIV 0xFFFF >> + >> +/* >> + * Two 32-bit registers for each PWM: REG0, and REG1. >> + * Base offset for PWM #i is at 8 * #i. >> + */ >> +#define IPQ_PWM_REG0 0 >> +#define IPQ_PWM_REG0_PWM_DIV GENMASK(15, 0) >> +#define IPQ_PWM_REG0_HI_DURATION GENMASK(31, 16) >> + >> +#define IPQ_PWM_REG1 4 >> +#define IPQ_PWM_REG1_PRE_DIV GENMASK(15, 0) >> +/* >> + * Enable bit is set to enable output toggling in pwm device. >> + * Update bit is set to reflect the changed divider and high duration >> + * values in register. >> + */ >> +#define IPQ_PWM_REG1_UPDATE BIT(30) >> +#define IPQ_PWM_REG1_ENABLE BIT(31) >> + >> + >> +struct ipq_pwm_chip { >> + struct pwm_chip chip; >> + struct clk *clk; >> + void __iomem *mem; >> +}; >> + >> +static struct ipq_pwm_chip *ipq_pwm_from_chip(struct pwm_chip *chip) >> +{ >> + return container_of(chip, struct ipq_pwm_chip, chip); >> +} >> + >> +static unsigned int ipq_pwm_reg_read(struct pwm_device *pwm, unsigned i= nt reg) >> +{ >> + struct ipq_pwm_chip *ipq_chip =3D ipq_pwm_from_chip(pwm->chip); >> + unsigned int off =3D 8 * pwm->hwpwm + reg; >> + >> + return readl(ipq_chip->mem + off); >> +} >> + >> +static void ipq_pwm_reg_write(struct pwm_device *pwm, unsigned int reg, >> + unsigned int val) >> +{ >> + struct ipq_pwm_chip *ipq_chip =3D ipq_pwm_from_chip(pwm->chip); >> + unsigned int off =3D 8 * pwm->hwpwm + reg; >> + >> + writel(val, ipq_chip->mem + off); >> +} >> + >> +static void config_div_and_duty(struct pwm_device *pwm, unsigned int pr= e_div, >> + unsigned int pwm_div, unsigned long rate, u64 duty_ns, >> + bool enable) >> +{ >> + unsigned long hi_dur; >> + unsigned long val =3D 0; >> + >> + /* >> + * high duration =3D pwm duty * (pwm div + 1) >> + * pwm duty =3D duty_ns / period_ns >> + */ >> + hi_dur =3D div64_u64(duty_ns * rate, (pre_div + 1) * NSEC_PER_SEC); >> + >> + val =3D FIELD_PREP(IPQ_PWM_REG0_HI_DURATION, hi_dur) | >> + FIELD_PREP(IPQ_PWM_REG0_PWM_DIV, pwm_div); >> + ipq_pwm_reg_write(pwm, IPQ_PWM_REG0, val); >> + >> + val =3D FIELD_PREP(IPQ_PWM_REG1_PRE_DIV, pre_div); >> + ipq_pwm_reg_write(pwm, IPQ_PWM_REG1, val); >> + >> + /* PWM enable toggle needs a separate write to REG1 */ >> + val |=3D IPQ_PWM_REG1_UPDATE; >> + if (enable) >> + val |=3D IPQ_PWM_REG1_ENABLE; >> + ipq_pwm_reg_write(pwm, IPQ_PWM_REG1, val); >> +} >> + >> +static int ipq_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, >> + const struct pwm_state *state) >> +{ >> + struct ipq_pwm_chip *ipq_chip =3D ipq_pwm_from_chip(chip); >> + unsigned int pre_div, pwm_div, best_pre_div, best_pwm_div; >> + unsigned long rate =3D clk_get_rate(ipq_chip->clk); >> + u64 period_ns, duty_ns, period_rate; >> + u64 min_diff; >> + >> + if (state->polarity !=3D PWM_POLARITY_NORMAL) >> + return -EINVAL; >> + >> + if (state->period < DIV64_U64_ROUND_UP(NSEC_PER_SEC, rate)) >> + return -ERANGE; >> + >> + period_ns =3D min(state->period, IPQ_PWM_MAX_PERIOD_NS); >> + duty_ns =3D min(state->duty_cycle, period_ns); >> + >> + /* >> + * period_ns is 1G or less. As long as rate is less than 16 GHz, >> + * period_rate does not overflow. Make that explicit. >> + */ >> + if (rate > 16ULL * GIGA) >> + return -EINVAL; >> + period_rate =3D period_ns * rate; >> + best_pre_div =3D IPQ_PWM_MAX_DIV; >> + best_pwm_div =3D IPQ_PWM_MAX_DIV; >> + /* >> + * We don't need to consider pre_div values smaller than >> + * >> + * period_rate >> + * pre_div_min :=3D ------------------------------------ >> + * NSEC_PER_SEC * (IPQ_PWM_MAX_DIV + 1) >> + * >> + * because pre_div =3D pre_div_min results in a better >> + * approximation. >> + */ >> + pre_div =3D div64_u64(period_rate, >> + (u64)NSEC_PER_SEC * (IPQ_PWM_MAX_DIV + 1)); >> + min_diff =3D period_rate; >> + >> + for (; pre_div <=3D IPQ_PWM_MAX_DIV; pre_div++) { >> + u64 remainder; >> + >> + pwm_div =3D div64_u64_rem(period_rate, >> + (u64)NSEC_PER_SEC * (pre_div + 1), &remainder); >> + /* pwm_div is unsigned; the check below catches underflow */ >> + pwm_div--; >> + >> + /* >> + * Swapping values for pre_div and pwm_div produces the same >> + * period length. So we can skip all settings with pre_div > >> + * pwm_div which results in bigger constraints for selecting >> + * the duty_cycle than with the two values swapped. >> + */ >> + if (pre_div > pwm_div) >> + break; >> + >> + /* >> + * Make sure we can do 100% duty cycle where >> + * hi_dur =3D=3D pwm_div + 1 >> + */ >> + if (pwm_div > IPQ_PWM_MAX_DIV - 1) >> + continue; >> + >> + if (remainder < min_diff) { >> + best_pre_div =3D pre_div; >> + best_pwm_div =3D pwm_div; >> + min_diff =3D remainder; >> + >> + if (min_diff =3D=3D 0) /* bingo */ >> + break; >> + } >> + } >> + >> + /* config divider values for the closest possible frequency */ >> + config_div_and_duty(pwm, best_pre_div, best_pwm_div, >> + rate, duty_ns, state->enabled); >> + >> + return 0; >> +} >> + >> +static void ipq_pwm_get_state(struct pwm_chip *chip, struct pwm_device = *pwm, >> + struct pwm_state *state) >> +{ >> + struct ipq_pwm_chip *ipq_chip =3D ipq_pwm_from_chip(chip); >> + unsigned long rate =3D clk_get_rate(ipq_chip->clk); >> + unsigned int pre_div, pwm_div, hi_dur; >> + u64 effective_div, hi_div; >> + u32 reg0, reg1; >> + >> + reg0 =3D ipq_pwm_reg_read(pwm, IPQ_PWM_REG0); >> + reg1 =3D ipq_pwm_reg_read(pwm, IPQ_PWM_REG1); >> + >> + state->polarity =3D PWM_POLARITY_NORMAL; >> + state->enabled =3D reg1 & IPQ_PWM_REG1_ENABLE; >> + >> + pwm_div =3D FIELD_GET(IPQ_PWM_REG0_PWM_DIV, reg0); >> + hi_dur =3D FIELD_GET(IPQ_PWM_REG0_HI_DURATION, reg0); >> + pre_div =3D FIELD_GET(IPQ_PWM_REG1_PRE_DIV, reg1); >> + >> + /* No overflow here, both pre_div and pwm_div <=3D 0xffff */ >> + effective_div =3D (u64)(pre_div + 1) * (pwm_div + 1); >> + state->period =3D DIV64_U64_ROUND_UP(effective_div * NSEC_PER_SEC, rat= e); >> + >> + hi_div =3D hi_dur * (pre_div + 1); >> + state->duty_cycle =3D DIV64_U64_ROUND_UP(hi_div * NSEC_PER_SEC, rate); >> +} >> + >> +static const struct pwm_ops ipq_pwm_ops =3D { >> + .apply =3D ipq_pwm_apply, >> + .get_state =3D ipq_pwm_get_state, >> + .owner =3D THIS_MODULE, >> +}; >> + >> +static int ipq_pwm_probe(struct platform_device *pdev) >> +{ >> + struct ipq_pwm_chip *pwm; >> + struct device *dev =3D &pdev->dev; >> + int ret; >> + >> + pwm =3D devm_kzalloc(dev, sizeof(*pwm), GFP_KERNEL); >> + if (!pwm) >> + return -ENOMEM; >> + >> + platform_set_drvdata(pdev, pwm); >> + >> + pwm->mem =3D devm_platform_ioremap_resource(pdev, 0); >> + if (IS_ERR(pwm->mem)) >> + return dev_err_probe(dev, PTR_ERR(pwm->mem), >> + "regs map failed"); >> + >> + pwm->clk =3D devm_clk_get(dev, NULL); >> + if (IS_ERR(pwm->clk)) >> + return dev_err_probe(dev, PTR_ERR(pwm->clk), >> + "failed to get clock"); >> + >> + ret =3D clk_prepare_enable(pwm->clk); >> + if (ret) >> + return dev_err_probe(dev, ret, "clock enable failed"); >> + >> + pwm->chip.dev =3D dev; >> + pwm->chip.ops =3D &ipq_pwm_ops; >> + pwm->chip.npwm =3D 4; >> + >> + ret =3D pwmchip_add(&pwm->chip); >> + if (ret < 0) { >> + dev_err_probe(dev, ret, "pwmchip_add() failed\n"); >> + clk_disable_unprepare(pwm->clk); >> + } >> + >> + return ret; >> +} >> + >> +static int ipq_pwm_remove(struct platform_device *pdev) >> +{ >> + struct ipq_pwm_chip *pwm =3D platform_get_drvdata(pdev); >> + >> + pwmchip_remove(&pwm->chip); >> + clk_disable_unprepare(pwm->clk); >> + >> + return 0; >> +} >> + >> +static const struct of_device_id pwm_ipq_dt_match[] =3D { >> + { .compatible =3D "qcom,ipq6018-pwm", }, >> + {} >> +}; >> +MODULE_DEVICE_TABLE(of, pwm_ipq_dt_match); >> + >> +static struct platform_driver ipq_pwm_driver =3D { >> + .driver =3D { >> + .name =3D "ipq-pwm", >> + .of_match_table =3D pwm_ipq_dt_match, >> + }, >> + .probe =3D ipq_pwm_probe, >> + .remove =3D ipq_pwm_remove, >> +}; >> + >> +module_platform_driver(ipq_pwm_driver); >> + >> +MODULE_LICENSE("Dual BSD/GPL"); --=20 ~. .~ Tk Open Systems =3D}------------------------------------------------ooO--U--Ooo------------= {=3D - baruch@tkos.co.il - tel: +972.52.368.4656, http://www.tkos.co.il - From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 50423EE6422 for ; Fri, 15 Sep 2023 06:47:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:Message-ID:In-reply-to: Date:Subject:Cc:To:From:References:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=Hx70fLWuJLTXIJoH7CvAoGEhGtzCdLja+BvO9TbN1Xg=; b=JaatTsLrYmXMwZ ty41MIpGcmEglxJMdp/CFZdEa8TKCRyDVMKUqZXEbZITRqjZzlJmMUSzK4xqHMgHGezSJAV3Kirw0 /Ym7pwUp3CgwC5RWwndWY/Qmd8o6EMJOs83eVEc7byrILQDw/QmGQPR/JhGS7OKHilYKv2Kfr9CiV +JRUvbXkafBXloVnIXtjGfTL9/yuMmke0Ube4jJw3ECCCulXihkD57mtVr6wXiv7jjtPQSFKm9j7T pLWfXs3CQJRl5MnJo7jKaQeA3qjmpn1eRsCtALJtdkskRq88PqrK2EQWfD4kf7BsmJX9Ixs+p4XHi EfK35eya+KrVStiQJyrg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qh2bl-009w0u-12; Fri, 15 Sep 2023 06:47:17 +0000 Received: from guitar.tkos.co.il ([84.110.109.230] helo=mail.tkos.co.il) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1qh2bb-009vvP-1W for linux-arm-kernel@lists.infradead.org; Fri, 15 Sep 2023 06:47:10 +0000 Received: from tarshish (unknown [10.0.8.2]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.tkos.co.il (Postfix) with ESMTPS id 64B094402B3; Fri, 15 Sep 2023 09:46:52 +0300 (IDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=tkos.co.il; s=default; t=1694760412; bh=fyZ+SkBRodjYD2mW6Xocvnd5U6+dMtwLSQid+Sw+7bw=; h=References:From:To:Cc:Subject:Date:In-reply-to:From; b=ZarfHsVIuebrXzUZwmPgNGOrYS2VXEyIxce7dm/sT7uE9l282WjenuTzf2cJZbCMl 1KVVVWtyydOw1O0KfOD8i8k1SzE+6CckTYcTEpERu/2vdVeQe48fBhEwLPE5zOaFMy 7B9qNH78ZYYBlO+7hMuVWetJiZAs80XIiksisHYrvZhR4Fgi3gSl6NLcjm5q5dk6ix nWVJbv7e9ad+vHYFaZD+TR9ST9BLK7hMEHQzgRE4MevrANxtlO3WsVqNDQ3Ds7wP7W XB3jyYcR3wOZmL5n3pKWCeARWkwndFwUs1CiOMjo7RHQ1xs4h31BKSZmsAjoZpDhlk JvNM9fYGrJfng== References: <17dd231f496d09ed8502bdd505eaa77bb6637e4b.1644226245.git.baruch@tkos.co.il> <8a331c88-c7d4-3a14-0ec3-fd616ea24a99@quicinc.com> User-agent: mu4e 1.9.21; emacs 29.1 From: Baruch Siach To: Devi Priya Cc: Thierry Reding , Uwe =?utf-8?Q?Kleine-K?= =?utf-8?Q?=C3=B6nig?= , Andy Gross , Bjorn Andersson , Rob Herring , Robert Marko , Kathiravan T , linux-pwm@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-msm@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: Re: [PATCH 1/3] pwm: driver for qualcomm ipq6018 pwm block Date: Fri, 15 Sep 2023 09:36:10 +0300 In-reply-to: <8a331c88-c7d4-3a14-0ec3-fd616ea24a99@quicinc.com> Message-ID: <87wmwsylup.fsf@tarshish> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20230914_234708_230823_7E0A79FD X-CRM114-Status: GOOD ( 35.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 SGkgRGV2aSwKClsgRHJvcHBlZC91cGRhdGVkIGNvZGVhdXJvcmEub3JnIGFkZHJlc3NlcyBdCgpP biBGcmksIFNlcCAxNSAyMDIzLCBEZXZpIFByaXlhIHdyb3RlOgo+IE9uIDIvNy8yMDIyIDM6MDAg UE0sIEJhcnVjaCBTaWFjaCB3cm90ZToKPj4gRnJvbTogQmFydWNoIFNpYWNoIDxiYXJ1Y2guc2lh Y2hAc2lrbHUuY29tPgo+PiBEcml2ZXIgZm9yIHRoZSBQV00gYmxvY2sgaW4gUXVhbGNvbW0gSVBR NjAxOCBsaW5lIG9mIFNvQ3MuIEJhc2VkIG9uCj4+IGRyaXZlciBmcm9tIGRvd25zdHJlYW0gQ29k ZWF1cm9yYSBrZXJuZWwgdHJlZS4gUmVtb3ZlZCBzdXBwb3J0IGZvciBvbGRlcgo+PiAoVjEpIHZh cmlhbnRzIGJlY2F1c2UgSSBoYXZlIG5vIGFjY2VzcyB0byB0aGF0IGhhcmR3YXJlLgo+PiBUZXN0 ZWQgb24gSVBRNjAxMCBiYXNlZCBoYXJkd2FyZS4KPj4gU2lnbmVkLW9mZi1ieTogQmFydWNoIFNp YWNoIDxiYXJ1Y2guc2lhY2hAc2lrbHUuY29tPgo+PiAtLS0KPj4gdjExOgo+Cj4gSnVzdCBjdXJp b3VzIHRvIGtub3cgaWYgeW91IGhhdmUgcGxhbnMgdG8gcG9zdCB0aGUgbmV4dCByZXZpc2lvbiEK CkkgaGF2ZSBiZWVuIHdhaXRpbmcgZm9yIGNvbW1lbnRzIGZyb20gcHdtIG1haW50YWluZXJzIGJl Zm9yZSBzZW5kaW5nIHRoZQpuZXh0IHJldmlzaW9uLgoKVW5mb3J0dW5hdGVseSBzaW5jZSB0aGVu IEkgbG9zdCBhY2Nlc3MgdG8gdGhlIGhhcmR3YXJlLCBzbyBJIGNhbid0IHRlc3QKc3VnZ2VzdGVk IGltcGxlbWVudGF0aW9uIGNoYW5nZXMuICBUaGUgb25seSBwZW5kaW5nIGlzc3VlIGluIHYxMSBp cyB0aGUKdHJpdmlhbCBjaGFuZ2UgdGhhdCBOYXRoYW4gQ2hhbmNlbGxvciBzdWdnZXN0ZWQsIHdo aWNoIHNob3VsZCBiZSBzYWZlLgoKSWYgeW91IGxpa2UgdG8gdGFrZSBpdCBmcm9tIGhlcmUgeW91 IGFyZSB3ZWxjb21lLgoKVGhhbmtzLApiYXJ1Y2gKCj4+IEFkZHJlc3MgY29tbWVudCBmcm9tIFV3 ZSBLbGVpbmUtS8O2bmlnOgo+PiAgICBEcm9wIHJlZHVuZGFudCByZWdpc3RlcnMgZmllbGQgY29t bWVudHMKPj4gICAgRml4IHBlcmlvZCBsaW1pdCBjaGVjayBpbiAuYXBwbHkKPj4gICAgQ2xhcmlm eSB0aGUgY29tbWVudCBleHBsYWluaW5nIHNraXAgb2YgcHJlX2RpdiA+IHB3bV9kaXYgdmFsdWVz Cj4+ICAgIEFkZCBleHBsaWNpdCBjaGVjayBmb3IgY2xvY2sgcmF0ZSB3aXRoaW4gbGltaXQKPj4g ICAgQWRkIGNvbW1lbnQgZXhwbGFpbmluZyB0aGUgc2VsZWN0aW9uIG9mIGluaXRpYWwgcHJlX2Rp dgo+PiAgICBVc2UgcHdtX2RpdiBkaXZpc2lvbiB3aXRoIHJlbWFpbmRlciBpbnN0ZWFkIG9mIHNl cGFyYXRlIGRpZmYgY2FsY3VsYXRpb24KPj4gICAgUm91bmQgdXAgZHV0eV9jeWNsZSBjYWxjdWxh dGlvbiBpbiAuZ2V0X3N0YXRlCj4+IHYxMDoKPj4gICAgUmVzdG9yZSByb3VuZCB1cCBpbiBwd21f ZGl2IGNhbGN1bGF0aW9uOyBvdGhlcndpc2UgZGlmZiBpcyBhbHdheXMgPD0KPj4gICAgMCwgc28g b25seSBiaW5nbyBtYXRjaCB3b3Jrcwo+PiAgICBEb24ndCBvdmVyd3JpdGUgbWluX2RpZmYgb24g ZXZlcnkgbG9vcCBpdGVyYXRpb24KPj4gdjk6Cj4+IEFkZHJlc3MgY29tbWVudCBmcm9tIFV3ZSBL bGVpbmUtS8O2bmlnOgo+PiAgICBVc2UgcGVyaW9kX25zKnJhdGUgaW4gZGl2aWRlcnMgY2FsY3Vs YXRpb24gZm9yIGJldHRlciBhY2N1cmFjeQo+PiAgICBSb3VuZCBkb3duIHByZV9kaXYgYW5kIHB3 bV9kaXYKPj4gICAgQWRkIGEgY29tbWVudCBleHBsYWluaW5nIHdoeSBwd21fZGl2IGNhbid0IHVu ZGVyZmxvdwo+PiAgICBBZGQgYSBjb21tZW50IGV4cGxhaW5pbmcgd2h5IHByZV9kaXYgPiBwd21f ZGl2IGVuZCB0aGUgc2VhcmNoIGxvb3AKPj4gICAgRHJvcCAnQ0ZHXycgZnJvbSByZWdpc3RlciBt YWNyb3MKPj4gICAgUmVuYW1lIHRvX2lwcV9wd21fY2hpcCgpIHRvIGlwcV9wd21fZnJvbV9jaGlw KCkKPj4gICAgQ2hhbmdlIGJhcmUgJ3Vuc2lnbmVkJyB0byAndW5zaWduZWQgaW50Jwo+PiAgICBD bGFyaWZ5IHRoZSBjb21tZW50IG9uIHNlcGFyYXRlIFJFRzEgd3JpdGUgZm9yIGVuYWJsZS9kaXNh YmxlCj4+ICAgIFJvdW5kIHVwIHRoZSBwZXJpb2QgdmFsdWUgaW4gLmdldF9zdGF0ZQo+PiAgICBV c2UgZGlyZWN0IHJlYWRsL3dyaXRlbCBzbyBubyBuZWVkIHRvIGNoZWNrIGZvciByZWdtYXAgZXJy b3JzCj4+IHY3Ogo+PiAgICBDaGFuZ2UgJ29mZnNldCcgdG8gJ3JlZycgZm9yIHRoZSB0Y3NyIG9m ZnNldCAoUm9iKQo+PiAgICBEcm9wIGNsb2NrIG5hbWU7IHRoZXJlIGlzIG9ubHkgb25lIGNsb2Nr IChCam9ybikKPj4gICAgU2ltcGxpZnkgcHJvYmUgZmFpbHVyZSBjb2RlIHBhdGggKEJqb3JuKQo+ PiB2NjoKPj4gQWRkcmVzcyBVd2UgS2xlaW5lLUvDtm5pZyByZXZpZXcgY29tbWVudHM6Cj4+ICAg IERyb3AgSVBRX1BXTV9NQVhfREVWSUNFUwo+PiAgICBSZWx5IG9uIGFzc2lnbmVkLWNsb2NrLXJh dGVzOyBkcm9wIElQUV9QV01fQ0xLX1NSQ19GUkVRCj4+ICAgIFNpbXBsaWZ5IHJlZ2lzdGVyIG9m ZnNldCBjYWxjdWxhdGlvbgo+PiAgICBDYWxjdWxhdGUgZHV0eSBjeWNsZSBtb3JlIHByZWNpc2Vs eQo+PiAgICBSZWZ1c2UgdG8gc2V0IGludmVydGVkIHBvbGFyaXR5Cj4+ICAgIERyb3AgcmVkdW5k YW50IElQUV9QV01fUkVHMV9FTkFCTEUgYml0IGNsZWFyCj4+ICAgIFJlbW92ZSB4MTAwMCBmYWN0 b3IgaW4gcHdtX2RpdiBjYWxjdWxhdGlvbiwgdXNlIHJhdGUgZGlyZWN0bHksIGFuZCByb3VuZAo+ PiB1cAo+PiAgICBDaG9vc2UgaW5pdGlhbCBwcmVfZGl2IHN1Y2ggdGhhdCBwd21fZGl2IDwgSVBR X1BXTV9NQVhfRElWCj4+ICAgIEVuc3VyZSBwcmVfZGl2IDw9IHB3bV9kaXYKPj4gICAgUmVuYW1l IGNsb3NlXyB0byBiZXN0Xwo+PiAgICBFeHBsYWluIGluIGNvbW1lbnQgd2h5IGVmZmVjdGl2ZV9k aXYgZG9lc24ndCBvdmVyZmxvdwo+PiAgICBMaW1pdCBwd21fZGl2IHRvIElQUV9QV01fTUFYX0RJ ViAtIDEgdG8gYWxsb3cgMTAwJSBkdXR5IGN5Y2xlCj4+ICAgIERpc2FibGUgY2xvY2sgb25seSBh ZnRlciBwd21jaGlwX3JlbW92ZSgpCj4+ICAgIGNvbnN0IHB3bV9vcHMKPj4gT3RoZXIgY2hhbmdl czoKPj4gICAgQWRkIG1pc3NpbmcgbGludXgvYml0ZmllbGQuaCBoZWFkZXIgaW5jbHVkZSAoa2Vy bmVsIHRlc3Qgcm9ib3QpCj4+ICAgIEFkanVzdCBjb2RlIGZvciBQV00gZGV2aWNlIG5vZGUgdW5k ZXIgVENTUiAoUm9iIEhlcnJpbmcpCj4+IHY1Ogo+PiBVc2UgJnRjc3JfcTYgc3lzY29uIHRvIGFj Y2VzcyByZWdpc3RlcnMgKEJqb3JuIEFuZGVyc3NvbikKPj4gQWRkcmVzcyBVd2UgS2xlaW5lLUvD tm5pZyByZXZpZXcgY29tbWVudHM6Cj4+ICAgIEltcGxlbWVudCAuZ2V0X3N0YXRlKCkKPj4gICAg QWRkIElQUV9QV01fIHByZWZpeCB0byBsb2NhbCBtYWNyb3MKPj4gICAgVXNlIEdFTk1BU0svQklU L0ZJRUxEX1BSRVAgZm9yIHJlZ2lzdGVyIGZpZWxkcyBhY2Nlc3MKPj4gICAgTWFrZSB0eXBlIG9m IGNvbmZpZ19kaXZfYW5kX2R1dHkoKSBwYXJhbWV0ZXJzIGNvbnNpc3RlbnQKPj4gICAgRGVyaXZl IElQUV9QV01fTUlOX1BFUklPRF9OUyBmcm9tIElQUV9QV01fQ0xLX1NSQ19GUkVRCj4+ICAgIElu dGVncmF0ZSBlbmFibGUvZGlzYWJsZSBpbnRvIGNvbmZpZ19kaXZfYW5kX2R1dHkoKSB0byBzYXZl IHJlZ2lzdGVyCj4+IHJlYWQsCj4+ICAgIGFuZCByZWR1Y2UgZnJlcXVlbmN5IGdsaXRjaCBvbiB1 cGRhdGUKPj4gICAgVXNlIG1pbigpIGluc3RlYWQgb2YgbWluX3QoKQo+PiAgICBGaXggY29tbWVu dCBmb3JtYXQKPj4gICAgVXNlIGRldl9lcnJfcHJvYmUoKSB0byBpbmRpY2F0ZSBwcm9iZSBzdGVw IGZhaWx1cmUKPj4gICAgQWRkIG1pc3NpbmcgY2xrX2Rpc2FibGVfdW5wcmVwYXJlKCkgaW4gLnJl bW92ZQo+PiAgICBEb24ndCBzZXQgLm93bmVyCj4+IHY0Ogo+PiAgICBVc2UgZGl2NjRfdTY0KCkg dG8gZml4IGxpbmsgZm9yIDMyLWJpdCB0YXJnZXRzICgoa2VybmVsIHRlc3Qgcm9ib3QKPj4gICAg PGxrcEBpbnRlbC5jb20+LCBVd2UgS2xlaW5lLUvDtm5pZykKPj4gdjM6Cj4+ICAgIHMvcWNvbSxw d20taXBxNjAxOC9xY29tLGlwcTYwMTgtcHdtLyAoUm9iIEhlcnJpbmcpCj4+ICAgIEZpeCBpbnRl Z2VyIG92ZXJmbG93IG9uIDMyLWJpdCB0YXJnZXRzIChrZXJuZWwgdGVzdCByb2JvdAo+PiA8bGtw QGludGVsLmNvbT4pCj4+IHYyOgo+PiBBZGRyZXNzIFV3ZSBLbGVpbmUtS8O2bmlnIHJldmlldyBj b21tZW50czoKPj4gICAgRml4IHBlcmlvZCBjYWxjdWxhdGlvbiB3aGVuIG91dCBvZiByYW5nZQo+ PiAgICBEb24ndCBzZXQgcGVyaW9kIGxhcmdlciB0aGFuIHJlcXVlc3RlZAo+PiAgICBSZW1vdmUg UFdNIGRpc2FibGUgb24gY29uZmlndXJhdGlvbiBjaGFuZ2UKPj4gICAgSW1wbGVtZW50IC5hcHBs eSBpbnN0ZWFkIG9mIG5vbi1hdG9taWMgLmNvbmZpZy8uZW5hYmxlLy5kaXNhYmxlCj4+ICAgIERv bid0IG1vZGlmeSBQV00gb24gLnJlcXVlc3QvLmZyZWUKPj4gICAgQ2hlY2sgcHdtX2RpdiB1bmRl cmZsb3cKPj4gICAgRml4IHZhcmlvdXMgY29kZSBhbmQgY29tbWVudCBmb3JtYXR0aW5nIGlzc3Vl cwo+PiBPdGhlciBjaGFuZ2VzOgo+PiAgICBVc2UgdTY0IGRpdmlzb3Igc2FmZSBkaXZpc2lvbgo+ PiAgICBSZW1vdmUgbm93IGVtcHR5IC5yZXF1ZXN0Ly5mcmVlCj4+IC0tLQo+PiAgIGRyaXZlcnMv cHdtL0tjb25maWcgICB8ICAxMiArKwo+PiAgIGRyaXZlcnMvcHdtL01ha2VmaWxlICB8ICAgMSAr Cj4+ICAgZHJpdmVycy9wd20vcHdtLWlwcS5jIHwgMjgxICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKwo+PiAgIDMgZmlsZXMgY2hhbmdlZCwgMjk0IGluc2VydGlvbnMo KykKPj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9wd20vcHdtLWlwcS5jCj4+IGRpZmYg LS1naXQgYS9kcml2ZXJzL3B3bS9LY29uZmlnIGIvZHJpdmVycy9wd20vS2NvbmZpZwo+PiBpbmRl eCAyMWUzYjA1YTUxNTMuLmUzOTcxODEzN2VjZCAxMDA2NDQKPj4gLS0tIGEvZHJpdmVycy9wd20v S2NvbmZpZwo+PiArKysgYi9kcml2ZXJzL3B3bS9LY29uZmlnCj4+IEBAIC0yNjAsNiArMjYwLDE4 IEBAIGNvbmZpZyBQV01fSU5URUxfTEdNCj4+ICAgCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBh cyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZTogdGhlIG1vZHVsZQo+PiAgIAkgIHdpbGwgYmUgY2Fs bGVkIHB3bS1pbnRlbC1sZ20uCj4+ICAgK2NvbmZpZyBQV01fSVBRCj4+ICsJdHJpc3RhdGUgIklQ USBQV00gc3VwcG9ydCIKPj4gKwlkZXBlbmRzIG9uIEFSQ0hfUUNPTSB8fCBDT01QSUxFX1RFU1QK Pj4gKwlkZXBlbmRzIG9uIEhBVkVfQ0xLICYmIEhBU19JT01FTQo+PiArCWhlbHAKPj4gKwkgIEdl bmVyaWMgUFdNIGZyYW1ld29yayBkcml2ZXIgZm9yIElQUSBQV00gYmxvY2sgd2hpY2ggc3VwcG9y dHMKPj4gKwkgIDQgcHdtIGNoYW5uZWxzLiBFYWNoIG9mIHRoZSB0aGVzZSBjaGFubmVscyBjYW4g YmUgY29uZmlndXJlZAo+PiArCSAgaW5kZXBlbmRlbnQgb2YgZWFjaCBvdGhlci4KPj4gKwo+PiAr CSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZTogdGhl IG1vZHVsZQo+PiArCSAgd2lsbCBiZSBjYWxsZWQgcHdtLWlwcS4KPj4gKwo+PiAgIGNvbmZpZyBQ V01fSVFTNjIwQQo+PiAgIAl0cmlzdGF0ZSAiQXpvdGVxIElRUzYyMEEgUFdNIHN1cHBvcnQiCj4+ ICAgCWRlcGVuZHMgb24gTUZEX0lRUzYyWCB8fCBDT01QSUxFX1RFU1QKPj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvcHdtL01ha2VmaWxlIGIvZHJpdmVycy9wd20vTWFrZWZpbGUKPj4gaW5kZXggNzA4 ODQwYjdmYmE4Li43NDAyZmVhZTRiMzYgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvcHdtL01ha2Vm aWxlCj4+ICsrKyBiL2RyaXZlcnMvcHdtL01ha2VmaWxlCj4+IEBAIC0yMiw2ICsyMiw3IEBAIG9i ai0kKENPTkZJR19QV01fSU1YMSkJCSs9IHB3bS1pbXgxLm8KPj4gICBvYmotJChDT05GSUdfUFdN X0lNWDI3KQkJKz0gcHdtLWlteDI3Lm8KPj4gICBvYmotJChDT05GSUdfUFdNX0lNWF9UUE0pCSs9 IHB3bS1pbXgtdHBtLm8KPj4gICBvYmotJChDT05GSUdfUFdNX0lOVEVMX0xHTSkJKz0gcHdtLWlu dGVsLWxnbS5vCj4+ICtvYmotJChDT05GSUdfUFdNX0lQUSkJCSs9IHB3bS1pcHEubwo+PiAgIG9i ai0kKENPTkZJR19QV01fSVFTNjIwQSkJKz0gcHdtLWlxczYyMGEubwo+PiAgIG9iai0kKENPTkZJ R19QV01fSlo0NzQwKQkrPSBwd20tano0NzQwLm8KPj4gICBvYmotJChDT05GSUdfUFdNX0tFRU1C QVkpCSs9IHB3bS1rZWVtYmF5Lm8KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvcHdtL3B3bS1pcHEu YyBiL2RyaXZlcnMvcHdtL3B3bS1pcHEuYwo+PiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+PiBpbmRl eCAwMDAwMDAwMDAwMDAuLjk5NDAyNzI5MGJjYgo+PiAtLS0gL2Rldi9udWxsCj4+ICsrKyBiL2Ry aXZlcnMvcHdtL3B3bS1pcHEuYwo+PiBAQCAtMCwwICsxLDI4MSBAQAo+PiArLy8gU1BEWC1MaWNl bnNlLUlkZW50aWZpZXI6IEJTRC0zLUNsYXVzZSBPUiBHUEwtMi4wCj4+ICsvKgo+PiArICogQ29w eXJpZ2h0IChjKSAyMDE2LTIwMTcsIDIwMjAgVGhlIExpbnV4IEZvdW5kYXRpb24uIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCj4+ICsgKi8KPj4gKwo+PiArI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ PiArI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgo+PiArI2luY2x1ZGUgPGxpbnV4 L3B3bS5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2lv Lmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvb2YuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9tYXRoNjQu aD4KPj4gKyNpbmNsdWRlIDxsaW51eC9vZl9kZXZpY2UuaD4KPj4gKyNpbmNsdWRlIDxsaW51eC9i aXRmaWVsZC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L3VuaXRzLmg+Cj4+ICsKPj4gKy8qIFRoZSBm cmVxdWVuY3kgcmFuZ2Ugc3VwcG9ydGVkIGlzIDEgSHogdG8gY2xvY2sgcmF0ZSAqLwo+PiArI2Rl ZmluZSBJUFFfUFdNX01BWF9QRVJJT0RfTlMJKCh1NjQpTlNFQ19QRVJfU0VDKQo+PiArCj4+ICsv Kgo+PiArICogVGhlIG1heCB2YWx1ZSBzcGVjaWZpZWQgZm9yIGVhY2ggZmllbGQgaXMgYmFzZWQg b24gdGhlIG51bWJlciBvZiBiaXRzCj4+ICsgKiBpbiB0aGUgcHdtIGNvbnRyb2wgcmVnaXN0ZXIg Zm9yIHRoYXQgZmllbGQKPj4gKyAqLwo+PiArI2RlZmluZSBJUFFfUFdNX01BWF9ESVYJCTB4RkZG Rgo+PiArCj4+ICsvKgo+PiArICogVHdvIDMyLWJpdCByZWdpc3RlcnMgZm9yIGVhY2ggUFdNOiBS RUcwLCBhbmQgUkVHMS4KPj4gKyAqIEJhc2Ugb2Zmc2V0IGZvciBQV00gI2kgaXMgYXQgOCAqICNp Lgo+PiArICovCj4+ICsjZGVmaW5lIElQUV9QV01fUkVHMAkJCTAKPj4gKyNkZWZpbmUgSVBRX1BX TV9SRUcwX1BXTV9ESVYJCUdFTk1BU0soMTUsIDApCj4+ICsjZGVmaW5lIElQUV9QV01fUkVHMF9I SV9EVVJBVElPTglHRU5NQVNLKDMxLCAxNikKPj4gKwo+PiArI2RlZmluZSBJUFFfUFdNX1JFRzEJ CQk0Cj4+ICsjZGVmaW5lIElQUV9QV01fUkVHMV9QUkVfRElWCQlHRU5NQVNLKDE1LCAwKQo+PiAr LyoKPj4gKyAqIEVuYWJsZSBiaXQgaXMgc2V0IHRvIGVuYWJsZSBvdXRwdXQgdG9nZ2xpbmcgaW4g cHdtIGRldmljZS4KPj4gKyAqIFVwZGF0ZSBiaXQgaXMgc2V0IHRvIHJlZmxlY3QgdGhlIGNoYW5n ZWQgZGl2aWRlciBhbmQgaGlnaCBkdXJhdGlvbgo+PiArICogdmFsdWVzIGluIHJlZ2lzdGVyLgo+ PiArICovCj4+ICsjZGVmaW5lIElQUV9QV01fUkVHMV9VUERBVEUJCUJJVCgzMCkKPj4gKyNkZWZp bmUgSVBRX1BXTV9SRUcxX0VOQUJMRQkJQklUKDMxKQo+PiArCj4+ICsKPj4gK3N0cnVjdCBpcHFf cHdtX2NoaXAgewo+PiArCXN0cnVjdCBwd21fY2hpcCBjaGlwOwo+PiArCXN0cnVjdCBjbGsgKmNs azsKPj4gKwl2b2lkIF9faW9tZW0gKm1lbTsKPj4gK307Cj4+ICsKPj4gK3N0YXRpYyBzdHJ1Y3Qg aXBxX3B3bV9jaGlwICppcHFfcHdtX2Zyb21fY2hpcChzdHJ1Y3QgcHdtX2NoaXAgKmNoaXApCj4+ ICt7Cj4+ICsJcmV0dXJuIGNvbnRhaW5lcl9vZihjaGlwLCBzdHJ1Y3QgaXBxX3B3bV9jaGlwLCBj aGlwKTsKPj4gK30KPj4gKwo+PiArc3RhdGljIHVuc2lnbmVkIGludCBpcHFfcHdtX3JlZ19yZWFk KHN0cnVjdCBwd21fZGV2aWNlICpwd20sIHVuc2lnbmVkIGludCByZWcpCj4+ICt7Cj4+ICsJc3Ry dWN0IGlwcV9wd21fY2hpcCAqaXBxX2NoaXAgPSBpcHFfcHdtX2Zyb21fY2hpcChwd20tPmNoaXAp Owo+PiArCXVuc2lnbmVkIGludCBvZmYgPSA4ICogcHdtLT5od3B3bSArIHJlZzsKPj4gKwo+PiAr CXJldHVybiByZWFkbChpcHFfY2hpcC0+bWVtICsgb2ZmKTsKPj4gK30KPj4gKwo+PiArc3RhdGlj IHZvaWQgaXBxX3B3bV9yZWdfd3JpdGUoc3RydWN0IHB3bV9kZXZpY2UgKnB3bSwgdW5zaWduZWQg aW50IHJlZywKPj4gKwkJCSAgICAgIHVuc2lnbmVkIGludCB2YWwpCj4+ICt7Cj4+ICsJc3RydWN0 IGlwcV9wd21fY2hpcCAqaXBxX2NoaXAgPSBpcHFfcHdtX2Zyb21fY2hpcChwd20tPmNoaXApOwo+ PiArCXVuc2lnbmVkIGludCBvZmYgPSA4ICogcHdtLT5od3B3bSArIHJlZzsKPj4gKwo+PiArCXdy aXRlbCh2YWwsIGlwcV9jaGlwLT5tZW0gKyBvZmYpOwo+PiArfQo+PiArCj4+ICtzdGF0aWMgdm9p ZCBjb25maWdfZGl2X2FuZF9kdXR5KHN0cnVjdCBwd21fZGV2aWNlICpwd20sIHVuc2lnbmVkIGlu dCBwcmVfZGl2LAo+PiArCQkJdW5zaWduZWQgaW50IHB3bV9kaXYsIHVuc2lnbmVkIGxvbmcgcmF0 ZSwgdTY0IGR1dHlfbnMsCj4+ICsJCQlib29sIGVuYWJsZSkKPj4gK3sKPj4gKwl1bnNpZ25lZCBs b25nIGhpX2R1cjsKPj4gKwl1bnNpZ25lZCBsb25nIHZhbCA9IDA7Cj4+ICsKPj4gKwkvKgo+PiAr CSAqIGhpZ2ggZHVyYXRpb24gPSBwd20gZHV0eSAqIChwd20gZGl2ICsgMSkKPj4gKwkgKiBwd20g ZHV0eSA9IGR1dHlfbnMgLyBwZXJpb2RfbnMKPj4gKwkgKi8KPj4gKwloaV9kdXIgPSBkaXY2NF91 NjQoZHV0eV9ucyAqIHJhdGUsIChwcmVfZGl2ICsgMSkgKiBOU0VDX1BFUl9TRUMpOwo+PiArCj4+ ICsJdmFsID0gRklFTERfUFJFUChJUFFfUFdNX1JFRzBfSElfRFVSQVRJT04sIGhpX2R1cikgfAo+ PiArCQlGSUVMRF9QUkVQKElQUV9QV01fUkVHMF9QV01fRElWLCBwd21fZGl2KTsKPj4gKwlpcHFf cHdtX3JlZ193cml0ZShwd20sIElQUV9QV01fUkVHMCwgdmFsKTsKPj4gKwo+PiArCXZhbCA9IEZJ RUxEX1BSRVAoSVBRX1BXTV9SRUcxX1BSRV9ESVYsIHByZV9kaXYpOwo+PiArCWlwcV9wd21fcmVn X3dyaXRlKHB3bSwgSVBRX1BXTV9SRUcxLCB2YWwpOwo+PiArCj4+ICsJLyogUFdNIGVuYWJsZSB0 b2dnbGUgbmVlZHMgYSBzZXBhcmF0ZSB3cml0ZSB0byBSRUcxICovCj4+ICsJdmFsIHw9IElQUV9Q V01fUkVHMV9VUERBVEU7Cj4+ICsJaWYgKGVuYWJsZSkKPj4gKwkJdmFsIHw9IElQUV9QV01fUkVH MV9FTkFCTEU7Cj4+ICsJaXBxX3B3bV9yZWdfd3JpdGUocHdtLCBJUFFfUFdNX1JFRzEsIHZhbCk7 Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBpbnQgaXBxX3B3bV9hcHBseShzdHJ1Y3QgcHdtX2NoaXAg KmNoaXAsIHN0cnVjdCBwd21fZGV2aWNlICpwd20sCj4+ICsJCQkgY29uc3Qgc3RydWN0IHB3bV9z dGF0ZSAqc3RhdGUpCj4+ICt7Cj4+ICsJc3RydWN0IGlwcV9wd21fY2hpcCAqaXBxX2NoaXAgPSBp cHFfcHdtX2Zyb21fY2hpcChjaGlwKTsKPj4gKwl1bnNpZ25lZCBpbnQgcHJlX2RpdiwgcHdtX2Rp diwgYmVzdF9wcmVfZGl2LCBiZXN0X3B3bV9kaXY7Cj4+ICsJdW5zaWduZWQgbG9uZyByYXRlID0g Y2xrX2dldF9yYXRlKGlwcV9jaGlwLT5jbGspOwo+PiArCXU2NCBwZXJpb2RfbnMsIGR1dHlfbnMs IHBlcmlvZF9yYXRlOwo+PiArCXU2NCBtaW5fZGlmZjsKPj4gKwo+PiArCWlmIChzdGF0ZS0+cG9s YXJpdHkgIT0gUFdNX1BPTEFSSVRZX05PUk1BTCkKPj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4+ICsK Pj4gKwlpZiAoc3RhdGUtPnBlcmlvZCA8IERJVjY0X1U2NF9ST1VORF9VUChOU0VDX1BFUl9TRUMs IHJhdGUpKQo+PiArCQlyZXR1cm4gLUVSQU5HRTsKPj4gKwo+PiArCXBlcmlvZF9ucyA9IG1pbihz dGF0ZS0+cGVyaW9kLCBJUFFfUFdNX01BWF9QRVJJT0RfTlMpOwo+PiArCWR1dHlfbnMgPSBtaW4o c3RhdGUtPmR1dHlfY3ljbGUsIHBlcmlvZF9ucyk7Cj4+ICsKPj4gKwkvKgo+PiArCSAqIHBlcmlv ZF9ucyBpcyAxRyBvciBsZXNzLiBBcyBsb25nIGFzIHJhdGUgaXMgbGVzcyB0aGFuIDE2IEdIeiwK Pj4gKwkgKiBwZXJpb2RfcmF0ZSBkb2VzIG5vdCBvdmVyZmxvdy4gTWFrZSB0aGF0IGV4cGxpY2l0 Lgo+PiArCSAqLwo+PiArCWlmIChyYXRlID4gMTZVTEwgKiBHSUdBKQo+PiArCQlyZXR1cm4gLUVJ TlZBTDsKPj4gKwlwZXJpb2RfcmF0ZSA9IHBlcmlvZF9ucyAqIHJhdGU7Cj4+ICsJYmVzdF9wcmVf ZGl2ID0gSVBRX1BXTV9NQVhfRElWOwo+PiArCWJlc3RfcHdtX2RpdiA9IElQUV9QV01fTUFYX0RJ VjsKPj4gKwkvKgo+PiArCSAqIFdlIGRvbid0IG5lZWQgdG8gY29uc2lkZXIgcHJlX2RpdiB2YWx1 ZXMgc21hbGxlciB0aGFuCj4+ICsJICoKPj4gKwkgKiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHBlcmlvZF9yYXRlCj4+ICsJICogIHByZV9kaXZfbWluIDo9IC0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLQo+PiArCSAqICAgICAgICAgICAgICAgICBOU0VDX1BFUl9TRUMg KiAoSVBRX1BXTV9NQVhfRElWICsgMSkKPj4gKwkgKgo+PiArCSAqIGJlY2F1c2UgcHJlX2RpdiA9 IHByZV9kaXZfbWluIHJlc3VsdHMgaW4gYSBiZXR0ZXIKPj4gKwkgKiBhcHByb3hpbWF0aW9uLgo+ PiArCSAqLwo+PiArCXByZV9kaXYgPSBkaXY2NF91NjQocGVyaW9kX3JhdGUsCj4+ICsJCQkodTY0 KU5TRUNfUEVSX1NFQyAqIChJUFFfUFdNX01BWF9ESVYgKyAxKSk7Cj4+ICsJbWluX2RpZmYgPSBw ZXJpb2RfcmF0ZTsKPj4gKwo+PiArCWZvciAoOyBwcmVfZGl2IDw9IElQUV9QV01fTUFYX0RJVjsg cHJlX2RpdisrKSB7Cj4+ICsJCXU2NCByZW1haW5kZXI7Cj4+ICsKPj4gKwkJcHdtX2RpdiA9IGRp djY0X3U2NF9yZW0ocGVyaW9kX3JhdGUsCj4+ICsJCQkJKHU2NClOU0VDX1BFUl9TRUMgKiAocHJl X2RpdiArIDEpLCAmcmVtYWluZGVyKTsKPj4gKwkJLyogcHdtX2RpdiBpcyB1bnNpZ25lZDsgdGhl IGNoZWNrIGJlbG93IGNhdGNoZXMgdW5kZXJmbG93ICovCj4+ICsJCXB3bV9kaXYtLTsKPj4gKwo+ PiArCQkvKgo+PiArCQkgKiBTd2FwcGluZyB2YWx1ZXMgZm9yIHByZV9kaXYgYW5kIHB3bV9kaXYg cHJvZHVjZXMgdGhlIHNhbWUKPj4gKwkJICogcGVyaW9kIGxlbmd0aC4gU28gd2UgY2FuIHNraXAg YWxsIHNldHRpbmdzIHdpdGggcHJlX2RpdiA+Cj4+ICsJCSAqIHB3bV9kaXYgd2hpY2ggcmVzdWx0 cyBpbiBiaWdnZXIgY29uc3RyYWludHMgZm9yIHNlbGVjdGluZwo+PiArCQkgKiB0aGUgZHV0eV9j eWNsZSB0aGFuIHdpdGggdGhlIHR3byB2YWx1ZXMgc3dhcHBlZC4KPj4gKwkJICovCj4+ICsJCWlm IChwcmVfZGl2ID4gcHdtX2RpdikKPj4gKwkJCWJyZWFrOwo+PiArCj4+ICsJCS8qCj4+ICsJCSAq IE1ha2Ugc3VyZSB3ZSBjYW4gZG8gMTAwJSBkdXR5IGN5Y2xlIHdoZXJlCj4+ICsJCSAqIGhpX2R1 ciA9PSBwd21fZGl2ICsgMQo+PiArCQkgKi8KPj4gKwkJaWYgKHB3bV9kaXYgPiBJUFFfUFdNX01B WF9ESVYgLSAxKQo+PiArCQkJY29udGludWU7Cj4+ICsKPj4gKwkJaWYgKHJlbWFpbmRlciA8IG1p bl9kaWZmKSB7Cj4+ICsJCQliZXN0X3ByZV9kaXYgPSBwcmVfZGl2Owo+PiArCQkJYmVzdF9wd21f ZGl2ID0gcHdtX2RpdjsKPj4gKwkJCW1pbl9kaWZmID0gcmVtYWluZGVyOwo+PiArCj4+ICsJCQlp ZiAobWluX2RpZmYgPT0gMCkgLyogYmluZ28gKi8KPj4gKwkJCQlicmVhazsKPj4gKwkJfQo+PiAr CX0KPj4gKwo+PiArCS8qIGNvbmZpZyBkaXZpZGVyIHZhbHVlcyBmb3IgdGhlIGNsb3Nlc3QgcG9z c2libGUgZnJlcXVlbmN5ICovCj4+ICsJY29uZmlnX2Rpdl9hbmRfZHV0eShwd20sIGJlc3RfcHJl X2RpdiwgYmVzdF9wd21fZGl2LAo+PiArCQkJICAgIHJhdGUsIGR1dHlfbnMsIHN0YXRlLT5lbmFi bGVkKTsKPj4gKwo+PiArCXJldHVybiAwOwo+PiArfQo+PiArCj4+ICtzdGF0aWMgdm9pZCBpcHFf cHdtX2dldF9zdGF0ZShzdHJ1Y3QgcHdtX2NoaXAgKmNoaXAsIHN0cnVjdCBwd21fZGV2aWNlICpw d20sCj4+ICsJCQkgICAgICBzdHJ1Y3QgcHdtX3N0YXRlICpzdGF0ZSkKPj4gK3sKPj4gKwlzdHJ1 Y3QgaXBxX3B3bV9jaGlwICppcHFfY2hpcCA9IGlwcV9wd21fZnJvbV9jaGlwKGNoaXApOwo+PiAr CXVuc2lnbmVkIGxvbmcgcmF0ZSA9IGNsa19nZXRfcmF0ZShpcHFfY2hpcC0+Y2xrKTsKPj4gKwl1 bnNpZ25lZCBpbnQgcHJlX2RpdiwgcHdtX2RpdiwgaGlfZHVyOwo+PiArCXU2NCBlZmZlY3RpdmVf ZGl2LCBoaV9kaXY7Cj4+ICsJdTMyIHJlZzAsIHJlZzE7Cj4+ICsKPj4gKwlyZWcwID0gaXBxX3B3 bV9yZWdfcmVhZChwd20sIElQUV9QV01fUkVHMCk7Cj4+ICsJcmVnMSA9IGlwcV9wd21fcmVnX3Jl YWQocHdtLCBJUFFfUFdNX1JFRzEpOwo+PiArCj4+ICsJc3RhdGUtPnBvbGFyaXR5ID0gUFdNX1BP TEFSSVRZX05PUk1BTDsKPj4gKwlzdGF0ZS0+ZW5hYmxlZCA9IHJlZzEgJiBJUFFfUFdNX1JFRzFf RU5BQkxFOwo+PiArCj4+ICsJcHdtX2RpdiA9IEZJRUxEX0dFVChJUFFfUFdNX1JFRzBfUFdNX0RJ ViwgcmVnMCk7Cj4+ICsJaGlfZHVyID0gRklFTERfR0VUKElQUV9QV01fUkVHMF9ISV9EVVJBVElP TiwgcmVnMCk7Cj4+ICsJcHJlX2RpdiA9IEZJRUxEX0dFVChJUFFfUFdNX1JFRzFfUFJFX0RJViwg cmVnMSk7Cj4+ICsKPj4gKwkvKiBObyBvdmVyZmxvdyBoZXJlLCBib3RoIHByZV9kaXYgYW5kIHB3 bV9kaXYgPD0gMHhmZmZmICovCj4+ICsJZWZmZWN0aXZlX2RpdiA9ICh1NjQpKHByZV9kaXYgKyAx KSAqIChwd21fZGl2ICsgMSk7Cj4+ICsJc3RhdGUtPnBlcmlvZCA9IERJVjY0X1U2NF9ST1VORF9V UChlZmZlY3RpdmVfZGl2ICogTlNFQ19QRVJfU0VDLCByYXRlKTsKPj4gKwo+PiArCWhpX2RpdiA9 IGhpX2R1ciAqIChwcmVfZGl2ICsgMSk7Cj4+ICsJc3RhdGUtPmR1dHlfY3ljbGUgPSBESVY2NF9V NjRfUk9VTkRfVVAoaGlfZGl2ICogTlNFQ19QRVJfU0VDLCByYXRlKTsKPj4gK30KPj4gKwo+PiAr c3RhdGljIGNvbnN0IHN0cnVjdCBwd21fb3BzIGlwcV9wd21fb3BzID0gewo+PiArCS5hcHBseSA9 IGlwcV9wd21fYXBwbHksCj4+ICsJLmdldF9zdGF0ZSA9IGlwcV9wd21fZ2V0X3N0YXRlLAo+PiAr CS5vd25lciA9IFRISVNfTU9EVUxFLAo+PiArfTsKPj4gKwo+PiArc3RhdGljIGludCBpcHFfcHdt X3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4+ICt7Cj4+ICsJc3RydWN0IGlw cV9wd21fY2hpcCAqcHdtOwo+PiArCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7Cj4+ ICsJaW50IHJldDsKPj4gKwo+PiArCXB3bSA9IGRldm1fa3phbGxvYyhkZXYsIHNpemVvZigqcHdt KSwgR0ZQX0tFUk5FTCk7Cj4+ICsJaWYgKCFwd20pCj4+ICsJCXJldHVybiAtRU5PTUVNOwo+PiAr Cj4+ICsJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgcHdtKTsKPj4gKwo+PiArCXB3bS0+bWVt ID0gZGV2bV9wbGF0Zm9ybV9pb3JlbWFwX3Jlc291cmNlKHBkZXYsIDApOwo+PiArCWlmIChJU19F UlIocHdtLT5tZW0pKQo+PiArCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIFBUUl9FUlIocHdt LT5tZW0pLAo+PiArCQkJCSJyZWdzIG1hcCBmYWlsZWQiKTsKPj4gKwo+PiArCXB3bS0+Y2xrID0g ZGV2bV9jbGtfZ2V0KGRldiwgTlVMTCk7Cj4+ICsJaWYgKElTX0VSUihwd20tPmNsaykpCj4+ICsJ CXJldHVybiBkZXZfZXJyX3Byb2JlKGRldiwgUFRSX0VSUihwd20tPmNsayksCj4+ICsJCQkJImZh aWxlZCB0byBnZXQgY2xvY2siKTsKPj4gKwo+PiArCXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShw d20tPmNsayk7Cj4+ICsJaWYgKHJldCkKPj4gKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoZGV2LCBy ZXQsICJjbG9jayBlbmFibGUgZmFpbGVkIik7Cj4+ICsKPj4gKwlwd20tPmNoaXAuZGV2ID0gZGV2 Owo+PiArCXB3bS0+Y2hpcC5vcHMgPSAmaXBxX3B3bV9vcHM7Cj4+ICsJcHdtLT5jaGlwLm5wd20g PSA0Owo+PiArCj4+ICsJcmV0ID0gcHdtY2hpcF9hZGQoJnB3bS0+Y2hpcCk7Cj4+ICsJaWYgKHJl dCA8IDApIHsKPj4gKwkJZGV2X2Vycl9wcm9iZShkZXYsIHJldCwgInB3bWNoaXBfYWRkKCkgZmFp bGVkXG4iKTsKPj4gKwkJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHB3bS0+Y2xrKTsKPj4gKwl9Cj4+ ICsKPj4gKwlyZXR1cm4gcmV0Owo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW50IGlwcV9wd21fcmVt b3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4+ICt7Cj4+ICsJc3RydWN0IGlwcV9w d21fY2hpcCAqcHdtID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7Cj4+ICsKPj4gKwlwd21j aGlwX3JlbW92ZSgmcHdtLT5jaGlwKTsKPj4gKwljbGtfZGlzYWJsZV91bnByZXBhcmUocHdtLT5j bGspOwo+PiArCj4+ICsJcmV0dXJuIDA7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBjb25zdCBzdHJ1 Y3Qgb2ZfZGV2aWNlX2lkIHB3bV9pcHFfZHRfbWF0Y2hbXSA9IHsKPj4gKwl7IC5jb21wYXRpYmxl ID0gInFjb20saXBxNjAxOC1wd20iLCB9LAo+PiArCXt9Cj4+ICt9Owo+PiArTU9EVUxFX0RFVklD RV9UQUJMRShvZiwgcHdtX2lwcV9kdF9tYXRjaCk7Cj4+ICsKPj4gK3N0YXRpYyBzdHJ1Y3QgcGxh dGZvcm1fZHJpdmVyIGlwcV9wd21fZHJpdmVyID0gewo+PiArCS5kcml2ZXIgPSB7Cj4+ICsJCS5u YW1lID0gImlwcS1wd20iLAo+PiArCQkub2ZfbWF0Y2hfdGFibGUgPSBwd21faXBxX2R0X21hdGNo LAo+PiArCX0sCj4+ICsJLnByb2JlID0gaXBxX3B3bV9wcm9iZSwKPj4gKwkucmVtb3ZlID0gaXBx X3B3bV9yZW1vdmUsCj4+ICt9Owo+PiArCj4+ICttb2R1bGVfcGxhdGZvcm1fZHJpdmVyKGlwcV9w d21fZHJpdmVyKTsKPj4gKwo+PiArTU9EVUxFX0xJQ0VOU0UoIkR1YWwgQlNEL0dQTCIpOwoKCi0t IAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH4u IC5+ICAgVGsgT3BlbiBTeXN0ZW1zCj19LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tb29PLS1VLS1Pb28tLS0tLS0tLS0tLS17PQogICAtIGJhcnVjaEB0a29z LmNvLmlsIC0gdGVsOiArOTcyLjUyLjM2OC40NjU2LCBodHRwOi8vd3d3LnRrb3MuY28uaWwgLQoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJt LWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3Jn Cmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtl cm5lbAo=