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 26D87C3ABC3 for ; Mon, 12 May 2025 22:42:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:Content-Transfer-Encoding: Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Subject:Cc:To: From:Date:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=WaQGhR/rRR1Brp8HCcUjM3Mn+GnR6GwcEYrZBzL9V3g=; b=g0drdWObKwz6rJhHpbZZy/KPEU +RjaqOkRiEou58BO3WhSaUDtjhxqGG+TNMefLYQUVaaw933KJzd2CQrEGIj6ZzHYZyuUvStGaJPy4 g8qLi91PI2ivaVHAnohK1eJ6W80KJcTYl5a0cecD3G7Bki1C8Eq9MPbO7UbbOfiEvNl/cdD03RaIK Bs0IwEHKctkdsnWuPtBYfhRGwqbnsGMs27TERgQKBPuB2zxYzT1qA6t6JPV1LG134lpkzOIPwrVdo ipCik95D9MEkgVg6BmXVZ8k978xhi7O94Ck9932kfMcwEr+93QiYR7dncInrDjTsQF0j9z3iXtfYK 3WRV0j6Q==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1uEbqc-0000000ArTi-3897; Mon, 12 May 2025 22:42:10 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1uEboZ-0000000ArGn-3Cvf; Mon, 12 May 2025 22:40:05 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 773C9150C; Mon, 12 May 2025 15:39:47 -0700 (PDT) Received: from minigeek.lan (usa-sjc-mx-foss1.foss.arm.com [172.31.20.19]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id F3FA73F63F; Mon, 12 May 2025 15:39:55 -0700 (PDT) Date: Mon, 12 May 2025 23:39:44 +0100 From: Andre Przywara To: Aleksandr Shubin Cc: linux-kernel@vger.kernel.org, Brandon Cheo Fusi , Uwe =?UTF-8?B?S2xlaW5lLUvDtm5pZw==?= , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , Philipp Zabel , linux-pwm@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sunxi@lists.linux.dev, linux-riscv@lists.infradead.org Subject: Re: [PATCH v12 2/3] pwm: Add Allwinner's D1/T113-S3/R329 SoCs PWM support Message-ID: <20250512233944.06bc1cb7@minigeek.lan> In-Reply-To: <20250427142500.151925-3-privatesub2@gmail.com> References: <20250427142500.151925-1-privatesub2@gmail.com> <20250427142500.151925-3-privatesub2@gmail.com> Organization: Arm Ltd. X-Mailer: Claws Mail 4.2.0 (GTK 3.24.31; x86_64-slackware-linux-gnu) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250512_154003_902573_104E5763 X-CRM114-Status: GOOD ( 46.74 ) 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: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org On Sun, 27 Apr 2025 17:24:54 +0300 Aleksandr Shubin wrote: Hi Aleksandr, thanks for your patience and persistence with this series! It seems like some people have some motivation now for getting mainline, so hopefully we can use this momentum now. Also the "new" Allwinner A523 uses the same IP as the D1, just with all 16 channels.=20 > Allwinner's D1, T113-S3 and R329 SoCs have a quite different PWM > controllers with ones supported by pwm-sun4i driver. >=20 > This patch adds a PWM controller driver for Allwinner's D1, > T113-S3 and R329 SoCs. The main difference between these SoCs > is the number of channels defined by the DT property. >=20 > Co-developed-by: Brandon Cheo Fusi > Signed-off-by: Brandon Cheo Fusi > Signed-off-by: Aleksandr Shubin > --- > drivers/pwm/Kconfig | 10 ++ > drivers/pwm/Makefile | 1 + > drivers/pwm/pwm-sun20i.c | 379 +++++++++++++++++++++++++++++++++++++++ > 3 files changed, 390 insertions(+) > create mode 100644 drivers/pwm/pwm-sun20i.c >=20 > diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig > index 4731d5b90d7e..230a5561385b 100644 > --- a/drivers/pwm/Kconfig > +++ b/drivers/pwm/Kconfig > @@ -662,6 +662,16 @@ config PWM_SUN4I > To compile this driver as a module, choose M here: the module > will be called pwm-sun4i. > =20 > +config PWM_SUN20I > + tristate "Allwinner D1/T113s/R329 PWM support" > + depends on ARCH_SUNXI || COMPILE_TEST > + depends on COMMON_CLK > + help > + Generic PWM framework driver for Allwinner D1/T113s/R329 SoCs. > + > + To compile this driver as a module, choose M here: the module > + will be called pwm-sun20i. > + > config PWM_SUNPLUS > tristate "Sunplus PWM support" > depends on ARCH_SUNPLUS || COMPILE_TEST > diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile > index 539e0def3f82..ef7515d2f974 100644 > --- a/drivers/pwm/Makefile > +++ b/drivers/pwm/Makefile > @@ -61,6 +61,7 @@ obj-$(CONFIG_PWM_STM32) +=3D pwm-stm32.o > obj-$(CONFIG_PWM_STM32_LP) +=3D pwm-stm32-lp.o > obj-$(CONFIG_PWM_STMPE) +=3D pwm-stmpe.o > obj-$(CONFIG_PWM_SUN4I) +=3D pwm-sun4i.o > +obj-$(CONFIG_PWM_SUN20I) +=3D pwm-sun20i.o > obj-$(CONFIG_PWM_SUNPLUS) +=3D pwm-sunplus.o > obj-$(CONFIG_PWM_TEGRA) +=3D pwm-tegra.o > obj-$(CONFIG_PWM_TIECAP) +=3D pwm-tiecap.o > diff --git a/drivers/pwm/pwm-sun20i.c b/drivers/pwm/pwm-sun20i.c > new file mode 100644 > index 000000000000..22486617f1ef > --- /dev/null > +++ b/drivers/pwm/pwm-sun20i.c > @@ -0,0 +1,379 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * PWM Controller Driver for sunxi platforms (D1, T113-S3 and R329) > + * > + * Limitations: > + * - When the parameters change, the current running period is not compl= eted > + * and new settings are applied immediately. > + * - The PWM output goes to a HIGH-Z state when the channel is disabled. > + * - Changing the clock configuration (SUN20I_PWM_CLK_CFG) > + * may cause a brief output glitch. > + * > + * Copyright (c) 2023 Aleksandr Shubin > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#define SUN20I_PWM_CLK_CFG(pair) (0x20 + ((pair) * 0x4)) > +#define SUN20I_PWM_CLK_CFG_SRC GENMASK(8, 7) > +#define SUN20I_PWM_CLK_CFG_DIV_M GENMASK(3, 0) > +#define SUN20I_PWM_CLK_DIV_M_MAX 8 > + > +#define SUN20I_PWM_CLK_GATE 0x40 > +#define SUN20I_PWM_CLK_GATE_BYPASS(chan) BIT((chan) + 16) > +#define SUN20I_PWM_CLK_GATE_GATING(chan) BIT(chan) > + > +#define SUN20I_PWM_ENABLE 0x80 > +#define SUN20I_PWM_ENABLE_EN(chan) BIT(chan) > + > +#define SUN20I_PWM_CTL(chan) (0x100 + (chan) * 0x20) > +#define SUN20I_PWM_CTL_ACT_STA BIT(8) > +#define SUN20I_PWM_CTL_PRESCAL_K GENMASK(7, 0) > +#define SUN20I_PWM_CTL_PRESCAL_K_MAX field_max(SUN20I_PWM_CTL_PRESCAL_K) > + > +#define SUN20I_PWM_PERIOD(chan) (0x104 + (chan) * 0x20) > +#define SUN20I_PWM_PERIOD_ENTIRE_CYCLE GENMASK(31, 16) > +#define SUN20I_PWM_PERIOD_ACT_CYCLE GENMASK(15, 0) > + > +#define SUN20I_PWM_PCNTR_SIZE BIT(16) > + > +/* > + * SUN20I_PWM_MAGIC is used to quickly compute the values of the clock d= ividers > + * div_m (SUN20I_PWM_CLK_CFG_DIV_M) & prescale_k (SUN20I_PWM_CTL_PRESCAL= _K) > + * without using a loop. These dividers limit the # of cycles in a period > + * to SUN20I_PWM_PCNTR_SIZE (65536) by applying a scaling factor of > + * 1/(div_m * (prescale_k + 1)) to the clock source. > + * > + * SUN20I_PWM_MAGIC is derived by solving for div_m and prescale_k > + * such that for a given requested period, > + * > + * i) div_m is minimized for any prescale_k =E2=89=A4 SUN20I_PWM_CTL_PRE= SCAL_K_MAX, > + * ii) prescale_k is minimized. > + * > + * The derivation proceeds as follows, with val =3D # of cycles for requ= ested > + * period: > + * > + * for a given value of div_m we want the smallest prescale_k such that > + * > + * (val >> div_m) // (prescale_k + 1) =E2=89=A4 65536 (=3D SUN20I_PWM_PC= NTR_SIZE) > + * > + * This is equivalent to: > + * > + * (val >> div_m) =E2=89=A4 65536 * (prescale_k + 1) + prescale_k > + * =E2=9F=BA (val >> div_m) =E2=89=A4 65537 * prescale_k + 65536 > + * =E2=9F=BA (val >> div_m) - 65536 =E2=89=A4 65537 * prescale_k > + * =E2=9F=BA ((val >> div_m) - 65536) / 65537 =E2=89=A4 prescale_k > + * > + * As prescale_k is integer, this becomes > + * > + * ((val >> div_m) - 65536) // 65537 =E2=89=A4 prescale_k > + * > + * And is minimized at > + * > + * ((val >> div_m) - 65536) // 65537 > + * > + * Now we pick the smallest div_m that satifies prescale_k =E2=89=A4 255 > + * (i.e SUN20I_PWM_CTL_PRESCAL_K_MAX), > + * > + * ((val >> div_m) - 65536) // 65537 =E2=89=A4 255 > + * =E2=9F=BA (val >> div_m) - 65536 =E2=89=A4 255 * 65537 + 65536 > + * =E2=9F=BA val >> div_m =E2=89=A4 255 * 65537 + 2 * 65536 > + * =E2=9F=BA val >> div_m < (255 * 65537 + 2 * 65536 + 1) > + * =E2=9F=BA div_m =3D fls((val) / (255 * 65537 + 2 * 65536 + 1)) > + * > + * Suggested by Uwe Kleine-K=C3=B6nig > + */ > +#define SUN20I_PWM_MAGIC (255 * 65537 + 2 * 65536 + 1) > +#define SUN20I_PWM_DIV_CONST 65537 > + > +struct sun20i_pwm_chip { > + struct clk *clk_hosc, *clk_apb; > + void __iomem *base; > +}; > + > +static inline struct sun20i_pwm_chip *to_sun20i_pwm_chip(struct pwm_chip= *chip) > +{ > + return pwmchip_get_drvdata(chip); > +} > + > +static inline u32 sun20i_pwm_readl(struct sun20i_pwm_chip *chip, > + unsigned long offset) > +{ > + return readl(chip->base + offset); > +} > + > +static inline void sun20i_pwm_writel(struct sun20i_pwm_chip *chip, > + u32 val, unsigned long offset) > +{ > + writel(val, chip->base + offset); > +} > + > +static int sun20i_pwm_get_state(struct pwm_chip *chip, > + struct pwm_device *pwm, > + struct pwm_state *state) > +{ > + struct sun20i_pwm_chip *sun20i_chip =3D to_sun20i_pwm_chip(chip); > + u16 ent_cycle, act_cycle, prescale_k; > + u64 clk_rate, tmp; > + u8 div_m; > + u32 val; > + > + val =3D sun20i_pwm_readl(sun20i_chip, SUN20I_PWM_CLK_CFG(pwm->hwpwm / 2= )); > + div_m =3D FIELD_GET(SUN20I_PWM_CLK_CFG_DIV_M, val); > + if (div_m > SUN20I_PWM_CLK_DIV_M_MAX) > + div_m =3D SUN20I_PWM_CLK_DIV_M_MAX; > + > + /* > + * If CLK_CFG_SRC is 0, use the hosc clock; > + * otherwise (any nonzero value) use the APB clock. > + */ > + if (FIELD_GET(SUN20I_PWM_CLK_CFG_SRC, val) =3D=3D 0) > + clk_rate =3D clk_get_rate(sun20i_chip->clk_hosc); > + else > + clk_rate =3D clk_get_rate(sun20i_chip->clk_apb); > + > + val =3D sun20i_pwm_readl(sun20i_chip, SUN20I_PWM_CTL(pwm->hwpwm)); > + state->polarity =3D (SUN20I_PWM_CTL_ACT_STA & val) ? > + PWM_POLARITY_NORMAL : PWM_POLARITY_INVERSED; > + > + prescale_k =3D FIELD_GET(SUN20I_PWM_CTL_PRESCAL_K, val) + 1; > + > + val =3D sun20i_pwm_readl(sun20i_chip, SUN20I_PWM_ENABLE); > + state->enabled =3D (SUN20I_PWM_ENABLE_EN(pwm->hwpwm) & val) ? true : fa= lse; > + > + val =3D sun20i_pwm_readl(sun20i_chip, SUN20I_PWM_PERIOD(pwm->hwpwm)); > + act_cycle =3D FIELD_GET(SUN20I_PWM_PERIOD_ACT_CYCLE, val); > + > + ent_cycle =3D FIELD_GET(SUN20I_PWM_PERIOD_ENTIRE_CYCLE, val); > + > + /* > + * The duration of the active phase should not be longer > + * than the duration of the period > + */ > + if (act_cycle > ent_cycle) > + act_cycle =3D ent_cycle; > + > + /* > + * We have act_cycle <=3D ent_cycle <=3D 0xffff, prescale_k <=3D 0x100, > + * div_m <=3D 8. So the multiplication fits into an u64 without > + * overflow. > + */ > + tmp =3D ((u64)(act_cycle) * prescale_k << div_m) * NSEC_PER_SEC; > + state->duty_cycle =3D DIV_ROUND_UP_ULL(tmp, clk_rate); > + tmp =3D ((u64)(ent_cycle) * prescale_k << div_m) * NSEC_PER_SEC; > + state->period =3D DIV_ROUND_UP_ULL(tmp, clk_rate); > + > + return 0; > +} > + > +static int sun20i_pwm_apply(struct pwm_chip *chip, struct pwm_device *pw= m, > + const struct pwm_state *state) > +{ > + struct sun20i_pwm_chip *sun20i_chip =3D to_sun20i_pwm_chip(chip); > + u64 bus_rate, hosc_rate, val, ent_cycle, act_cycle; > + u32 clk_gate, clk_cfg, pwm_en, ctl, reg_period; > + u32 prescale_k, div_m; > + bool use_bus_clk; > + > + pwm_en =3D sun20i_pwm_readl(sun20i_chip, SUN20I_PWM_ENABLE); > + clk_gate =3D sun20i_pwm_readl(sun20i_chip, SUN20I_PWM_CLK_GATE); > + > + if (!state->enabled) { > + if (state->enabled !=3D pwm->state.enabled) { > + clk_gate &=3D ~SUN20I_PWM_CLK_GATE_GATING(pwm->hwpwm); > + pwm_en &=3D ~SUN20I_PWM_ENABLE_EN(pwm->hwpwm); > + sun20i_pwm_writel(sun20i_chip, pwm_en, SUN20I_PWM_ENABLE); > + sun20i_pwm_writel(sun20i_chip, clk_gate, SUN20I_PWM_CLK_GATE); > + } > + return 0; > + } > + > + ctl =3D sun20i_pwm_readl(sun20i_chip, SUN20I_PWM_CTL(pwm->hwpwm)); > + clk_cfg =3D sun20i_pwm_readl(sun20i_chip, SUN20I_PWM_CLK_CFG(pwm->hwpwm= / 2)); > + hosc_rate =3D clk_get_rate(sun20i_chip->clk_hosc); > + bus_rate =3D clk_get_rate(sun20i_chip->clk_apb); > + if (pwm_en & SUN20I_PWM_ENABLE_EN(pwm->hwpwm ^ 1)) { > + /* If the neighbor channel is enabled, use the current clock settings = */ > + use_bus_clk =3D FIELD_GET(SUN20I_PWM_CLK_CFG_SRC, clk_cfg) !=3D 0; > + val =3D mul_u64_u64_div_u64(state->period, > + (use_bus_clk ? bus_rate : hosc_rate), > + NSEC_PER_SEC); > + > + div_m =3D FIELD_GET(SUN20I_PWM_CLK_CFG_DIV_M, clk_cfg); > + } else { > + /* > + * Select the clock source based on the period. > + * Since bus_rate > hosc_rate, which means bus_rate > + * can provide a higher frequency than hosc_rate. What does that mean, exactly? That we should prefer the faster clock? Because that's not what the code does, is it? > + */ > + use_bus_clk =3D false; > + val =3D mul_u64_u64_div_u64(state->period, hosc_rate, NSEC_PER_SEC); > + /* > + * If the calculated value is =E2=89=A4 1, the period is too short > + * for proper PWM operation > + */ > + if (val <=3D 1) { So if I get the code correctly, it prefers HOSC over APB? Is that really the best way? Shouldn't it be the other way around: we use the faster clock, since this will not limit the sibling channel? And another thing to consider are rounding errors due to integer division: certain period rates might be better achievable with one or the other source clock: 3 MHz works best as 24MHz/8, 3.125MHz as 100MHz/32. So shall we calculate the values and compare the errors instead? Oh, and also we need to consider bypassing, I feel like this should be checked first. In any case I think there should be a comment describing the strategy and give some rationale, I think. > + use_bus_clk =3D true; > + val =3D mul_u64_u64_div_u64(state->period, bus_rate, NSEC_PER_SEC); > + if (val <=3D 1) > + return -EINVAL; > + } > + div_m =3D fls(DIV_ROUND_DOWN_ULL(val, SUN20I_PWM_MAGIC)); > + if (div_m > SUN20I_PWM_CLK_DIV_M_MAX) > + return -EINVAL; > + > + /* Set up the CLK_DIV_M and clock CLK_SRC */ > + clk_cfg =3D FIELD_PREP(SUN20I_PWM_CLK_CFG_DIV_M, div_m); > + clk_cfg |=3D FIELD_PREP(SUN20I_PWM_CLK_CFG_SRC, use_bus_clk); > + > + sun20i_pwm_writel(sun20i_chip, clk_cfg, SUN20I_PWM_CLK_CFG(pwm->hwpwm = / 2)); > + } > + > + /* Calculate prescale_k and determine the number of cycles for a full P= WM period */ > + ent_cycle =3D val >> div_m; > + prescale_k =3D DIV_ROUND_DOWN_ULL(ent_cycle, SUN20I_PWM_DIV_CONST); > + if (prescale_k > SUN20I_PWM_CTL_PRESCAL_K_MAX) > + prescale_k =3D SUN20I_PWM_CTL_PRESCAL_K_MAX; > + > + do_div(ent_cycle, prescale_k + 1); > + > + /* ent_cycle must not be zero */ > + if (ent_cycle =3D=3D 0) > + return -EINVAL; > + > + /* For N cycles, PPRx.PWM_ENTIRE_CYCLE =3D (N-1) */ > + reg_period =3D FIELD_PREP(SUN20I_PWM_PERIOD_ENTIRE_CYCLE, ent_cycle - 1= ); > + > + /* Calculate the active cycles (duty cycle) */ > + val =3D mul_u64_u64_div_u64(state->duty_cycle, > + (use_bus_clk ? bus_rate : hosc_rate), > + NSEC_PER_SEC); > + act_cycle =3D val >> div_m; > + do_div(act_cycle, prescale_k + 1); > + > + /* > + * The formula of the output period and the duty-cycle for PWM are as f= ollows. > + * T period =3D PWM0_PRESCALE_K / PWM01_CLK * (PPR0.PWM_ENTIRE_CYCLE + = 1) > + * T high-level =3D PWM0_PRESCALE_K / PWM01_CLK * PPR0.PWM_ACT_CYCLE > + * Duty-cycle =3D T high-level / T period > + */ > + reg_period |=3D FIELD_PREP(SUN20I_PWM_PERIOD_ACT_CYCLE, act_cycle); > + sun20i_pwm_writel(sun20i_chip, reg_period, SUN20I_PWM_PERIOD(pwm->hwpwm= )); > + > + ctl =3D FIELD_PREP(SUN20I_PWM_CTL_PRESCAL_K, prescale_k); > + if (state->polarity =3D=3D PWM_POLARITY_NORMAL) > + ctl |=3D SUN20I_PWM_CTL_ACT_STA; > + > + sun20i_pwm_writel(sun20i_chip, ctl, SUN20I_PWM_CTL(pwm->hwpwm)); > + > + if (state->enabled !=3D pwm->state.enabled) { > + clk_gate &=3D ~SUN20I_PWM_CLK_GATE_BYPASS(pwm->hwpwm); > + clk_gate |=3D SUN20I_PWM_CLK_GATE_GATING(pwm->hwpwm); > + pwm_en |=3D SUN20I_PWM_ENABLE_EN(pwm->hwpwm); > + sun20i_pwm_writel(sun20i_chip, pwm_en, SUN20I_PWM_ENABLE); > + sun20i_pwm_writel(sun20i_chip, clk_gate, SUN20I_PWM_CLK_GATE); > + } > + > + return 0; > +} > + > +static const struct pwm_ops sun20i_pwm_ops =3D { > + .apply =3D sun20i_pwm_apply, > + .get_state =3D sun20i_pwm_get_state, > +}; > + > +static const struct of_device_id sun20i_pwm_dt_ids[] =3D { > + { .compatible =3D "allwinner,sun20i-d1-pwm" }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, sun20i_pwm_dt_ids); > + > +static int sun20i_pwm_probe(struct platform_device *pdev) > +{ > + struct pwm_chip *chip; > + struct sun20i_pwm_chip *sun20i_chip; > + struct clk *clk_bus; > + struct reset_control *rst; > + u32 npwm; > + int ret; > + > + ret =3D of_property_read_u32(pdev->dev.of_node, "allwinner,npwms", &npw= m); > + if (ret < 0) > + npwm =3D 8; /* Default value */ > + > + if (npwm > 16) { > + dev_info(&pdev->dev, "Limiting number of PWM lines from %u to 16", npw= m); I don't think we should proceed if the firmware information is clearly wrong. Just bail out with -EINVAL or so here, so that gets fixed in the DT. > + npwm =3D 16; > + } > + > + chip =3D devm_pwmchip_alloc(&pdev->dev, npwm, sizeof(*sun20i_chip)); > + if (IS_ERR(chip)) > + return PTR_ERR(chip); > + sun20i_chip =3D to_sun20i_pwm_chip(chip); > + > + sun20i_chip->base =3D devm_platform_ioremap_resource(pdev, 0); > + if (IS_ERR(sun20i_chip->base)) > + return PTR_ERR(sun20i_chip->base); > + > + clk_bus =3D devm_clk_get_enabled(&pdev->dev, "bus"); > + if (IS_ERR(clk_bus)) > + return dev_err_probe(&pdev->dev, PTR_ERR(clk_bus), > + "Failed to get bus clock\n"); > + > + sun20i_chip->clk_hosc =3D devm_clk_get_enabled(&pdev->dev, "hosc"); > + if (IS_ERR(sun20i_chip->clk_hosc)) > + return dev_err_probe(&pdev->dev, PTR_ERR(sun20i_chip->clk_hosc), > + "Failed to get hosc clock\n"); > + > + ret =3D devm_clk_rate_exclusive_get(&pdev->dev, sun20i_chip->clk_hosc); Just ignoring for a bit that the 24 MHz oscillator is a fixed clock anyway, but why would we want exclusivity already at probe time? Isn't that too limiting, as no one might ever use any PWM channels, but it would still "belong to us"? > + if (ret) > + return dev_err_probe(&pdev->dev, ret, > + "Failed to get hosc exclusive rate\n"); > + > + sun20i_chip->clk_apb =3D devm_clk_get_enabled(&pdev->dev, "apb"); > + if (IS_ERR(sun20i_chip->clk_apb)) > + return dev_err_probe(&pdev->dev, PTR_ERR(sun20i_chip->clk_apb), > + "Failed to get apb clock\n"); > + > + ret =3D devm_clk_rate_exclusive_get(&pdev->dev, sun20i_chip->clk_apb); Just for the records: APB is practically also a fixed clock, set up once in firmware and never changed, since it drives a lot of other peripherals. But same question as above, why do we lock its rate already here? > + if (ret) > + return dev_err_probe(&pdev->dev, ret, > + "Failed to get apb exclusive rate\n"); > + > + if (clk_get_rate(sun20i_chip->clk_apb) <=3D clk_get_rate(sun20i_chip->c= lk_hosc)) > + dev_info(&pdev->dev, "APB clock must be greater than hosc clock"); Why this check? Does the code make any assumptions about this relation? If yes, we must surely deny this and bail out. If not (and I feel we should handle it this way), we can just ignore this and not print anything. Cheers, Andre > + > + rst =3D devm_reset_control_get_exclusive_deasserted(&pdev->dev, NULL); > + if (IS_ERR(rst)) > + return dev_err_probe(&pdev->dev, PTR_ERR(rst), > + "Failed to get reset control\n"); > + > + chip->ops =3D &sun20i_pwm_ops; > + > + ret =3D devm_pwmchip_add(&pdev->dev, chip); > + if (ret < 0) > + return dev_err_probe(&pdev->dev, ret, "Failed to add PWM chip\n"); > + > + return 0; > +} > + > +static struct platform_driver sun20i_pwm_driver =3D { > + .driver =3D { > + .name =3D "sun20i-pwm", > + .of_match_table =3D sun20i_pwm_dt_ids, > + }, > + .probe =3D sun20i_pwm_probe, > +}; > +module_platform_driver(sun20i_pwm_driver); > + > +MODULE_AUTHOR("Aleksandr Shubin "); > +MODULE_DESCRIPTION("Allwinner sun20i PWM driver"); > +MODULE_LICENSE("GPL"); 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 00BD3C3ABCB for ; Mon, 12 May 2025 22:42:20 +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:References:In-Reply-To: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=jE8gopALVKDcpNLiMtdX0G7t8HIEHL8b+SBjcCanEuc=; b=aO7CQ97EareDDo xUlGQZDJajZTVBdB5aaaSbIgFk5uWAzlqUZygsOjzXKFFXDpMsPDRFNzlCqC3MY4Dz7aAla3p7Z99 gkocnZ2s74FtQS+YSegjAdhZ+6ra0DlWqkETIx48Ui0XVsVJJ51Y8hVcnCCVZZj8Psia4e1+MNlYd XwFlY0ylVq/PQGhLptae3rrGAaI8RjW6ppdubzeiSu6DH6XoXDphLJW5fCBfvcPtoT0Nj1fp4Ggk1 fKpOlMFqbTJGz+KPuuXViswyNteSajjcVuo/sTnVTnv/y88vdKR5VLJq6oWy5PVlLBcDqFXZVkMqG iENySIv440ctmUwo3xgg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1uEbqd-0000000ArTo-1BG5; Mon, 12 May 2025 22:42:11 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1uEboZ-0000000ArGn-3Cvf; Mon, 12 May 2025 22:40:05 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 773C9150C; Mon, 12 May 2025 15:39:47 -0700 (PDT) Received: from minigeek.lan (usa-sjc-mx-foss1.foss.arm.com [172.31.20.19]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id F3FA73F63F; Mon, 12 May 2025 15:39:55 -0700 (PDT) Date: Mon, 12 May 2025 23:39:44 +0100 From: Andre Przywara To: Aleksandr Shubin Cc: linux-kernel@vger.kernel.org, Brandon Cheo Fusi , Uwe =?UTF-8?B?S2xlaW5lLUvDtm5pZw==?= , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , Philipp Zabel , linux-pwm@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sunxi@lists.linux.dev, linux-riscv@lists.infradead.org Subject: Re: [PATCH v12 2/3] pwm: Add Allwinner's D1/T113-S3/R329 SoCs PWM support Message-ID: <20250512233944.06bc1cb7@minigeek.lan> In-Reply-To: <20250427142500.151925-3-privatesub2@gmail.com> References: <20250427142500.151925-1-privatesub2@gmail.com> <20250427142500.151925-3-privatesub2@gmail.com> Organization: Arm Ltd. X-Mailer: Claws Mail 4.2.0 (GTK 3.24.31; x86_64-slackware-linux-gnu) MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250512_154003_902573_104E5763 X-CRM114-Status: GOOD ( 46.74 ) X-BeenThere: linux-riscv@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-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org T24gU3VuLCAyNyBBcHIgMjAyNSAxNzoyNDo1NCArMDMwMApBbGVrc2FuZHIgU2h1YmluIDxwcml2 YXRlc3ViMkBnbWFpbC5jb20+IHdyb3RlOgoKSGkgQWxla3NhbmRyLAoKdGhhbmtzIGZvciB5b3Vy IHBhdGllbmNlIGFuZCBwZXJzaXN0ZW5jZSB3aXRoIHRoaXMgc2VyaWVzISBJdCBzZWVtcwpsaWtl IHNvbWUgcGVvcGxlIGhhdmUgc29tZSBtb3RpdmF0aW9uIG5vdyBmb3IgZ2V0dGluZyBtYWlubGlu ZSwgc28KaG9wZWZ1bGx5IHdlIGNhbiB1c2UgdGhpcyBtb21lbnR1bSBub3cuIEFsc28gdGhlICJu ZXciIEFsbHdpbm5lciBBNTIzCnVzZXMgdGhlIHNhbWUgSVAgYXMgdGhlIEQxLCBqdXN0IHdpdGgg YWxsIDE2IGNoYW5uZWxzLiAKCj4gQWxsd2lubmVyJ3MgRDEsIFQxMTMtUzMgYW5kIFIzMjkgU29D cyBoYXZlIGEgcXVpdGUgZGlmZmVyZW50IFBXTQo+IGNvbnRyb2xsZXJzIHdpdGggb25lcyBzdXBw b3J0ZWQgYnkgcHdtLXN1bjRpIGRyaXZlci4KPiAKPiBUaGlzIHBhdGNoIGFkZHMgYSBQV00gY29u dHJvbGxlciBkcml2ZXIgZm9yIEFsbHdpbm5lcidzIEQxLAo+IFQxMTMtUzMgYW5kIFIzMjkgU29D cy4gVGhlIG1haW4gZGlmZmVyZW5jZSBiZXR3ZWVuIHRoZXNlIFNvQ3MKPiBpcyB0aGUgbnVtYmVy IG9mIGNoYW5uZWxzIGRlZmluZWQgYnkgdGhlIERUIHByb3BlcnR5Lgo+IAo+IENvLWRldmVsb3Bl ZC1ieTogQnJhbmRvbiBDaGVvIEZ1c2kgPGZ1c2licmFuZG9uMTNAZ21haWwuY29tPgo+IFNpZ25l ZC1vZmYtYnk6IEJyYW5kb24gQ2hlbyBGdXNpIDxmdXNpYnJhbmRvbjEzQGdtYWlsLmNvbT4KPiBT aWduZWQtb2ZmLWJ5OiBBbGVrc2FuZHIgU2h1YmluIDxwcml2YXRlc3ViMkBnbWFpbC5jb20+Cj4g LS0tCj4gIGRyaXZlcnMvcHdtL0tjb25maWcgICAgICB8ICAxMCArKwo+ICBkcml2ZXJzL3B3bS9N YWtlZmlsZSAgICAgfCAgIDEgKwo+ICBkcml2ZXJzL3B3bS9wd20tc3VuMjBpLmMgfCAzNzkgKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gIDMgZmlsZXMgY2hhbmdlZCwg MzkwIGluc2VydGlvbnMoKykKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvcHdtL3B3bS1z dW4yMGkuYwo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3B3bS9LY29uZmlnIGIvZHJpdmVycy9w d20vS2NvbmZpZwo+IGluZGV4IDQ3MzFkNWI5MGQ3ZS4uMjMwYTU1NjEzODViIDEwMDY0NAo+IC0t LSBhL2RyaXZlcnMvcHdtL0tjb25maWcKPiArKysgYi9kcml2ZXJzL3B3bS9LY29uZmlnCj4gQEAg LTY2Miw2ICs2NjIsMTYgQEAgY29uZmlnIFBXTV9TVU40SQo+ICAJICBUbyBjb21waWxlIHRoaXMg ZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9vc2UgTSBoZXJlOiB0aGUgbW9kdWxlCj4gIAkgIHdpbGwg YmUgY2FsbGVkIHB3bS1zdW40aS4KPiAgCj4gK2NvbmZpZyBQV01fU1VOMjBJCj4gKwl0cmlzdGF0 ZSAiQWxsd2lubmVyIEQxL1QxMTNzL1IzMjkgUFdNIHN1cHBvcnQiCj4gKwlkZXBlbmRzIG9uIEFS Q0hfU1VOWEkgfHwgQ09NUElMRV9URVNUCj4gKwlkZXBlbmRzIG9uIENPTU1PTl9DTEsKPiArCWhl bHAKPiArCSAgR2VuZXJpYyBQV00gZnJhbWV3b3JrIGRyaXZlciBmb3IgQWxsd2lubmVyIEQxL1Qx MTNzL1IzMjkgU29Dcy4KPiArCj4gKwkgIFRvIGNvbXBpbGUgdGhpcyBkcml2ZXIgYXMgYSBtb2R1 bGUsIGNob29zZSBNIGhlcmU6IHRoZSBtb2R1bGUKPiArCSAgd2lsbCBiZSBjYWxsZWQgcHdtLXN1 bjIwaS4KPiArCj4gIGNvbmZpZyBQV01fU1VOUExVUwo+ICAJdHJpc3RhdGUgIlN1bnBsdXMgUFdN IHN1cHBvcnQiCj4gIAlkZXBlbmRzIG9uIEFSQ0hfU1VOUExVUyB8fCBDT01QSUxFX1RFU1QKPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9wd20vTWFrZWZpbGUgYi9kcml2ZXJzL3B3bS9NYWtlZmlsZQo+ IGluZGV4IDUzOWUwZGVmM2Y4Mi4uZWY3NTE1ZDJmOTc0IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMv cHdtL01ha2VmaWxlCj4gKysrIGIvZHJpdmVycy9wd20vTWFrZWZpbGUKPiBAQCAtNjEsNiArNjEs NyBAQCBvYmotJChDT05GSUdfUFdNX1NUTTMyKQkJKz0gcHdtLXN0bTMyLm8KPiAgb2JqLSQoQ09O RklHX1BXTV9TVE0zMl9MUCkJKz0gcHdtLXN0bTMyLWxwLm8KPiAgb2JqLSQoQ09ORklHX1BXTV9T VE1QRSkJCSs9IHB3bS1zdG1wZS5vCj4gIG9iai0kKENPTkZJR19QV01fU1VONEkpCQkrPSBwd20t c3VuNGkubwo+ICtvYmotJChDT05GSUdfUFdNX1NVTjIwSSkJKz0gcHdtLXN1bjIwaS5vCj4gIG9i ai0kKENPTkZJR19QV01fU1VOUExVUykJKz0gcHdtLXN1bnBsdXMubwo+ICBvYmotJChDT05GSUdf UFdNX1RFR1JBKQkJKz0gcHdtLXRlZ3JhLm8KPiAgb2JqLSQoQ09ORklHX1BXTV9USUVDQVApCSs9 IHB3bS10aWVjYXAubwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3B3bS9wd20tc3VuMjBpLmMgYi9k cml2ZXJzL3B3bS9wd20tc3VuMjBpLmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAw MDAwMDAwMDAwMC4uMjI0ODY2MTdmMWVmCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMv cHdtL3B3bS1zdW4yMGkuYwo+IEBAIC0wLDAgKzEsMzc5IEBACj4gKy8vIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wCj4gKy8qCj4gKyAqIFBXTSBDb250cm9sbGVyIERyaXZlciBmb3Ig c3VueGkgcGxhdGZvcm1zIChEMSwgVDExMy1TMyBhbmQgUjMyOSkKPiArICoKPiArICogTGltaXRh dGlvbnM6Cj4gKyAqIC0gV2hlbiB0aGUgcGFyYW1ldGVycyBjaGFuZ2UsIHRoZSBjdXJyZW50IHJ1 bm5pbmcgcGVyaW9kIGlzIG5vdCBjb21wbGV0ZWQKPiArICogICBhbmQgbmV3IHNldHRpbmdzIGFy ZSBhcHBsaWVkIGltbWVkaWF0ZWx5Lgo+ICsgKiAtIFRoZSBQV00gb3V0cHV0IGdvZXMgdG8gYSBI SUdILVogc3RhdGUgd2hlbiB0aGUgY2hhbm5lbCBpcyBkaXNhYmxlZC4KPiArICogLSBDaGFuZ2lu ZyB0aGUgY2xvY2sgY29uZmlndXJhdGlvbiAoU1VOMjBJX1BXTV9DTEtfQ0ZHKQo+ICsgKiAgIG1h eSBjYXVzZSBhIGJyaWVmIG91dHB1dCBnbGl0Y2guCj4gKyAqCj4gKyAqIENvcHlyaWdodCAoYykg MjAyMyBBbGVrc2FuZHIgU2h1YmluIDxwcml2YXRlc3ViMkBnbWFpbC5jb20+Cj4gKyAqLwo+ICsK PiArI2luY2x1ZGUgPGxpbnV4L2JpdGZpZWxkLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9jbGsuaD4K PiArI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgo+ICsjaW5jbHVkZSA8bGludXgvaW8uaD4KPiArI2lu Y2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvb2YuaD4KPiArI2luY2x1 ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvcHdtLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9yZXNldC5oPgo+ICsKPiArI2RlZmluZSBTVU4yMElfUFdNX0NMS19D RkcocGFpcikJCSgweDIwICsgKChwYWlyKSAqIDB4NCkpCj4gKyNkZWZpbmUgU1VOMjBJX1BXTV9D TEtfQ0ZHX1NSQwkJCUdFTk1BU0soOCwgNykKPiArI2RlZmluZSBTVU4yMElfUFdNX0NMS19DRkdf RElWX00JCUdFTk1BU0soMywgMCkKPiArI2RlZmluZSBTVU4yMElfUFdNX0NMS19ESVZfTV9NQVgJ CTgKPiArCj4gKyNkZWZpbmUgU1VOMjBJX1BXTV9DTEtfR0FURQkJCTB4NDAKPiArI2RlZmluZSBT VU4yMElfUFdNX0NMS19HQVRFX0JZUEFTUyhjaGFuKQlCSVQoKGNoYW4pICsgMTYpCj4gKyNkZWZp bmUgU1VOMjBJX1BXTV9DTEtfR0FURV9HQVRJTkcoY2hhbikJQklUKGNoYW4pCj4gKwo+ICsjZGVm aW5lIFNVTjIwSV9QV01fRU5BQkxFCQkJMHg4MAo+ICsjZGVmaW5lIFNVTjIwSV9QV01fRU5BQkxF X0VOKGNoYW4pCQlCSVQoY2hhbikKPiArCj4gKyNkZWZpbmUgU1VOMjBJX1BXTV9DVEwoY2hhbikJ CQkoMHgxMDAgKyAoY2hhbikgKiAweDIwKQo+ICsjZGVmaW5lIFNVTjIwSV9QV01fQ1RMX0FDVF9T VEEJCQlCSVQoOCkKPiArI2RlZmluZSBTVU4yMElfUFdNX0NUTF9QUkVTQ0FMX0sJCUdFTk1BU0so NywgMCkKPiArI2RlZmluZSBTVU4yMElfUFdNX0NUTF9QUkVTQ0FMX0tfTUFYCQlmaWVsZF9tYXgo U1VOMjBJX1BXTV9DVExfUFJFU0NBTF9LKQo+ICsKPiArI2RlZmluZSBTVU4yMElfUFdNX1BFUklP RChjaGFuKQkJCSgweDEwNCArIChjaGFuKSAqIDB4MjApCj4gKyNkZWZpbmUgU1VOMjBJX1BXTV9Q RVJJT0RfRU5USVJFX0NZQ0xFCQlHRU5NQVNLKDMxLCAxNikKPiArI2RlZmluZSBTVU4yMElfUFdN X1BFUklPRF9BQ1RfQ1lDTEUJCUdFTk1BU0soMTUsIDApCj4gKwo+ICsjZGVmaW5lIFNVTjIwSV9Q V01fUENOVFJfU0laRQkJCUJJVCgxNikKPiArCj4gKy8qCj4gKyAqIFNVTjIwSV9QV01fTUFHSUMg aXMgdXNlZCB0byBxdWlja2x5IGNvbXB1dGUgdGhlIHZhbHVlcyBvZiB0aGUgY2xvY2sgZGl2aWRl cnMKPiArICogZGl2X20gKFNVTjIwSV9QV01fQ0xLX0NGR19ESVZfTSkgJiBwcmVzY2FsZV9rIChT VU4yMElfUFdNX0NUTF9QUkVTQ0FMX0spCj4gKyAqIHdpdGhvdXQgdXNpbmcgYSBsb29wLiBUaGVz ZSBkaXZpZGVycyBsaW1pdCB0aGUgIyBvZiBjeWNsZXMgaW4gYSBwZXJpb2QKPiArICogdG8gU1VO MjBJX1BXTV9QQ05UUl9TSVpFICg2NTUzNikgYnkgYXBwbHlpbmcgYSBzY2FsaW5nIGZhY3RvciBv Zgo+ICsgKiAxLyhkaXZfbSAqIChwcmVzY2FsZV9rICsgMSkpIHRvIHRoZSBjbG9jayBzb3VyY2Uu Cj4gKyAqCj4gKyAqIFNVTjIwSV9QV01fTUFHSUMgaXMgZGVyaXZlZCBieSBzb2x2aW5nIGZvciBk aXZfbSBhbmQgcHJlc2NhbGVfawo+ICsgKiBzdWNoIHRoYXQgZm9yIGEgZ2l2ZW4gcmVxdWVzdGVk IHBlcmlvZCwKPiArICoKPiArICogaSkgZGl2X20gaXMgbWluaW1pemVkIGZvciBhbnkgcHJlc2Nh bGVfayDiiaQgU1VOMjBJX1BXTV9DVExfUFJFU0NBTF9LX01BWCwKPiArICogaWkpIHByZXNjYWxl X2sgaXMgbWluaW1pemVkLgo+ICsgKgo+ICsgKiBUaGUgZGVyaXZhdGlvbiBwcm9jZWVkcyBhcyBm b2xsb3dzLCB3aXRoIHZhbCA9ICMgb2YgY3ljbGVzIGZvciByZXF1ZXN0ZWQKPiArICogcGVyaW9k Ogo+ICsgKgo+ICsgKiBmb3IgYSBnaXZlbiB2YWx1ZSBvZiBkaXZfbSB3ZSB3YW50IHRoZSBzbWFs bGVzdCBwcmVzY2FsZV9rIHN1Y2ggdGhhdAo+ICsgKgo+ICsgKiAodmFsID4+IGRpdl9tKSAvLyAo cHJlc2NhbGVfayArIDEpIOKJpCA2NTUzNiAoPSBTVU4yMElfUFdNX1BDTlRSX1NJWkUpCj4gKyAq Cj4gKyAqIFRoaXMgaXMgZXF1aXZhbGVudCB0bzoKPiArICoKPiArICogKHZhbCA+PiBkaXZfbSkg 4omkIDY1NTM2ICogKHByZXNjYWxlX2sgKyAxKSArIHByZXNjYWxlX2sKPiArICog4p+6ICh2YWwg Pj4gZGl2X20pIOKJpCA2NTUzNyAqIHByZXNjYWxlX2sgKyA2NTUzNgo+ICsgKiDin7ogKHZhbCA+ PiBkaXZfbSkgLSA2NTUzNiDiiaQgNjU1MzcgKiBwcmVzY2FsZV9rCj4gKyAqIOKfuiAoKHZhbCA+ PiBkaXZfbSkgLSA2NTUzNikgLyA2NTUzNyDiiaQgcHJlc2NhbGVfawo+ICsgKgo+ICsgKiBBcyBw cmVzY2FsZV9rIGlzIGludGVnZXIsIHRoaXMgYmVjb21lcwo+ICsgKgo+ICsgKiAoKHZhbCA+PiBk aXZfbSkgLSA2NTUzNikgLy8gNjU1Mzcg4omkIHByZXNjYWxlX2sKPiArICoKPiArICogQW5kIGlz IG1pbmltaXplZCBhdAo+ICsgKgo+ICsgKiAoKHZhbCA+PiBkaXZfbSkgLSA2NTUzNikgLy8gNjU1 MzcKPiArICoKPiArICogTm93IHdlIHBpY2sgdGhlIHNtYWxsZXN0IGRpdl9tIHRoYXQgc2F0aWZp ZXMgcHJlc2NhbGVfayDiiaQgMjU1Cj4gKyAqIChpLmUgU1VOMjBJX1BXTV9DVExfUFJFU0NBTF9L X01BWCksCj4gKyAqCj4gKyAqICgodmFsID4+IGRpdl9tKSAtIDY1NTM2KSAvLyA2NTUzNyDiiaQg MjU1Cj4gKyAqIOKfuiAodmFsID4+IGRpdl9tKSAtIDY1NTM2IOKJpCAyNTUgKiA2NTUzNyArIDY1 NTM2Cj4gKyAqIOKfuiB2YWwgPj4gZGl2X20g4omkIDI1NSAqIDY1NTM3ICsgMiAqIDY1NTM2Cj4g KyAqIOKfuiB2YWwgPj4gZGl2X20gPCAoMjU1ICogNjU1MzcgKyAyICogNjU1MzYgKyAxKQo+ICsg KiDin7ogZGl2X20gPSBmbHMoKHZhbCkgLyAoMjU1ICogNjU1MzcgKyAyICogNjU1MzYgKyAxKSkK PiArICoKPiArICogU3VnZ2VzdGVkIGJ5IFV3ZSBLbGVpbmUtS8O2bmlnCj4gKyAqLwo+ICsjZGVm aW5lIFNVTjIwSV9QV01fTUFHSUMJCQkoMjU1ICogNjU1MzcgKyAyICogNjU1MzYgKyAxKQo+ICsj ZGVmaW5lIFNVTjIwSV9QV01fRElWX0NPTlNUCQkJNjU1MzcKPiArCj4gK3N0cnVjdCBzdW4yMGlf cHdtX2NoaXAgewo+ICsJc3RydWN0IGNsayAqY2xrX2hvc2MsICpjbGtfYXBiOwo+ICsJdm9pZCBf X2lvbWVtICpiYXNlOwo+ICt9Owo+ICsKPiArc3RhdGljIGlubGluZSBzdHJ1Y3Qgc3VuMjBpX3B3 bV9jaGlwICp0b19zdW4yMGlfcHdtX2NoaXAoc3RydWN0IHB3bV9jaGlwICpjaGlwKQo+ICt7Cj4g KwlyZXR1cm4gcHdtY2hpcF9nZXRfZHJ2ZGF0YShjaGlwKTsKPiArfQo+ICsKPiArc3RhdGljIGlu bGluZSB1MzIgc3VuMjBpX3B3bV9yZWFkbChzdHJ1Y3Qgc3VuMjBpX3B3bV9jaGlwICpjaGlwLAo+ ICsJCQkJICAgdW5zaWduZWQgbG9uZyBvZmZzZXQpCj4gK3sKPiArCXJldHVybiByZWFkbChjaGlw LT5iYXNlICsgb2Zmc2V0KTsKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSB2b2lkIHN1bjIwaV9w d21fd3JpdGVsKHN0cnVjdCBzdW4yMGlfcHdtX2NoaXAgKmNoaXAsCj4gKwkJCQkgICAgIHUzMiB2 YWwsIHVuc2lnbmVkIGxvbmcgb2Zmc2V0KQo+ICt7Cj4gKwl3cml0ZWwodmFsLCBjaGlwLT5iYXNl ICsgb2Zmc2V0KTsKPiArfQo+ICsKPiArc3RhdGljIGludCBzdW4yMGlfcHdtX2dldF9zdGF0ZShz dHJ1Y3QgcHdtX2NoaXAgKmNoaXAsCj4gKwkJCQlzdHJ1Y3QgcHdtX2RldmljZSAqcHdtLAo+ICsJ CQkJc3RydWN0IHB3bV9zdGF0ZSAqc3RhdGUpCj4gK3sKPiArCXN0cnVjdCBzdW4yMGlfcHdtX2No aXAgKnN1bjIwaV9jaGlwID0gdG9fc3VuMjBpX3B3bV9jaGlwKGNoaXApOwo+ICsJdTE2IGVudF9j eWNsZSwgYWN0X2N5Y2xlLCBwcmVzY2FsZV9rOwo+ICsJdTY0IGNsa19yYXRlLCB0bXA7Cj4gKwl1 OCBkaXZfbTsKPiArCXUzMiB2YWw7Cj4gKwo+ICsJdmFsID0gc3VuMjBpX3B3bV9yZWFkbChzdW4y MGlfY2hpcCwgU1VOMjBJX1BXTV9DTEtfQ0ZHKHB3bS0+aHdwd20gLyAyKSk7Cj4gKwlkaXZfbSA9 IEZJRUxEX0dFVChTVU4yMElfUFdNX0NMS19DRkdfRElWX00sIHZhbCk7Cj4gKwlpZiAoZGl2X20g PiBTVU4yMElfUFdNX0NMS19ESVZfTV9NQVgpCj4gKwkJZGl2X20gPSBTVU4yMElfUFdNX0NMS19E SVZfTV9NQVg7Cj4gKwo+ICsJLyoKPiArCSAqIElmIENMS19DRkdfU1JDIGlzIDAsIHVzZSB0aGUg aG9zYyBjbG9jazsKPiArCSAqIG90aGVyd2lzZSAoYW55IG5vbnplcm8gdmFsdWUpIHVzZSB0aGUg QVBCIGNsb2NrLgo+ICsJICovCj4gKwlpZiAoRklFTERfR0VUKFNVTjIwSV9QV01fQ0xLX0NGR19T UkMsIHZhbCkgPT0gMCkKPiArCQljbGtfcmF0ZSA9IGNsa19nZXRfcmF0ZShzdW4yMGlfY2hpcC0+ Y2xrX2hvc2MpOwo+ICsJZWxzZQo+ICsJCWNsa19yYXRlID0gY2xrX2dldF9yYXRlKHN1bjIwaV9j aGlwLT5jbGtfYXBiKTsKPiArCj4gKwl2YWwgPSBzdW4yMGlfcHdtX3JlYWRsKHN1bjIwaV9jaGlw LCBTVU4yMElfUFdNX0NUTChwd20tPmh3cHdtKSk7Cj4gKwlzdGF0ZS0+cG9sYXJpdHkgPSAoU1VO MjBJX1BXTV9DVExfQUNUX1NUQSAmIHZhbCkgPwo+ICsJCQkgICBQV01fUE9MQVJJVFlfTk9STUFM IDogUFdNX1BPTEFSSVRZX0lOVkVSU0VEOwo+ICsKPiArCXByZXNjYWxlX2sgPSBGSUVMRF9HRVQo U1VOMjBJX1BXTV9DVExfUFJFU0NBTF9LLCB2YWwpICsgMTsKPiArCj4gKwl2YWwgPSBzdW4yMGlf cHdtX3JlYWRsKHN1bjIwaV9jaGlwLCBTVU4yMElfUFdNX0VOQUJMRSk7Cj4gKwlzdGF0ZS0+ZW5h YmxlZCA9IChTVU4yMElfUFdNX0VOQUJMRV9FTihwd20tPmh3cHdtKSAmIHZhbCkgPyB0cnVlIDog ZmFsc2U7Cj4gKwo+ICsJdmFsID0gc3VuMjBpX3B3bV9yZWFkbChzdW4yMGlfY2hpcCwgU1VOMjBJ X1BXTV9QRVJJT0QocHdtLT5od3B3bSkpOwo+ICsJYWN0X2N5Y2xlID0gRklFTERfR0VUKFNVTjIw SV9QV01fUEVSSU9EX0FDVF9DWUNMRSwgdmFsKTsKPiArCj4gKwllbnRfY3ljbGUgPSBGSUVMRF9H RVQoU1VOMjBJX1BXTV9QRVJJT0RfRU5USVJFX0NZQ0xFLCB2YWwpOwo+ICsKPiArCS8qCj4gKwkg KiBUaGUgZHVyYXRpb24gb2YgdGhlIGFjdGl2ZSBwaGFzZSBzaG91bGQgbm90IGJlIGxvbmdlcgo+ ICsJICogdGhhbiB0aGUgZHVyYXRpb24gb2YgdGhlIHBlcmlvZAo+ICsJICovCj4gKwlpZiAoYWN0 X2N5Y2xlID4gZW50X2N5Y2xlKQo+ICsJCWFjdF9jeWNsZSA9IGVudF9jeWNsZTsKPiArCj4gKwkv Kgo+ICsJICogV2UgaGF2ZSBhY3RfY3ljbGUgPD0gZW50X2N5Y2xlIDw9IDB4ZmZmZiwgcHJlc2Nh bGVfayA8PSAweDEwMCwKPiArCSAqIGRpdl9tIDw9IDguIFNvIHRoZSBtdWx0aXBsaWNhdGlvbiBm aXRzIGludG8gYW4gdTY0IHdpdGhvdXQKPiArCSAqIG92ZXJmbG93Lgo+ICsJICovCj4gKwl0bXAg PSAoKHU2NCkoYWN0X2N5Y2xlKSAqIHByZXNjYWxlX2sgPDwgZGl2X20pICogTlNFQ19QRVJfU0VD Owo+ICsJc3RhdGUtPmR1dHlfY3ljbGUgPSBESVZfUk9VTkRfVVBfVUxMKHRtcCwgY2xrX3JhdGUp Owo+ICsJdG1wID0gKCh1NjQpKGVudF9jeWNsZSkgKiBwcmVzY2FsZV9rIDw8IGRpdl9tKSAqIE5T RUNfUEVSX1NFQzsKPiArCXN0YXRlLT5wZXJpb2QgPSBESVZfUk9VTkRfVVBfVUxMKHRtcCwgY2xr X3JhdGUpOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHN1bjIwaV9w d21fYXBwbHkoc3RydWN0IHB3bV9jaGlwICpjaGlwLCBzdHJ1Y3QgcHdtX2RldmljZSAqcHdtLAo+ ICsJCQkgICAgY29uc3Qgc3RydWN0IHB3bV9zdGF0ZSAqc3RhdGUpCj4gK3sKPiArCXN0cnVjdCBz dW4yMGlfcHdtX2NoaXAgKnN1bjIwaV9jaGlwID0gdG9fc3VuMjBpX3B3bV9jaGlwKGNoaXApOwo+ ICsJdTY0IGJ1c19yYXRlLCBob3NjX3JhdGUsIHZhbCwgZW50X2N5Y2xlLCBhY3RfY3ljbGU7Cj4g Kwl1MzIgY2xrX2dhdGUsIGNsa19jZmcsIHB3bV9lbiwgY3RsLCByZWdfcGVyaW9kOwo+ICsJdTMy IHByZXNjYWxlX2ssIGRpdl9tOwo+ICsJYm9vbCB1c2VfYnVzX2NsazsKPiArCj4gKwlwd21fZW4g PSBzdW4yMGlfcHdtX3JlYWRsKHN1bjIwaV9jaGlwLCBTVU4yMElfUFdNX0VOQUJMRSk7Cj4gKwlj bGtfZ2F0ZSA9IHN1bjIwaV9wd21fcmVhZGwoc3VuMjBpX2NoaXAsIFNVTjIwSV9QV01fQ0xLX0dB VEUpOwo+ICsKPiArCWlmICghc3RhdGUtPmVuYWJsZWQpIHsKPiArCQlpZiAoc3RhdGUtPmVuYWJs ZWQgIT0gcHdtLT5zdGF0ZS5lbmFibGVkKSB7Cj4gKwkJCWNsa19nYXRlICY9IH5TVU4yMElfUFdN X0NMS19HQVRFX0dBVElORyhwd20tPmh3cHdtKTsKPiArCQkJcHdtX2VuICY9IH5TVU4yMElfUFdN X0VOQUJMRV9FTihwd20tPmh3cHdtKTsKPiArCQkJc3VuMjBpX3B3bV93cml0ZWwoc3VuMjBpX2No aXAsIHB3bV9lbiwgU1VOMjBJX1BXTV9FTkFCTEUpOwo+ICsJCQlzdW4yMGlfcHdtX3dyaXRlbChz dW4yMGlfY2hpcCwgY2xrX2dhdGUsIFNVTjIwSV9QV01fQ0xLX0dBVEUpOwo+ICsJCX0KPiArCQly ZXR1cm4gMDsKPiArCX0KPiArCj4gKwljdGwgPSBzdW4yMGlfcHdtX3JlYWRsKHN1bjIwaV9jaGlw LCBTVU4yMElfUFdNX0NUTChwd20tPmh3cHdtKSk7Cj4gKwljbGtfY2ZnID0gc3VuMjBpX3B3bV9y ZWFkbChzdW4yMGlfY2hpcCwgU1VOMjBJX1BXTV9DTEtfQ0ZHKHB3bS0+aHdwd20gLyAyKSk7Cj4g Kwlob3NjX3JhdGUgPSBjbGtfZ2V0X3JhdGUoc3VuMjBpX2NoaXAtPmNsa19ob3NjKTsKPiArCWJ1 c19yYXRlID0gY2xrX2dldF9yYXRlKHN1bjIwaV9jaGlwLT5jbGtfYXBiKTsKPiArCWlmIChwd21f ZW4gJiBTVU4yMElfUFdNX0VOQUJMRV9FTihwd20tPmh3cHdtIF4gMSkpIHsKPiArCQkvKiBJZiB0 aGUgbmVpZ2hib3IgY2hhbm5lbCBpcyBlbmFibGVkLCB1c2UgdGhlIGN1cnJlbnQgY2xvY2sgc2V0 dGluZ3MgKi8KPiArCQl1c2VfYnVzX2NsayA9IEZJRUxEX0dFVChTVU4yMElfUFdNX0NMS19DRkdf U1JDLCBjbGtfY2ZnKSAhPSAwOwo+ICsJCXZhbCA9IG11bF91NjRfdTY0X2Rpdl91NjQoc3RhdGUt PnBlcmlvZCwKPiArCQkJCQkgICh1c2VfYnVzX2NsayA/IGJ1c19yYXRlIDogaG9zY19yYXRlKSwK PiArCQkJCQkgIE5TRUNfUEVSX1NFQyk7Cj4gKwo+ICsJCWRpdl9tID0gRklFTERfR0VUKFNVTjIw SV9QV01fQ0xLX0NGR19ESVZfTSwgY2xrX2NmZyk7Cj4gKwl9IGVsc2Ugewo+ICsJCS8qCj4gKwkJ ICogU2VsZWN0IHRoZSBjbG9jayBzb3VyY2UgYmFzZWQgb24gdGhlIHBlcmlvZC4KPiArCQkgKiBT aW5jZSBidXNfcmF0ZSA+IGhvc2NfcmF0ZSwgd2hpY2ggbWVhbnMgYnVzX3JhdGUKPiArCQkgKiBj YW4gcHJvdmlkZSBhIGhpZ2hlciBmcmVxdWVuY3kgdGhhbiBob3NjX3JhdGUuCgpXaGF0IGRvZXMg dGhhdCBtZWFuLCBleGFjdGx5PyBUaGF0IHdlIHNob3VsZCBwcmVmZXIgdGhlIGZhc3RlciBjbG9j az8KQmVjYXVzZSB0aGF0J3Mgbm90IHdoYXQgdGhlIGNvZGUgZG9lcywgaXMgaXQ/Cgo+ICsJCSAq Lwo+ICsJCXVzZV9idXNfY2xrID0gZmFsc2U7Cj4gKwkJdmFsID0gbXVsX3U2NF91NjRfZGl2X3U2 NChzdGF0ZS0+cGVyaW9kLCBob3NjX3JhdGUsIE5TRUNfUEVSX1NFQyk7Cj4gKwkJLyoKPiArCQkg KiBJZiB0aGUgY2FsY3VsYXRlZCB2YWx1ZSBpcyDiiaQgMSwgdGhlIHBlcmlvZCBpcyB0b28gc2hv cnQKPiArCQkgKiBmb3IgcHJvcGVyIFBXTSBvcGVyYXRpb24KPiArCQkgKi8KPiArCQlpZiAodmFs IDw9IDEpIHsKClNvIGlmIEkgZ2V0IHRoZSBjb2RlIGNvcnJlY3RseSwgaXQgcHJlZmVycyBIT1ND IG92ZXIgQVBCPyBJcyB0aGF0CnJlYWxseSB0aGUgYmVzdCB3YXk/IFNob3VsZG4ndCBpdCBiZSB0 aGUgb3RoZXIgd2F5IGFyb3VuZDogd2UgdXNlIHRoZQpmYXN0ZXIgY2xvY2ssIHNpbmNlIHRoaXMg d2lsbCBub3QgbGltaXQgdGhlIHNpYmxpbmcgY2hhbm5lbD8KCkFuZCBhbm90aGVyIHRoaW5nIHRv IGNvbnNpZGVyIGFyZSByb3VuZGluZyBlcnJvcnMgZHVlIHRvIGludGVnZXIKZGl2aXNpb246IGNl cnRhaW4gcGVyaW9kIHJhdGVzIG1pZ2h0IGJlIGJldHRlciBhY2hpZXZhYmxlIHdpdGggb25lIG9y CnRoZSBvdGhlciBzb3VyY2UgY2xvY2s6IDMgTUh6IHdvcmtzIGJlc3QgYXMgMjRNSHovOCwgMy4x MjVNSHogYXMKMTAwTUh6LzMyLgpTbyBzaGFsbCB3ZSBjYWxjdWxhdGUgdGhlIHZhbHVlcyBhbmQg Y29tcGFyZSB0aGUgZXJyb3JzIGluc3RlYWQ/Ck9oLCBhbmQgYWxzbyB3ZSBuZWVkIHRvIGNvbnNp ZGVyIGJ5cGFzc2luZywgSSBmZWVsIGxpa2UgdGhpcyBzaG91bGQgYmUKY2hlY2tlZCBmaXJzdC4K CkluIGFueSBjYXNlIEkgdGhpbmsgdGhlcmUgc2hvdWxkIGJlIGEgY29tbWVudCBkZXNjcmliaW5n IHRoZSBzdHJhdGVneQphbmQgZ2l2ZSBzb21lIHJhdGlvbmFsZSwgSSB0aGluay4KCj4gKwkJCXVz ZV9idXNfY2xrID0gdHJ1ZTsKPiArCQkJdmFsID0gbXVsX3U2NF91NjRfZGl2X3U2NChzdGF0ZS0+ cGVyaW9kLCBidXNfcmF0ZSwgTlNFQ19QRVJfU0VDKTsKPiArCQkJaWYgKHZhbCA8PSAxKQo+ICsJ CQkJcmV0dXJuIC1FSU5WQUw7Cj4gKwkJfQo+ICsJCWRpdl9tID0gZmxzKERJVl9ST1VORF9ET1dO X1VMTCh2YWwsIFNVTjIwSV9QV01fTUFHSUMpKTsKPiArCQlpZiAoZGl2X20gPiBTVU4yMElfUFdN X0NMS19ESVZfTV9NQVgpCj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCQkvKiBTZXQgdXAg dGhlIENMS19ESVZfTSBhbmQgY2xvY2sgQ0xLX1NSQyAqLwo+ICsJCWNsa19jZmcgPSBGSUVMRF9Q UkVQKFNVTjIwSV9QV01fQ0xLX0NGR19ESVZfTSwgZGl2X20pOwo+ICsJCWNsa19jZmcgfD0gRklF TERfUFJFUChTVU4yMElfUFdNX0NMS19DRkdfU1JDLCB1c2VfYnVzX2Nsayk7Cj4gKwo+ICsJCXN1 bjIwaV9wd21fd3JpdGVsKHN1bjIwaV9jaGlwLCBjbGtfY2ZnLCBTVU4yMElfUFdNX0NMS19DRkco cHdtLT5od3B3bSAvIDIpKTsKPiArCX0KPiArCj4gKwkvKiBDYWxjdWxhdGUgcHJlc2NhbGVfayBh bmQgZGV0ZXJtaW5lIHRoZSBudW1iZXIgb2YgY3ljbGVzIGZvciBhIGZ1bGwgUFdNIHBlcmlvZCAq Lwo+ICsJZW50X2N5Y2xlID0gdmFsID4+IGRpdl9tOwo+ICsJcHJlc2NhbGVfayA9IERJVl9ST1VO RF9ET1dOX1VMTChlbnRfY3ljbGUsIFNVTjIwSV9QV01fRElWX0NPTlNUKTsKPiArCWlmIChwcmVz Y2FsZV9rID4gU1VOMjBJX1BXTV9DVExfUFJFU0NBTF9LX01BWCkKPiArCQlwcmVzY2FsZV9rID0g U1VOMjBJX1BXTV9DVExfUFJFU0NBTF9LX01BWDsKPiArCj4gKwlkb19kaXYoZW50X2N5Y2xlLCBw cmVzY2FsZV9rICsgMSk7Cj4gKwo+ICsJLyogZW50X2N5Y2xlIG11c3Qgbm90IGJlIHplcm8gKi8K PiArCWlmIChlbnRfY3ljbGUgPT0gMCkKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwkvKiBG b3IgTiBjeWNsZXMsIFBQUnguUFdNX0VOVElSRV9DWUNMRSA9IChOLTEpICovCj4gKwlyZWdfcGVy aW9kID0gRklFTERfUFJFUChTVU4yMElfUFdNX1BFUklPRF9FTlRJUkVfQ1lDTEUsIGVudF9jeWNs ZSAtIDEpOwo+ICsKPiArCS8qIENhbGN1bGF0ZSB0aGUgYWN0aXZlIGN5Y2xlcyAoZHV0eSBjeWNs ZSkgKi8KPiArCXZhbCA9IG11bF91NjRfdTY0X2Rpdl91NjQoc3RhdGUtPmR1dHlfY3ljbGUsCj4g KwkJCQkgICh1c2VfYnVzX2NsayA/IGJ1c19yYXRlIDogaG9zY19yYXRlKSwKPiArCQkJCSAgTlNF Q19QRVJfU0VDKTsKPiArCWFjdF9jeWNsZSA9IHZhbCA+PiBkaXZfbTsKPiArCWRvX2RpdihhY3Rf Y3ljbGUsIHByZXNjYWxlX2sgKyAxKTsKPiArCj4gKwkvKgo+ICsJICogVGhlIGZvcm11bGEgb2Yg dGhlIG91dHB1dCBwZXJpb2QgYW5kIHRoZSBkdXR5LWN5Y2xlIGZvciBQV00gYXJlIGFzIGZvbGxv d3MuCj4gKwkgKiBUIHBlcmlvZCA9IFBXTTBfUFJFU0NBTEVfSyAvIFBXTTAxX0NMSyAqIChQUFIw LlBXTV9FTlRJUkVfQ1lDTEUgKyAxKQo+ICsJICogVCBoaWdoLWxldmVsID0gUFdNMF9QUkVTQ0FM RV9LIC8gUFdNMDFfQ0xLICogUFBSMC5QV01fQUNUX0NZQ0xFCj4gKwkgKiBEdXR5LWN5Y2xlID0g VCBoaWdoLWxldmVsIC8gVCBwZXJpb2QKPiArCSAqLwo+ICsJcmVnX3BlcmlvZCB8PSBGSUVMRF9Q UkVQKFNVTjIwSV9QV01fUEVSSU9EX0FDVF9DWUNMRSwgYWN0X2N5Y2xlKTsKPiArCXN1bjIwaV9w d21fd3JpdGVsKHN1bjIwaV9jaGlwLCByZWdfcGVyaW9kLCBTVU4yMElfUFdNX1BFUklPRChwd20t Pmh3cHdtKSk7Cj4gKwo+ICsJY3RsID0gRklFTERfUFJFUChTVU4yMElfUFdNX0NUTF9QUkVTQ0FM X0ssIHByZXNjYWxlX2spOwo+ICsJaWYgKHN0YXRlLT5wb2xhcml0eSA9PSBQV01fUE9MQVJJVFlf Tk9STUFMKQo+ICsJCWN0bCB8PSBTVU4yMElfUFdNX0NUTF9BQ1RfU1RBOwo+ICsKPiArCXN1bjIw aV9wd21fd3JpdGVsKHN1bjIwaV9jaGlwLCBjdGwsIFNVTjIwSV9QV01fQ1RMKHB3bS0+aHdwd20p KTsKPiArCj4gKwlpZiAoc3RhdGUtPmVuYWJsZWQgIT0gcHdtLT5zdGF0ZS5lbmFibGVkKSB7Cj4g KwkJY2xrX2dhdGUgJj0gflNVTjIwSV9QV01fQ0xLX0dBVEVfQllQQVNTKHB3bS0+aHdwd20pOwo+ ICsJCWNsa19nYXRlIHw9IFNVTjIwSV9QV01fQ0xLX0dBVEVfR0FUSU5HKHB3bS0+aHdwd20pOwo+ ICsJCXB3bV9lbiB8PSBTVU4yMElfUFdNX0VOQUJMRV9FTihwd20tPmh3cHdtKTsKPiArCQlzdW4y MGlfcHdtX3dyaXRlbChzdW4yMGlfY2hpcCwgcHdtX2VuLCBTVU4yMElfUFdNX0VOQUJMRSk7Cj4g KwkJc3VuMjBpX3B3bV93cml0ZWwoc3VuMjBpX2NoaXAsIGNsa19nYXRlLCBTVU4yMElfUFdNX0NM S19HQVRFKTsKPiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGNvbnN0 IHN0cnVjdCBwd21fb3BzIHN1bjIwaV9wd21fb3BzID0gewo+ICsJLmFwcGx5ID0gc3VuMjBpX3B3 bV9hcHBseSwKPiArCS5nZXRfc3RhdGUgPSBzdW4yMGlfcHdtX2dldF9zdGF0ZSwKPiArfTsKPiAr Cj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIHN1bjIwaV9wd21fZHRfaWRzW10g PSB7Cj4gKwl7IC5jb21wYXRpYmxlID0gImFsbHdpbm5lcixzdW4yMGktZDEtcHdtIiB9LAo+ICsJ eyB9Cj4gK307Cj4gK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIHN1bjIwaV9wd21fZHRfaWRzKTsK PiArCj4gK3N0YXRpYyBpbnQgc3VuMjBpX3B3bV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICpwZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgcHdtX2NoaXAgKmNoaXA7Cj4gKwlzdHJ1Y3Qgc3VuMjBp X3B3bV9jaGlwICpzdW4yMGlfY2hpcDsKPiArCXN0cnVjdCBjbGsgKmNsa19idXM7Cj4gKwlzdHJ1 Y3QgcmVzZXRfY29udHJvbCAqcnN0Owo+ICsJdTMyIG5wd207Cj4gKwlpbnQgcmV0Owo+ICsKPiAr CXJldCA9IG9mX3Byb3BlcnR5X3JlYWRfdTMyKHBkZXYtPmRldi5vZl9ub2RlLCAiYWxsd2lubmVy LG5wd21zIiwgJm5wd20pOwo+ICsJaWYgKHJldCA8IDApCj4gKwkJbnB3bSA9IDg7IC8qIERlZmF1 bHQgdmFsdWUgKi8KPiArCj4gKwlpZiAobnB3bSA+IDE2KSB7Cj4gKwkJZGV2X2luZm8oJnBkZXYt PmRldiwgIkxpbWl0aW5nIG51bWJlciBvZiBQV00gbGluZXMgZnJvbSAldSB0byAxNiIsIG5wd20p OwoKSSBkb24ndCB0aGluayB3ZSBzaG91bGQgcHJvY2VlZCBpZiB0aGUgZmlybXdhcmUgaW5mb3Jt YXRpb24gaXMgY2xlYXJseQp3cm9uZy4gSnVzdCBiYWlsIG91dCB3aXRoIC1FSU5WQUwgb3Igc28g aGVyZSwgc28gdGhhdCBnZXRzIGZpeGVkIGluIHRoZQpEVC4KCj4gKwkJbnB3bSA9IDE2Owo+ICsJ fQo+ICsKPiArCWNoaXAgPSBkZXZtX3B3bWNoaXBfYWxsb2MoJnBkZXYtPmRldiwgbnB3bSwgc2l6 ZW9mKCpzdW4yMGlfY2hpcCkpOwo+ICsJaWYgKElTX0VSUihjaGlwKSkKPiArCQlyZXR1cm4gUFRS X0VSUihjaGlwKTsKPiArCXN1bjIwaV9jaGlwID0gdG9fc3VuMjBpX3B3bV9jaGlwKGNoaXApOwo+ ICsKPiArCXN1bjIwaV9jaGlwLT5iYXNlID0gZGV2bV9wbGF0Zm9ybV9pb3JlbWFwX3Jlc291cmNl KHBkZXYsIDApOwo+ICsJaWYgKElTX0VSUihzdW4yMGlfY2hpcC0+YmFzZSkpCj4gKwkJcmV0dXJu IFBUUl9FUlIoc3VuMjBpX2NoaXAtPmJhc2UpOwo+ICsKPiArCWNsa19idXMgPSBkZXZtX2Nsa19n ZXRfZW5hYmxlZCgmcGRldi0+ZGV2LCAiYnVzIik7Cj4gKwlpZiAoSVNfRVJSKGNsa19idXMpKQo+ ICsJCXJldHVybiBkZXZfZXJyX3Byb2JlKCZwZGV2LT5kZXYsIFBUUl9FUlIoY2xrX2J1cyksCj4g KwkJCQkgICAgICJGYWlsZWQgdG8gZ2V0IGJ1cyBjbG9ja1xuIik7Cj4gKwo+ICsJc3VuMjBpX2No aXAtPmNsa19ob3NjID0gZGV2bV9jbGtfZ2V0X2VuYWJsZWQoJnBkZXYtPmRldiwgImhvc2MiKTsK PiArCWlmIChJU19FUlIoc3VuMjBpX2NoaXAtPmNsa19ob3NjKSkKPiArCQlyZXR1cm4gZGV2X2Vy cl9wcm9iZSgmcGRldi0+ZGV2LCBQVFJfRVJSKHN1bjIwaV9jaGlwLT5jbGtfaG9zYyksCj4gKwkJ CQkgICAgICJGYWlsZWQgdG8gZ2V0IGhvc2MgY2xvY2tcbiIpOwo+ICsKPiArCXJldCA9IGRldm1f Y2xrX3JhdGVfZXhjbHVzaXZlX2dldCgmcGRldi0+ZGV2LCBzdW4yMGlfY2hpcC0+Y2xrX2hvc2Mp OwoKSnVzdCBpZ25vcmluZyBmb3IgYSBiaXQgdGhhdCB0aGUgMjQgTUh6IG9zY2lsbGF0b3IgaXMg YSBmaXhlZCBjbG9jawphbnl3YXksIGJ1dCB3aHkgd291bGQgd2Ugd2FudCBleGNsdXNpdml0eSBh bHJlYWR5IGF0IHByb2JlIHRpbWU/IElzbid0CnRoYXQgdG9vIGxpbWl0aW5nLCBhcyBubyBvbmUg bWlnaHQgZXZlciB1c2UgYW55IFBXTSBjaGFubmVscywgYnV0IGl0CndvdWxkIHN0aWxsICJiZWxv bmcgdG8gdXMiPwoKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoJnBkZXYt PmRldiwgcmV0LAo+ICsJCQkJICAgICAiRmFpbGVkIHRvIGdldCBob3NjIGV4Y2x1c2l2ZSByYXRl XG4iKTsKPiArCj4gKwlzdW4yMGlfY2hpcC0+Y2xrX2FwYiA9IGRldm1fY2xrX2dldF9lbmFibGVk KCZwZGV2LT5kZXYsICJhcGIiKTsKPiArCWlmIChJU19FUlIoc3VuMjBpX2NoaXAtPmNsa19hcGIp KQo+ICsJCXJldHVybiBkZXZfZXJyX3Byb2JlKCZwZGV2LT5kZXYsIFBUUl9FUlIoc3VuMjBpX2No aXAtPmNsa19hcGIpLAo+ICsJCQkJICAgICAiRmFpbGVkIHRvIGdldCBhcGIgY2xvY2tcbiIpOwo+ ICsKPiArCXJldCA9IGRldm1fY2xrX3JhdGVfZXhjbHVzaXZlX2dldCgmcGRldi0+ZGV2LCBzdW4y MGlfY2hpcC0+Y2xrX2FwYik7CgpKdXN0IGZvciB0aGUgcmVjb3JkczogQVBCIGlzIHByYWN0aWNh bGx5IGFsc28gYSBmaXhlZCBjbG9jaywgc2V0IHVwCm9uY2UgaW4gZmlybXdhcmUgYW5kIG5ldmVy IGNoYW5nZWQsIHNpbmNlIGl0IGRyaXZlcyBhIGxvdCBvZiBvdGhlcgpwZXJpcGhlcmFscy4KQnV0 IHNhbWUgcXVlc3Rpb24gYXMgYWJvdmUsIHdoeSBkbyB3ZSBsb2NrIGl0cyByYXRlIGFscmVhZHkg aGVyZT8KCj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiBkZXZfZXJyX3Byb2JlKCZwZGV2LT5kZXYs IHJldCwKPiArCQkJCSAgICAgIkZhaWxlZCB0byBnZXQgYXBiIGV4Y2x1c2l2ZSByYXRlXG4iKTsK PiArCj4gKwlpZiAoY2xrX2dldF9yYXRlKHN1bjIwaV9jaGlwLT5jbGtfYXBiKSA8PSBjbGtfZ2V0 X3JhdGUoc3VuMjBpX2NoaXAtPmNsa19ob3NjKSkKPiArCQlkZXZfaW5mbygmcGRldi0+ZGV2LCAi QVBCIGNsb2NrIG11c3QgYmUgZ3JlYXRlciB0aGFuIGhvc2MgY2xvY2siKTsKCldoeSB0aGlzIGNo ZWNrPyBEb2VzIHRoZSBjb2RlIG1ha2UgYW55IGFzc3VtcHRpb25zIGFib3V0IHRoaXMgcmVsYXRp b24/CklmIHllcywgd2UgbXVzdCBzdXJlbHkgZGVueSB0aGlzIGFuZCBiYWlsIG91dC4KSWYgbm90 IChhbmQgSSBmZWVsIHdlIHNob3VsZCBoYW5kbGUgaXQgdGhpcyB3YXkpLCB3ZSBjYW4ganVzdCBp Z25vcmUKdGhpcyBhbmQgbm90IHByaW50IGFueXRoaW5nLgoKQ2hlZXJzLApBbmRyZQoKPiArCj4g Kwlyc3QgPSBkZXZtX3Jlc2V0X2NvbnRyb2xfZ2V0X2V4Y2x1c2l2ZV9kZWFzc2VydGVkKCZwZGV2 LT5kZXYsIE5VTEwpOwo+ICsJaWYgKElTX0VSUihyc3QpKQo+ICsJCXJldHVybiBkZXZfZXJyX3By b2JlKCZwZGV2LT5kZXYsIFBUUl9FUlIocnN0KSwKPiArCQkJCSAgICAgIkZhaWxlZCB0byBnZXQg cmVzZXQgY29udHJvbFxuIik7Cj4gKwo+ICsJY2hpcC0+b3BzID0gJnN1bjIwaV9wd21fb3BzOwo+ ICsKPiArCXJldCA9IGRldm1fcHdtY2hpcF9hZGQoJnBkZXYtPmRldiwgY2hpcCk7Cj4gKwlpZiAo cmV0IDwgMCkKPiArCQlyZXR1cm4gZGV2X2Vycl9wcm9iZSgmcGRldi0+ZGV2LCByZXQsICJGYWls ZWQgdG8gYWRkIFBXTSBjaGlwXG4iKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3Rh dGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgc3VuMjBpX3B3bV9kcml2ZXIgPSB7Cj4gKwkuZHJp dmVyID0gewo+ICsJCS5uYW1lID0gInN1bjIwaS1wd20iLAo+ICsJCS5vZl9tYXRjaF90YWJsZSA9 IHN1bjIwaV9wd21fZHRfaWRzLAo+ICsJfSwKPiArCS5wcm9iZSA9IHN1bjIwaV9wd21fcHJvYmUs Cj4gK307Cj4gK21vZHVsZV9wbGF0Zm9ybV9kcml2ZXIoc3VuMjBpX3B3bV9kcml2ZXIpOwo+ICsK PiArTU9EVUxFX0FVVEhPUigiQWxla3NhbmRyIFNodWJpbiA8cHJpdmF0ZXN1YjJAZ21haWwuY29t PiIpOwo+ICtNT0RVTEVfREVTQ1JJUFRJT04oIkFsbHdpbm5lciBzdW4yMGkgUFdNIGRyaXZlciIp Owo+ICtNT0RVTEVfTElDRU5TRSgiR1BMIik7CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KbGludXgtcmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2 QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9s aXN0aW5mby9saW51eC1yaXNjdgo=