From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mx-out2.startmail.com (mx-out2.startmail.com [145.131.90.155]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9226A2727FA; Wed, 1 Oct 2025 21:01:36 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=145.131.90.155 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759352498; cv=none; b=WntjaugkW/PENiNk8x2MJ/IRwJ1wJjmAaAar7OdS2m4TyKOBVyS7kCrlUfILQ522k1bb05w1S8RPVRy/OhGEcGazSR6dLg+SK05t8ne7dai80CMtIjyBtEO+jOXrIHParTRHbp/TgExgf/NYAr2y4GVM3qX1DmK123mIpTY/ESM= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1759352498; c=relaxed/simple; bh=h0SDlqzubMyx2T3IEnyVrEp7j/ci3ZmMZB1Oq8kB3UY=; h=Date:From:To:Cc:Subject:Message-ID:References:Mime-Version: Content-Type:Content-Disposition:In-Reply-To; b=ohIw8GbPAAC7aNqFmv0K3KrLncHrKhGzyaEM4ypajNDfRQACfWdTLWZ6Yu9OVlbnstDqwEy7LImGCeKfx0y+U0FWFUC5lH2AMskXuRRJmMZn1oJ/k675NJ+np7J5kCTptgqf7ES38Byax+6BD1Za9JHK8F7albeD1LWwh596Z/c= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=weathered-steel.dev; spf=pass smtp.mailfrom=weathered-steel.dev; dkim=pass (2048-bit key) header.d=weathered-steel.dev header.i=@weathered-steel.dev header.b=Q3rH9e6Q; arc=none smtp.client-ip=145.131.90.155 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=weathered-steel.dev Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=weathered-steel.dev Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=weathered-steel.dev header.i=@weathered-steel.dev header.b="Q3rH9e6Q" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=weathered-steel.dev; s=startmail1; t=1759351963; bh=UoLolgZjobGjS/KiQaI7MTlo0BgUiakv4CVrspm+7+k=; h=Date:From:To:Subject:Message-ID:References:Mime-Version: Content-Type:Content-Disposition:Content-Transfer-Encoding: In-Reply-To:From:Subject:To:Date:Sender:Content-Type: Content-Transfer-Encoding:Content-Disposition:Mime-Version: Reply-To:In-Reply-To:References:Message-Id:List-Unsubscribe: List-Unsubscribe-Post:Autocrypt; b=Q3rH9e6Q0Ei+/evpcdwzIcU4DnfCsJbXD/3fzLRk3weIh8Jbn85D2yBOaiHlOy1Ij 70EoEjE/a0a5mG74BJZ0kB9hohYooyTxdzwL4tRvWSQOrc0LZp1hvO7o5g2Orq7cAD 581zSHYD7PdTKvzV9Iqt9uMyml4z0nqhIzCjqZ5hDsi+HNAx80SJkMZ6NIHS5raroT 9RMbpSSwYEkniT4heI6UGS640jLv0gMSrUTJpPUjPv2AYV1NreZxBjHknWQLgYzaQZ wnFcksso4yoBF3nEC+ea83im1nG0tqdJ/MGoz4ypPQYmh8iNUON9jmEh5ag4oz91dA 1g9XW9XIIKfyA== Date: Wed, 1 Oct 2025 20:52:39 +0000 From: Elle Rhumsaa To: Michal Wilczynski Cc: Uwe =?iso-8859-1?Q?Kleine-K=F6nig?= , Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?iso-8859-1?Q?Bj=F6rn?= Roy Baron , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Guo Ren , Fu Wei , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , Marek Szyprowski , Benno Lossin , Michael Turquette , Drew Fustini , Daniel Almeida , linux-kernel@vger.kernel.org, linux-pwm@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-riscv@lists.infradead.org, devicetree@vger.kernel.org Subject: Re: [PATCH v15 2/7] rust: pwm: Add Kconfig and basic data structures Message-ID: References: <20250930-rust-next-pwm-working-fan-for-sending-v15-0-5661c3090877@samsung.com> <20250930-rust-next-pwm-working-fan-for-sending-v15-2-5661c3090877@samsung.com> Precedence: bulk X-Mailing-List: linux-pwm@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20250930-rust-next-pwm-working-fan-for-sending-v15-2-5661c3090877@samsung.com> On Tue, Sep 30, 2025 at 02:20:33PM +0200, Michal Wilczynski wrote: > Introduce the foundational support for PWM abstractions in Rust. > > This commit adds the `RUST_PWM_ABSTRACTIONS` Kconfig option to enable > the feature, along with the necessary build-system support and C > helpers. > > It also introduces the first set of safe wrappers for the PWM > subsystem, covering the basic data carrying C structs and enums: > - `Polarity`: A safe wrapper for `enum pwm_polarity`. > - `Waveform`: A wrapper for `struct pwm_waveform`. > - `State`: A wrapper for `struct pwm_state`. > > These types provide memory safe, idiomatic Rust representations of the > core PWM data structures and form the building blocks for the > abstractions that will follow. > > Tested-by: Drew Fustini > Reviewed-by: Daniel Almeida > Reviewed-by: Elle Rhumsaa > Signed-off-by: Michal Wilczynski > --- > MAINTAINERS | 8 ++++ > drivers/pwm/Kconfig | 13 +++++ > rust/bindings/bindings_helper.h | 1 + > rust/helpers/helpers.c | 1 + > rust/helpers/pwm.c | 20 ++++++++ > rust/kernel/lib.rs | 2 + > rust/kernel/pwm.rs | 102 ++++++++++++++++++++++++++++++++++++++++ > 7 files changed, 147 insertions(+) > > diff --git a/MAINTAINERS b/MAINTAINERS > index fe168477caa45799dfe07de2f54de6d6a1ce0615..5d7c0676c1d00a02b3d7db2de88b039c08c99c6e 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -20387,6 +20387,14 @@ F: include/linux/pwm.h > F: include/linux/pwm_backlight.h > K: pwm_(config|apply_might_sleep|apply_atomic|ops) > > +PWM SUBSYSTEM BINDINGS [RUST] > +M: Michal Wilczynski > +L: linux-pwm@vger.kernel.org > +L: rust-for-linux@vger.kernel.org > +S: Maintained > +F: rust/helpers/pwm.c > +F: rust/kernel/pwm.rs > + > PXA GPIO DRIVER > M: Robert Jarzmik > L: linux-gpio@vger.kernel.org > diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig > index f00ce973dddf651287168b44228574f4d5c28dc0..2b608f4378138775ee3ba4d53f682952e1914118 100644 > --- a/drivers/pwm/Kconfig > +++ b/drivers/pwm/Kconfig > @@ -800,4 +800,17 @@ config PWM_XILINX > To compile this driver as a module, choose M here: the module > will be called pwm-xilinx. > > + config RUST_PWM_ABSTRACTIONS > + bool "Rust PWM abstractions support" > + depends on RUST > + depends on PWM=y > + help > + This option enables the safe Rust abstraction layer for the PWM > + subsystem. It provides idiomatic wrappers and traits necessary for > + writing PWM controller drivers in Rust. > + > + The abstractions handle resource management (like memory and reference > + counting) and provide safe interfaces to the underlying C core, > + allowing driver logic to be written in safe Rust. > + > endif > diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helper.h > index 84d60635e8a9baef1f1a1b2752dc0fa044f8542f..7a06ee5781eadc9f21ccd456b574a9cb152cd58c 100644 > --- a/rust/bindings/bindings_helper.h > +++ b/rust/bindings/bindings_helper.h > @@ -66,6 +66,7 @@ > #include > #include > #include > +#include > #include > #include > #include > diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c > index 7cf7fe95e41dd51717050648d6160bebebdf4b26..861052ffffaff60e9c2e8109e55f3b6158ff2281 100644 > --- a/rust/helpers/helpers.c > +++ b/rust/helpers/helpers.c > @@ -35,6 +35,7 @@ > #include "platform.c" > #include "poll.c" > #include "property.c" > +#include "pwm.c" > #include "rbtree.c" > #include "rcu.c" > #include "refcount.c" > diff --git a/rust/helpers/pwm.c b/rust/helpers/pwm.c > new file mode 100644 > index 0000000000000000000000000000000000000000..d75c588863685d3990b525bb1b84aa4bc35ac397 > --- /dev/null > +++ b/rust/helpers/pwm.c > @@ -0,0 +1,20 @@ > +// SPDX-License-Identifier: GPL-2.0 > +// Copyright (c) 2025 Samsung Electronics Co., Ltd. > +// Author: Michal Wilczynski > + > +#include > + > +struct device *rust_helper_pwmchip_parent(const struct pwm_chip *chip) > +{ > + return pwmchip_parent(chip); > +} > + > +void *rust_helper_pwmchip_get_drvdata(struct pwm_chip *chip) > +{ > + return pwmchip_get_drvdata(chip); > +} > + > +void rust_helper_pwmchip_set_drvdata(struct pwm_chip *chip, void *data) > +{ > + pwmchip_set_drvdata(chip, data); > +} > diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs > index ed53169e795c0badf548025a57f946fa18bc73e3..e339b552f9650803b1efa1eb8ecc6fe9d2c56563 100644 > --- a/rust/kernel/lib.rs > +++ b/rust/kernel/lib.rs > @@ -117,6 +117,8 @@ > pub mod seq_file; > pub mod sizes; > mod static_assert; > +#[cfg(CONFIG_RUST_PWM_ABSTRACTIONS)] > +pub mod pwm; > #[doc(hidden)] > pub mod std_vendor; > pub mod str; > diff --git a/rust/kernel/pwm.rs b/rust/kernel/pwm.rs > new file mode 100644 > index 0000000000000000000000000000000000000000..beabf0086a2f1beea01e0b0a9f6540c601f77a49 > --- /dev/null > +++ b/rust/kernel/pwm.rs > @@ -0,0 +1,102 @@ > +// SPDX-License-Identifier: GPL-2.0 > +// Copyright (c) 2025 Samsung Electronics Co., Ltd. > +// Author: Michal Wilczynski > + > +//! PWM subsystem abstractions. > +//! > +//! C header: [`include/linux/pwm.h`](srctree/include/linux/pwm.h). > + > +use crate::{ > + bindings, > + prelude::*, > + types::Opaque, > +}; > +use core::convert::TryFrom; > + > +/// PWM polarity. Mirrors [`enum pwm_polarity`](srctree/include/linux/pwm.h). > +#[derive(Copy, Clone, Debug, PartialEq, Eq)] > +pub enum Polarity { > + /// Normal polarity (duty cycle defines the high period of the signal). > + Normal, > + > + /// Inversed polarity (duty cycle defines the low period of the signal). > + Inversed, > +} > + > +impl TryFrom for Polarity { > + type Error = Error; > + > + fn try_from(polarity: bindings::pwm_polarity) -> Result { > + match polarity { > + bindings::pwm_polarity_PWM_POLARITY_NORMAL => Ok(Polarity::Normal), > + bindings::pwm_polarity_PWM_POLARITY_INVERSED => Ok(Polarity::Inversed), > + _ => Err(EINVAL), > + } > + } > +} > + > +impl From for bindings::pwm_polarity { > + fn from(polarity: Polarity) -> Self { > + match polarity { > + Polarity::Normal => bindings::pwm_polarity_PWM_POLARITY_NORMAL, > + Polarity::Inversed => bindings::pwm_polarity_PWM_POLARITY_INVERSED, > + } > + } > +} > + > +/// Represents a PWM waveform configuration. > +/// Mirrors struct [`struct pwm_waveform`](srctree/include/linux/pwm.h). > +#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)] > +pub struct Waveform { > + /// Total duration of one complete PWM cycle, in nanoseconds. > + pub period_length_ns: u64, > + > + /// Duty-cycle active time, in nanoseconds. > + /// > + /// For a typical normal polarity configuration (active-high) this is the > + /// high time of the signal. > + pub duty_length_ns: u64, > + > + /// Duty-cycle start offset, in nanoseconds. > + /// > + /// Delay from the beginning of the period to the first active edge. > + /// In most simple PWM setups this is `0`, so the duty cycle starts > + /// immediately at each period’s start. > + pub duty_offset_ns: u64, > +} > + > +impl From for Waveform { > + fn from(wf: bindings::pwm_waveform) -> Self { > + Waveform { > + period_length_ns: wf.period_length_ns, > + duty_length_ns: wf.duty_length_ns, > + duty_offset_ns: wf.duty_offset_ns, > + } > + } > +} > + > +impl From for bindings::pwm_waveform { > + fn from(wf: Waveform) -> Self { > + bindings::pwm_waveform { > + period_length_ns: wf.period_length_ns, > + duty_length_ns: wf.duty_length_ns, > + duty_offset_ns: wf.duty_offset_ns, > + } > + } > +} > + > +/// Wrapper for PWM state [`struct pwm_state`](srctree/include/linux/pwm.h). > +#[repr(transparent)] > +pub struct State(bindings::pwm_state); > + > +impl State { > + /// Creates a `State` wrapper by taking ownership of a C `pwm_state` value. > + pub(crate) fn from_c(c_state: bindings::pwm_state) -> Self { > + State(c_state) > + } > + > + /// Returns `true` if the PWM signal is enabled. > + pub fn enabled(&self) -> bool { > + self.0.enabled > + } > +} > > -- > 2.34.1 > Reviewed-by: Elle Rhumsaa 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 08529CAC5BB for ; Wed, 1 Oct 2025 20:52:54 +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:In-Reply-To:Mime-Version:References: 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=lpskrt46L45Js9LJVEulY9OlIoEiSoimCNrGHBR0n7w=; b=UEO6zzg2DoMpo5 +eDHUkcTAYIPA2VSrVf4ih5c6xN6i3Hd1XTwWPl2mjpELNJWRdvGcwXWdG+UaRC6PNpoG0jF4qg+P hDFkpwO5QKzdKi3CMk1k8iMfUbksNmesfH/WxoXmW+8NwEUc2qUKHhxb/ihv0EDlFOE7n6JWRMqa4 rced9TpaEo330x/2ya6nU4R12papwljeOEjziSXIIJLpCWXXqbJ/WY0mujXs3PNcwfNEH5s3wjav6 pJjPBiC//SNg3uAr7/DbOzKVQGrz3QlPkY46j+KfY6k4eEfbTs00FLR0mnxGjsbLmScB8xsbGV9Hj 4/kQN58m2jSb5oaVFYfQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1v43of-00000008wpS-050w; Wed, 01 Oct 2025 20:52:49 +0000 Received: from mx-out2.startmail.com ([145.131.90.155]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1v43oc-00000008wmx-0G7y for linux-riscv@lists.infradead.org; Wed, 01 Oct 2025 20:52:47 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=weathered-steel.dev; s=startmail1; t=1759351963; bh=UoLolgZjobGjS/KiQaI7MTlo0BgUiakv4CVrspm+7+k=; h=Date:From:To:Subject:Message-ID:References:Mime-Version: Content-Type:Content-Disposition:Content-Transfer-Encoding: In-Reply-To:From:Subject:To:Date:Sender:Content-Type: Content-Transfer-Encoding:Content-Disposition:Mime-Version: Reply-To:In-Reply-To:References:Message-Id:List-Unsubscribe: List-Unsubscribe-Post:Autocrypt; b=Q3rH9e6Q0Ei+/evpcdwzIcU4DnfCsJbXD/3fzLRk3weIh8Jbn85D2yBOaiHlOy1Ij 70EoEjE/a0a5mG74BJZ0kB9hohYooyTxdzwL4tRvWSQOrc0LZp1hvO7o5g2Orq7cAD 581zSHYD7PdTKvzV9Iqt9uMyml4z0nqhIzCjqZ5hDsi+HNAx80SJkMZ6NIHS5raroT 9RMbpSSwYEkniT4heI6UGS640jLv0gMSrUTJpPUjPv2AYV1NreZxBjHknWQLgYzaQZ wnFcksso4yoBF3nEC+ea83im1nG0tqdJ/MGoz4ypPQYmh8iNUON9jmEh5ag4oz91dA 1g9XW9XIIKfyA== Date: Wed, 1 Oct 2025 20:52:39 +0000 From: Elle Rhumsaa To: Michal Wilczynski Cc: Uwe =?iso-8859-1?Q?Kleine-K=F6nig?= , Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?iso-8859-1?Q?Bj=F6rn?= Roy Baron , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Guo Ren , Fu Wei , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , Marek Szyprowski , Benno Lossin , Michael Turquette , Drew Fustini , Daniel Almeida , linux-kernel@vger.kernel.org, linux-pwm@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-riscv@lists.infradead.org, devicetree@vger.kernel.org Subject: Re: [PATCH v15 2/7] rust: pwm: Add Kconfig and basic data structures Message-ID: References: <20250930-rust-next-pwm-working-fan-for-sending-v15-0-5661c3090877@samsung.com> <20250930-rust-next-pwm-working-fan-for-sending-v15-2-5661c3090877@samsung.com> Mime-Version: 1.0 Content-Disposition: inline In-Reply-To: <20250930-rust-next-pwm-working-fan-for-sending-v15-2-5661c3090877@samsung.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20251001_135246_383822_37F0FC5D X-CRM114-Status: GOOD ( 27.00 ) 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 T24gVHVlLCBTZXAgMzAsIDIwMjUgYXQgMDI6MjA6MzNQTSArMDIwMCwgTWljaGFsIFdpbGN6eW5z a2kgd3JvdGU6Cj4gSW50cm9kdWNlIHRoZSBmb3VuZGF0aW9uYWwgc3VwcG9ydCBmb3IgUFdNIGFi c3RyYWN0aW9ucyBpbiBSdXN0Lgo+IAo+IFRoaXMgY29tbWl0IGFkZHMgdGhlIGBSVVNUX1BXTV9B QlNUUkFDVElPTlNgIEtjb25maWcgb3B0aW9uIHRvIGVuYWJsZQo+IHRoZSBmZWF0dXJlLCBhbG9u ZyB3aXRoIHRoZSBuZWNlc3NhcnkgYnVpbGQtc3lzdGVtIHN1cHBvcnQgYW5kIEMKPiBoZWxwZXJz Lgo+IAo+IEl0IGFsc28gaW50cm9kdWNlcyB0aGUgZmlyc3Qgc2V0IG9mIHNhZmUgd3JhcHBlcnMg Zm9yIHRoZSBQV00KPiBzdWJzeXN0ZW0sIGNvdmVyaW5nIHRoZSBiYXNpYyBkYXRhIGNhcnJ5aW5n IEMgc3RydWN0cyBhbmQgZW51bXM6Cj4gLSBgUG9sYXJpdHlgOiBBIHNhZmUgd3JhcHBlciBmb3Ig YGVudW0gcHdtX3BvbGFyaXR5YC4KPiAtIGBXYXZlZm9ybWA6IEEgd3JhcHBlciBmb3IgYHN0cnVj dCBwd21fd2F2ZWZvcm1gLgo+IC0gYFN0YXRlYDogQSB3cmFwcGVyIGZvciBgc3RydWN0IHB3bV9z dGF0ZWAuCj4gCj4gVGhlc2UgdHlwZXMgcHJvdmlkZSBtZW1vcnkgc2FmZSwgaWRpb21hdGljIFJ1 c3QgcmVwcmVzZW50YXRpb25zIG9mIHRoZQo+IGNvcmUgUFdNIGRhdGEgc3RydWN0dXJlcyBhbmQg Zm9ybSB0aGUgYnVpbGRpbmcgYmxvY2tzIGZvciB0aGUKPiBhYnN0cmFjdGlvbnMgdGhhdCB3aWxs IGZvbGxvdy4KPiAKPiBUZXN0ZWQtYnk6IERyZXcgRnVzdGluaSA8ZnVzdGluaUBrZXJuZWwub3Jn Pgo+IFJldmlld2VkLWJ5OiBEYW5pZWwgQWxtZWlkYSA8ZGFuaWVsLmFsbWVpZGFAY29sbGFib3Jh LmNvbT4KPiBSZXZpZXdlZC1ieTogRWxsZSBSaHVtc2FhIDxlbGxlQHdlYXRoZXJlZC1zdGVlbC5k ZXY+Cj4gU2lnbmVkLW9mZi1ieTogTWljaGFsIFdpbGN6eW5za2kgPG0ud2lsY3p5bnNraUBzYW1z dW5nLmNvbT4KPiAtLS0KPiAgTUFJTlRBSU5FUlMgICAgICAgICAgICAgICAgICAgICB8ICAgOCAr KysrCj4gIGRyaXZlcnMvcHdtL0tjb25maWcgICAgICAgICAgICAgfCAgMTMgKysrKysKPiAgcnVz dC9iaW5kaW5ncy9iaW5kaW5nc19oZWxwZXIuaCB8ICAgMSArCj4gIHJ1c3QvaGVscGVycy9oZWxw ZXJzLmMgICAgICAgICAgfCAgIDEgKwo+ICBydXN0L2hlbHBlcnMvcHdtLmMgICAgICAgICAgICAg IHwgIDIwICsrKysrKysrCj4gIHJ1c3Qva2VybmVsL2xpYi5ycyAgICAgICAgICAgICAgfCAgIDIg Kwo+ICBydXN0L2tlcm5lbC9wd20ucnMgICAgICAgICAgICAgIHwgMTAyICsrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysKPiAgNyBmaWxlcyBjaGFuZ2VkLCAxNDcgaW5zZXJ0 aW9ucygrKQo+IAo+IGRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCj4gaW5k ZXggZmUxNjg0NzdjYWE0NTc5OWRmZTA3ZGUyZjU0ZGU2ZDZhMWNlMDYxNS4uNWQ3YzA2NzZjMWQw MGEwMmIzZDdkYjJkZTg4YjAzOWMwOGM5OWM2ZSAxMDA2NDQKPiAtLS0gYS9NQUlOVEFJTkVSUwo+ ICsrKyBiL01BSU5UQUlORVJTCj4gQEAgLTIwMzg3LDYgKzIwMzg3LDE0IEBAIEY6CWluY2x1ZGUv bGludXgvcHdtLmgKPiAgRjoJaW5jbHVkZS9saW51eC9wd21fYmFja2xpZ2h0LmgKPiAgSzoJcHdt Xyhjb25maWd8YXBwbHlfbWlnaHRfc2xlZXB8YXBwbHlfYXRvbWljfG9wcykKPiAgCj4gK1BXTSBT VUJTWVNURU0gQklORElOR1MgW1JVU1RdCj4gK006CU1pY2hhbCBXaWxjenluc2tpIDxtLndpbGN6 eW5za2lAc2Ftc3VuZy5jb20+Cj4gK0w6CWxpbnV4LXB3bUB2Z2VyLmtlcm5lbC5vcmcKPiArTDoJ cnVzdC1mb3ItbGludXhAdmdlci5rZXJuZWwub3JnCj4gK1M6CU1haW50YWluZWQKPiArRjoJcnVz dC9oZWxwZXJzL3B3bS5jCj4gK0Y6CXJ1c3Qva2VybmVsL3B3bS5ycwo+ICsKPiAgUFhBIEdQSU8g RFJJVkVSCj4gIE06CVJvYmVydCBKYXJ6bWlrIDxyb2JlcnQuamFyem1pa0BmcmVlLmZyPgo+ICBM OglsaW51eC1ncGlvQHZnZXIua2VybmVsLm9yZwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3B3bS9L Y29uZmlnIGIvZHJpdmVycy9wd20vS2NvbmZpZwo+IGluZGV4IGYwMGNlOTczZGRkZjY1MTI4NzE2 OGI0NDIyODU3NGY0ZDVjMjhkYzAuLjJiNjA4ZjQzNzgxMzg3NzVlZTNiYTRkNTNmNjgyOTUyZTE5 MTQxMTggMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9wd20vS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMv cHdtL0tjb25maWcKPiBAQCAtODAwLDQgKzgwMCwxNyBAQCBjb25maWcgUFdNX1hJTElOWAo+ICAJ ICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9kdWxlLCBjaG9vc2UgTSBoZXJlOiB0aGUg bW9kdWxlCj4gIAkgIHdpbGwgYmUgY2FsbGVkIHB3bS14aWxpbnguCj4gIAo+ICsgY29uZmlnIFJV U1RfUFdNX0FCU1RSQUNUSU9OUwo+ICsJYm9vbCAiUnVzdCBQV00gYWJzdHJhY3Rpb25zIHN1cHBv cnQiCj4gKwlkZXBlbmRzIG9uIFJVU1QKPiArCWRlcGVuZHMgb24gUFdNPXkKPiArCWhlbHAKPiAr CSAgVGhpcyBvcHRpb24gZW5hYmxlcyB0aGUgc2FmZSBSdXN0IGFic3RyYWN0aW9uIGxheWVyIGZv ciB0aGUgUFdNCj4gKwkgIHN1YnN5c3RlbS4gSXQgcHJvdmlkZXMgaWRpb21hdGljIHdyYXBwZXJz IGFuZCB0cmFpdHMgbmVjZXNzYXJ5IGZvcgo+ICsJICB3cml0aW5nIFBXTSBjb250cm9sbGVyIGRy aXZlcnMgaW4gUnVzdC4KPiArCj4gKwkgIFRoZSBhYnN0cmFjdGlvbnMgaGFuZGxlIHJlc291cmNl IG1hbmFnZW1lbnQgKGxpa2UgbWVtb3J5IGFuZCByZWZlcmVuY2UKPiArCSAgY291bnRpbmcpIGFu ZCBwcm92aWRlIHNhZmUgaW50ZXJmYWNlcyB0byB0aGUgdW5kZXJseWluZyBDIGNvcmUsCj4gKwkg IGFsbG93aW5nIGRyaXZlciBsb2dpYyB0byBiZSB3cml0dGVuIGluIHNhZmUgUnVzdC4KPiArCj4g IGVuZGlmCj4gZGlmZiAtLWdpdCBhL3J1c3QvYmluZGluZ3MvYmluZGluZ3NfaGVscGVyLmggYi9y dXN0L2JpbmRpbmdzL2JpbmRpbmdzX2hlbHBlci5oCj4gaW5kZXggODRkNjA2MzVlOGE5YmFlZjFm MWExYjI3NTJkYzBmYTA0NGY4NTQyZi4uN2EwNmVlNTc4MWVhZGM5ZjIxY2NkNDU2YjU3NGE5Y2Ix NTJjZDU4YyAxMDA2NDQKPiAtLS0gYS9ydXN0L2JpbmRpbmdzL2JpbmRpbmdzX2hlbHBlci5oCj4g KysrIGIvcnVzdC9iaW5kaW5ncy9iaW5kaW5nc19oZWxwZXIuaAo+IEBAIC02Niw2ICs2Niw3IEBA Cj4gICNpbmNsdWRlIDxsaW51eC9wbV9vcHAuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L3BvbGwuaD4K PiAgI2luY2x1ZGUgPGxpbnV4L3Byb3BlcnR5Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9wd20uaD4K PiAgI2luY2x1ZGUgPGxpbnV4L3JlZmNvdW50Lmg+Cj4gICNpbmNsdWRlIDxsaW51eC9yZWd1bGF0 b3IvY29uc3VtZXIuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+Cj4gZGlmZiAtLWdpdCBh L3J1c3QvaGVscGVycy9oZWxwZXJzLmMgYi9ydXN0L2hlbHBlcnMvaGVscGVycy5jCj4gaW5kZXgg N2NmN2ZlOTVlNDFkZDUxNzE3MDUwNjQ4ZDYxNjBiZWJlYmRmNGIyNi4uODYxMDUyZmZmZmFmZjYw ZTljMmU4MTA5ZTU1ZjNiNjE1OGZmMjI4MSAxMDA2NDQKPiAtLS0gYS9ydXN0L2hlbHBlcnMvaGVs cGVycy5jCj4gKysrIGIvcnVzdC9oZWxwZXJzL2hlbHBlcnMuYwo+IEBAIC0zNSw2ICszNSw3IEBA Cj4gICNpbmNsdWRlICJwbGF0Zm9ybS5jIgo+ICAjaW5jbHVkZSAicG9sbC5jIgo+ICAjaW5jbHVk ZSAicHJvcGVydHkuYyIKPiArI2luY2x1ZGUgInB3bS5jIgo+ICAjaW5jbHVkZSAicmJ0cmVlLmMi Cj4gICNpbmNsdWRlICJyY3UuYyIKPiAgI2luY2x1ZGUgInJlZmNvdW50LmMiCj4gZGlmZiAtLWdp dCBhL3J1c3QvaGVscGVycy9wd20uYyBiL3J1c3QvaGVscGVycy9wd20uYwo+IG5ldyBmaWxlIG1v ZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uZDc1YzU4ODg2MzY4NWQzOTkwYjUyNWJiMWI4NGFhNGJjMzVhYzM5Nwo+IC0tLSAvZGV2L251 bGwKPiArKysgYi9ydXN0L2hlbHBlcnMvcHdtLmMKPiBAQCAtMCwwICsxLDIwIEBACj4gKy8vIFNQ RFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCj4gKy8vIENvcHlyaWdodCAoYykgMjAyNSBT YW1zdW5nIEVsZWN0cm9uaWNzIENvLiwgTHRkLgo+ICsvLyBBdXRob3I6IE1pY2hhbCBXaWxjenlu c2tpIDxtLndpbGN6eW5za2lAc2Ftc3VuZy5jb20+Cj4gKwo+ICsjaW5jbHVkZSA8bGludXgvcHdt Lmg+Cj4gKwo+ICtzdHJ1Y3QgZGV2aWNlICpydXN0X2hlbHBlcl9wd21jaGlwX3BhcmVudChjb25z dCBzdHJ1Y3QgcHdtX2NoaXAgKmNoaXApCj4gK3sKPiArCXJldHVybiBwd21jaGlwX3BhcmVudChj aGlwKTsKPiArfQo+ICsKPiArdm9pZCAqcnVzdF9oZWxwZXJfcHdtY2hpcF9nZXRfZHJ2ZGF0YShz dHJ1Y3QgcHdtX2NoaXAgKmNoaXApCj4gK3sKPiArCXJldHVybiBwd21jaGlwX2dldF9kcnZkYXRh KGNoaXApOwo+ICt9Cj4gKwo+ICt2b2lkIHJ1c3RfaGVscGVyX3B3bWNoaXBfc2V0X2RydmRhdGEo c3RydWN0IHB3bV9jaGlwICpjaGlwLCB2b2lkICpkYXRhKQo+ICt7Cj4gKwlwd21jaGlwX3NldF9k cnZkYXRhKGNoaXAsIGRhdGEpOwo+ICt9Cj4gZGlmZiAtLWdpdCBhL3J1c3Qva2VybmVsL2xpYi5y cyBiL3J1c3Qva2VybmVsL2xpYi5ycwo+IGluZGV4IGVkNTMxNjllNzk1YzBiYWRmNTQ4MDI1YTU3 Zjk0NmZhMThiYzczZTMuLmUzMzliNTUyZjk2NTA4MDNiMWVmYTFlYjhlY2M2ZmU5ZDJjNTY1NjMg MTAwNjQ0Cj4gLS0tIGEvcnVzdC9rZXJuZWwvbGliLnJzCj4gKysrIGIvcnVzdC9rZXJuZWwvbGli LnJzCj4gQEAgLTExNyw2ICsxMTcsOCBAQAo+ICBwdWIgbW9kIHNlcV9maWxlOwo+ICBwdWIgbW9k IHNpemVzOwo+ICBtb2Qgc3RhdGljX2Fzc2VydDsKPiArI1tjZmcoQ09ORklHX1JVU1RfUFdNX0FC U1RSQUNUSU9OUyldCj4gK3B1YiBtb2QgcHdtOwo+ICAjW2RvYyhoaWRkZW4pXQo+ICBwdWIgbW9k IHN0ZF92ZW5kb3I7Cj4gIHB1YiBtb2Qgc3RyOwo+IGRpZmYgLS1naXQgYS9ydXN0L2tlcm5lbC9w d20ucnMgYi9ydXN0L2tlcm5lbC9wd20ucnMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJlYWJmMDA4NmEyZjFi ZWVhMDFlMGIwYTlmNjU0MGM2MDFmNzdhNDkKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvcnVzdC9r ZXJuZWwvcHdtLnJzCj4gQEAgLTAsMCArMSwxMDIgQEAKPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50 aWZpZXI6IEdQTC0yLjAKPiArLy8gQ29weXJpZ2h0IChjKSAyMDI1IFNhbXN1bmcgRWxlY3Ryb25p Y3MgQ28uLCBMdGQuCj4gKy8vIEF1dGhvcjogTWljaGFsIFdpbGN6eW5za2kgPG0ud2lsY3p5bnNr aUBzYW1zdW5nLmNvbT4KPiArCj4gKy8vISBQV00gc3Vic3lzdGVtIGFic3RyYWN0aW9ucy4KPiAr Ly8hCj4gKy8vISBDIGhlYWRlcjogW2BpbmNsdWRlL2xpbnV4L3B3bS5oYF0oc3JjdHJlZS9pbmNs dWRlL2xpbnV4L3B3bS5oKS4KPiArCj4gK3VzZSBjcmF0ZTo6ewo+ICsgICAgYmluZGluZ3MsCj4g KyAgICBwcmVsdWRlOjoqLAo+ICsgICAgdHlwZXM6Ok9wYXF1ZSwKPiArfTsKPiArdXNlIGNvcmU6 OmNvbnZlcnQ6OlRyeUZyb207Cj4gKwo+ICsvLy8gUFdNIHBvbGFyaXR5LiBNaXJyb3JzIFtgZW51 bSBwd21fcG9sYXJpdHlgXShzcmN0cmVlL2luY2x1ZGUvbGludXgvcHdtLmgpLgo+ICsjW2Rlcml2 ZShDb3B5LCBDbG9uZSwgRGVidWcsIFBhcnRpYWxFcSwgRXEpXQo+ICtwdWIgZW51bSBQb2xhcml0 eSB7Cj4gKyAgICAvLy8gTm9ybWFsIHBvbGFyaXR5IChkdXR5IGN5Y2xlIGRlZmluZXMgdGhlIGhp Z2ggcGVyaW9kIG9mIHRoZSBzaWduYWwpLgo+ICsgICAgTm9ybWFsLAo+ICsKPiArICAgIC8vLyBJ bnZlcnNlZCBwb2xhcml0eSAoZHV0eSBjeWNsZSBkZWZpbmVzIHRoZSBsb3cgcGVyaW9kIG9mIHRo ZSBzaWduYWwpLgo+ICsgICAgSW52ZXJzZWQsCj4gK30KPiArCj4gK2ltcGwgVHJ5RnJvbTxiaW5k aW5nczo6cHdtX3BvbGFyaXR5PiBmb3IgUG9sYXJpdHkgewo+ICsgICAgdHlwZSBFcnJvciA9IEVy cm9yOwo+ICsKPiArICAgIGZuIHRyeV9mcm9tKHBvbGFyaXR5OiBiaW5kaW5nczo6cHdtX3BvbGFy aXR5KSAtPiBSZXN1bHQ8U2VsZiwgRXJyb3I+IHsKPiArICAgICAgICBtYXRjaCBwb2xhcml0eSB7 Cj4gKyAgICAgICAgICAgIGJpbmRpbmdzOjpwd21fcG9sYXJpdHlfUFdNX1BPTEFSSVRZX05PUk1B TCA9PiBPayhQb2xhcml0eTo6Tm9ybWFsKSwKPiArICAgICAgICAgICAgYmluZGluZ3M6OnB3bV9w b2xhcml0eV9QV01fUE9MQVJJVFlfSU5WRVJTRUQgPT4gT2soUG9sYXJpdHk6OkludmVyc2VkKSwK PiArICAgICAgICAgICAgXyA9PiBFcnIoRUlOVkFMKSwKPiArICAgICAgICB9Cj4gKyAgICB9Cj4g K30KPiArCj4gK2ltcGwgRnJvbTxQb2xhcml0eT4gZm9yIGJpbmRpbmdzOjpwd21fcG9sYXJpdHkg ewo+ICsgICAgZm4gZnJvbShwb2xhcml0eTogUG9sYXJpdHkpIC0+IFNlbGYgewo+ICsgICAgICAg IG1hdGNoIHBvbGFyaXR5IHsKPiArICAgICAgICAgICAgUG9sYXJpdHk6Ok5vcm1hbCA9PiBiaW5k aW5nczo6cHdtX3BvbGFyaXR5X1BXTV9QT0xBUklUWV9OT1JNQUwsCj4gKyAgICAgICAgICAgIFBv bGFyaXR5OjpJbnZlcnNlZCA9PiBiaW5kaW5nczo6cHdtX3BvbGFyaXR5X1BXTV9QT0xBUklUWV9J TlZFUlNFRCwKPiArICAgICAgICB9Cj4gKyAgICB9Cj4gK30KPiArCj4gKy8vLyBSZXByZXNlbnRz IGEgUFdNIHdhdmVmb3JtIGNvbmZpZ3VyYXRpb24uCj4gKy8vLyBNaXJyb3JzIHN0cnVjdCBbYHN0 cnVjdCBwd21fd2F2ZWZvcm1gXShzcmN0cmVlL2luY2x1ZGUvbGludXgvcHdtLmgpLgo+ICsjW2Rl cml2ZShDb3B5LCBDbG9uZSwgRGVidWcsIERlZmF1bHQsIFBhcnRpYWxFcSwgRXEpXQo+ICtwdWIg c3RydWN0IFdhdmVmb3JtIHsKPiArICAgIC8vLyBUb3RhbCBkdXJhdGlvbiBvZiBvbmUgY29tcGxl dGUgUFdNIGN5Y2xlLCBpbiBuYW5vc2Vjb25kcy4KPiArICAgIHB1YiBwZXJpb2RfbGVuZ3RoX25z OiB1NjQsCj4gKwo+ICsgICAgLy8vIER1dHktY3ljbGUgYWN0aXZlIHRpbWUsIGluIG5hbm9zZWNv bmRzLgo+ICsgICAgLy8vCj4gKyAgICAvLy8gRm9yIGEgdHlwaWNhbCBub3JtYWwgcG9sYXJpdHkg Y29uZmlndXJhdGlvbiAoYWN0aXZlLWhpZ2gpIHRoaXMgaXMgdGhlCj4gKyAgICAvLy8gaGlnaCB0 aW1lIG9mIHRoZSBzaWduYWwuCj4gKyAgICBwdWIgZHV0eV9sZW5ndGhfbnM6IHU2NCwKPiArCj4g KyAgICAvLy8gRHV0eS1jeWNsZSBzdGFydCBvZmZzZXQsIGluIG5hbm9zZWNvbmRzLgo+ICsgICAg Ly8vCj4gKyAgICAvLy8gRGVsYXkgZnJvbSB0aGUgYmVnaW5uaW5nIG9mIHRoZSBwZXJpb2QgdG8g dGhlIGZpcnN0IGFjdGl2ZSBlZGdlLgo+ICsgICAgLy8vIEluIG1vc3Qgc2ltcGxlIFBXTSBzZXR1 cHMgdGhpcyBpcyBgMGAsIHNvIHRoZSBkdXR5IGN5Y2xlIHN0YXJ0cwo+ICsgICAgLy8vIGltbWVk aWF0ZWx5IGF0IGVhY2ggcGVyaW9k4oCZcyBzdGFydC4KPiArICAgIHB1YiBkdXR5X29mZnNldF9u czogdTY0LAo+ICt9Cj4gKwo+ICtpbXBsIEZyb208YmluZGluZ3M6OnB3bV93YXZlZm9ybT4gZm9y IFdhdmVmb3JtIHsKPiArICAgIGZuIGZyb20od2Y6IGJpbmRpbmdzOjpwd21fd2F2ZWZvcm0pIC0+ IFNlbGYgewo+ICsgICAgICAgIFdhdmVmb3JtIHsKPiArICAgICAgICAgICAgcGVyaW9kX2xlbmd0 aF9uczogd2YucGVyaW9kX2xlbmd0aF9ucywKPiArICAgICAgICAgICAgZHV0eV9sZW5ndGhfbnM6 IHdmLmR1dHlfbGVuZ3RoX25zLAo+ICsgICAgICAgICAgICBkdXR5X29mZnNldF9uczogd2YuZHV0 eV9vZmZzZXRfbnMsCj4gKyAgICAgICAgfQo+ICsgICAgfQo+ICt9Cj4gKwo+ICtpbXBsIEZyb208 V2F2ZWZvcm0+IGZvciBiaW5kaW5nczo6cHdtX3dhdmVmb3JtIHsKPiArICAgIGZuIGZyb20od2Y6 IFdhdmVmb3JtKSAtPiBTZWxmIHsKPiArICAgICAgICBiaW5kaW5nczo6cHdtX3dhdmVmb3JtIHsK PiArICAgICAgICAgICAgcGVyaW9kX2xlbmd0aF9uczogd2YucGVyaW9kX2xlbmd0aF9ucywKPiAr ICAgICAgICAgICAgZHV0eV9sZW5ndGhfbnM6IHdmLmR1dHlfbGVuZ3RoX25zLAo+ICsgICAgICAg ICAgICBkdXR5X29mZnNldF9uczogd2YuZHV0eV9vZmZzZXRfbnMsCj4gKyAgICAgICAgfQo+ICsg ICAgfQo+ICt9Cj4gKwo+ICsvLy8gV3JhcHBlciBmb3IgUFdNIHN0YXRlIFtgc3RydWN0IHB3bV9z dGF0ZWBdKHNyY3RyZWUvaW5jbHVkZS9saW51eC9wd20uaCkuCj4gKyNbcmVwcih0cmFuc3BhcmVu dCldCj4gK3B1YiBzdHJ1Y3QgU3RhdGUoYmluZGluZ3M6OnB3bV9zdGF0ZSk7Cj4gKwo+ICtpbXBs IFN0YXRlIHsKPiArICAgIC8vLyBDcmVhdGVzIGEgYFN0YXRlYCB3cmFwcGVyIGJ5IHRha2luZyBv d25lcnNoaXAgb2YgYSBDIGBwd21fc3RhdGVgIHZhbHVlLgo+ICsgICAgcHViKGNyYXRlKSBmbiBm cm9tX2MoY19zdGF0ZTogYmluZGluZ3M6OnB3bV9zdGF0ZSkgLT4gU2VsZiB7Cj4gKyAgICAgICAg U3RhdGUoY19zdGF0ZSkKPiArICAgIH0KPiArCj4gKyAgICAvLy8gUmV0dXJucyBgdHJ1ZWAgaWYg dGhlIFBXTSBzaWduYWwgaXMgZW5hYmxlZC4KPiArICAgIHB1YiBmbiBlbmFibGVkKCZzZWxmKSAt PiBib29sIHsKPiArICAgICAgICBzZWxmLjAuZW5hYmxlZAo+ICsgICAgfQo+ICt9Cj4gCj4gLS0g Cj4gMi4zNC4xCj4gCgpSZXZpZXdlZC1ieTogRWxsZSBSaHVtc2FhIDxlbGxlQHdlYXRoZXJlZC1z dGVlbC5kZXY+CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwpsaW51eC1yaXNjdiBtYWlsaW5nIGxpc3QKbGludXgtcmlzY3ZAbGlzdHMuaW5mcmFkZWFkLm9y ZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJpc2N2 Cg==