From nobody Thu Apr 16 02:49:20 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 3E87D3233F4; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; cv=none; b=NXIPXvCf/KgYUmvZelCg8fZUMbY7xI8Eo5QWIgkUmk9kNNEWwVO9iuype43QhBoSPG0bzciCBuhP9mxRZi1PplhNj65oXxmCaLNAvvPSCYRmfa2QY33xQPHFInfoogrcN9U0FKwD0d42a4nF9PKkAWy4hOofEbOzUFOBRSRHZms= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; c=relaxed/simple; bh=oQRNQtP0Mu+VhP7ss07aer6abRPFBoH8+Skh4xsP5iQ=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=rNT7XXSu3wOkujXLFjtA++FNZsrjyBzQhW/My99wS8ReVZWpQ6FU/tWavFL22uBeMTPbS0yoOwjimwOCdBXItIXb8LSskn7CnPgblMJoKoqUEx4vjXQoWSAnd3UMR1o03Q/CUQeyrJ+rJjQFsE8W/E5JzQQfrvXpDk9YrHTVp24= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ujv+GkjJ; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="ujv+GkjJ" Received: by smtp.kernel.org (Postfix) with ESMTPS id F1B92C2BCB5; Wed, 15 Apr 2026 09:52:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776246738; bh=oQRNQtP0Mu+VhP7ss07aer6abRPFBoH8+Skh4xsP5iQ=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=ujv+GkjJxxDz/eMSX5Eow8Pc5ErWG9KHQQE37eG75PSdT4GoSIz24dnONmoU8hmBA 4ljc4cyfaCHNEz7mYKzKnu1wtw2B6IrDa1nYg+tuf+HiwDepNhsNOmI2FpMGG/M2/v WEYL/H5Cm9mHUiN9kjmO3yYl2wOROky+zWJ6y1ITn0Dhz2465j351NIsqU3ToGypiW oXSUMQAgjFJNC9GGLSMEgq90C5Zr6WQIvsIXsEX2CLlWSnXLPrFTvOeIRkDCR5AKwW +pKVS3Zp+bk83jIusl9uoAxDj4U7hvYtYsxZ6gZXNMRs61bJQuQ0RwuJSxqrHd8Ptp dJKJrDfbDNYDg== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id E0C12F41987; Wed, 15 Apr 2026 09:52:17 +0000 (UTC) From: Rodrigo Alencar via B4 Relay Date: Wed, 15 Apr 2026 10:51:44 +0100 Subject: [PATCH v10 01/11] dt-bindings: iio: frequency: add adf41513 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260415-adf41513-iio-driver-v10-1-df61046d5457@analog.com> References: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> In-Reply-To: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> To: linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jonathan Cameron , David Lechner , Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet , Andrew Morton , Petr Mladek , Steven Rostedt , Andy Shevchenko , Rasmus Villemoes , Sergey Senozhatsky , Shuah Khan , Rodrigo Alencar , Krzysztof Kozlowski X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1776246736; l=9281; i=rodrigo.alencar@analog.com; s=default; h=from:subject:message-id; bh=6PPSDxQtzDNN7iKcHepdk2du6jUDlEQ2vG/F8xUgeeU=; b=w+7mPtjI3gjJps16/HgLadsp8T9oy4LMLJb4TetWrO2okl7VuE99ew6m/9j99+lR2D5pFjbFk OcoygJ7A0OoB9SeGhEIIXROkSeGHquL9xeL5XgQCm5LczbOQCFNT/qg X-Developer-Key: i=rodrigo.alencar@analog.com; a=ed25519; pk=ULeHbgU/OYh/PG/4anHDfLgldFItQHAhOktYRVLMFRo= X-Endpoint-Received: by B4 Relay for rodrigo.alencar@analog.com/default with auth_id=561 X-Original-From: Rodrigo Alencar Reply-To: rodrigo.alencar@analog.com From: Rodrigo Alencar DT-bindings for ADF41513, an ultralow noise PLL frequency synthesizer that can be used to implement local oscillators (LOs) as high as 26.5 GHz. Some properties are based upon an existing PLL device properties (e.g. ADF4350). Reviewed-by: Krzysztof Kozlowski Signed-off-by: Rodrigo Alencar --- .../bindings/iio/frequency/adi,adf41513.yaml | 215 +++++++++++++++++= ++++ MAINTAINERS | 7 + 2 files changed, 222 insertions(+) diff --git a/Documentation/devicetree/bindings/iio/frequency/adi,adf41513.y= aml b/Documentation/devicetree/bindings/iio/frequency/adi,adf41513.yaml new file mode 100644 index 000000000000..2d09cb94b6ff --- /dev/null +++ b/Documentation/devicetree/bindings/iio/frequency/adi,adf41513.yaml @@ -0,0 +1,215 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/iio/frequency/adi,adf41513.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Analog Devices ADF41513 PLL Frequency Synthesizer + +maintainers: + - Rodrigo Alencar + +description: + The ADF41513 is an ultralow noise frequency synthesizer that can be used= to + implement local oscillators (LOs) as high as 26.5 GHz in the upconversio= n and + downconversion sections of wireless receivers and transmitters. The ADF4= 1510 + supports frequencies up to 10 GHz. + + https://www.analog.com/en/products/adf41510.html + https://www.analog.com/en/products/adf41513.html + +$ref: /schemas/spi/spi-peripheral-props.yaml# + +properties: + compatible: + enum: + - adi,adf41510 + - adi,adf41513 + + reg: + maxItems: 1 + + spi-max-frequency: + maximum: 25000000 + + clocks: + maxItems: 1 + description: Clock that provides the reference input frequency. + + avdd1-supply: + description: PFD and Up and Down Digital Driver Power Supply (3.3 V) + + avdd2-supply: + description: RF Buffer and Prescaler Power Supply (3.3 V) + + avdd3-supply: + description: N Divider Power Supply (3.3 V) + + avdd4-supply: + description: R Divider and Lock Detector Power Supply (3.3 V) + + avdd5-supply: + description: Sigma-Delta Modulator and SPI Power Supply (3.3 V) + + vp-supply: + description: Charge Pump Power Supply (3.3 V) + + enable-gpios: + description: + GPIO that controls the chip enable pin. A logic low on this pin + powers down the device and puts the charge pump output into + three-state mode. + maxItems: 1 + + lock-detect-gpios: + description: + GPIO for lock detect functionality. When configured for digital lock + detect, this pin will output a logic high when the PLL is locked. + maxItems: 1 + + adi,power-up-frequency-mhz: + minimum: 1000 + maximum: 26500 + default: 10000 + description: + The PLL tunes to this frequency during the initialization sequence. + This property should be set to a frequency supported by the loop fil= ter + and VCO used in the design. Range is 1 GHz to 26.5 GHz for ADF41513, + and 1 GHz to 10 GHz for ADF41510. + + adi,reference-div-factor: + $ref: /schemas/types.yaml#/definitions/uint32 + minimum: 1 + maximum: 32 + default: 1 + description: + Value for the reference division factor (R Counter). The driver will + increment R Counter as needed to achieve a PFD frequency within the + allowed range. High R counter values will reduce the PFD frequency, = which + lowers the frequency resolution, and affects phase noise performance. + As it affects the PFD frequency, this value depends on the loop filt= er + design. + + adi,reference-doubler-enable: + description: + Enables the reference doubler when deriving the PFD frequency. + The maximum reference frequency when the doubler is enabled is 225 M= Hz. + As it affects the PFD frequency, this value depends on the loop filt= er + design. + type: boolean + + adi,reference-div2-enable: + description: + Enables the reference divide-by-2 function when deriving the PFD + frequency. As it affects the PFD frequency, this value depends on the + loop filter design. + type: boolean + + adi,charge-pump-resistor-ohms: + minimum: 1800 + maximum: 10000 + default: 2700 + description: + External charge pump resistor (R_SET) value in ohms. This sets the m= aximum + charge pump current along with the charge pump current setting. + + adi,charge-pump-current-microamp: + description: + Charge pump current (I_CP) in microamps. The value will be rounded t= o the + nearest supported value. Range of acceptable values depends on the + charge pump resistor value, such that 810 mV <=3D I_CP * R_SET <=3D = 12960 mV. + This value depends on the loop filter and the VCO design. + + adi,logic-level-1v8-enable: + description: + Set MUXOUT and DLD logic levels to 1.8V. Default is 3.3V. + type: boolean + + adi,phase-detector-polarity-positive-enable: + description: + Set phase detector polarity to positive. Default is negative. + Use positive polarity with non-inverting loop filter and VCO with + positive tuning slope, or with inverting loop filter and VCO with + negative tuning slope. + type: boolean + + adi,lock-detector-count: + $ref: /schemas/types.yaml#/definitions/uint32 + default: 64 + description: + Sets the value for Lock Detector count of the PLL, which determines = the + number of consecutive phase detector cycles that must be within the = lock + detector window before lock is declared. Lower values increase the l= ock + detection sensitivity, while higher values provides a more stable lo= ck + detection. Applications that consume the lock detect signal may requ= ire + different settings based on system requirements. + enum: [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192] + + adi,phase-resync-period-ns: + default: 0 + description: + When this value is non-zero, enable phase resync functionality, which + produces a consistent output phase offset with respect to the input + reference. The value specifies the resync period in nanoseconds, used + to configure clock dividers with respect to the PFD frequency. This = value + should be set to a value that is at least as long as the worst case = lock + time, i.e., it depends mostly on the loop filter design. + + adi,le-sync-enable: + description: + Synchronizes Load Enable (LE) transitions with the reference signal = to + avoid asynchronous glitches in the output. This is recommended when = using + the PLL as a frequency synthesizer, where the reference signal will = always + be present while the device is being configured. When using the PLL = as a + frequency tracker, where the reference signal may be absent, LE sync + should be left disabled. + type: boolean + +dependencies: + adi,charge-pump-resistor-ohms: [ 'adi,charge-pump-current-microamp' ] + +required: + - compatible + - reg + - clocks + - avdd1-supply + - avdd2-supply + - avdd3-supply + - avdd4-supply + - avdd5-supply + - vp-supply + +unevaluatedProperties: false + +examples: + - | + #include + spi { + #address-cells =3D <1>; + #size-cells =3D <0>; + + pll@0 { + compatible =3D "adi,adf41513"; + reg =3D <0>; + spi-max-frequency =3D <25000000>; + clocks =3D <&ref_clk>; + avdd1-supply =3D <&avdd1_3v3>; + avdd2-supply =3D <&avdd2_3v3>; + avdd3-supply =3D <&avdd3_3v3>; + avdd4-supply =3D <&avdd4_3v3>; + avdd5-supply =3D <&avdd5_3v3>; + vp-supply =3D <&vp_3v3>; + enable-gpios =3D <&gpio0 10 GPIO_ACTIVE_HIGH>; + lock-detect-gpios =3D <&gpio0 11 GPIO_ACTIVE_HIGH>; + + adi,power-up-frequency-mhz =3D <15500>; + adi,charge-pump-current-microamp =3D <3600>; + adi,charge-pump-resistor-ohms =3D <2700>; + adi,reference-doubler-enable; + adi,lock-detector-count =3D <64>; + adi,phase-resync-period-ns =3D <0>; + adi,phase-detector-polarity-positive-enable; + adi,le-sync-enable; + }; + }; +... diff --git a/MAINTAINERS b/MAINTAINERS index c981cbdff500..b4511f86c54f 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1654,6 +1654,13 @@ W: https://ez.analog.com/linux-software-drivers F: Documentation/devicetree/bindings/iio/adc/adi,ade9000.yaml F: drivers/iio/adc/ade9000.c =20 +ANALOG DEVICES INC ADF41513 DRIVER +M: Rodrigo Alencar +L: linux-iio@vger.kernel.org +S: Supported +W: https://ez.analog.com/linux-software-drivers +F: Documentation/devicetree/bindings/iio/frequency/adi,adf41513.yaml + ANALOG DEVICES INC ADF4377 DRIVER M: Antoniu Miclaus L: linux-iio@vger.kernel.org --=20 2.43.0 From nobody Thu Apr 16 02:49:20 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 47F33328611; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; cv=none; b=mUT+WicrfBjOXe7GmgvZfxWc38Mb1GHrEFsEmerqm+7xQTEYqZFpXFq6tPW1YTkEG2n4DPvaC3aAJ3LeldG+qHCdw+BoQmfCo3wqQrvaA6odQynjby7rp5QqS4twsUCYNeeYpPbNTHNIKjc+8lMNCn6sIuoEC4xRQFRvxbQ6Y/Q= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; c=relaxed/simple; bh=2+TerP07gtH1TPPTrBAvH+uY0hepaE75kcSpEWfPvAU=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=LjZmEa2SDN6ReXg6MUUpb974GL/XW2OOxd1fr5QEJeHmx0+Ab1njEXpqYdAjz3rebx6BATe/+FR+9b8YWtfnnxA/DvFuPXvMydfNaN/bfZ20cUeTW3790pThZDWiwxS5vLVOufzBaaGaPmO0n08sotxTsLa1a+tM+BzdvVfCLd8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=KsugmP5y; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="KsugmP5y" Received: by smtp.kernel.org (Postfix) with ESMTPS id 0AC1AC2BCB4; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776246738; bh=2+TerP07gtH1TPPTrBAvH+uY0hepaE75kcSpEWfPvAU=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=KsugmP5yun/Vs8rQY8h3/IyYvk1ZKc9v+HSdQpwcNrt2YzRsFK1JzLJmPHNJ7lHNU 9FeKQimibK/SjO6gDXTOtfe4Ap79k2n0sXYl9BoCUpP36ZujJYl7qy0C1/lhqNWd87 U7oWXOZqO3XrOseplvFntRSGthMMcAb1b1ke0iAlHXC4hnU4UBdszntbMcBfcnoBP1 BpyAUTGvOxcIH8MRqFjnsexRoP/1jk6ydx21eTzKemUFOTWteaPfkvCFOyd1SHlJ9h zLw06RkaJ8VcGgh3v9//4r/nrGQV6Ca7gWBkA1FvukixW5LbSVcNWsDFws2/ONWSYI qxvp14fVqaa+w== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id F0E3EF41984; Wed, 15 Apr 2026 09:52:17 +0000 (UTC) From: Rodrigo Alencar via B4 Relay Date: Wed, 15 Apr 2026 10:51:45 +0100 Subject: [PATCH v10 02/11] lib: kstrtox: add kstrtoudec64() and kstrtodec64() Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260415-adf41513-iio-driver-v10-2-df61046d5457@analog.com> References: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> In-Reply-To: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> To: linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jonathan Cameron , David Lechner , Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet , Andrew Morton , Petr Mladek , Steven Rostedt , Andy Shevchenko , Rasmus Villemoes , Sergey Senozhatsky , Shuah Khan , Rodrigo Alencar X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1776246736; l=4926; i=rodrigo.alencar@analog.com; s=default; h=from:subject:message-id; bh=gkjWYVr90c95wpp/Yql7eG3M6Wm527JyFFIrkEU+vqo=; b=HSnxW+fshlzb/IdPSLzVHlS+Hneej/X27VnG5QHCh6Kds867Ljf7abFOT874ebJ8hTCiDUG0H Fvy12dkWztAB4w5Jq3G6DD1WQxeAXv75S95fflOD9V4Ak/OQXDOx0F4 X-Developer-Key: i=rodrigo.alencar@analog.com; a=ed25519; pk=ULeHbgU/OYh/PG/4anHDfLgldFItQHAhOktYRVLMFRo= X-Endpoint-Received: by B4 Relay for rodrigo.alencar@analog.com/default with auth_id=561 X-Original-From: Rodrigo Alencar Reply-To: rodrigo.alencar@analog.com From: Rodrigo Alencar Add helpers that parses decimal numbers into 64-bit number, i.e., decimal point numbers with pre-defined scale are parsed into a 64-bit value (fixed precision). After the decimal point, digits beyond the specified scale are ignored. Signed-off-by: Rodrigo Alencar --- include/linux/kstrtox.h | 3 ++ lib/kstrtox.c | 105 ++++++++++++++++++++++++++++++++++++++++++++= ++++ 2 files changed, 108 insertions(+) diff --git a/include/linux/kstrtox.h b/include/linux/kstrtox.h index 6ea897222af1..bec2fc17bde0 100644 --- a/include/linux/kstrtox.h +++ b/include/linux/kstrtox.h @@ -97,6 +97,9 @@ int __must_check kstrtou8(const char *s, unsigned int bas= e, u8 *res); int __must_check kstrtos8(const char *s, unsigned int base, s8 *res); int __must_check kstrtobool(const char *s, bool *res); =20 +int __must_check kstrtoudec64(const char *s, unsigned int scale, u64 *res); +int __must_check kstrtodec64(const char *s, unsigned int scale, s64 *res); + int __must_check kstrtoull_from_user(const char __user *s, size_t count, u= nsigned int base, unsigned long long *res); int __must_check kstrtoll_from_user(const char __user *s, size_t count, un= signed int base, long long *res); int __must_check kstrtoul_from_user(const char __user *s, size_t count, un= signed int base, unsigned long *res); diff --git a/lib/kstrtox.c b/lib/kstrtox.c index 97be2a39f537..c7625ba4ac88 100644 --- a/lib/kstrtox.c +++ b/lib/kstrtox.c @@ -17,6 +17,7 @@ #include #include #include +#include #include #include =20 @@ -392,6 +393,110 @@ int kstrtobool(const char *s, bool *res) } EXPORT_SYMBOL(kstrtobool); =20 +static int _kstrtoudec64(const char *s, unsigned int scale, u64 *res) +{ + u64 _res =3D 0, _frac =3D 0; + unsigned int rv; + + if (scale > 19) /* log10(2^64) =3D 19.26 */ + return -EINVAL; + + if (*s !=3D '.') { + rv =3D _parse_integer(s, 10, &_res); + if (rv & KSTRTOX_OVERFLOW) + return -ERANGE; + if (rv =3D=3D 0) + return -EINVAL; + s +=3D rv; + } + + if (*s =3D=3D '.' && scale) { + s++; /* skip decimal point */ + rv =3D _parse_integer_limit(s, 10, &_frac, scale); + if (rv & KSTRTOX_OVERFLOW) + return -ERANGE; + if (rv =3D=3D 0) + return -EINVAL; + s +=3D rv; + if (rv < scale) + _frac *=3D int_pow(10, scale - rv); + while (isdigit(*s)) /* truncate */ + s++; + } + + if (*s =3D=3D '\n') + s++; + if (*s) + return -EINVAL; + + if (check_mul_overflow(_res, int_pow(10, scale), &_res) || + check_add_overflow(_res, _frac, &_res)) + return -ERANGE; + + *res =3D _res; + return 0; +} + +/** + * kstrtoudec64 - convert a string to an unsigned 64-bit decimal number + * @s: The start of the string. The string must be null-terminated, and ma= y also + * include a single newline before its terminating null. The first charac= ter + * may also be a plus sign, but not a minus sign. Digits beyond the speci= fied + * scale are ignored. + * @scale: The number of digits to the right of the decimal point. For exa= mple, + * a scale of 2 would mean the number is represented with two decimal pla= ces, + * so "123.45" would be represented as 12345. + * @res: Where to write the result of the conversion on success. + * + * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error. + */ +noinline +int kstrtoudec64(const char *s, unsigned int scale, u64 *res) +{ + if (s[0] =3D=3D '+') + s++; + return _kstrtoudec64(s, scale, res); +} +EXPORT_SYMBOL(kstrtoudec64); + +/** + * kstrtodec64 - convert a string to a signed 64-bit decimal number + * @s: The start of the string. The string must be null-terminated, and ma= y also + * include a single newline before its terminating null. The first charac= ter + * may also be a plus sign or a minus sign. Digits beyond the specified + * scale are ignored. + * @scale: The number of digits to the right of the decimal point. For exa= mple, + * a scale of 5 would mean the number is represented with five decimal pl= aces, + * so "-3.141592" would be represented as -314159. + * @res: Where to write the result of the conversion on success. + * + * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error. + */ +noinline +int kstrtodec64(const char *s, unsigned int scale, s64 *res) +{ + u64 tmp; + int rv; + + if (s[0] =3D=3D '-') { + rv =3D _kstrtoudec64(s + 1, scale, &tmp); + if (rv < 0) + return rv; + if ((s64)-tmp > 0) + return -ERANGE; + *res =3D -tmp; + } else { + rv =3D kstrtoudec64(s, scale, &tmp); + if (rv < 0) + return rv; + if ((s64)tmp < 0) + return -ERANGE; + *res =3D tmp; + } + return 0; +} +EXPORT_SYMBOL(kstrtodec64); + /* * Since "base" would be a nonsense argument, this open-codes the * _from_user helper instead of using the helper macro below. --=20 2.43.0 From nobody Thu Apr 16 02:49:20 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 537A533986F; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; cv=none; b=gr8yfwamtN8m7RoWuk14qHiq7Q/tydZJP3FmrSJei2TCcg6je2PexlaZa6GiDvRAMv2b1Xh8EpFk+8VXLFFFPt/A25iTPn5US70hC6yMNCa8JY3c4YKSUF35kw+wNyXnUlgWI2WwPb9QbunLW/kIS9LQSpskAXd6e70MVwEoP6s= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; c=relaxed/simple; bh=tYSiChWY60UEfjkPSWHZ7WrCYK8Mvc1/d8kd0bxtPTE=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=rS9xOPiaKvjM7YtLf0lMAb0FtK1QhJY4VzK29nbZEEabeJyLBmNgyyGgXRzar05UzL6LZUoQGAt2JQ0o6fJHV9YDXM8rK5TiC/rO9mse8l379tjGSF31Swn0VYbsPow8nGIaE8xxJKPRznbjgFNc4YxWZdUe27UhFkd0nN+bklQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=POHJ89pf; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="POHJ89pf" Received: by smtp.kernel.org (Postfix) with ESMTPS id 1904EC2BCB6; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776246738; bh=tYSiChWY60UEfjkPSWHZ7WrCYK8Mvc1/d8kd0bxtPTE=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=POHJ89pfiXk69Pzr1ukq57Ab041v3rfP3hSyQdW0bA/Ik7AqTZuCqawHr+t/25yxF U2w11OIp0HOcBZNGjF1ER0X+ZZ24pqixJw1xcCV2WyLcyXrOtmhXO+ChLET2e4V/Ev ydkeg3PMXSR35bVPEUgS4YLCAYF6+BL2hYWy+rpqVWYgJ88NgYfYlFmvYN9UBv6j4p 3SYcuvl9Y6zbDX/p9k/ij6vJYxFYMm+uHC9OZckVgXDdYugoX/Yk0A44YjuLxh7LmM qM42YG7Mr385a1XHthc9p5TXY++FapQfquX+tjdZwkjxgg+eafHNSSafF1BrzmCCwv sje6gIOTL69Qw== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0DDBDF41988; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) From: Rodrigo Alencar via B4 Relay Date: Wed, 15 Apr 2026 10:51:46 +0100 Subject: [PATCH v10 03/11] lib: test-kstrtox: tests for kstrtodec64() and kstrtoudec64() Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260415-adf41513-iio-driver-v10-3-df61046d5457@analog.com> References: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> In-Reply-To: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> To: linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jonathan Cameron , David Lechner , Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet , Andrew Morton , Petr Mladek , Steven Rostedt , Andy Shevchenko , Rasmus Villemoes , Sergey Senozhatsky , Shuah Khan , Rodrigo Alencar X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1776246736; l=4968; i=rodrigo.alencar@analog.com; s=default; h=from:subject:message-id; bh=tp8hvAbYc3biI7q7ogMTaReytHsO+RY7GLMjwvwZ1gQ=; b=704ko2KuGMnZE//7PGnbtuXfNh1boSbdctudy9ceg63lFRejeK5xtrYkJPkhlfumppdARxh5c GRr+ZI632rsAzIP4zDSnS6eO7tQaJ7gogP/qFQbruoQY9LVD2nxBCcA X-Developer-Key: i=rodrigo.alencar@analog.com; a=ed25519; pk=ULeHbgU/OYh/PG/4anHDfLgldFItQHAhOktYRVLMFRo= X-Endpoint-Received: by B4 Relay for rodrigo.alencar@analog.com/default with auth_id=561 X-Original-From: Rodrigo Alencar Reply-To: rodrigo.alencar@analog.com From: Rodrigo Alencar Add tests for decimal parsing helpers kstrtodec64() and kstrtoudec64(). The test infrastructure is reused from other kstrto*() functions, i.e., the decimal parsers have fixed base of 10, so base field is used as scale input for the helpers. Signed-off-by: Rodrigo Alencar --- lib/test-kstrtox.c | 156 +++++++++++++++++++++++++++++++++++++++++++++++++= ++++ 1 file changed, 156 insertions(+) diff --git a/lib/test-kstrtox.c b/lib/test-kstrtox.c index ee87fef66cb5..ee9b535bcf1c 100644 --- a/lib/test-kstrtox.c +++ b/lib/test-kstrtox.c @@ -703,6 +703,156 @@ static void __init test_kstrtos8_fail(void) TEST_FAIL(kstrtos8, s8, "%hhd", test_s8_fail); } =20 +static void __init test_kstrtoudec64_ok(void) +{ + DECLARE_TEST_OK(u64, struct test_udec64); + static DEFINE_TEST_OK(struct test_udec64, test_udec64_ok) =3D { + /* basic: integer.fraction, exact digits */ + {"0.0", 1, 0}, + {"1.5", 1, 15}, + {"1.234", 3, 1234}, + {"42.0", 1, 420}, + /* zero */ + {"0.0", 1, 0}, + {"0.000", 3, 0}, + /* integer only (no decimal point) */ + {"0", 1, 0}, + {"42", 3, 42000}, + {"1", 1, 10}, + /* fractional only (leading dot) */ + {".5", 1, 5}, + {".123", 3, 123}, + {".001", 3, 1}, + /* zero padding: fewer fractional digits than scale */ + {"1.2", 3, 1200}, + {"1.2", 6, 1200000}, + {"0.01", 3, 10}, + {"0.1", 9, 100000000ULL}, + {"0.01", 9, 10000000}, + /* truncation: more fractional digits than scale */ + {"1.23456", 3, 1234}, + {"3.1415926535", 6, 3141592}, + {"0.999999999", 3, 999}, + {"1.99", 1, 19}, + /* trailing newline */ + {"1.5\n", 1, 15}, + {"42\n", 3, 42000}, + /* plus sign */ + {"+1.5", 1, 15}, + {"+.5", 1, 5}, + /* scale progression */ + {"1.0", 1, 10}, + {"1.00", 2, 100}, + {"1.000", 3, 1000}, + {"1.000000", 6, 1000000}, + {"1.000000000", 9, 1000000000ULL}, + /* large values spanning u64 range */ + {"9223372036.854775807", 9, 9223372036854775807ULL}, + {"18446744073709.551615", 6, 18446744073709551615ULL}, + }; + TEST_OK(kstrtoudec64, u64, "%llu", test_udec64_ok); +} + +static void __init test_kstrtoudec64_fail(void) +{ + static DEFINE_TEST_FAIL(test_udec64_fail) =3D { + /* empty / whitespace */ + {"", 3}, + {"\n", 3}, + /* invalid scale */ + {"1.0", 21}, + /* minus sign (unsigned) */ + {"-1.5", 1}, + {"-0.5", 1}, + /* no digits after dot */ + {"1.", 3}, + {".", 3}, + /* no digits at all */ + {"+", 3}, + /* non-digit characters */ + {"abc", 3}, + {"1.2x", 3}, + /* leading/trailing space */ + {" 1.5", 1}, + {"1.5 ", 1}, + /* overflow */ + {"18446744073710.551615", 6}, + {"99999999999999999999", 1}, + }; + TEST_FAIL(kstrtoudec64, u64, "%llu", test_udec64_fail); +} + +static void __init test_kstrtodec64_ok(void) +{ + DECLARE_TEST_OK(s64, struct test_dec64); + static DEFINE_TEST_OK(struct test_dec64, test_dec64_ok) =3D { + /* basic positive */ + {"0.0", 1, 0}, + {"1.5", 1, 15}, + {"1.234", 3, 1234}, + /* basic negative */ + {"-1.5", 1, -15}, + {"-1.234", 3, -1234}, + {"-0.5", 1, -5}, + {"-0.001", 3, -1}, + /* zero (signed) */ + {"-0", 1, 0}, + {"-0.0", 1, 0}, + {"0.000", 3, 0}, + /* integer only */ + {"42", 3, 42000}, + {"-42", 3, -42000}, + /* fractional only */ + {".5", 1, 5}, + {"-.5", 1, -5}, + /* zero padding */ + {"1.2", 3, 1200}, + {"-1.2", 3, -1200}, + {"0.01", 3, 10}, + {"-0.01", 3, -10}, + /* truncation */ + {"1.23456", 3, 1234}, + {"-1.23456", 3, -1234}, + {"0.999999999", 3, 999}, + {"-0.999999999", 3, -999}, + /* trailing newline */ + {"1.5\n", 1, 15}, + {"-1.5\n", 1, -15}, + /* plus sign */ + {"+1.5", 1, 15}, + /* limits */ + {"9223372036.854775807", 9, LLONG_MAX}, + {"-9223372036.854775808", 9, LLONG_MIN}, + }; + TEST_OK(kstrtodec64, s64, "%lld", test_dec64_ok); +} + +static void __init test_kstrtodec64_fail(void) +{ + static DEFINE_TEST_FAIL(test_dec64_fail) =3D { + /* empty / whitespace */ + {"", 3}, + {"\n", 3}, + /* invalid scale */ + {"1.0", 21}, + /* no digits after dot */ + {"1.", 3}, + {".", 3}, + {"-.", 3}, + /* no digits at all */ + {"+", 3}, + {"-", 3}, + /* non-digit characters */ + {"abc", 3}, + {"-1.2x", 3}, + /* signed overflow */ + {"9223372036.854775808", 9}, + {"-9223372036.854775809", 9}, + {"99999999999999999999", 1}, + }; + TEST_FAIL(kstrtodec64, s64, "%lld", test_dec64_fail); +} + static int __init test_kstrtox_init(void) { test_kstrtoull_ok(); @@ -729,6 +879,12 @@ static int __init test_kstrtox_init(void) test_kstrtou8_fail(); test_kstrtos8_ok(); test_kstrtos8_fail(); + + test_kstrtoudec64_ok(); + test_kstrtoudec64_fail(); + test_kstrtodec64_ok(); + test_kstrtodec64_fail(); + return -EINVAL; } module_init(test_kstrtox_init); --=20 2.43.0 From nobody Thu Apr 16 02:49:20 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 6078B33C536; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; cv=none; b=mrqut14ZYtKuzw7FGE63FF1mJ62x7NtOyLnj2hX5/GcEtyEj4lxQ4BTb7AyynFZtgR6TNzfPTqxKYboZ8IeD6vdmlh0kAYthynDSr129+bp8Z/G1mOE40xeETnjyDS1lGNHspJW0uXhrWp/WVskM8j3KsILqqovD2+qizpVANjA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; c=relaxed/simple; bh=+PnoWBfKnfV07TYFgJMKkg0KM9nPZ2plTh6bMfU0YFo=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=OTOsuEYdmMflIOhZ5NwWffC9+ih2FiokE1uOwVIy15cScnS/5i4u7J7hUX5BXJ/CCP/dngzp7WSnNzFoYrl6bSi3sQ7UhQOnuwv/Zyu+ej1ECsm3SABeYujO00NBFbdjE5kqUq2iTc7aFa7fvY6c1/fsqFdUZBnB1brfV3m69dY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ho/pCNK3; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="ho/pCNK3" Received: by smtp.kernel.org (Postfix) with ESMTPS id 249ECC2BCB8; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776246738; bh=+PnoWBfKnfV07TYFgJMKkg0KM9nPZ2plTh6bMfU0YFo=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=ho/pCNK3GeKMEK2GtWNZ8XB4rjh10RkaI/opiqnL2MU2MQVE1BJ5Ixk7NxtKPZcQX 2vpBNgFW4FvfBjvWKOPNMQP3vsh6IHdsydp57PitkztjxcqDu4IqEzOPg6tLJzHrQH BwyEaMMqoxjcZksZvBWP6JGDer3SsYkU8qSL+3mgVIO5OY5BUHNjbXTmkztzDmxNHK 9TBwITDAET0bPOxOa5EWlDwLLNPTunPz9ldD9xV+wxHocgU36O8pWdZQ2URUXKALLl jtDNtReMoVkrQneFigwVVXitevs/Drh/MJzzZ6zFnD/9DTghIeI9wK+oWgf29dSNwv dEAp4wxEi4Z1Q== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1D0D7F41987; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) From: Rodrigo Alencar via B4 Relay Date: Wed, 15 Apr 2026 10:51:47 +0100 Subject: [PATCH v10 04/11] lib: math: div64: add div64_s64_rem() Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260415-adf41513-iio-driver-v10-4-df61046d5457@analog.com> References: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> In-Reply-To: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> To: linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jonathan Cameron , David Lechner , Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet , Andrew Morton , Petr Mladek , Steven Rostedt , Andy Shevchenko , Rasmus Villemoes , Sergey Senozhatsky , Shuah Khan , Rodrigo Alencar X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1776246736; l=2261; i=rodrigo.alencar@analog.com; s=default; h=from:subject:message-id; bh=2v2lygWWRh+YYmi1idrGFbtPNUJ9kh0HFK3mhrgB4es=; b=dWSk7W28BiSoqqG798KAJG0PjF1a0g0ucyax7n98whSjDtc+hwbi/OMSGk5InQY9DqI4nAuED CazcA3ZR+TrCb49CH5CIhAtBPraxW9Kd3TxXP7z+Tvr9l+PEwX7+ugQ X-Developer-Key: i=rodrigo.alencar@analog.com; a=ed25519; pk=ULeHbgU/OYh/PG/4anHDfLgldFItQHAhOktYRVLMFRo= X-Endpoint-Received: by B4 Relay for rodrigo.alencar@analog.com/default with auth_id=561 X-Original-From: Rodrigo Alencar Reply-To: rodrigo.alencar@analog.com From: Rodrigo Alencar Add div64_s64_rem() function, with 32-bit implementation that uses div64_u64_rem() and a branchless approach to resolve the sign of the remainder and quotient (negation in two's complement). Signed-off-by: Rodrigo Alencar --- include/linux/math64.h | 18 ++++++++++++++++++ lib/math/div64.c | 15 +++++++++++++++ 2 files changed, 33 insertions(+) diff --git a/include/linux/math64.h b/include/linux/math64.h index cc305206d89f..99189410d4bb 100644 --- a/include/linux/math64.h +++ b/include/linux/math64.h @@ -57,6 +57,20 @@ static inline u64 div64_u64_rem(u64 dividend, u64 diviso= r, u64 *remainder) return dividend / divisor; } =20 +/** + * div64_s64_rem - signed 64bit divide with 64bit divisor and remainder + * @dividend: signed 64bit dividend + * @divisor: signed 64bit divisor + * @remainder: pointer to signed 64bit remainder + * + * Return: sets ``*remainder``, then returns dividend / divisor + */ +static inline s64 div64_s64_rem(s64 dividend, s64 divisor, s64 *remainder) +{ + *remainder =3D dividend % divisor; + return dividend / divisor; +} + /** * div64_u64 - unsigned 64bit divide with 64bit divisor * @dividend: unsigned 64bit dividend @@ -102,6 +116,10 @@ extern s64 div_s64_rem(s64 dividend, s32 divisor, s32 = *remainder); extern u64 div64_u64_rem(u64 dividend, u64 divisor, u64 *remainder); #endif =20 +#ifndef div64_s64_rem +extern s64 div64_s64_rem(s64 dividend, s64 divisor, s64 *remainder); +#endif + #ifndef div64_u64 extern u64 div64_u64(u64 dividend, u64 divisor); #endif diff --git a/lib/math/div64.c b/lib/math/div64.c index d1e92ea24fce..0b10ded09a9b 100644 --- a/lib/math/div64.c +++ b/lib/math/div64.c @@ -158,6 +158,21 @@ u64 div64_u64(u64 dividend, u64 divisor) EXPORT_SYMBOL(div64_u64); #endif =20 +#ifndef div64_s64_rem +s64 div64_s64_rem(s64 dividend, s64 divisor, s64 *remainder) +{ + s64 quot, t, rem; + + quot =3D div64_u64_rem(abs(dividend), abs(divisor), (u64 *)&rem); + t =3D dividend >> 63; + *remainder =3D (rem ^ t) - t; + t =3D (dividend ^ divisor) >> 63; + + return (quot ^ t) - t; +} +EXPORT_SYMBOL(div64_s64_rem); +#endif + #ifndef div64_s64 s64 div64_s64(s64 dividend, s64 divisor) { --=20 2.43.0 From nobody Thu Apr 16 02:49:20 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 6910833F360; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; cv=none; b=Id9Y+1xD12lXYcBU+dGp54u+g/2Q6wKxat3nVGCtPFGdObpuTCA2wotD341iiH1PpLfcmEZ69iP4EElsv4NCu7+of2j2lCPgRh/Q4bNHX7fUiDVNYYQwegnluH+gNeEh8dSc2+rK/c4q+ro/WQ5wtzY8QK5y3QMdYkPVc8NZ4Jk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; c=relaxed/simple; bh=unUKaotBgd2qq2mXtCY2CK7EaUUEtQ3a+Kh4cMvBRGM=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=jZiv6jfr9r9sYVT/IlTFJGmsNW6P+S5Y3mr0JsAkB52Q5cFDpXBxNC9or06XaNIp1DpWVB6rxl7jtEbrqFB4V0qooWpHW4prmM7tczqmEPZH+z7iS6SfaWGldPYp4HbdGwQI230+xUKpEIhHZ17J4S2Acf1nsRbt9lySN2pAQkU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=EGKMicc9; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="EGKMicc9" Received: by smtp.kernel.org (Postfix) with ESMTPS id 362E4C2BCC4; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776246738; bh=unUKaotBgd2qq2mXtCY2CK7EaUUEtQ3a+Kh4cMvBRGM=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=EGKMicc9Tq/VSHx4Emak8f/wnBEe/mDKO7M0S/zanu+AB2vWyu0/yMv/hv5pFuaeM 3eCxMzXJrPxMimcxvAalYHGKm+cw8x8A5uRm7PsA4jdoh/XwPXWbslwpBgNrCoN18n qN1JIkIKAu2Md/wS48M/3N+6zkxhn76eqx9kRg0rr8wOlRT524ODAe3UjSETI8Yfzy yS4YckxGXahpLh3CjpoX3RgznBUjy06KExFelU/kt1q/rq250R0EDD2QjnpQogXgXr LrNlX4YFmSAxZKL5hi4b9+f08qirdwEF4f/QzXAzDXJxSCK9KSwd01pwIAoGLikYW8 15/7RPbscjF9w== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2D810F41984; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) From: Rodrigo Alencar via B4 Relay Date: Wed, 15 Apr 2026 10:51:48 +0100 Subject: [PATCH v10 05/11] iio: core: add decimal value formatting into 64-bit value Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260415-adf41513-iio-driver-v10-5-df61046d5457@analog.com> References: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> In-Reply-To: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> To: linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jonathan Cameron , David Lechner , Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet , Andrew Morton , Petr Mladek , Steven Rostedt , Andy Shevchenko , Rasmus Villemoes , Sergey Senozhatsky , Shuah Khan , Rodrigo Alencar X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1776246736; l=5995; i=rodrigo.alencar@analog.com; s=default; h=from:subject:message-id; bh=lY64PRQ5Ca0xe9W1hLlAEr5MdEHp4nUoXKfx41OisA4=; b=ljJjCeJNuW38vUFalEDEqqHPLWd1VeNTZ7JbiqXkgk5OE+cTsHIq4td6uXSik+JyNXtJMxsWy orR9QE8A8laBE4EGI2GcVuN3g6UWZpqe5VptFixDo97RZFhAJe0HRQh X-Developer-Key: i=rodrigo.alencar@analog.com; a=ed25519; pk=ULeHbgU/OYh/PG/4anHDfLgldFItQHAhOktYRVLMFRo= X-Endpoint-Received: by B4 Relay for rodrigo.alencar@analog.com/default with auth_id=561 X-Original-From: Rodrigo Alencar Reply-To: rodrigo.alencar@analog.com From: Rodrigo Alencar Create new format types for iio values (IIO_VAL_DECIMAL64_*), which defines the representation of fixed decimal point values into a single 64-bit number. This new format increases the range of represented values, allowing for integer parts greater than 2^32, as bits are not "wasted" in the fractional part, which can be seen in IIO_VAL_INT_PLUS_MICRO and IIO_VAL_INT_PLUS_NANO. Helper macros are created to compose and decompose 64-bit decimals into integer values used in IIO formatting interfaces, which creates consistency and avoid error-prone manual assignments when using wordpart macros. When doing the parsing, kstrtodec64() is used with the scale defined by the specific decimal format type. Signed-off-by: Rodrigo Alencar --- drivers/iio/industrialio-core.c | 46 +++++++++++++++++++++++++++++++++----= ---- include/linux/iio/types.h | 33 +++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+), 9 deletions(-) diff --git a/drivers/iio/industrialio-core.c b/drivers/iio/industrialio-cor= e.c index bd6f4f9f4533..24bc1577fdac 100644 --- a/drivers/iio/industrialio-core.c +++ b/drivers/iio/industrialio-core.c @@ -19,6 +19,7 @@ #include #include #include +#include #include #include #include @@ -26,7 +27,6 @@ #include #include #include -#include =20 #include #include @@ -707,8 +707,25 @@ static ssize_t __iio_format_value(char *buf, size_t of= fset, unsigned int type, case IIO_VAL_CHAR: return sysfs_emit_at(buf, offset, "%c", (char)vals[0]); case IIO_VAL_INT_64: - tmp2 =3D (s64)((((u64)vals[1]) << 32) | (u32)vals[0]); + tmp2 =3D iio_val_s64_from_array(vals); return sysfs_emit_at(buf, offset, "%lld", tmp2); + case IIO_VAL_DECIMAL64_MILLI: + case IIO_VAL_DECIMAL64_MICRO: + case IIO_VAL_DECIMAL64_NANO: + case IIO_VAL_DECIMAL64_PICO: + { + s64 frac; + unsigned int scale =3D type - IIO_VAL_DECIMAL64_BASE; + + tmp2 =3D div64_s64_rem(iio_val_s64_from_array(vals), + int_pow(10, scale), &frac); + if (tmp2 =3D=3D 0 && frac < 0) + return sysfs_emit_at(buf, offset, "-0.%0*lld", scale, + abs(frac)); + else + return sysfs_emit_at(buf, offset, "%lld.%0*lld", tmp2, + scale, abs(frac)); + } default: return 0; } @@ -977,7 +994,7 @@ static ssize_t iio_write_channel_info(struct device *de= v, { struct iio_dev *indio_dev =3D dev_to_iio_dev(dev); struct iio_dev_attr *this_attr =3D to_iio_dev_attr(attr); - int ret, fract_mult =3D 100000; + int type, ret, fract_mult =3D 100000, dec_scale =3D 0; int integer, fract =3D 0; long long integer64; bool is_char =3D false; @@ -988,9 +1005,11 @@ static ssize_t iio_write_channel_info(struct device *= dev, if (!indio_dev->info->write_raw) return -EINVAL; =20 - if (indio_dev->info->write_raw_get_fmt) - switch (indio_dev->info->write_raw_get_fmt(indio_dev, - this_attr->c, this_attr->address)) { + if (indio_dev->info->write_raw_get_fmt) { + type =3D indio_dev->info->write_raw_get_fmt(indio_dev, + this_attr->c, + this_attr->address); + switch (type) { case IIO_VAL_INT: fract_mult =3D 0; break; @@ -1006,12 +1025,19 @@ static ssize_t iio_write_channel_info(struct device= *dev, case IIO_VAL_CHAR: is_char =3D true; break; + case IIO_VAL_DECIMAL64_MILLI: + case IIO_VAL_DECIMAL64_MICRO: + case IIO_VAL_DECIMAL64_NANO: + case IIO_VAL_DECIMAL64_PICO: + dec_scale =3D type - IIO_VAL_DECIMAL64_BASE; + fallthrough; case IIO_VAL_INT_64: is_64bit =3D true; break; default: return -EINVAL; } + } =20 if (is_char) { char ch; @@ -1020,12 +1046,14 @@ static ssize_t iio_write_channel_info(struct device= *dev, return -EINVAL; integer =3D ch; } else if (is_64bit) { - ret =3D kstrtoll(buf, 0, &integer64); + if (dec_scale) + ret =3D kstrtodec64(buf, dec_scale, &integer64); + else + ret =3D kstrtoll(buf, 0, &integer64); if (ret) return ret; =20 - fract =3D upper_32_bits(integer64); - integer =3D lower_32_bits(integer64); + iio_val_s64_decompose(integer64, &integer, &fract); } else { ret =3D __iio_str_to_fixpoint(buf, fract_mult, &integer, &fract, scale_db); diff --git a/include/linux/iio/types.h b/include/linux/iio/types.h index 4e3099defc1d..52285adf46ef 100644 --- a/include/linux/iio/types.h +++ b/include/linux/iio/types.h @@ -7,6 +7,7 @@ #ifndef _IIO_TYPES_H_ #define _IIO_TYPES_H_ =20 +#include #include =20 enum iio_event_info { @@ -34,6 +35,38 @@ enum iio_event_info { #define IIO_VAL_FRACTIONAL_LOG2 11 #define IIO_VAL_CHAR 12 =20 +#define IIO_VAL_DECIMAL64_BASE 100 +#define IIO_VAL_DECIMAL64_MILLI (IIO_VAL_DECIMAL64_BASE + 3) +#define IIO_VAL_DECIMAL64_MICRO (IIO_VAL_DECIMAL64_BASE + 6) +#define IIO_VAL_DECIMAL64_NANO (IIO_VAL_DECIMAL64_BASE + 9) +#define IIO_VAL_DECIMAL64_PICO (IIO_VAL_DECIMAL64_BASE + 12) + +#define iio_val_s64_compose(_val0, _val1) \ + ({ (s64)((((u64)(_val1)) << 32) | (u32)(_val0)); }) + +#define iio_val_s64_from_array(_vals) \ + ({ \ + const int *_arr =3D (const int *)(_vals); \ + s64 _dec64 =3D iio_val_s64_compose(_arr[0], _arr[1]); \ + \ + _dec64; \ + }) + +#define iio_val_s64_decompose(_dec64, _val0, _val1) \ + do { \ + s64 _tmp64 =3D (s64)(_dec64); \ + \ + *(_val0) =3D lower_32_bits(_tmp64); \ + *(_val1) =3D upper_32_bits(_tmp64); \ + } while (0) + +#define iio_val_s64_array_populate(_dec64, _vals) \ + do { \ + int *_arr =3D (int *)(_vals); \ + \ + iio_val_s64_decompose((_dec64), &_arr[0], &_arr[1]); \ + } while (0) + enum iio_available_type { IIO_AVAIL_LIST, IIO_AVAIL_RANGE, --=20 2.43.0 From nobody Thu Apr 16 02:49:20 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 6F8EB33F5A0; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; cv=none; b=W1IoysLLE0jsCcWxkKFjoYXgALbxN3CrVknf8uFfkjLonFIdm28pHz5yYTz8OH7DWnbs8hnQ5eetfRoFUPlesIYCtBLmoWYSzeUYDTLTD804XFABBEEcfpD2/kolT7MGBm50OpVLUglHrBEwBhx0MStaSdVm02eUa9zyp/0aOfU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; c=relaxed/simple; bh=Gl8BKoBCF2V77XMlkR0lJ8OgLBba8DD++QnrWkI3lII=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=IwhxClVDY7yhdqP3OBDoRIXBhSQBwuBzp0YmudegTwZ+QQrHaWw1+iNZ8jm0suieQmNWQNkza+n/Mad8xvFiJTrGGf3Q2/R0P/9pStAfS3oeAu1p8A/uHzqc4LgUG8e4Zhsv6r2pH7u/wKjPU0j9Kx2NCaGWukllqV4MExzo584= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ie1LDbkp; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="ie1LDbkp" Received: by smtp.kernel.org (Postfix) with ESMTPS id 4650AC2BCF7; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776246738; bh=Gl8BKoBCF2V77XMlkR0lJ8OgLBba8DD++QnrWkI3lII=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=ie1LDbkpoq6T+IBYz6e6VprVz3HvKJMffyhC3wTDqWXvur7ZaTIugMcuYb98ruZoI VmkUSVbtg5nXQzHzdft8kL0ZdZplCeRDSpn8qzg3aoeUE5q91OxIGAoaHanL0ayyqT Uq63Q+OjahPRwRQ2eQuRSnEzNgPpJ+XOW4kGXBRv2mRO2jjzroWZ5f6/VrZhpzG+Cy kUQANWXHXRkYAo+jxi2M50yZMT3sV9PUVWhKhgeaLuNjJcCz/uEUhnphGRP6t3t/rJ uj5iAAX8CnO2aDhF3qzd+JkByJN9HpgQ31VZpxrIcZTul0UxPDl1P8pS+ykbsG4Bke QlnAgyy7TVaAQ== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3E42DF41987; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) From: Rodrigo Alencar via B4 Relay Date: Wed, 15 Apr 2026 10:51:49 +0100 Subject: [PATCH v10 06/11] iio: test: iio-test-format: add test case for decimal format Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260415-adf41513-iio-driver-v10-6-df61046d5457@analog.com> References: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> In-Reply-To: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> To: linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jonathan Cameron , David Lechner , Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet , Andrew Morton , Petr Mladek , Steven Rostedt , Andy Shevchenko , Rasmus Villemoes , Sergey Senozhatsky , Shuah Khan , Rodrigo Alencar X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1776246736; l=6713; i=rodrigo.alencar@analog.com; s=default; h=from:subject:message-id; bh=z+7GfhAI5DqW1tt8XtRcWYlfgn90H7P6U7JnxowjBIY=; b=rzyoEcqfHx+2Y4y396typJDQ9QONd3E96mwvAahpoIc3dSaMHaNtU09iPg5lrhob3cfYl7M4D QbzkLl6up6BAT+mZDZFOJvnZaZidXuQoZagdnBaIIuq+2UOC4+Fr5fP X-Developer-Key: i=rodrigo.alencar@analog.com; a=ed25519; pk=ULeHbgU/OYh/PG/4anHDfLgldFItQHAhOktYRVLMFRo= X-Endpoint-Received: by B4 Relay for rodrigo.alencar@analog.com/default with auth_id=561 X-Original-From: Rodrigo Alencar Reply-To: rodrigo.alencar@analog.com From: Rodrigo Alencar Add iio_test_iio_format_value_decimal_64() kunit test case for decimal value formatting, exploring different scales types. Also, the same iio_val_s64_array_populate() macro used to populate local array is used in iio_test_iio_format_value_integer_64(). Signed-off-by: Rodrigo Alencar --- drivers/iio/test/iio-test-format.c | 97 +++++++++++++++++++++++++++++-----= ---- 1 file changed, 75 insertions(+), 22 deletions(-) diff --git a/drivers/iio/test/iio-test-format.c b/drivers/iio/test/iio-test= -format.c index 872dd8582003..a2a9b4360c92 100644 --- a/drivers/iio/test/iio-test-format.c +++ b/drivers/iio/test/iio-test-format.c @@ -200,56 +200,108 @@ static void iio_test_iio_format_value_multiple(struc= t kunit *test) static void iio_test_iio_format_value_integer_64(struct kunit *test) { int values[2]; - s64 value; char *buf; int ret; =20 buf =3D kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf); =20 - value =3D 24; - values[0] =3D lower_32_bits(value); - values[1] =3D upper_32_bits(value); + iio_val_s64_array_populate(24, values); ret =3D iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values); IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "24\n"); =20 - value =3D -24; - values[0] =3D lower_32_bits(value); - values[1] =3D upper_32_bits(value); + iio_val_s64_array_populate(-24, values); ret =3D iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values); IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-24\n"); =20 - value =3D 0; - values[0] =3D lower_32_bits(value); - values[1] =3D upper_32_bits(value); + iio_val_s64_array_populate(0, values); ret =3D iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values); IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0\n"); =20 - value =3D UINT_MAX; - values[0] =3D lower_32_bits(value); - values[1] =3D upper_32_bits(value); + iio_val_s64_array_populate(UINT_MAX, values); ret =3D iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values); IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "4294967295\n"); =20 - value =3D -((s64)UINT_MAX); - values[0] =3D lower_32_bits(value); - values[1] =3D upper_32_bits(value); + iio_val_s64_array_populate(-((s64)UINT_MAX), values); ret =3D iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values); IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-4294967295\n"); =20 - value =3D LLONG_MAX; - values[0] =3D lower_32_bits(value); - values[1] =3D upper_32_bits(value); + iio_val_s64_array_populate(LLONG_MAX, values); ret =3D iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values); IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "9223372036854775807\n"); =20 - value =3D LLONG_MIN; - values[0] =3D lower_32_bits(value); - values[1] =3D upper_32_bits(value); + iio_val_s64_array_populate(LLONG_MIN, values); ret =3D iio_format_value(buf, IIO_VAL_INT_64, ARRAY_SIZE(values), values); IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-9223372036854775808\n"); } =20 +static void iio_test_iio_format_value_decimal_64(struct kunit *test) +{ + int values[2]; + char *buf; + int ret; + + buf =3D kunit_kmalloc(test, PAGE_SIZE, GFP_KERNEL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, buf); + + /* DECIMAL64_MILLI: positive >=3D 1, value 1.234 */ + iio_val_s64_array_populate(1234, values); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_MILLI, ARRAY_SIZE(values)= , values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1.234\n"); + + /* DECIMAL64_MICRO: positive >=3D 1, value 3.141592 */ + iio_val_s64_array_populate(3141592, values); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_MICRO, ARRAY_SIZE(values)= , values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "3.141592\n"); + + /* DECIMAL64_MILLI: positive < 1, value 0.042 */ + iio_val_s64_array_populate(42, values); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_MILLI, ARRAY_SIZE(values)= , values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.042\n"); + + /* DECIMAL64_MILLI: negative <=3D -1, value -1.234 */ + iio_val_s64_array_populate(-1234, values); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_MILLI, ARRAY_SIZE(values)= , values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-1.234\n"); + + /* DECIMAL64_MILLI: negative > -1, value -0.123 */ + iio_val_s64_array_populate(-123, values); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_MILLI, ARRAY_SIZE(values)= , values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-0.123\n"); + + /* DECIMAL64_MILLI: zero */ + iio_val_s64_array_populate(0, values); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_MILLI, ARRAY_SIZE(values)= , values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "0.000\n"); + + /* DECIMAL64_NANO: value 1.000000001 */ + iio_val_s64_array_populate(1000000001, values); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_NANO, ARRAY_SIZE(values),= values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "1.000000001\n"); + + /* DECIMAL64_MICRO: large value using upper 32 bits */ + iio_val_s64_array_populate(5000000000000042LL, values); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_MICRO, ARRAY_SIZE(values)= , values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "5000000000.000042\n"); + + /* limits */ + iio_val_s64_array_populate(LLONG_MAX, values); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_PICO, ARRAY_SIZE(values),= values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "9223372.036854775807\n"); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_NANO, ARRAY_SIZE(values),= values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "9223372036.854775807\n"); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_MICRO, ARRAY_SIZE(values)= , values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "9223372036854.775807\n"); + + iio_val_s64_array_populate(LLONG_MIN, values); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_PICO, ARRAY_SIZE(values),= values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-9223372.036854775808\n"); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_NANO, ARRAY_SIZE(values),= values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-9223372036.854775808\n"); + ret =3D iio_format_value(buf, IIO_VAL_DECIMAL64_MICRO, ARRAY_SIZE(values)= , values); + IIO_TEST_FORMAT_EXPECT_EQ(test, buf, ret, "-9223372036854.775808\n"); +} + static struct kunit_case iio_format_test_cases[] =3D { KUNIT_CASE(iio_test_iio_format_value_integer), KUNIT_CASE(iio_test_iio_format_value_fixedpoint), @@ -257,6 +309,7 @@ static struct kunit_case iio_format_test_cases[] =3D { KUNIT_CASE(iio_test_iio_format_value_fractional_log2), KUNIT_CASE(iio_test_iio_format_value_multiple), KUNIT_CASE(iio_test_iio_format_value_integer_64), + KUNIT_CASE(iio_test_iio_format_value_decimal_64), { } }; =20 --=20 2.43.0 From nobody Thu Apr 16 02:49:20 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 78A6F33F5B2; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; cv=none; b=mH7qvxIn+lNi3EvmptnEAwhSNX3vEfHM29KXtRDI5Zcmu9dUhqc0NgIlOa0CfVv+fPgFbHmMGvn552vKiMZKXRmN1rFyDVsq4yJzS9VDV2Nh3QeTFTpDIy4Pfff3doIxYvRm2kfG2hceRih0biEEOGp4jvq0tC0J3oPG9PR+Rrk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; c=relaxed/simple; bh=Qqh8q+rb8JUW2veb1lh5j5ejA18m91PsWqKjz/Z/0Tg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=bxw4e5hv4FDLu/Ya8POAlaEtr75k3K5dX+H90hdw9rSJJRSueHz23gYL2ZuKhefiBKPk50BrUCeWM7za40ojLqtEjK2XMnTdbabV5rKn6fYKPxC5bZnK6DOo1mgIaFHLP57qt3/y1W56j05wgZnh18OkzUkMBv915/b7Tgyih/k= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=hxtHubKp; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="hxtHubKp" Received: by smtp.kernel.org (Postfix) with ESMTPS id 58FA2C2BCB7; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776246738; bh=Qqh8q+rb8JUW2veb1lh5j5ejA18m91PsWqKjz/Z/0Tg=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=hxtHubKpxHDTT63eILApCHEdtKaIzxnFWWVzxF66a36xrjBSUJXLReicnEXA09XzD HewnCJCUCc3/UQHu/3aJryugp5w/6hdPX/+5iw2Jk7I9SSkI0KllaO+1vz/7GEVLbn yYKd3YYRQS5VPDik7p01uxAiCtgFbHNbFCCsdKxYx9eSGRIP33Yw3YmgBIXo/C3xam brE4kpTJW1dFM2yorXYLWmPjYvyWNDJ8EGj3xPgGOn1IcSyKXw74uOPMxX/n4Ohm9W fH8J0/ZVUjpArXFELG9QyJtgXSxmI6r4LMP+MsrfgzBRMBnTnGve0Pc3KdVYj0s3XY LWw1dxj9VLHDw== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4FF6FF41984; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) From: Rodrigo Alencar via B4 Relay Date: Wed, 15 Apr 2026 10:51:50 +0100 Subject: [PATCH v10 07/11] iio: frequency: adf41513: driver implementation Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260415-adf41513-iio-driver-v10-7-df61046d5457@analog.com> References: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> In-Reply-To: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> To: linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jonathan Cameron , David Lechner , Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet , Andrew Morton , Petr Mladek , Steven Rostedt , Andy Shevchenko , Rasmus Villemoes , Sergey Senozhatsky , Shuah Khan , Rodrigo Alencar X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1776246736; l=38527; i=rodrigo.alencar@analog.com; s=default; h=from:subject:message-id; bh=sPIq9eP04SOSjpUcLM0CgeWQYZUhT5ryNlw/G5RqbTw=; b=mgPwRCQ0yBvZeQQ0EIyp263wWsYqVsFtmfFKTY1cRNwKCk33uT1qclD0JF6C6ymflDXdI1XEe zf+atZFq5DVBhzy2Z1vc1G5yKEU/4vUtYKHpd6GXADID8lVcUKyNo+o X-Developer-Key: i=rodrigo.alencar@analog.com; a=ed25519; pk=ULeHbgU/OYh/PG/4anHDfLgldFItQHAhOktYRVLMFRo= X-Endpoint-Received: by B4 Relay for rodrigo.alencar@analog.com/default with auth_id=561 X-Original-From: Rodrigo Alencar Reply-To: rodrigo.alencar@analog.com From: Rodrigo Alencar The driver is based on existing PLL drivers in the IIO subsystem and implements the following key features: - Integer-N and fractional-N (fixed/variable modulus) synthesis modes - High-resolution frequency calculations using microhertz (=C2=B5Hz) precis= ion to handle sub-Hz resolution across multi-GHz frequency ranges - IIO debugfs interface for direct register access - FW property parsing from devicetree including charge pump settings, reference path configuration and muxout options - Power management support with suspend/resume callbacks - Lock detect GPIO monitoring Signed-off-by: Rodrigo Alencar --- MAINTAINERS | 1 + drivers/iio/frequency/Kconfig | 10 + drivers/iio/frequency/Makefile | 1 + drivers/iio/frequency/adf41513.c | 1101 ++++++++++++++++++++++++++++++++++= ++++ 4 files changed, 1113 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index b4511f86c54f..4e28f54cb34f 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1660,6 +1660,7 @@ L: linux-iio@vger.kernel.org S: Supported W: https://ez.analog.com/linux-software-drivers F: Documentation/devicetree/bindings/iio/frequency/adi,adf41513.yaml +F: drivers/iio/frequency/adf41513.c =20 ANALOG DEVICES INC ADF4377 DRIVER M: Antoniu Miclaus diff --git a/drivers/iio/frequency/Kconfig b/drivers/iio/frequency/Kconfig index 583cbdf4e8cd..90c6304c4bcd 100644 --- a/drivers/iio/frequency/Kconfig +++ b/drivers/iio/frequency/Kconfig @@ -29,6 +29,16 @@ endmenu =20 menu "Phase-Locked Loop (PLL) frequency synthesizers" =20 +config ADF41513 + tristate "Analog Devices ADF41513 PLL Frequency Synthesizer" + depends on SPI + help + Say yes here to build support for Analog Devices ADF41513 + 26.5 GHz Integer-N/Fractional-N PLL Frequency Synthesizer. + + To compile this driver as a module, choose M here: the + module will be called adf41513. + config ADF4350 tristate "Analog Devices ADF4350/ADF4351 Wideband Synthesizers" depends on SPI diff --git a/drivers/iio/frequency/Makefile b/drivers/iio/frequency/Makefile index 70d0e0b70e80..53b4d01414d8 100644 --- a/drivers/iio/frequency/Makefile +++ b/drivers/iio/frequency/Makefile @@ -5,6 +5,7 @@ =20 # When adding new entries keep the list in alphabetical order obj-$(CONFIG_AD9523) +=3D ad9523.o +obj-$(CONFIG_ADF41513) +=3D adf41513.o obj-$(CONFIG_ADF4350) +=3D adf4350.o obj-$(CONFIG_ADF4371) +=3D adf4371.o obj-$(CONFIG_ADF4377) +=3D adf4377.o diff --git a/drivers/iio/frequency/adf41513.c b/drivers/iio/frequency/adf41= 513.c new file mode 100644 index 000000000000..bf2d6c941082 --- /dev/null +++ b/drivers/iio/frequency/adf41513.c @@ -0,0 +1,1101 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * ADF41513 SPI PLL Frequency Synthesizer driver + * + * Copyright 2026 Analog Devices Inc. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Registers */ +#define ADF41513_REG0 0 +#define ADF41513_REG1 1 +#define ADF41513_REG2 2 +#define ADF41513_REG3 3 +#define ADF41513_REG4 4 +#define ADF41513_REG5 5 +#define ADF41513_REG6 6 +#define ADF41513_REG7 7 +#define ADF41513_REG8 8 +#define ADF41513_REG9 9 +#define ADF41513_REG10 10 +#define ADF41513_REG11 11 +#define ADF41513_REG12 12 +#define ADF41513_REG13 13 +#define ADF41513_REG_NUM 14 + +#define ADF41513_SYNC_REG0 BIT(ADF41513_REG0) +#define ADF41513_SYNC_REG1 BIT(ADF41513_REG1) +#define ADF41513_SYNC_REG2 BIT(ADF41513_REG2) +#define ADF41513_SYNC_REG3 BIT(ADF41513_REG3) +#define ADF41513_SYNC_REG4 BIT(ADF41513_REG4) +#define ADF41513_SYNC_REG5 BIT(ADF41513_REG5) +#define ADF41513_SYNC_REG6 BIT(ADF41513_REG6) +#define ADF41513_SYNC_REG7 BIT(ADF41513_REG7) +#define ADF41513_SYNC_REG9 BIT(ADF41513_REG9) +#define ADF41513_SYNC_REG11 BIT(ADF41513_REG11) +#define ADF41513_SYNC_REG12 BIT(ADF41513_REG12) +#define ADF41513_SYNC_REG13 BIT(ADF41513_REG13) +#define ADF41513_SYNC_DIFF 0 +#define ADF41513_SYNC_ALL GENMASK(ADF41513_REG13, ADF41513_REG0) + +/* REG0 Bit Definitions */ +#define ADF41513_REG0_CTRL_BITS_MSK GENMASK(3, 0) +#define ADF41513_REG0_INT_MSK GENMASK(19, 4) +#define ADF41513_REG0_VAR_MOD_MSK BIT(28) + +/* REG1 Bit Definitions */ +#define ADF41513_REG1_FRAC1_MSK GENMASK(28, 4) +#define ADF41513_REG1_DITHER2_MSK BIT(31) + +/* REG2 Bit Definitions */ +#define ADF41513_REG2_PHASE_VAL_MSK GENMASK(15, 4) +#define ADF41513_REG2_PHASE_ADJ_MSK BIT(31) + +/* REG3 Bit Definitions */ +#define ADF41513_REG3_FRAC2_MSK GENMASK(27, 4) + +/* REG4 Bit Definitions */ +#define ADF41513_REG4_MOD2_MSK GENMASK(27, 4) + +/* REG5 Bit Definitions */ +#define ADF41513_REG5_CLK1_DIV_MSK GENMASK(15, 4) +#define ADF41513_REG5_R_CNT_MSK GENMASK(20, 16) +#define ADF41513_REG5_REF_DOUBLER_MSK BIT(21) +#define ADF41513_REG5_RDIV2_MSK BIT(22) +#define ADF41513_REG5_PRESCALER_MSK BIT(23) +#define ADF41513_REG5_LSB_P1_MSK BIT(24) +#define ADF41513_REG5_CP_CURRENT_MSK GENMASK(28, 25) +#define ADF41513_REG5_DLD_MODES_MSK GENMASK(31, 30) + +/* REG6 Bit Definitions */ +#define ADF41513_REG6_COUNTER_RESET_MSK BIT(4) +#define ADF41513_REG6_CP_TRISTATE_MSK BIT(5) +#define ADF41513_REG6_POWER_DOWN_MSK BIT(6) +#define ADF41513_REG6_PD_POLARITY_MSK BIT(7) +#define ADF41513_REG6_LDP_MSK GENMASK(9, 8) +#define ADF41513_REG6_CP_TRISTATE_PD_ON_MSK BIT(16) +#define ADF41513_REG6_SD_RESET_MSK BIT(17) +#define ADF41513_REG6_LOL_ENABLE_MSK BIT(18) +#define ADF41513_REG6_ABP_MSK BIT(19) +#define ADF41513_REG6_INT_MODE_MSK BIT(20) +#define ADF41513_REG6_BLEED_ENABLE_MSK BIT(22) +#define ADF41513_REG6_BLEED_POLARITY_MSK BIT(23) +#define ADF41513_REG6_BLEED_CURRENT_MSK GENMASK(31, 24) + +/* REG7 Bit Definitions */ +#define ADF41513_REG7_CLK2_DIV_MSK GENMASK(17, 6) +#define ADF41513_REG7_CLK_DIV_MODE_MSK GENMASK(19, 18) +#define ADF41513_REG7_PS_BIAS_MSK GENMASK(21, 20) +#define ADF41513_REG7_N_DELAY_MSK GENMASK(23, 22) +#define ADF41513_REG7_LD_CLK_SEL_MSK BIT(26) +#define ADF41513_REG7_LD_COUNT_MSK GENMASK(29, 27) + +/* REG9 Bit Definitions */ +#define ADF41513_REG9_LD_BIAS_MSK GENMASK(31, 30) + +/* REG11 Bit Definitions */ +#define ADF41513_REG11_POWER_DOWN_SEL_MSK BIT(31) + +/* REG12 Bit Definitions */ +#define ADF41513_REG12_READBACK_SEL_MSK GENMASK(19, 14) +#define ADF41513_REG12_LE_SELECT_MSK BIT(20) +#define ADF41513_REG12_MASTER_RESET_MSK BIT(22) +#define ADF41513_REG12_LOGIC_LEVEL_MSK BIT(27) +#define ADF41513_REG12_MUXOUT_MSK GENMASK(31, 28) + +/* MUXOUT Selection */ +#define ADF41513_MUXOUT_TRISTATE 0x0 +#define ADF41513_MUXOUT_DVDD 0x1 +#define ADF41513_MUXOUT_DGND 0x2 +#define ADF41513_MUXOUT_R_DIV 0x3 +#define ADF41513_MUXOUT_N_DIV 0x4 +#define ADF41513_MUXOUT_DIG_LD 0x6 +#define ADF41513_MUXOUT_SDO 0x7 +#define ADF41513_MUXOUT_READBACK 0x8 +#define ADF41513_MUXOUT_CLK1_DIV 0xA +#define ADF41513_MUXOUT_R_DIV2 0xD +#define ADF41513_MUXOUT_N_DIV2 0xE + +/* DLD Mode Selection */ +#define ADF41513_DLD_TRISTATE 0x0 +#define ADF41513_DLD_DIG_LD 0x1 +#define ADF41513_DLD_LOW 0x2 +#define ADF41513_DLD_HIGH 0x3 + +/* Prescaler Selection */ +#define ADF41513_PRESCALER_4_5 0 +#define ADF41513_PRESCALER_8_9 1 +#define ADF41513_PRESCALER_AUTO 2 + +/* Specifications */ +#define ADF41510_MAX_RF_FREQ_HZ (10ULL * HZ_PER_GHZ) +#define ADF41513_MIN_RF_FREQ_HZ (1ULL * HZ_PER_GHZ) +#define ADF41513_MAX_RF_FREQ_HZ (26500ULL * HZ_PER_MHZ) + +#define ADF41513_MIN_REF_FREQ_HZ (10 * HZ_PER_MHZ) +#define ADF41513_MAX_REF_FREQ_HZ (800 * HZ_PER_MHZ) +#define ADF41513_MAX_REF_FREQ_DOUBLER_HZ (225 * HZ_PER_MHZ) + +#define ADF41513_MAX_PFD_FREQ_INT_N_UHZ (250ULL * MEGA * MICROHZ_PER_HZ) +#define ADF41513_MAX_PFD_FREQ_FRAC_N_UHZ (125ULL * MEGA * MICROHZ_PER_HZ) +#define ADF41513_MAX_FREQ_RESOLUTION_UHZ (100ULL * KILO * MICROHZ_PER_HZ) + +#define ADF41513_MIN_INT_4_5 20 +#define ADF41513_MAX_INT_4_5 511 +#define ADF41513_MIN_INT_8_9 64 +#define ADF41513_MAX_INT_8_9 1023 + +#define ADF41513_MIN_INT_FRAC_4_5 23 +#define ADF41513_MIN_INT_FRAC_8_9 75 + +#define ADF41513_MIN_R_CNT 1 +#define ADF41513_MAX_R_CNT 32 + +#define ADF41513_MIN_R_SET 1800 +#define ADF41513_DEFAULT_R_SET 2700 +#define ADF41513_MAX_R_SET 10000 + +#define ADF41513_MIN_CP_VOLTAGE_mV 810 +#define ADF41513_DEFAULT_CP_VOLTAGE_mV 6480 +#define ADF41513_MAX_CP_VOLTAGE_mV 12960 + +#define ADF41513_LD_COUNT_FAST_MIN 2 +#define ADF41513_LD_COUNT_FAST_LIMIT 64 +#define ADF41513_LD_COUNT_MIN 64 +#define ADF41513_LD_COUNT_MAX 8192 + +#define ADF41513_FIXED_MODULUS BIT(25) +#define ADF41513_MAX_MOD2 (BIT(24) - 1) +#define ADF41513_MAX_PHASE_VAL (BIT(12) - 1) +#define ADF41513_MAX_CLK_DIVIDER (BIT(12) - 1) + +#define ADF41513_HZ_DECIMAL_SCALE 6 +#define ADF41513_PS_BIAS_INIT 0x2 +#define ADF41513_MAX_PHASE_MICRORAD ((2 * 314159265UL) / 100) + +enum { + ADF41513_POWER_DOWN, + ADF41513_FREQ_RESOLUTION, +}; + +enum adf41513_pll_mode { + ADF41513_MODE_INVALID, + ADF41513_MODE_INTEGER_N, + ADF41513_MODE_FIXED_MODULUS, + ADF41513_MODE_VARIABLE_MODULUS, +}; + +struct adf41513_chip_info { + const char *name; + u64 max_rf_freq_hz; + bool has_prescaler_8_9; +}; + +struct adf41513_data { + u64 power_up_frequency_hz; + u64 freq_resolution_uhz; + u32 charge_pump_voltage_mv; + u32 lock_detect_count; + + u8 ref_div_factor; + bool ref_doubler_en; + bool ref_div2_en; + bool phase_detector_polarity; + + bool logic_lvl_1v8_en; +}; + +struct adf41513_pll_settings { + enum adf41513_pll_mode mode; + + /* reference path parameters */ + u8 r_counter; + u8 ref_doubler; + u8 ref_div2; + u8 prescaler; + + /* frequency parameters */ + u64 target_frequency_uhz; + u64 actual_frequency_uhz; + u64 pfd_frequency_uhz; + + /* pll parameters */ + u32 frac1; + u32 frac2; + u32 mod2; + u16 int_value; +}; + +struct adf41513_state { + const struct adf41513_chip_info *chip_info; + struct spi_device *spi; + struct gpio_desc *lock_detect; + struct gpio_desc *chip_enable; + struct clk *ref_clk; + u32 ref_freq_hz; + + /* + * Lock for accessing device registers. Some operations require + * multiple consecutive R/W operations, during which the device + * shouldn't be interrupted. The buffers are also shared across + * all operations so need to be protected on stand alone reads and + * writes. + */ + struct mutex lock; + + /* Cached register values */ + u32 regs[ADF41513_REG_NUM]; + u32 regs_hw[ADF41513_REG_NUM]; + + struct adf41513_data data; + struct adf41513_pll_settings settings; +}; + +static const char * const adf41513_power_supplies[] =3D { + "avdd1", "avdd2", "avdd3", "avdd4", "avdd5", "vp", +}; + +static int adf41513_sync_config(struct adf41513_state *st, u16 sync_mask) +{ + __be32 d32; + int ret, i; + + /* write registers in reverse order (R13 to R0)*/ + for (i =3D ADF41513_REG13; i >=3D ADF41513_REG0; i--) { + if (st->regs_hw[i] =3D=3D st->regs[i] && !(sync_mask & BIT(i))) + continue; + + d32 =3D cpu_to_be32(st->regs[i] | i); + ret =3D spi_write_then_read(st->spi, &d32, sizeof(d32), NULL, 0); + if (ret < 0) + return ret; + st->regs_hw[i] =3D st->regs[i]; + dev_dbg(&st->spi->dev, "REG%d <=3D 0x%08X\n", i, st->regs[i] | i); + } + + return 0; +} + +static u64 adf41513_pll_get_rate(struct adf41513_state *st) +{ + struct adf41513_pll_settings *cfg =3D &st->settings; + + if (cfg->mode !=3D ADF41513_MODE_INVALID) + return cfg->actual_frequency_uhz; + + /* get pll settings from regs_hw */ + cfg->int_value =3D FIELD_GET(ADF41513_REG0_INT_MSK, st->regs_hw[ADF41513_= REG0]); + cfg->frac1 =3D FIELD_GET(ADF41513_REG1_FRAC1_MSK, st->regs_hw[ADF41513_RE= G1]); + cfg->frac2 =3D FIELD_GET(ADF41513_REG3_FRAC2_MSK, st->regs_hw[ADF41513_RE= G3]); + cfg->mod2 =3D FIELD_GET(ADF41513_REG4_MOD2_MSK, st->regs_hw[ADF41513_REG4= ]); + cfg->r_counter =3D FIELD_GET(ADF41513_REG5_R_CNT_MSK, st->regs_hw[ADF4151= 3_REG5]); + cfg->ref_doubler =3D FIELD_GET(ADF41513_REG5_REF_DOUBLER_MSK, st->regs_hw= [ADF41513_REG5]); + cfg->ref_div2 =3D FIELD_GET(ADF41513_REG5_RDIV2_MSK, st->regs_hw[ADF41513= _REG5]); + cfg->prescaler =3D FIELD_GET(ADF41513_REG5_PRESCALER_MSK, st->regs_hw[ADF= 41513_REG5]); + + /* calculate pfd frequency */ + cfg->pfd_frequency_uhz =3D (u64)st->ref_freq_hz * MICRO; + if (cfg->ref_doubler) + cfg->pfd_frequency_uhz <<=3D 1; + if (cfg->ref_div2) + cfg->pfd_frequency_uhz >>=3D 1; + cfg->pfd_frequency_uhz =3D div_u64(cfg->pfd_frequency_uhz, cfg->r_counter= ); + cfg->actual_frequency_uhz =3D (u64)cfg->int_value * cfg->pfd_frequency_uh= z; + + /* check if int mode is selected */ + if (FIELD_GET(ADF41513_REG6_INT_MODE_MSK, st->regs_hw[ADF41513_REG6])) { + cfg->mode =3D ADF41513_MODE_INTEGER_N; + } else { + cfg->actual_frequency_uhz +=3D mul_u64_u32_div(cfg->pfd_frequency_uhz, + cfg->frac1, + ADF41513_FIXED_MODULUS); + + /* check if variable modulus is selected */ + if (FIELD_GET(ADF41513_REG0_VAR_MOD_MSK, st->regs_hw[ADF41513_REG0])) { + cfg->actual_frequency_uhz +=3D + mul_u64_u64_div_u64(cfg->frac2, + cfg->pfd_frequency_uhz, + (u64)cfg->mod2 * ADF41513_FIXED_MODULUS); + + cfg->mode =3D ADF41513_MODE_VARIABLE_MODULUS; + } else { + /* LSB_P1 offset */ + if (!FIELD_GET(ADF41513_REG5_LSB_P1_MSK, st->regs_hw[ADF41513_REG5])) + cfg->actual_frequency_uhz +=3D + div_u64(cfg->pfd_frequency_uhz, + 2 * ADF41513_FIXED_MODULUS); + cfg->mode =3D ADF41513_MODE_FIXED_MODULUS; + } + } + + cfg->target_frequency_uhz =3D cfg->actual_frequency_uhz; + + return cfg->actual_frequency_uhz; +} + +static int adf41513_calc_pfd_frequency(struct adf41513_state *st, + struct adf41513_pll_settings *result, + u64 fpfd_limit_uhz) +{ + result->ref_div2 =3D st->data.ref_div2_en; + result->ref_doubler =3D st->data.ref_doubler_en; + + if (st->data.ref_doubler_en && + st->ref_freq_hz > ADF41513_MAX_REF_FREQ_DOUBLER_HZ) { + result->ref_doubler =3D 0; + dev_warn(&st->spi->dev, "Disabling ref doubler due to high reference fre= quency\n"); + } + + result->r_counter =3D st->data.ref_div_factor - 1; + do { + result->r_counter++; + /* f_PFD =3D REF_IN =C3=97 ((1 + D)/(R =C3=97 (1 + T))) */ + result->pfd_frequency_uhz =3D (u64)st->ref_freq_hz * MICRO; + if (result->ref_doubler) + result->pfd_frequency_uhz <<=3D 1; + if (result->ref_div2) + result->pfd_frequency_uhz >>=3D 1; + result->pfd_frequency_uhz =3D div_u64(result->pfd_frequency_uhz, + result->r_counter); + } while (result->pfd_frequency_uhz > fpfd_limit_uhz); + + if (result->r_counter > ADF41513_MAX_R_CNT) { + dev_err(&st->spi->dev, "Cannot optimize PFD frequency\n"); + return -ERANGE; + } + + return 0; +} + +static int adf41513_calc_integer_n(struct adf41513_state *st, + struct adf41513_pll_settings *result) +{ + u16 max_int =3D st->chip_info->has_prescaler_8_9 ? + ADF41513_MAX_INT_8_9 : ADF41513_MAX_INT_4_5; + u64 freq_error_uhz; + u16 int_value =3D div64_u64_rem(result->target_frequency_uhz, result->pfd= _frequency_uhz, + &freq_error_uhz); + + /* check if freq error is within a tolerance of 1/2 resolution */ + if (freq_error_uhz > (result->pfd_frequency_uhz >> 1) && int_value < max_= int) { + int_value++; + freq_error_uhz =3D result->pfd_frequency_uhz - freq_error_uhz; + } + + if (freq_error_uhz > st->data.freq_resolution_uhz) + return -ERANGE; + + /* set prescaler */ + if (st->chip_info->has_prescaler_8_9 && int_value >=3D ADF41513_MIN_INT_8= _9 && + int_value <=3D ADF41513_MAX_INT_8_9) + result->prescaler =3D 1; + else if (int_value >=3D ADF41513_MIN_INT_4_5 && int_value <=3D ADF41513_M= AX_INT_4_5) + result->prescaler =3D 0; + else + return -ERANGE; + + result->actual_frequency_uhz =3D (u64)int_value * result->pfd_frequency_u= hz; + result->mode =3D ADF41513_MODE_INTEGER_N; + result->int_value =3D int_value; + result->frac1 =3D 0; + result->frac2 =3D 0; + result->mod2 =3D 0; + + return 0; +} + +static int adf41513_calc_fixed_mod(struct adf41513_state *st, + struct adf41513_pll_settings *result) +{ + u64 freq_error_uhz; + u64 resolution_uhz =3D div_u64(result->pfd_frequency_uhz, ADF41513_FIXED_= MODULUS); + u64 target_frequency_uhz =3D result->target_frequency_uhz; + u32 frac1; + u16 int_value; + bool lsb_p1_offset =3D !FIELD_GET(ADF41513_REG5_LSB_P1_MSK, st->regs_hw[A= DF41513_REG5]); + + /* LSB_P1 adds a frequency offset of f_pfd/2^26 */ + if (lsb_p1_offset) + target_frequency_uhz -=3D resolution_uhz >> 1; + + int_value =3D div64_u64_rem(target_frequency_uhz, result->pfd_frequency_u= hz, + &freq_error_uhz); + + if (st->chip_info->has_prescaler_8_9 && int_value >=3D ADF41513_MIN_INT_F= RAC_8_9 && + int_value <=3D ADF41513_MAX_INT_8_9) + result->prescaler =3D 1; + else if (int_value >=3D ADF41513_MIN_INT_FRAC_4_5 && int_value <=3D ADF41= 513_MAX_INT_4_5) + result->prescaler =3D 0; + else + return -ERANGE; + + /* compute frac1 and fixed modulus error */ + frac1 =3D mul_u64_u64_div_u64(freq_error_uhz, ADF41513_FIXED_MODULUS, + result->pfd_frequency_uhz); + freq_error_uhz -=3D mul_u64_u32_div(result->pfd_frequency_uhz, frac1, + ADF41513_FIXED_MODULUS); + + /* check if freq error is within a tolerance of 1/2 resolution */ + if (freq_error_uhz > (resolution_uhz >> 1) && frac1 < (ADF41513_FIXED_MOD= ULUS - 1)) { + frac1++; + freq_error_uhz =3D resolution_uhz - freq_error_uhz; + } + + if (freq_error_uhz > st->data.freq_resolution_uhz) + return -ERANGE; + + /* integer part */ + result->actual_frequency_uhz =3D (u64)int_value * result->pfd_frequency_u= hz; + /* fractional part */ + if (lsb_p1_offset) + result->actual_frequency_uhz +=3D (resolution_uhz >> 1); + result->actual_frequency_uhz +=3D mul_u64_u32_div(result->pfd_frequency_u= hz, frac1, + ADF41513_FIXED_MODULUS); + result->mode =3D ADF41513_MODE_FIXED_MODULUS; + result->int_value =3D int_value; + result->frac1 =3D frac1; + result->frac2 =3D 0; + result->mod2 =3D 0; + + return 0; +} + +static int adf41513_calc_variable_mod(struct adf41513_state *st, + struct adf41513_pll_settings *result) +{ + u64 freq_error_uhz, mod2; + u32 frac1, frac2; + u16 int_value =3D div64_u64_rem(result->target_frequency_uhz, + result->pfd_frequency_uhz, + &freq_error_uhz); + + if (st->chip_info->has_prescaler_8_9 && int_value >=3D ADF41513_MIN_INT_F= RAC_8_9 && + int_value <=3D ADF41513_MAX_INT_8_9) + result->prescaler =3D 1; + else if (int_value >=3D ADF41513_MIN_INT_FRAC_4_5 && int_value <=3D ADF41= 513_MAX_INT_4_5) + result->prescaler =3D 0; + else + return -ERANGE; + + /* calculate required mod2 based on target resolution / 2 */ + mod2 =3D DIV64_U64_ROUND_CLOSEST(result->pfd_frequency_uhz << 1, + st->data.freq_resolution_uhz * ADF41513_FIXED_MODULUS); + /* ensure mod2 is at least 2 for meaningful operation */ + mod2 =3D clamp(mod2, 2, ADF41513_MAX_MOD2); + + /* calculate frac1 and frac2 */ + frac1 =3D mul_u64_u64_div_u64(freq_error_uhz, ADF41513_FIXED_MODULUS, + result->pfd_frequency_uhz); + freq_error_uhz -=3D mul_u64_u32_div(result->pfd_frequency_uhz, frac1, + ADF41513_FIXED_MODULUS); + frac2 =3D mul_u64_u64_div_u64(freq_error_uhz, mod2 * ADF41513_FIXED_MODUL= US, + result->pfd_frequency_uhz); + + /* integer part */ + result->actual_frequency_uhz =3D (u64)int_value * result->pfd_frequency_u= hz; + /* fractional part */ + result->actual_frequency_uhz +=3D mul_u64_u64_div_u64(mod2 * frac1 + frac= 2, + result->pfd_frequency_uhz, + mod2 * ADF41513_FIXED_MODULUS); + result->mode =3D ADF41513_MODE_VARIABLE_MODULUS; + result->int_value =3D int_value; + result->frac1 =3D frac1; + result->frac2 =3D frac2; + result->mod2 =3D mod2; + + return 0; +} + +static int adf41513_calc_pll_settings(struct adf41513_state *st, + struct adf41513_pll_settings *result, + u64 rf_out_uhz) +{ + u64 max_rf_freq_uhz =3D st->chip_info->max_rf_freq_hz * MICRO; + u64 min_rf_freq_uhz =3D ADF41513_MIN_RF_FREQ_HZ * MICRO; + u64 pfd_freq_limit_uhz; + int ret; + + if (rf_out_uhz < min_rf_freq_uhz || rf_out_uhz > max_rf_freq_uhz) { + dev_err(&st->spi->dev, "RF frequency %llu uHz out of range [%llu, %llu] = uHz\n", + rf_out_uhz, min_rf_freq_uhz, max_rf_freq_uhz); + return -EINVAL; + } + + result->target_frequency_uhz =3D rf_out_uhz; + + /* try integer-N first (best phase noise performance) */ + pfd_freq_limit_uhz =3D min(div_u64(rf_out_uhz, ADF41513_MIN_INT_4_5), + ADF41513_MAX_PFD_FREQ_INT_N_UHZ); + ret =3D adf41513_calc_pfd_frequency(st, result, pfd_freq_limit_uhz); + if (ret < 0) + return ret; + + if (adf41513_calc_integer_n(st, result) =3D=3D 0) + return 0; + + /* try fractional-N: recompute pfd frequency if necessary */ + pfd_freq_limit_uhz =3D min(div_u64(rf_out_uhz, ADF41513_MIN_INT_FRAC_4_5), + ADF41513_MAX_PFD_FREQ_FRAC_N_UHZ); + if (pfd_freq_limit_uhz < result->pfd_frequency_uhz) { + ret =3D adf41513_calc_pfd_frequency(st, result, pfd_freq_limit_uhz); + if (ret < 0) + return ret; + } + + /* fixed-modulus attempt */ + if (adf41513_calc_fixed_mod(st, result) =3D=3D 0) + return 0; + + /* variable-modulus attempt */ + ret =3D adf41513_calc_variable_mod(st, result); + if (ret < 0) { + dev_err(&st->spi->dev, + "no valid PLL configuration found for %llu uHz\n", + rf_out_uhz); + return -EINVAL; + } + + return 0; +} + +static int adf41513_set_frequency(struct adf41513_state *st, u64 freq_uhz,= u16 sync_mask) +{ + struct adf41513_pll_settings result; + int ret; + + ret =3D adf41513_calc_pll_settings(st, &result, freq_uhz); + if (ret < 0) + return ret; + + /* apply computed results to pll settings */ + st->settings =3D result; + + dev_dbg(&st->spi->dev, + "%s mode: int=3D%u, frac1=3D%u, frac2=3D%u, mod2=3D%u, fpdf=3D%llu Hz, p= rescaler=3D%s\n", + (result.mode =3D=3D ADF41513_MODE_INTEGER_N) ? "integer-n" : + (result.mode =3D=3D ADF41513_MODE_FIXED_MODULUS) ? "fixed-modulus" : "va= riable-modulus", + result.int_value, result.frac1, result.frac2, result.mod2, + div64_u64(result.pfd_frequency_uhz, MICRO), + result.prescaler ? "8/9" : "4/5"); + + st->regs[ADF41513_REG0] =3D FIELD_PREP(ADF41513_REG0_INT_MSK, + st->settings.int_value); + if (st->settings.mode =3D=3D ADF41513_MODE_VARIABLE_MODULUS) + st->regs[ADF41513_REG0] |=3D ADF41513_REG0_VAR_MOD_MSK; + + st->regs[ADF41513_REG1] =3D FIELD_PREP(ADF41513_REG1_FRAC1_MSK, + st->settings.frac1); + if (st->settings.mode !=3D ADF41513_MODE_INTEGER_N) + st->regs[ADF41513_REG1] |=3D ADF41513_REG1_DITHER2_MSK; + + st->regs[ADF41513_REG3] =3D FIELD_PREP(ADF41513_REG3_FRAC2_MSK, + st->settings.frac2); + FIELD_MODIFY(ADF41513_REG4_MOD2_MSK, &st->regs[ADF41513_REG4], + st->settings.mod2); + FIELD_MODIFY(ADF41513_REG5_R_CNT_MSK, &st->regs[ADF41513_REG5], + st->settings.r_counter); + FIELD_MODIFY(ADF41513_REG5_REF_DOUBLER_MSK, &st->regs[ADF41513_REG5], + st->settings.ref_doubler); + FIELD_MODIFY(ADF41513_REG5_RDIV2_MSK, &st->regs[ADF41513_REG5], + st->settings.ref_div2); + FIELD_MODIFY(ADF41513_REG5_PRESCALER_MSK, &st->regs[ADF41513_REG5], + st->settings.prescaler); + + if (st->settings.mode =3D=3D ADF41513_MODE_INTEGER_N) { + st->regs[ADF41513_REG6] |=3D ADF41513_REG6_INT_MODE_MSK; + st->regs[ADF41513_REG6] &=3D ~ADF41513_REG6_BLEED_ENABLE_MSK; + } else { + st->regs[ADF41513_REG6] &=3D ~ADF41513_REG6_INT_MODE_MSK; + st->regs[ADF41513_REG6] |=3D ADF41513_REG6_BLEED_ENABLE_MSK; + } + + return adf41513_sync_config(st, sync_mask | ADF41513_SYNC_REG0); +} + +static int adf41513_suspend(struct adf41513_state *st) +{ + st->regs[ADF41513_REG6] |=3D FIELD_PREP(ADF41513_REG6_POWER_DOWN_MSK, 1); + return adf41513_sync_config(st, ADF41513_SYNC_DIFF); +} + +static int adf41513_resume(struct adf41513_state *st) +{ + st->regs[ADF41513_REG6] &=3D ~ADF41513_REG6_POWER_DOWN_MSK; + return adf41513_sync_config(st, ADF41513_SYNC_DIFF); +} + +static ssize_t adf41513_read_resolution(struct iio_dev *indio_dev, + uintptr_t private, + const struct iio_chan_spec *chan, + char *buf) +{ + struct adf41513_state *st =3D iio_priv(indio_dev); + int vals[2]; + + guard(mutex)(&st->lock); + + switch (private) { + case ADF41513_FREQ_RESOLUTION: + iio_val_s64_array_populate(st->data.freq_resolution_uhz, vals); + return iio_format_value(buf, IIO_VAL_DECIMAL64_MICRO, + ARRAY_SIZE(vals), vals); + default: + return -EINVAL; + } +} + +static ssize_t adf41513_read_powerdown(struct iio_dev *indio_dev, + uintptr_t private, + const struct iio_chan_spec *chan, + char *buf) +{ + struct adf41513_state *st =3D iio_priv(indio_dev); + u32 val; + + guard(mutex)(&st->lock); + + switch (private) { + case ADF41513_POWER_DOWN: + val =3D FIELD_GET(ADF41513_REG6_POWER_DOWN_MSK, + st->regs_hw[ADF41513_REG6]); + return sysfs_emit(buf, "%u\n", val); + default: + return -EINVAL; + } +} + +static ssize_t adf41513_write_resolution(struct iio_dev *indio_dev, + uintptr_t private, + const struct iio_chan_spec *chan, + const char *buf, size_t len) +{ + struct adf41513_state *st =3D iio_priv(indio_dev); + u64 freq_uhz; + int ret; + + ret =3D kstrtoudec64(buf, ADF41513_HZ_DECIMAL_SCALE, &freq_uhz); + if (ret) + return ret; + + guard(mutex)(&st->lock); + + switch ((u32)private) { + case ADF41513_FREQ_RESOLUTION: + if (freq_uhz =3D=3D 0 || freq_uhz > ADF41513_MAX_FREQ_RESOLUTION_UHZ) + return -EINVAL; + st->data.freq_resolution_uhz =3D freq_uhz; + return len; + default: + return -EINVAL; + } +} + +static ssize_t adf41513_write_powerdown(struct iio_dev *indio_dev, + uintptr_t private, + const struct iio_chan_spec *chan, + const char *buf, size_t len) +{ + struct adf41513_state *st =3D iio_priv(indio_dev); + unsigned long readin; + int ret; + + ret =3D kstrtoul(buf, 10, &readin); + if (ret) + return ret; + + guard(mutex)(&st->lock); + + switch ((u32)private) { + case ADF41513_POWER_DOWN: + if (readin) + ret =3D adf41513_suspend(st); + else + ret =3D adf41513_resume(st); + break; + default: + return -EINVAL; + } + + return ret ?: len; +} + +#define _ADF41513_EXT_PD_INFO(_name, _ident) { \ + .name =3D _name, \ + .read =3D adf41513_read_powerdown, \ + .write =3D adf41513_write_powerdown, \ + .private =3D _ident, \ + .shared =3D IIO_SEPARATE, \ +} + +#define _ADF41513_EXT_RES_INFO(_name, _ident) { \ + .name =3D _name, \ + .read =3D adf41513_read_resolution, \ + .write =3D adf41513_write_resolution, \ + .private =3D _ident, \ + .shared =3D IIO_SEPARATE, \ +} + +static const struct iio_chan_spec_ext_info adf41513_ext_info[] =3D { + _ADF41513_EXT_RES_INFO("frequency_resolution", ADF41513_FREQ_RESOLUTION), + _ADF41513_EXT_PD_INFO("powerdown", ADF41513_POWER_DOWN), + { } +}; + +static const struct iio_chan_spec adf41513_chan =3D { + .type =3D IIO_ALTVOLTAGE, + .indexed =3D 1, + .output =3D 1, + .channel =3D 0, + .info_mask_separate =3D BIT(IIO_CHAN_INFO_FREQUENCY) | + BIT(IIO_CHAN_INFO_PHASE), + .ext_info =3D adf41513_ext_info, +}; + +static int adf41513_read_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int *val, int *val2, long info) +{ + struct adf41513_state *st =3D iio_priv(indio_dev); + u64 tmp64; + u16 phase_val; + + guard(mutex)(&st->lock); + + switch (info) { + case IIO_CHAN_INFO_FREQUENCY: + tmp64 =3D adf41513_pll_get_rate(st); + if (st->lock_detect && + !gpiod_get_value_cansleep(st->lock_detect)) { + dev_dbg(&st->spi->dev, "PLL un-locked\n"); + return -EBUSY; + } + iio_val_s64_decompose(tmp64, val, val2); + return IIO_VAL_DECIMAL64_MICRO; + case IIO_CHAN_INFO_PHASE: + phase_val =3D FIELD_GET(ADF41513_REG2_PHASE_VAL_MSK, + st->regs_hw[ADF41513_REG2]); + tmp64 =3D (u64)phase_val * ADF41513_MAX_PHASE_MICRORAD; + tmp64 >>=3D 12; + iio_val_s64_decompose(tmp64, val, val2); + return IIO_VAL_DECIMAL64_MICRO; + default: + return -EINVAL; + } +} + +static int adf41513_write_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int val, int val2, long info) +{ + struct adf41513_state *st =3D iio_priv(indio_dev); + u64 tmp64 =3D iio_val_s64_compose(val, val2); + u16 phase_val; + + guard(mutex)(&st->lock); + + switch (info) { + case IIO_CHAN_INFO_FREQUENCY: + return adf41513_set_frequency(st, tmp64, ADF41513_SYNC_DIFF); + case IIO_CHAN_INFO_PHASE: + if (tmp64 >=3D ADF41513_MAX_PHASE_MICRORAD) + return -EINVAL; + + phase_val =3D DIV_U64_ROUND_CLOSEST(tmp64 << 12, + ADF41513_MAX_PHASE_MICRORAD); + phase_val =3D min(phase_val, ADF41513_MAX_PHASE_VAL); + st->regs[ADF41513_REG2] |=3D ADF41513_REG2_PHASE_ADJ_MSK; + FIELD_MODIFY(ADF41513_REG2_PHASE_VAL_MSK, + &st->regs[ADF41513_REG2], phase_val); + return adf41513_sync_config(st, ADF41513_SYNC_REG0); + default: + return -EINVAL; + } +} + +static int adf41513_write_raw_get_fmt(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + long mask) +{ + switch (mask) { + case IIO_CHAN_INFO_FREQUENCY: + case IIO_CHAN_INFO_PHASE: + return IIO_VAL_DECIMAL64_MICRO; + default: + return -EINVAL; + } +} + +static int adf41513_reg_access(struct iio_dev *indio_dev, unsigned int reg, + unsigned int writeval, unsigned int *readval) +{ + struct adf41513_state *st =3D iio_priv(indio_dev); + + if (reg > ADF41513_REG13) + return -EINVAL; + + guard(mutex)(&st->lock); + + if (!readval) { + if (reg <=3D ADF41513_REG6) + st->settings.mode =3D ADF41513_MODE_INVALID; + st->regs[reg] =3D writeval & ~0xF; /* Clear control bits */ + return adf41513_sync_config(st, BIT(reg)); + } + + *readval =3D st->regs_hw[reg]; + return 0; +} + +static const struct iio_info adf41513_info =3D { + .read_raw =3D adf41513_read_raw, + .write_raw =3D adf41513_write_raw, + .write_raw_get_fmt =3D adf41513_write_raw_get_fmt, + .debugfs_reg_access =3D &adf41513_reg_access, +}; + +static int adf41513_parse_fw(struct adf41513_state *st) +{ + struct device *dev =3D &st->spi->dev; + u32 tmp, cp_resistance, cp_current; + int ret; + + tmp =3D ADF41510_MAX_RF_FREQ_HZ / MEGA; + device_property_read_u32(dev, "adi,power-up-frequency-mhz", &tmp); + st->data.power_up_frequency_hz =3D (u64)tmp * MEGA; + if (st->data.power_up_frequency_hz < ADF41513_MIN_RF_FREQ_HZ || + st->data.power_up_frequency_hz > ADF41513_MAX_RF_FREQ_HZ) + return dev_err_probe(dev, -ERANGE, + "power-up frequency %llu Hz out of range\n", + st->data.power_up_frequency_hz); + + tmp =3D ADF41513_MIN_R_CNT; + device_property_read_u32(dev, "adi,reference-div-factor", &tmp); + if (tmp < ADF41513_MIN_R_CNT || tmp > ADF41513_MAX_R_CNT) + return dev_err_probe(dev, -ERANGE, + "invalid reference div factor %u\n", tmp); + st->data.ref_div_factor =3D tmp; + + st->data.ref_doubler_en =3D device_property_read_bool(dev, "adi,reference= -doubler-enable"); + st->data.ref_div2_en =3D device_property_read_bool(dev, "adi,reference-di= v2-enable"); + + cp_resistance =3D ADF41513_DEFAULT_R_SET; + device_property_read_u32(dev, "adi,charge-pump-resistor-ohms", &cp_resist= ance); + if (cp_resistance < ADF41513_MIN_R_SET || cp_resistance > ADF41513_MAX_R_= SET) + return dev_err_probe(dev, -ERANGE, "R_SET %u Ohms out of range\n", cp_re= sistance); + + st->data.charge_pump_voltage_mv =3D ADF41513_DEFAULT_CP_VOLTAGE_mV; + ret =3D device_property_read_u32(dev, "adi,charge-pump-current-microamp",= &cp_current); + if (!ret) { + tmp =3D DIV_ROUND_CLOSEST(cp_current * cp_resistance, MILLI); /* convert= to mV */ + if (tmp < ADF41513_MIN_CP_VOLTAGE_mV || tmp > ADF41513_MAX_CP_VOLTAGE_mV) + return dev_err_probe(dev, -ERANGE, "I_CP %u uA (%u Ohms) out of range\n= ", + cp_current, cp_resistance); + st->data.charge_pump_voltage_mv =3D tmp; + } + + st->data.phase_detector_polarity =3D + device_property_read_bool(dev, "adi,phase-detector-polarity-positive-ena= ble"); + + st->data.logic_lvl_1v8_en =3D device_property_read_bool(dev, "adi,logic-l= evel-1v8-enable"); + + tmp =3D ADF41513_LD_COUNT_MIN; + device_property_read_u32(dev, "adi,lock-detector-count", &tmp); + if (tmp < ADF41513_LD_COUNT_FAST_MIN || tmp > ADF41513_LD_COUNT_MAX || + !is_power_of_2(tmp)) + return dev_err_probe(dev, -ERANGE, + "invalid lock detect count: %u\n", tmp); + st->data.lock_detect_count =3D tmp; + + st->data.freq_resolution_uhz =3D MICROHZ_PER_HZ; + + return 0; +} + +static int adf41513_setup(struct adf41513_state *st) +{ + u32 tmp; + + memset(st->regs_hw, 0xFF, sizeof(st->regs_hw)); + + /* assuming DLD pin is used for lock detection */ + st->regs[ADF41513_REG5] =3D FIELD_PREP(ADF41513_REG5_DLD_MODES_MSK, + ADF41513_DLD_DIG_LD); + + tmp =3D DIV_ROUND_CLOSEST(st->data.charge_pump_voltage_mv, ADF41513_MIN_C= P_VOLTAGE_mV); + st->regs[ADF41513_REG5] |=3D FIELD_PREP(ADF41513_REG5_CP_CURRENT_MSK, tmp= - 1); + + st->regs[ADF41513_REG6] =3D ADF41513_REG6_ABP_MSK | + ADF41513_REG6_LOL_ENABLE_MSK | + ADF41513_REG6_SD_RESET_MSK; + if (st->data.phase_detector_polarity) + st->regs[ADF41513_REG6] |=3D ADF41513_REG6_PD_POLARITY_MSK; + + st->regs[ADF41513_REG7] =3D FIELD_PREP(ADF41513_REG7_PS_BIAS_MSK, + ADF41513_PS_BIAS_INIT); + tmp =3D ilog2(st->data.lock_detect_count); + if (st->data.lock_detect_count < ADF41513_LD_COUNT_FAST_LIMIT) { + tmp -=3D const_ilog2(ADF41513_LD_COUNT_FAST_MIN); + st->regs[ADF41513_REG7] |=3D ADF41513_REG7_LD_CLK_SEL_MSK; + } else { + tmp -=3D const_ilog2(ADF41513_LD_COUNT_MIN); + } + st->regs[ADF41513_REG7] |=3D FIELD_PREP(ADF41513_REG7_LD_COUNT_MSK, tmp); + + st->regs[ADF41513_REG11] =3D ADF41513_REG11_POWER_DOWN_SEL_MSK; + st->regs[ADF41513_REG12] =3D FIELD_PREP(ADF41513_REG12_LOGIC_LEVEL_MSK, + st->data.logic_lvl_1v8_en ? 0 : 1); + + /* perform initialization sequence with power-up frequency */ + return adf41513_set_frequency(st, st->data.power_up_frequency_hz * MICRO, + ADF41513_SYNC_ALL); +} + +static void adf41513_power_down(void *data) +{ + struct adf41513_state *st =3D data; + + adf41513_suspend(st); + gpiod_set_value_cansleep(st->chip_enable, 0); +} + +static int adf41513_pm_suspend(struct device *dev) +{ + return adf41513_suspend(dev_get_drvdata(dev)); +} + +static int adf41513_pm_resume(struct device *dev) +{ + return adf41513_resume(dev_get_drvdata(dev)); +} + +static const struct adf41513_chip_info adf41510_chip_info =3D { + .name =3D "adf41510", + .max_rf_freq_hz =3D ADF41510_MAX_RF_FREQ_HZ, + .has_prescaler_8_9 =3D false, +}; + +static const struct adf41513_chip_info adf41513_chip_info =3D { + .name =3D "adf41513", + .max_rf_freq_hz =3D ADF41513_MAX_RF_FREQ_HZ, + .has_prescaler_8_9 =3D true, +}; + +static int adf41513_probe(struct spi_device *spi) +{ + struct device *dev =3D &spi->dev; + struct iio_dev *indio_dev; + struct adf41513_state *st; + int ret; + + indio_dev =3D devm_iio_device_alloc(dev, sizeof(*st)); + if (!indio_dev) + return -ENOMEM; + + st =3D iio_priv(indio_dev); + st->spi =3D spi; + st->chip_info =3D spi_get_device_match_data(spi); + if (!st->chip_info) + return -EINVAL; + + spi_set_drvdata(spi, st); + + st->ref_clk =3D devm_clk_get_enabled(dev, NULL); + if (IS_ERR(st->ref_clk)) + return PTR_ERR(st->ref_clk); + + st->ref_freq_hz =3D clk_get_rate(st->ref_clk); + if (st->ref_freq_hz < ADF41513_MIN_REF_FREQ_HZ || + st->ref_freq_hz > ADF41513_MAX_REF_FREQ_HZ) + return dev_err_probe(dev, -ERANGE, + "reference frequency %u Hz out of range\n", + st->ref_freq_hz); + + ret =3D adf41513_parse_fw(st); + if (ret) + return ret; + + ret =3D devm_regulator_bulk_get_enable(dev, + ARRAY_SIZE(adf41513_power_supplies), + adf41513_power_supplies); + if (ret) + return dev_err_probe(dev, ret, + "failed to get and enable regulators\n"); + + st->chip_enable =3D devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_HIGH= ); + if (IS_ERR(st->chip_enable)) + return dev_err_probe(dev, PTR_ERR(st->chip_enable), + "fail to request chip enable GPIO\n"); + + st->lock_detect =3D devm_gpiod_get_optional(dev, "lock-detect", GPIOD_IN); + if (IS_ERR(st->lock_detect)) + return dev_err_probe(dev, PTR_ERR(st->lock_detect), + "fail to request lock detect GPIO\n"); + + ret =3D devm_mutex_init(dev, &st->lock); + if (ret) + return ret; + + indio_dev->name =3D st->chip_info->name; + indio_dev->info =3D &adf41513_info; + indio_dev->modes =3D INDIO_DIRECT_MODE; + indio_dev->channels =3D &adf41513_chan; + indio_dev->num_channels =3D 1; + + ret =3D adf41513_setup(st); + if (ret < 0) + return dev_err_probe(dev, ret, "failed to setup device\n"); + + ret =3D devm_add_action_or_reset(dev, adf41513_power_down, st); + if (ret) + return dev_err_probe(dev, ret, "Failed to add power down action\n"); + + return devm_iio_device_register(dev, indio_dev); +} + +static const struct spi_device_id adf41513_id[] =3D { + {"adf41510", (kernel_ulong_t)&adf41510_chip_info}, + {"adf41513", (kernel_ulong_t)&adf41513_chip_info}, + { } +}; +MODULE_DEVICE_TABLE(spi, adf41513_id); + +static const struct of_device_id adf41513_of_match[] =3D { + { .compatible =3D "adi,adf41510", .data =3D &adf41510_chip_info }, + { .compatible =3D "adi,adf41513", .data =3D &adf41513_chip_info }, + { } +}; +MODULE_DEVICE_TABLE(of, adf41513_of_match); + +static DEFINE_SIMPLE_DEV_PM_OPS(adf41513_pm_ops, adf41513_pm_suspend, adf4= 1513_pm_resume); + +static struct spi_driver adf41513_driver =3D { + .driver =3D { + .name =3D "adf41513", + .pm =3D pm_ptr(&adf41513_pm_ops), + .of_match_table =3D adf41513_of_match, + }, + .probe =3D adf41513_probe, + .id_table =3D adf41513_id, +}; +module_spi_driver(adf41513_driver); + +MODULE_AUTHOR("Rodrigo Alencar "); +MODULE_DESCRIPTION("Analog Devices ADF41513 PLL Frequency Synthesizer"); +MODULE_LICENSE("GPL"); --=20 2.43.0 From nobody Thu Apr 16 02:49:20 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 8D3FC33FE1F; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; cv=none; b=ntWOg8Q/92OlOHqO+mi+hAhtza22xS+fGTiVFrzyi3VgmMNsR/iTsuMBH/5m5dR2WyOjMqtHzTziqTyMhOjpnKCrxGtgxsY9kVQ49wFWmvUNH1RBF1LpotwbCSb3dz2NvrpEJDxkd7lwYhZGOF1UOI7Z2Y09QEnYvn7sPsAjR68= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; c=relaxed/simple; bh=/F/vXtXGrzHEBwVeB7Y/1jw5Q2mwhAKdk6JpIv1I3ck=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=QI1qLwfyHxe1+buLM1wGCDSlwXCUShDSDw4vsnHk4iqRIcfS6CsZI+duAx2WxwJHL5h888XnMS/w9VCtIvwP77bR/8Bmnt0F6cYjdf3Az7FYRqsV3RYTxnY+KZS6/B8hPQ2d3LCvGMBZD3AQx0815/QceB23wB8vqA8W5fribAA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=iwl9x9W2; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="iwl9x9W2" Received: by smtp.kernel.org (Postfix) with ESMTPS id 6A958C2BCB4; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776246738; bh=/F/vXtXGrzHEBwVeB7Y/1jw5Q2mwhAKdk6JpIv1I3ck=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=iwl9x9W2fon/MwJwFr9RZyzQQF6fQ1DY6gUj1VUDN6Okoq+fmIOdlK5SSw8oHkujg Hxn3WP9WG4oUT7O7o56nizXXDFpJUQJL2m4cqipsAaExqVcBF/91Z8IhTtThk1kRDo ZmmAl9FmeO8uKIudpFI1mhsK8JDexb7umunYxcYjgCEFM93Oagp7BfyT4h8UCa8g4k pRYzLQJsqiOei3r3ZscTEtjoFnINQgAhqqaUr8urJCxkHZyvEOxVodi/wYAxr8xADR tEJNJl/TGSecbPYsiegx2/yuQdvyjtpDTCpVjkHIvVaFtQFK3AWLYEX6Vrq1XLa5PX 4ZESoHgQFHAbQ== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5FC8CF41989; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) From: Rodrigo Alencar via B4 Relay Date: Wed, 15 Apr 2026 10:51:51 +0100 Subject: [PATCH v10 08/11] iio: frequency: adf41513: handle LE synchronization feature Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260415-adf41513-iio-driver-v10-8-df61046d5457@analog.com> References: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> In-Reply-To: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> To: linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jonathan Cameron , David Lechner , Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet , Andrew Morton , Petr Mladek , Steven Rostedt , Andy Shevchenko , Rasmus Villemoes , Sergey Senozhatsky , Shuah Khan , Rodrigo Alencar X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1776246736; l=3003; i=rodrigo.alencar@analog.com; s=default; h=from:subject:message-id; bh=1N4hl+53gVhZqwR7ZrhtDowFDxjDZzrTUryk250qKQ0=; b=0GZwEj6YfChnzYyKezzqDyYhJ/znQ3a76DUC9bZepo8icxQQr/i9bqZ/9SkDLcH7F4r476EWo vgfKCPEovoCDJSRg75ZiQnycgLpAFFyIQRVs3svsAUEYcj/bNmpwWw+ X-Developer-Key: i=rodrigo.alencar@analog.com; a=ed25519; pk=ULeHbgU/OYh/PG/4anHDfLgldFItQHAhOktYRVLMFRo= X-Endpoint-Received: by B4 Relay for rodrigo.alencar@analog.com/default with auth_id=561 X-Original-From: Rodrigo Alencar Reply-To: rodrigo.alencar@analog.com From: Rodrigo Alencar When LE sync is enabled, it is must be set after powering up and must be disabled when powering down. It is recommended when using the PLL as a frequency synthesizer, where reference signal will always be present while the device is being configured. Signed-off-by: Rodrigo Alencar --- drivers/iio/frequency/adf41513.c | 35 ++++++++++++++++++++++++++++++++--- 1 file changed, 32 insertions(+), 3 deletions(-) diff --git a/drivers/iio/frequency/adf41513.c b/drivers/iio/frequency/adf41= 513.c index bf2d6c941082..1921008a40d6 100644 --- a/drivers/iio/frequency/adf41513.c +++ b/drivers/iio/frequency/adf41513.c @@ -220,6 +220,7 @@ struct adf41513_data { bool phase_detector_polarity; =20 bool logic_lvl_1v8_en; + bool le_sync_en; }; =20 struct adf41513_pll_settings { @@ -632,13 +633,27 @@ static int adf41513_set_frequency(struct adf41513_sta= te *st, u64 freq_uhz, u16 s static int adf41513_suspend(struct adf41513_state *st) { st->regs[ADF41513_REG6] |=3D FIELD_PREP(ADF41513_REG6_POWER_DOWN_MSK, 1); + st->regs[ADF41513_REG12] &=3D ~ADF41513_REG12_LE_SELECT_MSK; return adf41513_sync_config(st, ADF41513_SYNC_DIFF); } =20 static int adf41513_resume(struct adf41513_state *st) { + int ret; + st->regs[ADF41513_REG6] &=3D ~ADF41513_REG6_POWER_DOWN_MSK; - return adf41513_sync_config(st, ADF41513_SYNC_DIFF); + ret =3D adf41513_sync_config(st, ADF41513_SYNC_DIFF); + if (ret) + return ret; + + if (st->data.le_sync_en) { + st->regs[ADF41513_REG12] |=3D ADF41513_REG12_LE_SELECT_MSK; + ret =3D adf41513_sync_config(st, ADF41513_SYNC_DIFF); + if (ret) + return ret; + } + + return 0; } =20 static ssize_t adf41513_read_resolution(struct iio_dev *indio_dev, @@ -923,6 +938,8 @@ static int adf41513_parse_fw(struct adf41513_state *st) "invalid lock detect count: %u\n", tmp); st->data.lock_detect_count =3D tmp; =20 + /* load enable sync */ + st->data.le_sync_en =3D device_property_read_bool(dev, "adi,le-sync-enabl= e"); st->data.freq_resolution_uhz =3D MICROHZ_PER_HZ; =20 return 0; @@ -930,6 +947,7 @@ static int adf41513_parse_fw(struct adf41513_state *st) =20 static int adf41513_setup(struct adf41513_state *st) { + int ret; u32 tmp; =20 memset(st->regs_hw, 0xFF, sizeof(st->regs_hw)); @@ -963,8 +981,19 @@ static int adf41513_setup(struct adf41513_state *st) st->data.logic_lvl_1v8_en ? 0 : 1); =20 /* perform initialization sequence with power-up frequency */ - return adf41513_set_frequency(st, st->data.power_up_frequency_hz * MICRO, - ADF41513_SYNC_ALL); + ret =3D adf41513_set_frequency(st, st->data.power_up_frequency_hz * MICRO, + ADF41513_SYNC_ALL); + if (ret) + return ret; + + if (st->data.le_sync_en) { + st->regs[ADF41513_REG12] |=3D ADF41513_REG12_LE_SELECT_MSK; + ret =3D adf41513_sync_config(st, ADF41513_SYNC_DIFF); + if (ret) + return ret; + } + + return 0; } =20 static void adf41513_power_down(void *data) --=20 2.43.0 From nobody Thu Apr 16 02:49:20 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 931A1340A43; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; cv=none; b=LK2IYigX3PrEgwLV3YwNX41Ti4R7o10sPe5HmhpN6yA6ox9E6+Lw3ZYdOnhGcRTI8CL30qCX88BTjGU6LcCbqESBGcHFSPbCHBlPbpK+Srym/ZmjwgKTjOpnaLk5xDvWbnPx7i48FqvyGMmdsdi5NVYW824V6fMBDqP/AmFppiw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; c=relaxed/simple; bh=QS3KSj/Z+N3oTGsERXPcYw6LotaCkL0Ak7Bud/qyZf0=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=cXT0f23ESEENgw4wCWYJRIk1dnpPPGr9F4dvqgIPmXxw3K34nx+JAaDDrIuwr8Q+NhBwUZUjJFkdxb9kzElypB3jy72qLMdX+snXy7d679RWYbldJRxmkkHzEUgZf9lOLWKcSmmDpQRFCUOpDXgmZ9+jpwvPQcIdBlvlwwVT1Eo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=KIDN8Xcl; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="KIDN8Xcl" Received: by smtp.kernel.org (Postfix) with ESMTPS id 75FAFC2BCB6; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776246738; bh=QS3KSj/Z+N3oTGsERXPcYw6LotaCkL0Ak7Bud/qyZf0=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=KIDN8XclrMV8MAdEOMVcfzuYrC9KoX2gaiQv1uwqtOp1seVf/APDgCa0ar2sFc90w 0oFTqi9bAPXXMjSQ/IGrIOw75sRdiOjJOl1fUiIrr9spPCy0+rpMbuFhOBV+AMxaVM Tows/xOZdRiF73YyzPJeIYP/BZGiPdvU2ZlACFIH+IbEJyCEa6K+XJaVMFE4gY8wTs oNKqkHKpSoX2vgwy96K+gP6njbPQemXwWNOJfDuDC4ojIHO/d2PPCn2L+mZq7YO02Y TQF9liKRcIuTMgpvluoe4i0oALnSR4GOm8PNsPD8A12P8Xbnjqu8c6Ve2acDt4raXe PpdlNe+YlUkmw== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6EBAEF4198C; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) From: Rodrigo Alencar via B4 Relay Date: Wed, 15 Apr 2026 10:51:52 +0100 Subject: [PATCH v10 09/11] iio: frequency: adf41513: features on frequency change Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260415-adf41513-iio-driver-v10-9-df61046d5457@analog.com> References: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> In-Reply-To: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> To: linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jonathan Cameron , David Lechner , Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet , Andrew Morton , Petr Mladek , Steven Rostedt , Andy Shevchenko , Rasmus Villemoes , Sergey Senozhatsky , Shuah Khan , Rodrigo Alencar X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1776246736; l=5625; i=rodrigo.alencar@analog.com; s=default; h=from:subject:message-id; bh=gDD3FRA2MrFKZKogjkMwG1U4pmg260YBhmQHV4QYtIA=; b=rMVp75+BVd3SvjPY6bs91KAJKZ7mx5AtdNZwVVh3FrERwqzGz5pxekwVxbmOCsiUn0i+2UxAV SZCyT9NxqGBDoHgsB9vwTugRJmOH3iEwidh7v/t5uh2VfSuAuSSPJ0B X-Developer-Key: i=rodrigo.alencar@analog.com; a=ed25519; pk=ULeHbgU/OYh/PG/4anHDfLgldFItQHAhOktYRVLMFRo= X-Endpoint-Received: by B4 Relay for rodrigo.alencar@analog.com/default with auth_id=561 X-Original-From: Rodrigo Alencar Reply-To: rodrigo.alencar@analog.com From: Rodrigo Alencar Set Bleed current when PFD frequency changes (bleed enabled when in fractional mode). Set lock detector window size, handling bias and precision. Add phase resync support, setting clock dividers when PFD frequency changes. Signed-off-by: Rodrigo Alencar --- drivers/iio/frequency/adf41513.c | 100 +++++++++++++++++++++++++++++++++++= ++++ 1 file changed, 100 insertions(+) diff --git a/drivers/iio/frequency/adf41513.c b/drivers/iio/frequency/adf41= 513.c index 1921008a40d6..78479e8a1abe 100644 --- a/drivers/iio/frequency/adf41513.c +++ b/drivers/iio/frequency/adf41513.c @@ -20,6 +20,7 @@ #include #include #include +#include #include #include =20 @@ -211,6 +212,7 @@ struct adf41513_chip_info { struct adf41513_data { u64 power_up_frequency_hz; u64 freq_resolution_uhz; + u32 phase_resync_period_ns; u32 charge_pump_voltage_mv; u32 lock_detect_count; =20 @@ -269,6 +271,16 @@ struct adf41513_state { struct adf41513_pll_settings settings; }; =20 +static const u16 adf41513_ld_window_x10_ns[] =3D { + 9, 12, 16, 17, 21, 28, 29, 35, /* 0 - 7 */ + 43, 47, 49, 52, 70, 79, 115, /* 8 - 14 */ +}; + +static const u8 adf41513_ldp_bias[] =3D { + 0xC, 0xD, 0xE, 0x8, 0x9, 0x4, 0xA, 0x5, /* 0 - 7 */ + 0x0, 0x6, 0xB, 0x1, 0x2, 0x7, 0x3, /* 8 - 14 */ +}; + static const char * const adf41513_power_supplies[] =3D { "avdd1", "avdd2", "avdd3", "avdd4", "avdd5", "vp", }; @@ -576,9 +588,82 @@ static int adf41513_calc_pll_settings(struct adf41513_= state *st, return 0; } =20 +static void adf41513_set_bleed_val(struct adf41513_state *st) +{ + u32 bleed_value, cp_index; + + if (st->data.phase_detector_polarity) + bleed_value =3D 90; + else + bleed_value =3D 144; + + cp_index =3D 1 + FIELD_GET(ADF41513_REG5_CP_CURRENT_MSK, + st->regs[ADF41513_REG5]); + bleed_value =3D div64_u64(st->settings.pfd_frequency_uhz * cp_index * ble= ed_value, + 1600ULL * MEGA * MICROHZ_PER_HZ); + + FIELD_MODIFY(ADF41513_REG6_BLEED_CURRENT_MSK, &st->regs[ADF41513_REG6], + bleed_value); +} + +static void adf41513_set_ld_window(struct adf41513_state *st) +{ + /* + * The ideal lock detector window size is halfway between the max + * window, set by the phase comparison period t_PFD =3D (1 / f_PFD), + * and the minimum is set by (I_BLEED/I_CP) =C3=97 t_PFD + */ + u16 ld_window_10x_ns =3D div64_u64(10ULL * NSEC_PER_SEC * MICROHZ_PER_HZ, + st->settings.pfd_frequency_uhz << 1); + u8 ld_idx, ldp, ld_bias; + + if (st->settings.mode !=3D ADF41513_MODE_INTEGER_N) { + /* account for bleed current (deduced from eq.6 and eq.7) */ + if (st->data.phase_detector_polarity) + ld_window_10x_ns +=3D 4; + else + ld_window_10x_ns +=3D 6; + } + + ld_idx =3D find_closest(ld_window_10x_ns, adf41513_ld_window_x10_ns, + ARRAY_SIZE(adf41513_ld_window_x10_ns)); + ldp =3D (adf41513_ldp_bias[ld_idx] >> 2) & 0x3; + ld_bias =3D adf41513_ldp_bias[ld_idx] & 0x3; + + FIELD_MODIFY(ADF41513_REG6_LDP_MSK, &st->regs[ADF41513_REG6], ldp); + FIELD_MODIFY(ADF41513_REG9_LD_BIAS_MSK, &st->regs[ADF41513_REG9], ld_bias= ); +} + +static void adf41513_set_phase_resync(struct adf41513_state *st) +{ + u32 total_div, clk1_div, clk2_div; + + if (!st->data.phase_resync_period_ns) + return; + + /* assuming both clock dividers hold similar values */ + total_div =3D mul_u64_u64_div_u64(st->settings.pfd_frequency_uhz, + st->data.phase_resync_period_ns, + 1ULL * MICROHZ_PER_HZ * NSEC_PER_SEC); + clk1_div =3D clamp(int_sqrt(total_div), 1, + ADF41513_MAX_CLK_DIVIDER); + clk2_div =3D clamp(DIV_ROUND_CLOSEST(total_div, clk1_div), 1, + ADF41513_MAX_CLK_DIVIDER); + + FIELD_MODIFY(ADF41513_REG5_CLK1_DIV_MSK, &st->regs[ADF41513_REG5], + clk1_div); + FIELD_MODIFY(ADF41513_REG7_CLK2_DIV_MSK, &st->regs[ADF41513_REG7], + clk2_div); + + /* enable phase resync */ + st->regs[ADF41513_REG7] |=3D ADF41513_REG7_CLK_DIV_MODE_MSK; +} + static int adf41513_set_frequency(struct adf41513_state *st, u64 freq_uhz,= u16 sync_mask) { struct adf41513_pll_settings result; + bool pfd_change =3D false; + bool mode_change =3D false; int ret; =20 ret =3D adf41513_calc_pll_settings(st, &result, freq_uhz); @@ -586,6 +671,8 @@ static int adf41513_set_frequency(struct adf41513_state= *st, u64 freq_uhz, u16 s return ret; =20 /* apply computed results to pll settings */ + pfd_change =3D st->settings.pfd_frequency_uhz !=3D result.pfd_frequency_u= hz; + mode_change =3D st->settings.mode !=3D result.mode; st->settings =3D result; =20 dev_dbg(&st->spi->dev, @@ -627,6 +714,14 @@ static int adf41513_set_frequency(struct adf41513_stat= e *st, u64 freq_uhz, u16 s st->regs[ADF41513_REG6] |=3D ADF41513_REG6_BLEED_ENABLE_MSK; } =20 + if (pfd_change) { + adf41513_set_bleed_val(st); + adf41513_set_phase_resync(st); + } + + if (pfd_change || mode_change) + adf41513_set_ld_window(st); + return adf41513_sync_config(st, sync_mask | ADF41513_SYNC_REG0); } =20 @@ -928,6 +1023,11 @@ static int adf41513_parse_fw(struct adf41513_state *s= t) st->data.phase_detector_polarity =3D device_property_read_bool(dev, "adi,phase-detector-polarity-positive-ena= ble"); =20 + st->data.phase_resync_period_ns =3D 0; + ret =3D device_property_read_u32(dev, "adi,phase-resync-period-ns", &tmp); + if (!ret) + st->data.phase_resync_period_ns =3D tmp; + st->data.logic_lvl_1v8_en =3D device_property_read_bool(dev, "adi,logic-l= evel-1v8-enable"); =20 tmp =3D ADF41513_LD_COUNT_MIN; --=20 2.43.0 From nobody Thu Apr 16 02:49:20 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 AB37E344030; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; cv=none; b=a8Xm31Y5z2fVtKT/17SCR+GFRN7Oo9Zw32686t7KNRs5cEKCNNQTv/YjJbAEaaY1PjieNtOF0fug2X8eUUxZz+xCWhUJ7hVM0PXgOia62GpYt3n9G33b4YdXgGjn5zz5l6AqjP8ajR8cC75OH/1FN1kXHU2fzvh+NONQx96nCtk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; c=relaxed/simple; bh=RNYDtXqT1zPcbr9VepIxSH0SXBfwTx2GpBllBP9ixHg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=YS6TIu7XBZkFdaMVZ4PHWQcOSEiYEqk4AAj7XstyaBKPrTlryVy4Wv2tOzKFRix6GY9WYR5UQbPTO6Af0e0KNoDPGloFgRjVHuJW6It/e5l+AMteY9sD31HKpoTftJmdlQJXvVCleP9tbm7/DiVqDNF8EMI4TAidOSvpBArE1t0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=j/NB5G27; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="j/NB5G27" Received: by smtp.kernel.org (Postfix) with ESMTPS id 87217C2BCC7; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776246738; bh=RNYDtXqT1zPcbr9VepIxSH0SXBfwTx2GpBllBP9ixHg=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=j/NB5G27ewb5MjI19hpyRJpV+UGFmq3i4UmFBSEwD3yveUdUUpJMKN7GTPREkDWm2 FWU1P0yypq35GuE6uY9ebVGofinGwawL0QYVTpXZQ5FCfhtI4g/tXd9+2qSkifhYj3 nSbSIA4jMu/KZB7yevBbgibXKPneu5j3EUmjqfcRHo82tcmBDhYRnmxfPYMujOary5 jBZsDNo1myuiPPadp+8C+gDoxniSo9dEQubvcfTrOtuFahjjGGjbXSN69PuglbEEKd kbtQLeWYByb7YFBbi1NzHQ5fCklhJCSqf2SecbeFlKsO7wtsorNxVjhbR9+GRbQeqV m1+BRQO1ub1gA== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7EE2EF41987; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) From: Rodrigo Alencar via B4 Relay Date: Wed, 15 Apr 2026 10:51:53 +0100 Subject: [PATCH v10 10/11] docs: iio: add documentation for adf41513 driver Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260415-adf41513-iio-driver-v10-10-df61046d5457@analog.com> References: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> In-Reply-To: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> To: linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jonathan Cameron , David Lechner , Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet , Andrew Morton , Petr Mladek , Steven Rostedt , Andy Shevchenko , Rasmus Villemoes , Sergey Senozhatsky , Shuah Khan , Rodrigo Alencar X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1776246736; l=9001; i=rodrigo.alencar@analog.com; s=default; h=from:subject:message-id; bh=44S046rKQ8vJjwYP3E0/B2wareoeDdEt/WCnvjcW9yk=; b=gNVYoZ/qJxM7zXNL3TMwPofCDiuRjPTdzjf3I009BrlO1wbR/kCqOr677BJFdXH8EEsFdcBG8 qdL200KfzNWA57FsTTRp2SgNVeKxtrc/2OGIxKwyFNloaWHiyJVDVTY X-Developer-Key: i=rodrigo.alencar@analog.com; a=ed25519; pk=ULeHbgU/OYh/PG/4anHDfLgldFItQHAhOktYRVLMFRo= X-Endpoint-Received: by B4 Relay for rodrigo.alencar@analog.com/default with auth_id=561 X-Original-From: Rodrigo Alencar Reply-To: rodrigo.alencar@analog.com From: Rodrigo Alencar Add documentation for ADF41513 driver, which describes the device driver files and shows how userspace may consume the ABI for various tasks. Signed-off-by: Rodrigo Alencar --- Documentation/iio/adf41513.rst | 199 +++++++++++++++++++++++++++++++++++++= ++++ Documentation/iio/index.rst | 1 + MAINTAINERS | 1 + 3 files changed, 201 insertions(+) diff --git a/Documentation/iio/adf41513.rst b/Documentation/iio/adf41513.rst new file mode 100644 index 000000000000..4193c825b532 --- /dev/null +++ b/Documentation/iio/adf41513.rst @@ -0,0 +1,199 @@ +.. SPDX-License-Identifier: GPL-2.0 + +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D +ADF41513 driver +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +This driver supports Analog Devices' ADF41513 and similar SPI PLL frequency +synthesizers. + +1. Supported devices +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +* `ADF41510 `_ +* `ADF41513 `_ + +The ADF41513 is an ultralow noise frequency synthesizer that can be used to +implement local oscillators (LOs) as high as 26.5 GHz in the upconversion = and +downconversion sections of wireless receivers and transmitters. The ADF415= 10 +is a similar device that supports frequencies up to 10 GHz. + +Both devices support integer-N and fractional-N operation modes, providing +excellent phase noise performance and flexible frequency generation +capabilities. + +Key Features: + +- **ADF41510**: 1 GHz to 10 GHz frequency range +- **ADF41513**: 1 GHz to 26.5 GHz frequency range +- Integer-N and fractional-N operation modes +- Ultra-low phase noise (-235 dBc/Hz integer-N, -231 dBc/Hz fractional-N) +- High maximum PFD frequency (250 MHz integer-N, 125 MHz fractional-N) +- 25-bit fixed modulus or 49-bit variable modulus fractional modes +- Programmable charge pump currents with 16x range +- Digital lock detect functionality +- Phase resync capability for consistent output phase + +2. Device attributes +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +The ADF41513 driver provides the following IIO extended attributes for +frequency control and monitoring: + +Each IIO device has a device folder under ``/sys/bus/iio/devices/iio:devic= eX``, +where X is the IIO index of the device. Under these folders reside a set of +device files that provide access to the synthesizer's functionality. + +The following table shows the ADF41513 related device files: + ++----------------------+--------------------------------------------------= -----+ +| Device file | Description = | ++=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D+=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D+ +| frequency | RF output frequency control and readback (Hz) = | ++----------------------+--------------------------------------------------= -----+ +| frequency_resolution | Target frequency resolution control (Hz) = | ++----------------------+--------------------------------------------------= -----+ +| powerdown | Power management control (0=3Dactive, 1=3Dpower d= own) | ++----------------------+--------------------------------------------------= -----+ +| phase | RF output phase adjustment and readback (radians)= | ++----------------------+--------------------------------------------------= -----+ + +2.1 Frequency Control +---------------------- + +The ``frequency`` attribute controls the RF output frequency with sub-Hz +precision. The driver automatically selects between integer-N and fraction= al-N +modes to achieve the requested frequency with the best possible phase noise +performance. + +**Supported ranges:** + +- **ADF41510**: 1,000,000,000 Hz to 10,000,000,000 Hz (1 GHz to 10 GHz) +- **ADF41513**: 1,000,000,000 Hz to 26,500,000,000 Hz (1 GHz to 26.5 GHz) + +The frequency is specified in Hz, for sub-Hz precision use decimal notatio= n. +For example, 12.102 GHz would be written as "12102000000.000000". + +2.2 Frequency Resolution Control +-------------------------------- + +The ``frequency_resolution`` attribute controls the target frequency resol= ution +that the driver attempts to achieve. This affects the choice between integ= er-N +and fractional-N modes, including fixed modulus (25-bit) and variable modu= lus +(49-bit) fractional-N modes: + +- **Integer-N**: Resolution =3D f_PFD +- **Fixed modulus**: Resolution =3D f_PFD / 2^25 (~3 Hz with 100 MHz PFD) +- **Variable modulus**: Resolution =3D f_PFD / 2^49 (=C2=B5Hz resolution p= ossible) + +Default resolution is 1 Hz (1,000,000 =C2=B5Hz). + +2.3 Phase adjustment +-------------------- + +The ``phase`` attribute allows adjustment of the output phase in radians. +Setting this attribute enables phase adjustment. It can be set from 0 to 2= *pi +radians. Reading this attribute returns the current phase offset of the ou= tput +signal. To create a consistent phase relationship with the reference signa= l, +the phase resync feature needs to be enabled by setting a non-zero value t= o the +``adi,phase-resync-period-ns`` device property, which triggers a phase +resynchronization after locking is achieved. + +3. Operating modes +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +3.1 Integer-N Mode +------------------ + +When the requested frequency can be achieved as an integer multiple of the= PFD +frequency (within the specified resolution tolerance), the driver automati= cally +selects integer-N mode for optimal phase noise performance. + +In integer-N mode: + +- Phase noise: -235 dBc/Hz normalized floor +- Frequency resolution: f_PFD (same as PFD frequency) +- Maximum PFD frequency: 250 MHz +- Bleed current: Disabled + +3.2 Fractional-N Mode +--------------------- + +When sub-integer frequency steps are required, the driver automatically se= lects +fractional-N mode using either fixed or variable modulus. + +**Fixed Modulus (25-bit)**: + +- Used when variable modulus is not required +- Resolution: f_PFD / 2^25 +- Simpler implementation, faster settling + +**Variable Modulus (49-bit)**: + +- Used for maximum resolution requirements +- Resolution: f_PFD / 2^49 (theoretical) +- Exact frequency synthesis capability + +In fractional-N mode: + +- Phase noise: -231 dBc/Hz normalized floor +- Maximum PFD frequency: 125 MHz +- Bleed current: Automatically enabled and optimized +- Dithering: Enabled to reduce fractional spurs + +3.3 Automatic Mode Selection +---------------------------- + +The driver automatically selects the optimal operating mode based on: + +1. **Frequency accuracy requirements**: Determined by frequency_resolution= setting +2. **Phase noise optimization**: Integer-N preferred when possible +3. **PFD frequency constraints**: Different limits for integer vs fraction= al modes +4. **Prescaler selection**: Automatic 4/5 vs 8/9 prescaler selection based= on frequency + +4. Usage examples +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +4.1 Basic Frequency Setting +---------------------------- + +Set output frequency to 12.102 GHz: + +.. code-block:: bash + + root:/sys/bus/iio/devices/iio:device0> echo 12102000000 > out_altvolta= ge0_frequency + +Read current frequency: + +.. code-block:: bash + + root:/sys/bus/iio/devices/iio:device0> cat out_altvoltage0_frequency + 12101999999.582767 + +4.2 High Resolution Frequency Control +------------------------------------- + +Configure for sub-Hz resolution and set a precise frequency: + +.. code-block:: bash + + # Set resolution to 0.1 Hz (100,000 =C2=B5Hz) + root:/sys/bus/iio/devices/iio:device0> echo 0.1 > out_altvoltage0_freq= uency_resolution + + # Set frequency to 12.102 GHz (1 =C2=B5Hz precision) + root:/sys/bus/iio/devices/iio:device0> echo 12102000000 > out_altvolta= ge0_frequency + root:/sys/bus/iio/devices/iio:device0> cat out_altvoltage0_frequency + 12101999999.980131 + +4.3 Monitor Lock Status +----------------------- + +When lock detect GPIO is configured, check if PLL is locked: + +.. code-block:: bash + + # Read frequency - will return error if not locked + root:/sys/bus/iio/devices/iio:device0> cat out_altvoltage0_frequency + +If the PLL is not locked, the frequency read will return ``-EBUSY`` (Devic= e or +resource busy). diff --git a/Documentation/iio/index.rst b/Documentation/iio/index.rst index ba3e609c6a13..605871765c78 100644 --- a/Documentation/iio/index.rst +++ b/Documentation/iio/index.rst @@ -30,6 +30,7 @@ Industrial I/O Kernel Drivers ad7625 ad7944 ade9000 + adf41513 adis16475 adis16480 adis16550 diff --git a/MAINTAINERS b/MAINTAINERS index 4e28f54cb34f..37fc22dc525b 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1660,6 +1660,7 @@ L: linux-iio@vger.kernel.org S: Supported W: https://ez.analog.com/linux-software-drivers F: Documentation/devicetree/bindings/iio/frequency/adi,adf41513.yaml +F: Documentation/iio/adf41513.rst F: drivers/iio/frequency/adf41513.c =20 ANALOG DEVICES INC ADF4377 DRIVER --=20 2.43.0 From nobody Thu Apr 16 02:49:20 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 C53F43451CC; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; cv=none; b=m0hbKjIDsxbJuHnOZZ2EjEBa4IxXhZUVpdWDZPNuwUfkjj86ZwyNULh8IEm+07auMmPTkCgYlbyzzp4/24CfJtTLqoDaYmO03TFW8XvVnwc7m8p7LsKS43rL2dpaoDeqtHIzFsC3RjITx9m/4oPHJIiWUIhEEG82RH+VAbMIk+Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776246738; c=relaxed/simple; bh=9B+csSwynGBtD47HQVlSlvUhKYSoSrYkjk2oqbGoZOQ=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=ubkXOpKYXhrjQLkJ+3rnSXtvFzc7lcZ1QCNb0mpvyOo7J7lhl390U5DIrW7sRyfHNvDk6N+pnlOHrR+ZNbdXxUaDE5BxtaPdiQQ/bKwDIF0QcR/9KaCQMhZKzvy4mD+ieYdweDIOqNAwVxPMETchz5FEUEun43NcdhnajtJaC3o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=kZDAG51Q; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="kZDAG51Q" Received: by smtp.kernel.org (Postfix) with ESMTPS id 98C11C4AF0F; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776246738; bh=9B+csSwynGBtD47HQVlSlvUhKYSoSrYkjk2oqbGoZOQ=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=kZDAG51Q60gMOKz0hRK+Oirn8cMJ9phYP8/be5On9P0opQ+6oCQ+2LsBSFXjuP3ys 0bl5zN2Bkd0ya9YKb2ZGOFzff/aEEYHkArE1oNHaQPZpLxF6YxVg5ydIiaoXIkLL9L HaKFAl2e5Zypn/Hi27MvgbZEFtF8Jv69h/R6me5usKPmhfgJ+hhfwEkSScuL0FwwRV BPOkpiYQMGmKjyxyAESlyO6NEB5KVmWnvzW9mdgBDzBAXC6MIvB7mWAnDI6Ndd+blE vtTno4OLXLFXrr9Y1Oc6NNFurE/vUOPWR/+eokxSLjd3Ee219AUOoKTQAjPYIXJmOi 6fTtUyNZn6F3Q== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8D521F4198D; Wed, 15 Apr 2026 09:52:18 +0000 (UTC) From: Rodrigo Alencar via B4 Relay Date: Wed, 15 Apr 2026 10:51:54 +0100 Subject: [PATCH v10 11/11] Documentation: ABI: testing: add common ABI file for iio/frequency Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260415-adf41513-iio-driver-v10-11-df61046d5457@analog.com> References: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> In-Reply-To: <20260415-adf41513-iio-driver-v10-0-df61046d5457@analog.com> To: linux-kernel@vger.kernel.org, linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jonathan Cameron , David Lechner , Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet , Andrew Morton , Petr Mladek , Steven Rostedt , Andy Shevchenko , Rasmus Villemoes , Sergey Senozhatsky , Shuah Khan , Rodrigo Alencar X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1776246736; l=2210; i=rodrigo.alencar@analog.com; s=default; h=from:subject:message-id; bh=OhPLAamt4hmbeCatH+/iPHehi/HIntujTnWeOacWI/A=; b=jVKPi+ySD9retpXx91x/DPGFm6uXP4JfoI+dsgC86R+zCxB8G4gYqZIbIelYX9DptQHEjSFuR 3NadidVcBXmDJ34fTjrL5jyjAsTSN3BDUi0k5kA0aFDixAiMt6ou+7/ X-Developer-Key: i=rodrigo.alencar@analog.com; a=ed25519; pk=ULeHbgU/OYh/PG/4anHDfLgldFItQHAhOktYRVLMFRo= X-Endpoint-Received: by B4 Relay for rodrigo.alencar@analog.com/default with auth_id=561 X-Original-From: Rodrigo Alencar Reply-To: rodrigo.alencar@analog.com From: Rodrigo Alencar Add ABI documentation file for PLL/DDS devices with frequency_resolution sysfs entry attribute used by both ADF4350 and ADF41513. Signed-off-by: Rodrigo Alencar --- Documentation/ABI/testing/sysfs-bus-iio-frequency | 11 +++++++++++ Documentation/ABI/testing/sysfs-bus-iio-frequency-adf4350 | 10 ---------- 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/Documentation/ABI/testing/sysfs-bus-iio-frequency b/Documentat= ion/ABI/testing/sysfs-bus-iio-frequency new file mode 100644 index 000000000000..1ce8ae578fd6 --- /dev/null +++ b/Documentation/ABI/testing/sysfs-bus-iio-frequency @@ -0,0 +1,11 @@ +What: /sys/bus/iio/devices/iio:deviceX/out_altvoltageY_frequency_resoluti= on +KernelVersion: 6.20 +Contact: linux-iio@vger.kernel.org +Description: + Stores channel Y frequency resolution/channel spacing in Hz for PLL + devices. The given value directly influences the operating mode when + fractional-N synthesis is required, as it derives values for + configurable modulus parameters used in the calculation of the output + frequency. It is assumed that the algorithm that is used to compute + the various dividers, is able to generate proper values for multiples + of channel spacing. diff --git a/Documentation/ABI/testing/sysfs-bus-iio-frequency-adf4350 b/Do= cumentation/ABI/testing/sysfs-bus-iio-frequency-adf4350 index 1254457a726e..76987a119feb 100644 --- a/Documentation/ABI/testing/sysfs-bus-iio-frequency-adf4350 +++ b/Documentation/ABI/testing/sysfs-bus-iio-frequency-adf4350 @@ -1,13 +1,3 @@ -What: /sys/bus/iio/devices/iio:deviceX/out_altvoltageY_frequency_resoluti= on -KernelVersion: 3.4.0 -Contact: linux-iio@vger.kernel.org -Description: - Stores channel Y frequency resolution/channel spacing in Hz. - The value given directly influences the MODULUS used by - the fractional-N PLL. It is assumed that the algorithm - that is used to compute the various dividers, is able to - generate proper values for multiples of channel spacing. - What: /sys/bus/iio/devices/iio:deviceX/out_altvoltageY_refin_frequency KernelVersion: 3.4.0 Contact: linux-iio@vger.kernel.org --=20 2.43.0