From nobody Thu Dec 18 18:05:48 2025 Received: from mail-wm1-f50.google.com (mail-wm1-f50.google.com [209.85.128.50]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4FD8526137F for ; Fri, 14 Feb 2025 12:23:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.50 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739535799; cv=none; b=Kh7xy6nvVMvWXSK2H082F40yE/4seMN/u7n1duouoYKpGruyoP0gpRmjOKUxRX0ef869/vfVoynzAyzi+5stQClxX7RgQDq4ggGy/G3FLXOSM048p//3wGA5b0LHD+HSS7SLqfQV3miPhssilWH5G+oxA0O1Oim5i9IwIzf6tAE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739535799; c=relaxed/simple; bh=GZiQ6zwLnj9czKKnGwp69ohjckNVfoQP2zmeBSWPev8=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=qOZzjgKFZlCJ1eknKVF0UVJzEqY0dve6ly+kQ9uhnhHSX7QM9GP3A/rxE8OD32SG7PNlMxRxGjfNn1Hsz0KEFZ7Jg9nI1GHvnMNvR35ZvoTWzLJrYDcQqP2zue1FQYbTwNtrmy1P+jIV+ly/BKe9yBDx36fU7nkTavecurz+ljc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com; spf=pass smtp.mailfrom=baylibre.com; dkim=pass (2048-bit key) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.b=c9INqQ8E; arc=none smtp.client-ip=209.85.128.50 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=baylibre.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.b="c9INqQ8E" Received: by mail-wm1-f50.google.com with SMTP id 5b1f17b1804b1-4395a06cf43so12787585e9.2 for ; Fri, 14 Feb 2025 04:23:16 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20230601.gappssmtp.com; s=20230601; t=1739535795; x=1740140595; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=fm3SdUr+XcDlqAYhLCX7VaMzzxMU+2eGpj/VQCDpL2c=; b=c9INqQ8EMECrE/uzzfiffuljT6tpaFvIjHluodQcowUiKNWxXq2B9E68gQEw7/Q6k2 9zAa4uJEKwxyTzUixB+3MDzn0mK14RYo1uCC5+CljSuiOI1+G417MkN+xsccCwIHDMQX VM4Ki1qwhgIR3qMaYDEQMplqdYjEHHw+Dzga3U34/ZTTYY5fXnN3YvC/ksuRsS0KTQpQ dqCgWLrbUslypyrZtM55jr8uuK8iw8bpDe+S3xrxEpCU0qrhecW6scvFHA6elo2n7pUc 3249hsaYDTeUy/c5xc1gDL7iqvLolEjCZw43ihatnzLZwLL2PC+pcFdBxXsGXMg7gO2L 8n2A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1739535795; x=1740140595; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=fm3SdUr+XcDlqAYhLCX7VaMzzxMU+2eGpj/VQCDpL2c=; b=m0tzPpsdsAGx9Fag8RjSLlZdJAuAoAaeUW8DnWY7Phk/2VFpV55LIbQdBtEEHg7u9W cTvIXPS0f0A+5ygCRv9qvvpjXpTKvKfmD/mpszjsKnAWx3Za0iBiDWriEVI4aTCBlXvq qjZ4nKkCsjNQoPeRJgY3bQ68d4fYbvl0vnv7hFy2CvGCmkHfw1XFBBRkkgznzG1cagH6 PHi5EkTYorI5fl+Vl/z1LARXquJNYLcY8rNp/dnnDLk+BeAXHo5OYoHaVsef0hQw4YKz 7i+cfRH94OiB+lLC6RBzDiwSn7NtyY39IduVqfIRDdFFexsMcL1UWqu/P8PTZ2N4Tx1g 6PPg== X-Forwarded-Encrypted: i=1; AJvYcCX9e4pF1KXJt3EfK/eIECKydlJeJnf5m1aJn/tsn3CVc04J+ctVKeMgboM1/nbk7F04kvx7+Gz1izsjAcE=@vger.kernel.org X-Gm-Message-State: AOJu0Yzs+2Wm+Ohbaw6wSJvnOtNHY5E6NCiBwlGbhb25mF93eZ06FzSN 4vU83LNGBxYQD7jfh2b+u9Y69x5aCforOZxDoU44ox/EaujNYszdi9k3QWgZElk= X-Gm-Gg: ASbGncuGbv0j5+XT4j+WpTnq5vlb9OetPrRhAuGrFi8pMYekTD372eWbFj9e98weUno pA3A6VTDJwF1PHmHPCpxyu3OQEyr5Owm9s9IdPQU8SbhUJh/Y57A4Nr0g8KYxatORSaGMNOsnif fEpZzp/kzuS5eWoZUnyi7BM5TuSlfJqpy+KrtE2x8RPSo+OqZG3hRDiyxeaHGaZiUZgCxep/6PY 0kcAGP6s3xOHuGgNLjCfqaf2Ja+LYYpzJ8UfMebNdXcrtuENpAgbKYuxBADkR0OV0nqURD42UGH Ivv1p61kHgKmUXL8Hiez7vYFTyYNUtLjtm+m9LlIFi8uEmQj3rzPTdRoHgfbjrgPlwbpzkO4 X-Google-Smtp-Source: AGHT+IGwkq07676KTqyEaxNz9NvrlZsawD0WRNZ0jroOP1Gbp3SkUEhcQHH3b90tMjHwD3iIKtLR2A== X-Received: by 2002:a05:600c:870a:b0:439:554e:70d4 with SMTP id 5b1f17b1804b1-439601694f2mr75256105e9.1.1739535794612; Fri, 14 Feb 2025 04:23:14 -0800 (PST) Received: from [127.0.0.1] (amontpellier-556-1-148-206.w109-210.abo.wanadoo.fr. [109.210.4.206]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-38f259f7b68sm4424654f8f.85.2025.02.14.04.23.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 14 Feb 2025 04:23:14 -0800 (PST) From: Esteban Blanc Date: Fri, 14 Feb 2025 13:22:31 +0100 Subject: [PATCH v4 1/6] dt-bindings: iio: adc: add ADI ad4030, ad4630 and ad4632 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: <20250214-eblanc-ad4630_v1-v4-1-135dd66cab6a@baylibre.com> References: <20250214-eblanc-ad4630_v1-v4-0-135dd66cab6a@baylibre.com> In-Reply-To: <20250214-eblanc-ad4630_v1-v4-0-135dd66cab6a@baylibre.com> To: Lars-Peter Clausen , Michael Hennerich , =?utf-8?q?Nuno_S=C3=A1?= , Jonathan Cameron , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet Cc: Michael Hennerich , linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org, Esteban Blanc , Conor Dooley X-Mailer: b4 0.14.2 This adds a binding specification for the Analog Devices Inc. AD4030, AD4630 and AD4632 families of ADCs. - ad4030-24 is a 1 channel SAR ADC with 24 bits of precision and a sampling rate of 2M samples per second - ad4032-24 is a 1 channel SAR ADC with 24 bits of precision and a sampling rate of 500K samples per second - ad4630-16 is a 2 channels SAR ADC with 16 bits of precision and a sampling rate of 2M samples per second - ad4630-24 is a 2 channels SAR ADC with 24 bits of precision and a sampling rate of 2M samples per second - ad4632-16 is a 2 channels SAR ADC with 16 bits of precision and a sampling rate of 500K samples per second - ad4632-24 is a 2 channels SAR ADC with 24 bits of precision and a sampling rate of 500K samples per second Reviewed-by: Conor Dooley Signed-off-by: Esteban Blanc --- .../devicetree/bindings/iio/adc/adi,ad4030.yaml | 111 +++++++++++++++++= ++++ MAINTAINERS | 9 ++ 2 files changed, 120 insertions(+) diff --git a/Documentation/devicetree/bindings/iio/adc/adi,ad4030.yaml b/Do= cumentation/devicetree/bindings/iio/adc/adi,ad4030.yaml new file mode 100644 index 0000000000000000000000000000000000000000..cef2dc1eefb9126f836794c742b= 9e471a847296a --- /dev/null +++ b/Documentation/devicetree/bindings/iio/adc/adi,ad4030.yaml @@ -0,0 +1,111 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +# Copyright 2024 Analog Devices Inc. +# Copyright 2024 BayLibre, SAS. +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/iio/adc/adi,ad4030.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Analog Devices AD4030 and AD4630 ADC families + +maintainers: + - Michael Hennerich + - Nuno Sa + +description: | + Analog Devices AD4030 single channel and AD4630/AD4632 dual channel prec= ision + SAR ADC families + + * https://www.analog.com/media/en/technical-documentation/data-sheets/ad= 4030-24-4032-24.pdf + * https://www.analog.com/media/en/technical-documentation/data-sheets/ad= 4630-24_ad4632-24.pdf + * https://www.analog.com/media/en/technical-documentation/data-sheets/ad= 4630-16-4632-16.pdf + +properties: + compatible: + enum: + - adi,ad4030-24 + - adi,ad4032-24 + - adi,ad4630-16 + - adi,ad4630-24 + - adi,ad4632-16 + - adi,ad4632-24 + + reg: + maxItems: 1 + + spi-max-frequency: + maximum: 102040816 + + spi-rx-bus-width: + enum: [1, 2, 4] + + vdd-5v-supply: true + vdd-1v8-supply: true + vio-supply: true + + ref-supply: + description: + Optional External unbuffered reference. Used when refin-supply is not + connected. + + refin-supply: + description: + Internal buffered Reference. Used when ref-supply is not connected. + + cnv-gpios: + description: + The Convert Input (CNV). It initiates the sampling conversions. + maxItems: 1 + + reset-gpios: + description: + The Reset Input (/RST). Used for asynchronous device reset. + maxItems: 1 + + interrupts: + description: + The BUSY pin is used to signal that the conversions results are avai= lable + to be transferred when in SPI Clocking Mode. This nodes should be + connected to an interrupt that is triggered when the BUSY line goes = low. + maxItems: 1 + + interrupt-names: + const: busy + +required: + - compatible + - reg + - vdd-5v-supply + - vdd-1v8-supply + - vio-supply + - cnv-gpios + +oneOf: + - required: + - ref-supply + - required: + - refin-supply + +unevaluatedProperties: false + +examples: + - | + #include + + spi { + #address-cells =3D <1>; + #size-cells =3D <0>; + + adc@0 { + compatible =3D "adi,ad4030-24"; + reg =3D <0>; + spi-max-frequency =3D <80000000>; + vdd-5v-supply =3D <&supply_5V>; + vdd-1v8-supply =3D <&supply_1_8V>; + vio-supply =3D <&supply_1_8V>; + ref-supply =3D <&supply_5V>; + cnv-gpios =3D <&gpio0 0 GPIO_ACTIVE_HIGH>; + reset-gpios =3D <&gpio0 1 GPIO_ACTIVE_LOW>; + }; + }; + diff --git a/MAINTAINERS b/MAINTAINERS index 25c86f47353de25c88291cc7fd6c4e9bfb12d5c4..f0c7aa6d744040ba530917b566c= a68087a49492f 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1306,6 +1306,15 @@ F: Documentation/devicetree/bindings/iio/adc/adi,ad4= 000.yaml F: Documentation/iio/ad4000.rst F: drivers/iio/adc/ad4000.c =20 +AD4030 ADC DRIVER (AD4030-24/AD4630-16/AD4630-24/AD4632-16/AD4632-24) +M: Michael Hennerich +M: Nuno S=C3=A1 +R: Esteban Blanc +L: linux-iio@vger.kernel.org +S: Supported +W: https://ez.analog.com/linux-software-drivers +F: Documentation/devicetree/bindings/iio/adc/adi,ad4030.yaml + ANALOG DEVICES INC AD4130 DRIVER M: Cosmin Tanislav L: linux-iio@vger.kernel.org --=20 2.47.2 From nobody Thu Dec 18 18:05:48 2025 Received: from mail-wm1-f52.google.com (mail-wm1-f52.google.com [209.85.128.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9037C263F2A for ; Fri, 14 Feb 2025 12:23:17 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.52 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739535800; cv=none; b=b19Vsu3ATRwNarNAT48a8WXjTW4DzxIgvlSzhopLr1vPblaq640bsNaRMlWWG6DWuDW5pHXwcJC4rk8TjsiN0KiSkjQFx48Mbius0HgoBUU4ZVNvp669a2cYDfn2exR0GsczTVdq5BsK5DgWwEVRHsMQrgGCquvhUWoBENVV92I= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739535800; c=relaxed/simple; bh=O4bcBeepBuXL2xmP+Yzons/EZRNUdcC2RNlOcVtA7Yo=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=urOJUrTVPnZeCJA2c34AUAllTQ0ADCs742Sd36L1gc1sSgP9OIZL2wt1ny2v29HncdKeWT6fOMtQs/ytdU069Lc8Ang90OOqi4WqzgIhl6o8h8VzAihMXExTIPX7iTgm2dwKizYE1Ge6yVdajogmG6JrcgPv/jBj3eaCWijRzlY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com; spf=pass smtp.mailfrom=baylibre.com; dkim=pass (2048-bit key) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.b=Zenacc76; arc=none smtp.client-ip=209.85.128.52 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=baylibre.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.b="Zenacc76" Received: by mail-wm1-f52.google.com with SMTP id 5b1f17b1804b1-43962f7b0e4so11467785e9.3 for ; Fri, 14 Feb 2025 04:23:17 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20230601.gappssmtp.com; s=20230601; t=1739535796; x=1740140596; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=NBc4TMCqDu+1Ja4d2OSdJ84d8/kneW6YCcz8kLI6ebk=; b=Zenacc769/QD0aEUMjGlReOeFOxnjX+4bUpZSVvnxpPmoMjqx/XjYCPrHJ5KnJe2PL VXuJF0K/77F0u0wJXms2Zhzb/FlnxFVFM0HtMevFOyK87INObZpZw0NZ9m0wF+iPNpnx ZIENQRdGEfOT27MN5mY4uSNaNJx+upREIlkMrZx4Fd++uaeJBXD2SLdF1ClHMwb39hcR FvxO8no36BhYP87zbQ/vVT+hnZ6Tl/ZRLfcMrQ36Rm0DHoXkzZAZmH6aD7w6Vha9gcI5 Ziu2+WY2iHa+SKytZA1xwotuuy2dwUFSQ6klnUtX4V21F0r/AFRaksRWpnoQJsAG6pok 45Iw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1739535796; x=1740140596; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=NBc4TMCqDu+1Ja4d2OSdJ84d8/kneW6YCcz8kLI6ebk=; b=EnQV1fKcBYg1f4ImlYJUmzVjLtW6fNk2eozN1vIvobtDWvHMgovCjGD0lHZ3EywHXQ TnTZoQL/NkOfvzn8mu1+mWDQojP0CAVd7F+hbWph0nZPNqW1otRUh/OVHe4y4+iK+dvZ 2zsiPDhgUE2nen1Jc28A1lPtEXgEViHAyLJsmjzVUGaKfJ8STYpa5iHNHege8a1QYVjH EoQA2KHAYj95mS+zbklim0fKilgVXawVptSu2EtDe/TMj4rP4hkL9w4HiJ3YBHzqdjn0 pLf+RLM11axrD61HHfITtA9PlLavYQtA5pxlX1NeII1+OFKU27EbyPJfTyY9KAoX89Ko LRUQ== X-Forwarded-Encrypted: i=1; AJvYcCU9QGrlNo6wticutmkxf/pIaFWG9gCNsDTLi+frAeqxGvAA7eT2ajkcocbNTBxp8MYkIOkXCo+H6Ib7qjM=@vger.kernel.org X-Gm-Message-State: AOJu0YxUh0Q6AezO7+8AZjNhBAUubPKg1Rm0qXnheoKV0r0JZPFv7j+q TJM9AVFfuDtnjBgjmrrDYiP2xfco2wWDekmFGUq5iLngxIjcZaZyDEumCZjcfrE= X-Gm-Gg: ASbGnctSxiagxFErjvIAvmXYll+ObFW+N8VUcISRK7JP29r8HReUclJjkOqcJ5vbha6 FpRNF2AS7Jg2z7KCihfImtqOLf4ArwkG3CbKh/eeTKbfxy/bDv3j3+NOUlZdRkr0Lc/KEIjPM94 cZK577Z8cZsKxsaOc3Nt8Dcco7FuAJwZt7W+T4kFhQVguII+0hULWhtD7N3xj5idLSctNRGFtUX QjHEk0+hPgGouDK2uVTgZ19gAJWEY4xY+P4rqSH1AKHxirPKGwITV7kVQo59GH6DBpzbsiVygVf E28B4huddVO1wlsPqG5IYvVqMl0jfWj6NvPMeBxnp6lNLPp6X+qB+kJ61TVSfQAGP2fbYLwF X-Google-Smtp-Source: AGHT+IH3216O+ZluZXNO1aVO4JKCmKysMBDlsRKJO7twiYi4wQ9rha8Kd3VltLXnucwJIGCUP6rehA== X-Received: by 2002:a05:6000:1fae:b0:38d:e092:3ced with SMTP id ffacd0b85a97d-38f244d64b2mr8194266f8f.7.1739535795587; Fri, 14 Feb 2025 04:23:15 -0800 (PST) Received: from [127.0.0.1] (amontpellier-556-1-148-206.w109-210.abo.wanadoo.fr. [109.210.4.206]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-38f259f7b68sm4424654f8f.85.2025.02.14.04.23.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 14 Feb 2025 04:23:15 -0800 (PST) From: Esteban Blanc Date: Fri, 14 Feb 2025 13:22:32 +0100 Subject: [PATCH v4 2/6] iio: adc: ad4030: add driver for ad4030-24 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: <20250214-eblanc-ad4630_v1-v4-2-135dd66cab6a@baylibre.com> References: <20250214-eblanc-ad4630_v1-v4-0-135dd66cab6a@baylibre.com> In-Reply-To: <20250214-eblanc-ad4630_v1-v4-0-135dd66cab6a@baylibre.com> To: Lars-Peter Clausen , Michael Hennerich , =?utf-8?q?Nuno_S=C3=A1?= , Jonathan Cameron , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet Cc: Michael Hennerich , linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org, Esteban Blanc X-Mailer: b4 0.14.2 This adds a new driver for the Analog Devices INC. AD4030-24 ADC. The driver implements basic support for the AD4030-24 1 channel differential ADC with hardware gain and offset control. Signed-off-by: Esteban Blanc --- MAINTAINERS | 1 + drivers/iio/adc/Kconfig | 14 + drivers/iio/adc/Makefile | 1 + drivers/iio/adc/ad4030.c | 922 +++++++++++++++++++++++++++++++++++++++++++= ++++ 4 files changed, 938 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index f0c7aa6d744040ba530917b566ca68087a49492f..bfb739c2f5f4ef9182c9789c797= e63a93ab08080 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1314,6 +1314,7 @@ L: linux-iio@vger.kernel.org S: Supported W: https://ez.analog.com/linux-software-drivers F: Documentation/devicetree/bindings/iio/adc/adi,ad4030.yaml +F: drivers/iio/adc/ad4030.c =20 ANALOG DEVICES INC AD4130 DRIVER M: Cosmin Tanislav diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig index 849c90203071a77ec7d94cec06d4378ece44440b..9677343a3269db6405dfdd4e938= 423806c891b47 100644 --- a/drivers/iio/adc/Kconfig +++ b/drivers/iio/adc/Kconfig @@ -33,6 +33,20 @@ config AD4000 To compile this driver as a module, choose M here: the module will be called ad4000. =20 +config AD4030 + tristate "Analog Devices AD4030 ADC Driver" + depends on SPI + depends on GPIOLIB + select REGMAP + select IIO_BUFFER + select IIO_TRIGGERED_BUFFER + help + Say yes here to build support for Analog Devices AD4030 and AD4630 high= speed + SPI analog to digital converters (ADC). + + To compile this driver as a module, choose M here: the module will be + called ad4030. + config AD4130 tristate "Analog Device AD4130 ADC Driver" depends on SPI diff --git a/drivers/iio/adc/Makefile b/drivers/iio/adc/Makefile index ee19afba62b7fe0a68309c16f3581d98c5b8f653..326536bb672da3d6229b66af138= 74d122b2f7b94 100644 --- a/drivers/iio/adc/Makefile +++ b/drivers/iio/adc/Makefile @@ -7,6 +7,7 @@ obj-$(CONFIG_AB8500_GPADC) +=3D ab8500-gpadc.o obj-$(CONFIG_AD_SIGMA_DELTA) +=3D ad_sigma_delta.o obj-$(CONFIG_AD4000) +=3D ad4000.o +obj-$(CONFIG_AD4030) +=3D ad4030.o obj-$(CONFIG_AD4130) +=3D ad4130.o obj-$(CONFIG_AD4695) +=3D ad4695.o obj-$(CONFIG_AD7091R) +=3D ad7091r-base.o diff --git a/drivers/iio/adc/ad4030.c b/drivers/iio/adc/ad4030.c new file mode 100644 index 0000000000000000000000000000000000000000..8188d44bdd664aa74a7adcaa1f8= 36e79a54a6050 --- /dev/null +++ b/drivers/iio/adc/ad4030.c @@ -0,0 +1,922 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Analog Devices AD4030 and AD4630 ADC family driver. + * + * Copyright 2024 Analog Devices, Inc. + * Copyright 2024 BayLibre, SAS + * + * based on code from: + * Analog Devices, Inc. + * Sergiu Cuciurean + * Nuno Sa + * Marcelo Schmitt + * Liviu Adace + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define AD4030_REG_INTERFACE_CONFIG_A 0x00 +#define AD4030_REG_INTERFACE_CONFIG_A_SW_RESET (BIT(0) | BIT(7)) +#define AD4030_REG_INTERFACE_CONFIG_B 0x01 +#define AD4030_REG_DEVICE_CONFIG 0x02 +#define AD4030_REG_CHIP_TYPE 0x03 +#define AD4030_REG_PRODUCT_ID_L 0x04 +#define AD4030_REG_PRODUCT_ID_H 0x05 +#define AD4030_REG_CHIP_GRADE 0x06 +#define AD4030_REG_CHIP_GRADE_AD4030_24_GRADE 0x10 +#define AD4030_REG_CHIP_GRADE_MASK_CHIP_GRADE GENMASK(7, 3) +#define AD4030_REG_SCRATCH_PAD 0x0A +#define AD4030_REG_SPI_REVISION 0x0B +#define AD4030_REG_VENDOR_L 0x0C +#define AD4030_REG_VENDOR_H 0x0D +#define AD4030_REG_STREAM_MODE 0x0E +#define AD4030_REG_INTERFACE_CONFIG_C 0x10 +#define AD4030_REG_INTERFACE_STATUS_A 0x11 +#define AD4030_REG_EXIT_CFG_MODE 0x14 +#define AD4030_REG_EXIT_CFG_MODE_EXIT_MSK BIT(0) +#define AD4030_REG_AVG 0x15 +#define AD4030_REG_AVG_MASK_AVG_SYNC BIT(7) +#define AD4030_REG_AVG_MASK_AVG_VAL GENMASK(4, 0) +#define AD4030_REG_OFFSET_X0_0 0x16 +#define AD4030_REG_OFFSET_X0_1 0x17 +#define AD4030_REG_OFFSET_X0_2 0x18 +#define AD4030_REG_OFFSET_X1_0 0x19 +#define AD4030_REG_OFFSET_X1_1 0x1A +#define AD4030_REG_OFFSET_X1_2 0x1B +#define AD4030_REG_OFFSET_BYTES_NB 3 +#define AD4030_REG_OFFSET_CHAN(ch) \ + (AD4030_REG_OFFSET_X0_2 + (AD4030_REG_OFFSET_BYTES_NB * (ch))) +#define AD4030_REG_GAIN_X0_LSB 0x1C +#define AD4030_REG_GAIN_X0_MSB 0x1D +#define AD4030_REG_GAIN_X1_LSB 0x1E +#define AD4030_REG_GAIN_X1_MSB 0x1F +#define AD4030_REG_GAIN_MAX_GAIN 1999970 +#define AD4030_REG_GAIN_BYTES_NB 2 +#define AD4030_REG_GAIN_CHAN(ch) \ + (AD4030_REG_GAIN_X0_MSB + (AD4030_REG_GAIN_BYTES_NB * (ch))) +#define AD4030_REG_MODES 0x20 +#define AD4030_REG_MODES_MASK_OUT_DATA_MODE GENMASK(2, 0) +#define AD4030_REG_MODES_MASK_LANE_MODE GENMASK(7, 6) +#define AD4030_REG_OSCILATOR 0x21 +#define AD4030_REG_IO 0x22 +#define AD4030_REG_IO_MASK_IO2X BIT(1) +#define AD4030_REG_PAT0 0x23 +#define AD4030_REG_PAT1 0x24 +#define AD4030_REG_PAT2 0x25 +#define AD4030_REG_PAT3 0x26 +#define AD4030_REG_DIG_DIAG 0x34 +#define AD4030_REG_DIG_ERR 0x35 + +/* Sequence starting with "1 0 1" to enable reg access */ +#define AD4030_REG_ACCESS 0xA0 + +#define AD4030_MAX_IIO_SAMPLE_SIZE_BUFFERED BITS_TO_BYTES(64) +#define AD4030_MAX_HARDWARE_CHANNEL_NB 2 +#define AD4030_MAX_IIO_CHANNEL_NB 5 +#define AD4030_SINGLE_COMMON_BYTE_CHANNELS_MASK 0b10 +#define AD4030_GAIN_MIDLE_POINT 0x8000 +/* + * This accounts for 1 sample per channel plus one s64 for the timestamp, + * aligned on a s64 boundary + */ +#define AD4030_MAXIMUM_RX_BUFFER_SIZE \ + (ALIGN(AD4030_MAX_IIO_SAMPLE_SIZE_BUFFERED * \ + AD4030_MAX_HARDWARE_CHANNEL_NB, \ + sizeof(s64)) + sizeof(s64)) + +#define AD4030_VREF_MIN_UV (4096 * MILLI) +#define AD4030_VREF_MAX_UV (5000 * MILLI) +#define AD4030_VIO_THRESHOLD_UV (1400 * MILLI) +#define AD4030_SPI_MAX_XFER_LEN 8 +#define AD4030_SPI_MAX_REG_XFER_SPEED (80 * MEGA) +#define AD4030_TCNVH_NS 10 +#define AD4030_TCNVL_NS 20 +#define AD4030_TCYC_NS 500 +#define AD4030_TCYC_ADJUSTED_NS (AD4030_TCYC_NS - AD4030_TCNVL_NS) +#define AD4030_TRESET_PW_NS 50 + +enum ad4030_out_mode { + AD4030_OUT_DATA_MD_DIFF, + AD4030_OUT_DATA_MD_16_DIFF_8_COM, + AD4030_OUT_DATA_MD_24_DIFF_8_COM, + AD4030_OUT_DATA_MD_30_AVERAGED_DIFF, + AD4030_OUT_DATA_MD_32_PATTERN, +}; + +struct ad4030_chip_info { + const char *name; + const unsigned long *available_masks; + const struct iio_chan_spec channels[AD4030_MAX_IIO_CHANNEL_NB]; + u8 grade; + u8 precision_bits; + /* Number of hardware channels */ + int num_voltage_inputs; + unsigned int tcyc_ns; +}; + +struct ad4030_state { + struct spi_device *spi; + struct regmap *regmap; + const struct ad4030_chip_info *chip; + struct gpio_desc *cnv_gpio; + int vref_uv; + int vio_uv; + int offset_avail[3]; + enum ad4030_out_mode mode; + + /* + * DMA (thus cache coherency maintenance) requires the transfer buffers + * to live in their own cache lines. + */ + u8 tx_data[AD4030_SPI_MAX_XFER_LEN] __aligned(IIO_DMA_MINALIGN); + union { + u8 raw[AD4030_MAXIMUM_RX_BUFFER_SIZE]; + struct { + s32 diff; + u8 common; + }; + } rx_data; +}; + +/* + * For a chip with 2 hardware channel this will be used to create 2 common= -mode + * channels: + * - voltage4 + * - voltage5 + * As the common-mode channels are after the differential ones, we compute= the + * channel number like this: + * - _idx is the scan_index (the order in the output buffer) + * - _ch is the hardware channel number this common-mode channel is related + * - _idx - _ch gives us the number of channel in the chip + * - _idx - _ch * 2 is the starting number of the common-mode channels, si= nce + * for each differential channel there is a common-mode channel + * - _idx - _ch * 2 + _ch gives the channel number for this specific commo= n-mode + * channel + */ +#define AD4030_CHAN_CMO(_idx, _ch) { \ + .info_mask_separate =3D BIT(IIO_CHAN_INFO_RAW) | \ + BIT(IIO_CHAN_INFO_SCALE), \ + .type =3D IIO_VOLTAGE, \ + .indexed =3D 1, \ + .address =3D (_ch), \ + .channel =3D ((_idx) - (_ch)) * 2 + (_ch), \ + .scan_index =3D (_idx), \ + .scan_type =3D { \ + .sign =3D 'u', \ + .storagebits =3D 8, \ + .realbits =3D 8, \ + .endianness =3D IIO_BE, \ + }, \ +} + +/* + * For a chip with 2 hardware channel this will be used to create 2 differ= ential + * channels: + * - voltage0-voltage1 + * - voltage2-voltage3 + */ +#define AD4030_CHAN_DIFF(_idx, _storage, _real, _shift) { \ + .info_mask_separate =3D BIT(IIO_CHAN_INFO_SCALE) | \ + BIT(IIO_CHAN_INFO_CALIBSCALE) | \ + BIT(IIO_CHAN_INFO_CALIBBIAS) | \ + BIT(IIO_CHAN_INFO_RAW), \ + .info_mask_separate_available =3D BIT(IIO_CHAN_INFO_CALIBBIAS) | \ + BIT(IIO_CHAN_INFO_CALIBSCALE), \ + .type =3D IIO_VOLTAGE, \ + .indexed =3D 1, \ + .address =3D (_idx), \ + .channel =3D (_idx) * 2, \ + .channel2 =3D (_idx) * 2 + 1, \ + .scan_index =3D (_idx), \ + .differential =3D true, \ + .scan_type =3D { \ + .sign =3D 's', \ + .storagebits =3D _storage, \ + .realbits =3D _real, \ + .shift =3D _shift, \ + .endianness =3D IIO_BE, \ + }, \ +} + +static int ad4030_enter_config_mode(struct ad4030_state *st) +{ + st->tx_data[0] =3D AD4030_REG_ACCESS; + + struct spi_transfer xfer =3D { + .tx_buf =3D st->tx_data, + .bits_per_word =3D 8, + .len =3D 1, + .speed_hz =3D AD4030_SPI_MAX_REG_XFER_SPEED, + }; + + return spi_sync_transfer(st->spi, &xfer, 1); +} + +static int ad4030_exit_config_mode(struct ad4030_state *st) +{ + st->tx_data[0] =3D 0; + st->tx_data[1] =3D AD4030_REG_EXIT_CFG_MODE; + st->tx_data[2] =3D AD4030_REG_EXIT_CFG_MODE_EXIT_MSK; + + struct spi_transfer xfer =3D { + .tx_buf =3D st->tx_data, + .bits_per_word =3D 8, + .len =3D 3, + .speed_hz =3D AD4030_SPI_MAX_REG_XFER_SPEED, + }; + + return spi_sync_transfer(st->spi, &xfer, 1); +} + +static int ad4030_spi_read(void *context, const void *reg, size_t reg_size, + void *val, size_t val_size) +{ + int ret; + struct ad4030_state *st =3D context; + struct spi_transfer xfer =3D { + .tx_buf =3D st->tx_data, + .rx_buf =3D st->rx_data.raw, + .bits_per_word =3D 8, + .len =3D reg_size + val_size, + .speed_hz =3D AD4030_SPI_MAX_REG_XFER_SPEED, + }; + + if (xfer.len > sizeof(st->tx_data) || + xfer.len > sizeof(st->rx_data.raw)) + return -EINVAL; + + ret =3D ad4030_enter_config_mode(st); + if (ret) + return ret; + + memset(st->tx_data, 0, sizeof(st->tx_data)); + memcpy(st->tx_data, reg, reg_size); + + ret =3D spi_sync_transfer(st->spi, &xfer, 1); + if (ret) + return ret; + + memcpy(val, &st->rx_data.raw[reg_size], val_size); + + return ad4030_exit_config_mode(st); +} + +static int ad4030_spi_write(void *context, const void *data, size_t count) +{ + int ret; + struct ad4030_state *st =3D context; + bool is_reset =3D count >=3D 3 && + ((u8 *)data)[0] =3D=3D 0 && + ((u8 *)data)[1] =3D=3D 0 && + ((u8 *)data)[2] =3D=3D 0x81; + struct spi_transfer xfer =3D { + .tx_buf =3D st->tx_data, + .bits_per_word =3D 8, + .len =3D count, + .speed_hz =3D AD4030_SPI_MAX_REG_XFER_SPEED, + }; + + if (count > sizeof(st->tx_data)) + return -EINVAL; + + ret =3D ad4030_enter_config_mode(st); + if (ret) + return ret; + + memcpy(st->tx_data, data, count); + + ret =3D spi_sync_transfer(st->spi, &xfer, 1); + if (ret) + return ret; + + /* + * From datasheet: "After a [...] reset, no SPI commands or conversions + * can be started for 750us" + * After a reset we are in conversion mode, no need to exit config mode + */ + if (is_reset) { + fsleep(750); + return 0; + } + + return ad4030_exit_config_mode(st); +} + +static const struct regmap_bus ad4030_regmap_bus =3D { + .read =3D ad4030_spi_read, + .write =3D ad4030_spi_write, + .reg_format_endian_default =3D REGMAP_ENDIAN_BIG, +}; + +static const struct regmap_range ad4030_regmap_rd_range[] =3D { + regmap_reg_range(AD4030_REG_INTERFACE_CONFIG_A, AD4030_REG_CHIP_GRADE), + regmap_reg_range(AD4030_REG_SCRATCH_PAD, AD4030_REG_STREAM_MODE), + regmap_reg_range(AD4030_REG_INTERFACE_CONFIG_C, + AD4030_REG_INTERFACE_STATUS_A), + regmap_reg_range(AD4030_REG_EXIT_CFG_MODE, AD4030_REG_PAT3), + regmap_reg_range(AD4030_REG_DIG_DIAG, AD4030_REG_DIG_ERR), +}; + +static const struct regmap_range ad4030_regmap_wr_range[] =3D { + regmap_reg_range(AD4030_REG_CHIP_TYPE, AD4030_REG_CHIP_GRADE), + regmap_reg_range(AD4030_REG_SPI_REVISION, AD4030_REG_VENDOR_H), +}; + +static const struct regmap_access_table ad4030_regmap_rd_table =3D { + .yes_ranges =3D ad4030_regmap_rd_range, + .n_yes_ranges =3D ARRAY_SIZE(ad4030_regmap_rd_range), +}; + +static const struct regmap_access_table ad4030_regmap_wr_table =3D { + .no_ranges =3D ad4030_regmap_wr_range, + .n_no_ranges =3D ARRAY_SIZE(ad4030_regmap_wr_range), +}; + +static const struct regmap_config ad4030_regmap_config =3D { + .reg_bits =3D 16, + .val_bits =3D 8, + .read_flag_mask =3D 0x80, + .rd_table =3D &ad4030_regmap_rd_table, + .wr_table =3D &ad4030_regmap_wr_table, + .max_register =3D AD4030_REG_DIG_ERR, +}; + +static int ad4030_get_chan_scale(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int *val, + int *val2) +{ + struct ad4030_state *st =3D iio_priv(indio_dev); + + if (chan->differential) { + *val =3D (st->vref_uv * 2) / MILLI; + *val2 =3D chan->scan_type.realbits; + return IIO_VAL_FRACTIONAL_LOG2; + } + + *val =3D st->vref_uv / MILLI; + *val2 =3D chan->scan_type.realbits; + return IIO_VAL_FRACTIONAL_LOG2; +} + +static int ad4030_get_chan_calibscale(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int *val, + int *val2) +{ + struct ad4030_state *st =3D iio_priv(indio_dev); + u16 gain; + int ret; + + ret =3D regmap_bulk_read(st->regmap, AD4030_REG_GAIN_CHAN(chan->address), + st->rx_data.raw, AD4030_REG_GAIN_BYTES_NB); + if (ret) + return ret; + + gain =3D get_unaligned_be16(st->rx_data.raw); + + /* From datasheet: multiplied output =3D input =C3=97 gain word/0x8000 */ + *val =3D gain / AD4030_GAIN_MIDLE_POINT; + *val2 =3D mul_u64_u32_div(gain % AD4030_GAIN_MIDLE_POINT, NANO, + AD4030_GAIN_MIDLE_POINT); + + return IIO_VAL_INT_PLUS_NANO; +} + +/* Returns the offset where 1 LSB =3D (VREF/2^precision_bits - 1)/gain */ +static int ad4030_get_chan_calibbias(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int *val) +{ + struct ad4030_state *st =3D iio_priv(indio_dev); + int ret; + + ret =3D regmap_bulk_read(st->regmap, + AD4030_REG_OFFSET_CHAN(chan->address), + st->rx_data.raw, AD4030_REG_OFFSET_BYTES_NB); + if (ret) + return ret; + + switch (st->chip->precision_bits) { + case 16: + *val =3D sign_extend32(get_unaligned_be16(st->rx_data.raw), 15); + return IIO_VAL_INT; + + case 24: + *val =3D sign_extend32(get_unaligned_be24(st->rx_data.raw), 23); + return IIO_VAL_INT; + + default: + return -EINVAL; + } +} + +static int ad4030_set_chan_calibscale(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int gain_int, + int gain_frac) +{ + struct ad4030_state *st =3D iio_priv(indio_dev); + u64 gain; + + if (gain_int < 0 || gain_frac < 0) + return -EINVAL; + + gain =3D mul_u32_u32(gain_int, MICRO) + gain_frac; + + if (gain > AD4030_REG_GAIN_MAX_GAIN) + return -EINVAL; + + put_unaligned_be16(DIV_ROUND_CLOSEST_ULL(gain * AD4030_GAIN_MIDLE_POINT, + MICRO), + st->tx_data); + + return regmap_bulk_write(st->regmap, + AD4030_REG_GAIN_CHAN(chan->address), + st->tx_data, AD4030_REG_GAIN_BYTES_NB); +} + +static int ad4030_set_chan_calibbias(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + int offset) +{ + struct ad4030_state *st =3D iio_priv(indio_dev); + + if (offset < st->offset_avail[0] || offset > st->offset_avail[2]) + return -EINVAL; + + st->tx_data[2] =3D 0; + + switch (st->chip->precision_bits) { + case 16: + put_unaligned_be16(offset, st->tx_data); + break; + + case 24: + put_unaligned_be24(offset, st->tx_data); + break; + + default: + return -EINVAL; + } + + return regmap_bulk_write(st->regmap, + AD4030_REG_OFFSET_CHAN(chan->address), + st->tx_data, AD4030_REG_OFFSET_BYTES_NB); +} + +static bool ad4030_is_common_byte_asked(struct ad4030_state *st, + unsigned int mask) +{ + return mask & AD4030_SINGLE_COMMON_BYTE_CHANNELS_MASK; +} + +static int ad4030_set_mode(struct iio_dev *indio_dev, unsigned long mask) +{ + struct ad4030_state *st =3D iio_priv(indio_dev); + + if (ad4030_is_common_byte_asked(st, mask)) + st->mode =3D AD4030_OUT_DATA_MD_24_DIFF_8_COM; + else + st->mode =3D AD4030_OUT_DATA_MD_DIFF; + + return regmap_update_bits(st->regmap, AD4030_REG_MODES, + AD4030_REG_MODES_MASK_OUT_DATA_MODE, + st->mode); +} + +static int ad4030_conversion(struct iio_dev *indio_dev) +{ + struct ad4030_state *st =3D iio_priv(indio_dev); + const struct iio_scan_type scan_type =3D indio_dev->channels->scan_type; + unsigned char diff_realbytes =3D BITS_TO_BYTES(scan_type.realbits); + unsigned int bytes_to_read; + int ret; + + /* Number of bytes for one differential channel */ + bytes_to_read =3D diff_realbytes; + /* Add one byte if we are using a differential + common byte mode */ + bytes_to_read +=3D (st->mode =3D=3D AD4030_OUT_DATA_MD_24_DIFF_8_COM || + st->mode =3D=3D AD4030_OUT_DATA_MD_16_DIFF_8_COM) ? 1 : 0; + /* Mulitiply by the number of hardware channels */ + bytes_to_read *=3D st->chip->num_voltage_inputs; + + gpiod_set_value_cansleep(st->cnv_gpio, 1); + ndelay(AD4030_TCNVH_NS); + gpiod_set_value_cansleep(st->cnv_gpio, 0); + ndelay(st->chip->tcyc_ns); + + ret =3D spi_read(st->spi, st->rx_data.raw, bytes_to_read); + if (ret) + return ret; + + if (st->mode !=3D AD4030_OUT_DATA_MD_24_DIFF_8_COM) + return 0; + + st->rx_data.common =3D st->rx_data.raw[diff_realbytes]; + + return 0; +} + +static int ad4030_single_conversion(struct iio_dev *indio_dev, + const struct iio_chan_spec *chan, int *val) +{ + struct ad4030_state *st =3D iio_priv(indio_dev); + int ret; + + ret =3D ad4030_set_mode(indio_dev, BIT(chan->scan_index)); + if (ret) + return ret; + + ret =3D ad4030_conversion(indio_dev); + if (ret) + return ret; + + if (chan->differential) + *val =3D st->rx_data.diff; + else + *val =3D st->rx_data.common; + + return IIO_VAL_INT; +} + +static irqreturn_t ad4030_trigger_handler(int irq, void *p) +{ + struct iio_poll_func *pf =3D p; + struct iio_dev *indio_dev =3D pf->indio_dev; + struct ad4030_state *st =3D iio_priv(indio_dev); + int ret; + + ret =3D ad4030_conversion(indio_dev); + if (ret) + goto out; + + iio_push_to_buffers_with_timestamp(indio_dev, st->rx_data.raw, + pf->timestamp); + +out: + iio_trigger_notify_done(indio_dev->trig); + + return IRQ_HANDLED; +} + +static const int ad4030_gain_avail[3][2] =3D { + { 0, 0 }, + { 0, 30518 }, + { 1, 999969482 }, +}; + +static int ad4030_read_avail(struct iio_dev *indio_dev, + struct iio_chan_spec const *channel, + const int **vals, int *type, + int *length, long mask) +{ + struct ad4030_state *st =3D iio_priv(indio_dev); + + switch (mask) { + case IIO_CHAN_INFO_CALIBBIAS: + *vals =3D st->offset_avail; + *type =3D IIO_VAL_INT; + return IIO_AVAIL_RANGE; + + case IIO_CHAN_INFO_CALIBSCALE: + *vals =3D (void *)ad4030_gain_avail; + *type =3D IIO_VAL_INT_PLUS_NANO; + return IIO_AVAIL_RANGE; + + default: + return -EINVAL; + } +} + +static int ad4030_read_raw_dispatch(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, int *val, + int *val2, long info) +{ + switch (info) { + case IIO_CHAN_INFO_RAW: + return ad4030_single_conversion(indio_dev, chan, val); + + case IIO_CHAN_INFO_CALIBSCALE: + return ad4030_get_chan_calibscale(indio_dev, chan, val, val2); + + case IIO_CHAN_INFO_CALIBBIAS: + return ad4030_get_chan_calibbias(indio_dev, chan, val); + + default: + return -EINVAL; + } +} + +static int ad4030_read_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, int *val, + int *val2, long info) +{ + int ret; + + if (info =3D=3D IIO_CHAN_INFO_SCALE) + return ad4030_get_chan_scale(indio_dev, chan, val, val2); + + ret =3D iio_device_claim_direct_mode(indio_dev); + if (ret) + return ret; + + ret =3D ad4030_read_raw_dispatch(indio_dev, chan, val, val2, info); + + iio_device_release_direct_mode(indio_dev); + + return ret; +} + +static int ad4030_write_raw_dispatch(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, int val, + int val2, long info) +{ + switch (info) { + case IIO_CHAN_INFO_CALIBSCALE: + return ad4030_set_chan_calibscale(indio_dev, chan, val, val2); + + case IIO_CHAN_INFO_CALIBBIAS: + if (val2 !=3D 0) + return -EINVAL; + return ad4030_set_chan_calibbias(indio_dev, chan, val); + + default: + return -EINVAL; + } +} + +static int ad4030_write_raw(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, int val, + int val2, long info) +{ + int ret; + + ret =3D iio_device_claim_direct_mode(indio_dev); + if (ret) + return ret; + + ret =3D ad4030_write_raw_dispatch(indio_dev, chan, val, val2, info); + + iio_device_release_direct_mode(indio_dev); + + return ret; +} + +static int ad4030_reg_access(struct iio_dev *indio_dev, unsigned int reg, + unsigned int writeval, unsigned int *readval) +{ + const struct ad4030_state *st =3D iio_priv(indio_dev); + int ret; + + ret =3D iio_device_claim_direct_mode(indio_dev); + if (ret) + return ret; + + if (readval) + ret =3D regmap_read(st->regmap, reg, readval); + else + ret =3D regmap_write(st->regmap, reg, writeval); + + iio_device_release_direct_mode(indio_dev); + + return ret; +} + +static int ad4030_read_label(struct iio_dev *indio_dev, + struct iio_chan_spec const *chan, + char *label) +{ + if (chan->differential) + return sprintf(label, "differential%lu\n", chan->address); + return sprintf(label, "common-mode%lu\n", chan->address); +} + +static const struct iio_info ad4030_iio_info =3D { + .read_avail =3D ad4030_read_avail, + .read_raw =3D ad4030_read_raw, + .write_raw =3D ad4030_write_raw, + .debugfs_reg_access =3D ad4030_reg_access, + .read_label =3D ad4030_read_label, +}; + +static int ad4030_buffer_preenable(struct iio_dev *indio_dev) +{ + return ad4030_set_mode(indio_dev, *indio_dev->active_scan_mask); +} + +static const struct iio_buffer_setup_ops ad4030_buffer_setup_ops =3D { + .preenable =3D ad4030_buffer_preenable, +}; + +static int ad4030_regulators_get(struct ad4030_state *st) +{ + struct device *dev =3D &st->spi->dev; + static const char * const ids[] =3D { "vdd-5v", "vdd-1v8" }; + int ret; + + ret =3D devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(ids), ids); + if (ret) + return dev_err_probe(dev, ret, "Failed to enable regulators\n"); + + st->vio_uv =3D devm_regulator_get_enable_read_voltage(dev, "vio"); + if (st->vio_uv < 0) + return dev_err_probe(dev, st->vio_uv, + "Failed to enable and read vio voltage\n"); + + st->vref_uv =3D devm_regulator_get_enable_read_voltage(dev, "ref"); + if (st->vref_uv < 0) { + if (st->vref_uv !=3D -ENODEV) + return dev_err_probe(dev, st->vref_uv, + "Failed to read ref voltage\n"); + + /* if not using optional REF, the REFIN must be used */ + st->vref_uv =3D devm_regulator_get_enable_read_voltage(dev, + "refin"); + if (st->vref_uv < 0) + return dev_err_probe(dev, st->vref_uv, + "Failed to read refin voltage\n"); + } + + return 0; +} + +static int ad4030_reset(struct ad4030_state *st) +{ + struct device *dev =3D &st->spi->dev; + struct gpio_desc *reset; + + reset =3D devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH); + if (IS_ERR(reset)) + return dev_err_probe(dev, PTR_ERR(reset), + "Failed to get reset GPIO\n"); + + if (reset) { + ndelay(50); + gpiod_set_value_cansleep(reset, 0); + return 0; + } + + return regmap_write(st->regmap, AD4030_REG_INTERFACE_CONFIG_A, + AD4030_REG_INTERFACE_CONFIG_A_SW_RESET); +} + +static int ad4030_detect_chip_info(const struct ad4030_state *st) +{ + unsigned int grade; + int ret; + + ret =3D regmap_read(st->regmap, AD4030_REG_CHIP_GRADE, &grade); + if (ret) + return ret; + + grade =3D FIELD_GET(AD4030_REG_CHIP_GRADE_MASK_CHIP_GRADE, grade); + if (grade !=3D st->chip->grade) + dev_warn(&st->spi->dev, "Unknown grade(0x%x) for %s\n", grade, + st->chip->name); + + return 0; +} + +static int ad4030_config(struct ad4030_state *st) +{ + st->offset_avail[0] =3D (int)BIT(st->chip->precision_bits - 1) * -1; + st->offset_avail[1] =3D 1; + st->offset_avail[2] =3D BIT(st->chip->precision_bits - 1) - 1; + + if (st->vio_uv < AD4030_VIO_THRESHOLD_UV) + return regmap_write(st->regmap, AD4030_REG_IO, + AD4030_REG_IO_MASK_IO2X); + + return 0; +} + +static int ad4030_probe(struct spi_device *spi) +{ + struct device *dev =3D &spi->dev; + struct iio_dev *indio_dev; + struct ad4030_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->regmap =3D devm_regmap_init(dev, &ad4030_regmap_bus, st, + &ad4030_regmap_config); + if (IS_ERR(st->regmap)) + dev_err_probe(dev, PTR_ERR(st->regmap), + "Failed to initialize regmap\n"); + + st->chip =3D spi_get_device_match_data(spi); + if (!st->chip) + return -EINVAL; + + ret =3D ad4030_regulators_get(st); + if (ret) + return ret; + + /* + * From datasheet: "Perform a reset no sooner than 3ms after the power + * supplies are valid and stable" + */ + fsleep(3000); + + ret =3D ad4030_reset(st); + if (ret) + return ret; + + ret =3D ad4030_detect_chip_info(st); + if (ret) + return ret; + + ret =3D ad4030_config(st); + if (ret) + return ret; + + st->cnv_gpio =3D devm_gpiod_get(dev, "cnv", GPIOD_OUT_LOW); + if (IS_ERR(st->cnv_gpio)) + return dev_err_probe(dev, PTR_ERR(st->cnv_gpio), + "Failed to get cnv gpio\n"); + + /* + * One hardware channel is split in two software channels when using + * common byte mode. Add one more channel for the timestamp. + */ + indio_dev->num_channels =3D 2 * st->chip->num_voltage_inputs + 1; + indio_dev->name =3D st->chip->name; + indio_dev->modes =3D INDIO_DIRECT_MODE; + indio_dev->info =3D &ad4030_iio_info; + indio_dev->channels =3D st->chip->channels; + indio_dev->available_scan_masks =3D st->chip->available_masks; + + ret =3D devm_iio_triggered_buffer_setup(dev, indio_dev, + iio_pollfunc_store_time, + ad4030_trigger_handler, + &ad4030_buffer_setup_ops); + if (ret) + return dev_err_probe(dev, ret, + "Failed to setup triggered buffer\n"); + + return devm_iio_device_register(dev, indio_dev); +} + +static const unsigned long ad4030_channel_masks[] =3D { + /* Differential only */ + BIT(0), + /* Differential and common-mode voltage */ + GENMASK(1, 0), + 0, +}; + +static const struct ad4030_chip_info ad4030_24_chip_info =3D { + .name =3D "ad4030-24", + .available_masks =3D ad4030_channel_masks, + .channels =3D { + AD4030_CHAN_DIFF(0, 32, 24, 8), + AD4030_CHAN_CMO(1, 0), + IIO_CHAN_SOFT_TIMESTAMP(2), + }, + .grade =3D AD4030_REG_CHIP_GRADE_AD4030_24_GRADE, + .precision_bits =3D 24, + .num_voltage_inputs =3D 1, + .tcyc_ns =3D AD4030_TCYC_ADJUSTED_NS, +}; + +static const struct spi_device_id ad4030_id_table[] =3D { + { "ad4030-24", (kernel_ulong_t)&ad4030_24_chip_info }, + { } +}; +MODULE_DEVICE_TABLE(spi, ad4030_id_table); + +static const struct of_device_id ad4030_of_match[] =3D { + { .compatible =3D "adi,ad4030-24", .data =3D &ad4030_24_chip_info }, + { } +}; +MODULE_DEVICE_TABLE(of, ad4030_of_match); + +static struct spi_driver ad4030_driver =3D { + .driver =3D { + .name =3D "ad4030", + .of_match_table =3D ad4030_of_match, + }, + .probe =3D ad4030_probe, + .id_table =3D ad4030_id_table, +}; +module_spi_driver(ad4030_driver); + +MODULE_AUTHOR("Esteban Blanc "); +MODULE_DESCRIPTION("Analog Devices AD4630 ADC family driver"); +MODULE_LICENSE("GPL"); --=20 2.47.2 From nobody Thu Dec 18 18:05:48 2025 Received: from mail-wm1-f45.google.com (mail-wm1-f45.google.com [209.85.128.45]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 974AD263F36 for ; Fri, 14 Feb 2025 12:23:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739535802; cv=none; b=RrRULRPI6VwQGHnqrwB7LR8XKmrwew9VazQLMIOWYkmEaSEoeue9XyD50U95249Ob9OdEIMs2QOpYdiR+Xk2atsDIO9uu83lrEORCDcq3tOeaCskhBL8QmHxIOacUPDr9Y2Cmc4s1Vx1hNpSxWu0VHjvFajvdHX54OoS+/aB90o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739535802; c=relaxed/simple; bh=p8Wa7z/Q/7dSNDxemWU5T+iHPTUSb8GpjjzP82LumuI=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=ro2r5iFA2Am+sj8zQ/hMgwOpNmUyswb8dx7WFlrexvv5QcOAXnEJPNxHDinQ3M3u77HfW3dMd6YlbcehHLsrckSVnXbh2WhQnfp4ZbrHQutxplISMiw2Ojj27FEuySJOi/TcSafBd6vGgu81IQE4A+S807H2NvOFnRE7CKkrYPk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com; spf=pass smtp.mailfrom=baylibre.com; dkim=pass (2048-bit key) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.b=e7AcmVJ/; arc=none smtp.client-ip=209.85.128.45 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=baylibre.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.b="e7AcmVJ/" Received: by mail-wm1-f45.google.com with SMTP id 5b1f17b1804b1-4394036c0efso12471415e9.2 for ; Fri, 14 Feb 2025 04:23:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20230601.gappssmtp.com; s=20230601; t=1739535797; x=1740140597; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=HlYXGEnZSyAGc7MM6POcCvycJIpFlDa3P8VoTqsifSY=; b=e7AcmVJ/DLOkpZqSI3LYHnJduAwNz8giZnK4ywr2aELhVnxlpe45OkjX0A8Sdt/zxX hgg+zRBSO0wMiAhztWl6VQpnTyuC3jrQpTOE2ZxEdxFe+G94iRkk/mhsbOf8X7h62WLQ qo+NRL3ERONfEhuP7fx4glAIAJ1Nldq9QrA4Bwotxr4syJtzMy4zEs8Lvh3+76E0nSDU Yyv9JF6wFHcyEYElscBF/4w+nUajPoNLveehvIAeiW1UBAI7G5YlKNzU6MclYg0ibF7+ ydlzSyYYYRa+Q10LTdZQ6aLNw4GxAay1G2EnVa4pmnTzmy1qgm8gPsgjjzNG/2Jr5TZ4 wLxA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1739535797; x=1740140597; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=HlYXGEnZSyAGc7MM6POcCvycJIpFlDa3P8VoTqsifSY=; b=DmeVQZ84hSQQYyM4a5+54drIR4Gq96FRJtrib5Y3s+a5Z2+GFaX538oFbXaPealn7V B9CPYMVUDryTyEZz0wTV8wC9bBX4scM6LP8ZmSWHnLhETRIJwa1WMJXdd6LJ4bsK1+FQ ir3B/VwUZMRk5jcdCPPwBzEwgbR7Ij8qZKdpoRs9jY7IpX5olFutUSipZLl3rAcIitrr egLdXTRBECoxBAikXFiovKID0dZGoK2RCfr4vZ3BMX+0ctgPzSdm3aTEL2OTXOSf/8hO xgqJaSvKpKYBVgmy30dXT7RqGkdyBXjIs+OE42DCD/9KwMOTP3jWSwwIpz6dbmuoEAhj czyw== X-Forwarded-Encrypted: i=1; AJvYcCVoJdNRdL3ifbWgfgp+1vokKXdnvI6kC1VwC9+m4NqgleWWsG75ssgBQhTjAYM+aKE21zrWLrKVauXJL1o=@vger.kernel.org X-Gm-Message-State: AOJu0YzZKBPbPYKFqx+LdK/jCK5z4XZW7/5KZ0HU5VWZ4xZT+Acq35e7 T6gODSVRp3UdceNS7ql/pqvfqiLZpOGIy6ZDAltkDS9z+uQ8kQgA/fmbskitwf8= X-Gm-Gg: ASbGnctNmrnUawYiQdMJ2lEgA3VNMTQ+YljfDFnDVT0JK4oLWyQ8/cOIa0bDp7KTdfP 91glsEFbLZEHSzFs8bdRsEGFzg9QHW3MbiS9yXEfTwbfe5CUw1tfAzshaucaTaILvehv2Fpf6GZ 1aqyiTcESLWJonvDlrgQ+E9jo9uroACLiXN1QA3kPZSHZmZOE2udiIV761e2p5uWu7Pjj48SUvp OFrmeJYvhBcPvdKzH5TrAElZd2rVTQK0v13hWuEssStpdA4RUKzl5xYq6uHtvj21azG4731taYY Ayup5Z/M5u08i0Vzajh4MLqvsO3tadvpYYtAN1PUm+vrLznxev3FJr6ZLfowWI0k3Zgz1REJ X-Google-Smtp-Source: AGHT+IFoC01qxJzU78vr1oDwa5zbdgFcBCFHYW7HDipNsAWGs43U42rSRQJgmmX59I2PytOJU2Lv2w== X-Received: by 2002:a5d:5989:0:b0:38d:e15e:17e9 with SMTP id ffacd0b85a97d-38dea2d5fefmr14841438f8f.35.1739535796634; Fri, 14 Feb 2025 04:23:16 -0800 (PST) Received: from [127.0.0.1] (amontpellier-556-1-148-206.w109-210.abo.wanadoo.fr. [109.210.4.206]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-38f259f7b68sm4424654f8f.85.2025.02.14.04.23.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 14 Feb 2025 04:23:16 -0800 (PST) From: Esteban Blanc Date: Fri, 14 Feb 2025 13:22:33 +0100 Subject: [PATCH v4 3/6] iio: adc: ad4030: add averaging support 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: <20250214-eblanc-ad4630_v1-v4-3-135dd66cab6a@baylibre.com> References: <20250214-eblanc-ad4630_v1-v4-0-135dd66cab6a@baylibre.com> In-Reply-To: <20250214-eblanc-ad4630_v1-v4-0-135dd66cab6a@baylibre.com> To: Lars-Peter Clausen , Michael Hennerich , =?utf-8?q?Nuno_S=C3=A1?= , Jonathan Cameron , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet Cc: Michael Hennerich , linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org, Esteban Blanc X-Mailer: b4 0.14.2 This add support for the averaging mode of AD4030 using oversampling IIO attribute Signed-off-by: Esteban Blanc --- drivers/iio/adc/ad4030.c | 136 +++++++++++++++++++++++++++++++++++++++++--= ---- 1 file changed, 119 insertions(+), 17 deletions(-) diff --git a/drivers/iio/adc/ad4030.c b/drivers/iio/adc/ad4030.c index 8188d44bdd664aa74a7adcaa1f836e79a54a6050..ed31a3d1d13b831f46818cb7235= 3e11b1689407d 100644 --- a/drivers/iio/adc/ad4030.c +++ b/drivers/iio/adc/ad4030.c @@ -112,6 +112,11 @@ enum ad4030_out_mode { AD4030_OUT_DATA_MD_32_PATTERN, }; =20 +enum { + AD4030_SCAN_TYPE_NORMAL, + AD4030_SCAN_TYPE_AVG, +}; + struct ad4030_chip_info { const char *name; const unsigned long *available_masks; @@ -127,10 +132,12 @@ struct ad4030_state { struct spi_device *spi; struct regmap *regmap; const struct ad4030_chip_info *chip; + const struct iio_scan_type *current_scan_type; struct gpio_desc *cnv_gpio; int vref_uv; int vio_uv; int offset_avail[3]; + unsigned int avg_log2; enum ad4030_out_mode mode; =20 /* @@ -184,7 +191,11 @@ struct ad4030_state { * - voltage0-voltage1 * - voltage2-voltage3 */ -#define AD4030_CHAN_DIFF(_idx, _storage, _real, _shift) { \ +#define AD4030_CHAN_DIFF(_idx, _scan_type) { \ + .info_mask_shared_by_all =3D \ + BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \ + .info_mask_shared_by_all_available =3D \ + BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \ .info_mask_separate =3D BIT(IIO_CHAN_INFO_SCALE) | \ BIT(IIO_CHAN_INFO_CALIBSCALE) | \ BIT(IIO_CHAN_INFO_CALIBBIAS) | \ @@ -198,15 +209,17 @@ struct ad4030_state { .channel2 =3D (_idx) * 2 + 1, \ .scan_index =3D (_idx), \ .differential =3D true, \ - .scan_type =3D { \ - .sign =3D 's', \ - .storagebits =3D _storage, \ - .realbits =3D _real, \ - .shift =3D _shift, \ - .endianness =3D IIO_BE, \ - }, \ + .has_ext_scan_type =3D 1, \ + .ext_scan_type =3D _scan_type, \ + .num_ext_scan_type =3D ARRAY_SIZE(_scan_type), \ } =20 +static const int ad4030_average_modes[] =3D { + 1, 2, 4, 8, 16, 32, 64, 128, + 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, + 65536, +}; + static int ad4030_enter_config_mode(struct ad4030_state *st) { st->tx_data[0] =3D AD4030_REG_ACCESS; @@ -356,10 +369,13 @@ static int ad4030_get_chan_scale(struct iio_dev *indi= o_dev, int *val2) { struct ad4030_state *st =3D iio_priv(indio_dev); + struct iio_scan_type *scan_type; =20 if (chan->differential) { + scan_type =3D iio_get_current_scan_type(indio_dev, + st->chip->channels); *val =3D (st->vref_uv * 2) / MILLI; - *val2 =3D chan->scan_type.realbits; + *val2 =3D scan_type->realbits; return IIO_VAL_FRACTIONAL_LOG2; } =20 @@ -474,6 +490,27 @@ static int ad4030_set_chan_calibbias(struct iio_dev *i= ndio_dev, st->tx_data, AD4030_REG_OFFSET_BYTES_NB); } =20 +static int ad4030_set_avg_frame_len(struct iio_dev *dev, int avg_val) +{ + struct ad4030_state *st =3D iio_priv(dev); + unsigned int avg_log2 =3D ilog2(avg_val); + unsigned int last_avg_idx =3D ARRAY_SIZE(ad4030_average_modes) - 1; + int ret; + + if (avg_val < 0 || avg_val > ad4030_average_modes[last_avg_idx]) + return -EINVAL; + + ret =3D regmap_write(st->regmap, AD4030_REG_AVG, + AD4030_REG_AVG_MASK_AVG_SYNC | + FIELD_PREP(AD4030_REG_AVG_MASK_AVG_VAL, avg_log2)); + if (ret) + return ret; + + st->avg_log2 =3D avg_log2; + + return 0; +} + static bool ad4030_is_common_byte_asked(struct ad4030_state *st, unsigned int mask) { @@ -484,11 +521,18 @@ static int ad4030_set_mode(struct iio_dev *indio_dev,= unsigned long mask) { struct ad4030_state *st =3D iio_priv(indio_dev); =20 - if (ad4030_is_common_byte_asked(st, mask)) + if (st->avg_log2 > 0) + st->mode =3D AD4030_OUT_DATA_MD_30_AVERAGED_DIFF; + else if (ad4030_is_common_byte_asked(st, mask)) st->mode =3D AD4030_OUT_DATA_MD_24_DIFF_8_COM; else st->mode =3D AD4030_OUT_DATA_MD_DIFF; =20 + st->current_scan_type =3D iio_get_current_scan_type(indio_dev, + st->chip->channels); + if (IS_ERR(st->current_scan_type)) + return PTR_ERR(st->current_scan_type); + return regmap_update_bits(st->regmap, AD4030_REG_MODES, AD4030_REG_MODES_MASK_OUT_DATA_MODE, st->mode); @@ -497,9 +541,11 @@ static int ad4030_set_mode(struct iio_dev *indio_dev, = unsigned long mask) static int ad4030_conversion(struct iio_dev *indio_dev) { struct ad4030_state *st =3D iio_priv(indio_dev); - const struct iio_scan_type scan_type =3D indio_dev->channels->scan_type; - unsigned char diff_realbytes =3D BITS_TO_BYTES(scan_type.realbits); + unsigned char diff_realbytes =3D + BITS_TO_BYTES(st->current_scan_type->realbits); unsigned int bytes_to_read; + unsigned long cnv_nb =3D BIT(st->avg_log2); + unsigned int i; int ret; =20 /* Number of bytes for one differential channel */ @@ -510,10 +556,12 @@ static int ad4030_conversion(struct iio_dev *indio_de= v) /* Mulitiply by the number of hardware channels */ bytes_to_read *=3D st->chip->num_voltage_inputs; =20 - gpiod_set_value_cansleep(st->cnv_gpio, 1); - ndelay(AD4030_TCNVH_NS); - gpiod_set_value_cansleep(st->cnv_gpio, 0); - ndelay(st->chip->tcyc_ns); + for (i =3D 0; i < cnv_nb; i++) { + gpiod_set_value_cansleep(st->cnv_gpio, 1); + ndelay(AD4030_TCNVH_NS); + gpiod_set_value_cansleep(st->cnv_gpio, 0); + ndelay(st->chip->tcyc_ns); + } =20 ret =3D spi_read(st->spi, st->rx_data.raw, bytes_to_read); if (ret) @@ -593,6 +641,12 @@ static int ad4030_read_avail(struct iio_dev *indio_dev, *type =3D IIO_VAL_INT_PLUS_NANO; return IIO_AVAIL_RANGE; =20 + case IIO_CHAN_INFO_OVERSAMPLING_RATIO: + *vals =3D ad4030_average_modes; + *type =3D IIO_VAL_INT; + *length =3D ARRAY_SIZE(ad4030_average_modes); + return IIO_AVAIL_LIST; + default: return -EINVAL; } @@ -602,6 +656,8 @@ static int ad4030_read_raw_dispatch(struct iio_dev *ind= io_dev, struct iio_chan_spec const *chan, int *val, int *val2, long info) { + struct ad4030_state *st =3D iio_priv(indio_dev); + switch (info) { case IIO_CHAN_INFO_RAW: return ad4030_single_conversion(indio_dev, chan, val); @@ -612,6 +668,10 @@ static int ad4030_read_raw_dispatch(struct iio_dev *in= dio_dev, case IIO_CHAN_INFO_CALIBBIAS: return ad4030_get_chan_calibbias(indio_dev, chan, val); =20 + case IIO_CHAN_INFO_OVERSAMPLING_RATIO: + *val =3D BIT(st->avg_log2); + return IIO_VAL_INT; + default: return -EINVAL; } @@ -650,6 +710,9 @@ static int ad4030_write_raw_dispatch(struct iio_dev *in= dio_dev, return -EINVAL; return ad4030_set_chan_calibbias(indio_dev, chan, val); =20 + case IIO_CHAN_INFO_OVERSAMPLING_RATIO: + return ad4030_set_avg_frame_len(indio_dev, val); + default: return -EINVAL; } @@ -701,12 +764,21 @@ static int ad4030_read_label(struct iio_dev *indio_de= v, return sprintf(label, "common-mode%lu\n", chan->address); } =20 +static int ad4030_get_current_scan_type(const struct iio_dev *indio_dev, + const struct iio_chan_spec *chan) +{ + struct ad4030_state *st =3D iio_priv(indio_dev); + + return st->avg_log2 ? AD4030_SCAN_TYPE_AVG : AD4030_SCAN_TYPE_NORMAL; +} + static const struct iio_info ad4030_iio_info =3D { .read_avail =3D ad4030_read_avail, .read_raw =3D ad4030_read_raw, .write_raw =3D ad4030_write_raw, .debugfs_reg_access =3D ad4030_reg_access, .read_label =3D ad4030_read_label, + .get_current_scan_type =3D ad4030_get_current_scan_type, }; =20 static int ad4030_buffer_preenable(struct iio_dev *indio_dev) @@ -714,8 +786,21 @@ static int ad4030_buffer_preenable(struct iio_dev *ind= io_dev) return ad4030_set_mode(indio_dev, *indio_dev->active_scan_mask); } =20 +static bool ad4030_validate_scan_mask(struct iio_dev *indio_dev, + const unsigned long *scan_mask) +{ + struct ad4030_state *st =3D iio_priv(indio_dev); + + /* Asking for both common channels and averaging */ + if (st->avg_log2 && ad4030_is_common_byte_asked(st, *scan_mask)) + return false; + + return true; +} + static const struct iio_buffer_setup_ops ad4030_buffer_setup_ops =3D { .preenable =3D ad4030_buffer_preenable, + .validate_scan_mask =3D ad4030_validate_scan_mask, }; =20 static int ad4030_regulators_get(struct ad4030_state *st) @@ -881,11 +966,28 @@ static const unsigned long ad4030_channel_masks[] =3D= { 0, }; =20 +static const struct iio_scan_type ad4030_24_scan_types[] =3D { + [AD4030_SCAN_TYPE_NORMAL] =3D { + .sign =3D 's', + .storagebits =3D 32, + .realbits =3D 24, + .shift =3D 8, + .endianness =3D IIO_BE, + }, + [AD4030_SCAN_TYPE_AVG] =3D { + .sign =3D 's', + .storagebits =3D 32, + .realbits =3D 30, + .shift =3D 2, + .endianness =3D IIO_BE, + }, +}; + static const struct ad4030_chip_info ad4030_24_chip_info =3D { .name =3D "ad4030-24", .available_masks =3D ad4030_channel_masks, .channels =3D { - AD4030_CHAN_DIFF(0, 32, 24, 8), + AD4030_CHAN_DIFF(0, ad4030_24_scan_types), AD4030_CHAN_CMO(1, 0), IIO_CHAN_SOFT_TIMESTAMP(2), }, --=20 2.47.2 From nobody Thu Dec 18 18:05:48 2025 Received: from mail-wr1-f46.google.com (mail-wr1-f46.google.com [209.85.221.46]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5F9D2263F32 for ; Fri, 14 Feb 2025 12:23:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.46 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739535802; cv=none; b=aBGLIOv2pexGFMb85q0faDz/jb8YuTaPmxT2xTFE8HAUuvlHUhwpWu4HFCKaMTR6WgHawTCbni/F+DcAlSc1nUUvAypphh47zUd9pt6EpQVdEX3bJnJf+qPyz/Jtbc6f+YQ51OBgwgMDrreVU1scv+xiYfKMiLgw4banO8u1qB8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739535802; c=relaxed/simple; bh=W9yMKieEXNBYhbCo5Jvnb/3ZjTot++8G3dNCwWJvpts=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=l4zqViZuyWRXkr3pdR3gMMSt4lEeUd5KJ8+cNMs55L7EwC/FQThvZw+jZSV3snVvGra2cGw+iHEvIpWhzOvtnykE0nNFnBctupQHlkQ1XRgl20yfy+ZAOP8ivZ6P5P7Z6kxJmguVMqg3gi6+2b4PcOBapj5O4+vevx/ugRpGqMc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com; spf=pass smtp.mailfrom=baylibre.com; dkim=pass (2048-bit key) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.b=3Oj7a4fr; arc=none smtp.client-ip=209.85.221.46 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=baylibre.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.b="3Oj7a4fr" Received: by mail-wr1-f46.google.com with SMTP id ffacd0b85a97d-38f2cb1ba55so549819f8f.3 for ; Fri, 14 Feb 2025 04:23:19 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20230601.gappssmtp.com; s=20230601; t=1739535797; x=1740140597; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=lpVt0ni+2FVUdo6X72Cjhq/6puDDJr6iZ54cPTEPmD4=; b=3Oj7a4frtc90yfCON6GkY0DN+WkAXSx0VodZ1jPdpwaf5wiVc32hodAb3iqf7e5BvM OEPDfXEd4S0+ZicLp2AdXeusvxSVxagpH1DGkpK6Q/ZI18vXrEvgoBm31tRvPKfKyPtP sczJb9qr6yh6qcnIg6KuF5w5Pyqpy2QqhI6/LCztowwOzomYznbyu+48EL7UfRj1gOqb wvoPG7aj7f0f56IjZbO64/mrQYBxKcqN0y1XvFJS0LpYMidTKtor1TAmq7vEoKsDaNFw sFg1U7SS2R02Zr1C5rkR00yJUi571AElAJXsiEryUb9+7g88JABqmNZaB+NGNlIhX52i 85xw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1739535797; x=1740140597; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=lpVt0ni+2FVUdo6X72Cjhq/6puDDJr6iZ54cPTEPmD4=; b=Vdj70XENoRl4r+lKf7ZZB8LyD87ZeZMkiXz/Nv6YB3p1nTbqpGjaiyJRk3pjQpGWwZ p+iX4yxQ3d/NG/Xu0trIFM/XmNdu0xhBwAvTeTRkmCsBQHgC6Rh53gsXQlZftHqb5ggr 35D00y3z1Grbt9zjh7Ijs+WWaR7J1cNn2UDtI4/+kPyJqj4OIcLJ+LpQHs5JI5sa7O7D WnB9whiZZh32jRQ/sJ0lF5m23T1ynk/MIRyPVLjiGyuRYO5RFnqAR/4ELoO0rd8UPxZi uIghEv5FSxw3uVpgeKzTD1g9hpH9vINJmqYmyf+8Tp22axp+JTN2NQkWV8MIHJuWyh5k RfGw== X-Forwarded-Encrypted: i=1; AJvYcCVG3qySoQ0nHHzIbvRIFeTc27YPr8j9iN3Rxrzu5fyv0xfZXPQ73rYgN89w/vKbKStiW28c2AdnLLooTM4=@vger.kernel.org X-Gm-Message-State: AOJu0YzTh59eXf2qeCqFscNuSb6Kg40p7PH70rJcDseOXY4ztNKhE1Ny JcUVboUch753urpQ+G8HePfML7F8sV6GkHNHXUpGreo9pAiDycTimaAkVd08V40= X-Gm-Gg: ASbGncuPQOStRcyiZAZFLpc1VWCsB8z0ylcH5A6Ddau2dzi5udxLwbWtR0njx8uHm0x JD6QdvhqrGFxgZe2HVFFhsUIXFRbEXW9N9N+m9z1ebjbnBY0tvZZhOXKf9+xRqUC0qAmWCN9NZA j81D1LIZZwVnJ7Xw6IPihT1wzc/LS7LdaD+Clv0TOLqCkYSwTee6iRA/+q2BYSgXQ5meNnQ/htd wHqNgAduc5A0VNukIS176JYph++ezrAnuhtowTlQDv4OXNliH5j3eShDul/djiwqJC0vGLbX6W1 DSDTE4AhGjnU/6hFvqUZdsIdKKzN/JAIBu2HcXQV8CgaELxUT5hWJrIxDf9iDNb5Aa33YvuP X-Google-Smtp-Source: AGHT+IEo2eWy8FjWbjRUiobCa7fMsyW0SSgMypjbUFM7AXc2ZBqs2NJpv2cjQxhCkYWytklrO/kpVw== X-Received: by 2002:a05:6000:1f81:b0:38f:2173:b7b7 with SMTP id ffacd0b85a97d-38f2173b9aemr9978221f8f.18.1739535797516; Fri, 14 Feb 2025 04:23:17 -0800 (PST) Received: from [127.0.0.1] (amontpellier-556-1-148-206.w109-210.abo.wanadoo.fr. [109.210.4.206]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-38f259f7b68sm4424654f8f.85.2025.02.14.04.23.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 14 Feb 2025 04:23:17 -0800 (PST) From: Esteban Blanc Date: Fri, 14 Feb 2025 13:22:34 +0100 Subject: [PATCH v4 4/6] iio: adc: ad4030: add support for ad4630-24 and ad4630-16 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: <20250214-eblanc-ad4630_v1-v4-4-135dd66cab6a@baylibre.com> References: <20250214-eblanc-ad4630_v1-v4-0-135dd66cab6a@baylibre.com> In-Reply-To: <20250214-eblanc-ad4630_v1-v4-0-135dd66cab6a@baylibre.com> To: Lars-Peter Clausen , Michael Hennerich , =?utf-8?q?Nuno_S=C3=A1?= , Jonathan Cameron , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet Cc: Michael Hennerich , linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org, Esteban Blanc X-Mailer: b4 0.14.2 AD4630-24 and AD4630-16 are 2 channels ADCs. Both channels are interleaved bit per bit on SDO line. Signed-off-by: Esteban Blanc --- drivers/iio/adc/ad4030.c | 188 +++++++++++++++++++++++++++++++++++++++++++= +--- 1 file changed, 178 insertions(+), 10 deletions(-) diff --git a/drivers/iio/adc/ad4030.c b/drivers/iio/adc/ad4030.c index ed31a3d1d13b831f46818cb72353e11b1689407d..a5f08522175493b5574144352e7= 1d3e70bb6ad3e 100644 --- a/drivers/iio/adc/ad4030.c +++ b/drivers/iio/adc/ad4030.c @@ -33,6 +33,8 @@ #define AD4030_REG_PRODUCT_ID_H 0x05 #define AD4030_REG_CHIP_GRADE 0x06 #define AD4030_REG_CHIP_GRADE_AD4030_24_GRADE 0x10 +#define AD4030_REG_CHIP_GRADE_AD4630_16_GRADE 0x03 +#define AD4030_REG_CHIP_GRADE_AD4630_24_GRADE 0x00 #define AD4030_REG_CHIP_GRADE_MASK_CHIP_GRADE GENMASK(7, 3) #define AD4030_REG_SCRATCH_PAD 0x0A #define AD4030_REG_SPI_REVISION 0x0B @@ -83,6 +85,7 @@ #define AD4030_MAX_HARDWARE_CHANNEL_NB 2 #define AD4030_MAX_IIO_CHANNEL_NB 5 #define AD4030_SINGLE_COMMON_BYTE_CHANNELS_MASK 0b10 +#define AD4030_DUAL_COMMON_BYTE_CHANNELS_MASK 0b1100 #define AD4030_GAIN_MIDLE_POINT 0x8000 /* * This accounts for 1 sample per channel plus one s64 for the timestamp, @@ -112,6 +115,13 @@ enum ad4030_out_mode { AD4030_OUT_DATA_MD_32_PATTERN, }; =20 +enum { + AD4030_LANE_MD_1_PER_CH, + AD4030_LANE_MD_2_PER_CH, + AD4030_LANE_MD_4_PER_CH, + AD4030_LANE_MD_INTERLEAVED, +}; + enum { AD4030_SCAN_TYPE_NORMAL, AD4030_SCAN_TYPE_AVG, @@ -150,7 +160,11 @@ struct ad4030_state { struct { s32 diff; u8 common; - }; + } single; + struct { + s32 diff[2]; + u8 common[2]; + } dual; } rx_data; }; =20 @@ -514,19 +528,33 @@ static int ad4030_set_avg_frame_len(struct iio_dev *d= ev, int avg_val) static bool ad4030_is_common_byte_asked(struct ad4030_state *st, unsigned int mask) { - return mask & AD4030_SINGLE_COMMON_BYTE_CHANNELS_MASK; + return mask & (st->chip->num_voltage_inputs =3D=3D 1 ? + AD4030_SINGLE_COMMON_BYTE_CHANNELS_MASK : + AD4030_DUAL_COMMON_BYTE_CHANNELS_MASK); } =20 static int ad4030_set_mode(struct iio_dev *indio_dev, unsigned long mask) { struct ad4030_state *st =3D iio_priv(indio_dev); =20 - if (st->avg_log2 > 0) + if (st->avg_log2 > 0) { st->mode =3D AD4030_OUT_DATA_MD_30_AVERAGED_DIFF; - else if (ad4030_is_common_byte_asked(st, mask)) - st->mode =3D AD4030_OUT_DATA_MD_24_DIFF_8_COM; - else + } else if (ad4030_is_common_byte_asked(st, mask)) { + switch (st->chip->precision_bits) { + case 16: + st->mode =3D AD4030_OUT_DATA_MD_16_DIFF_8_COM; + break; + + case 24: + st->mode =3D AD4030_OUT_DATA_MD_24_DIFF_8_COM; + break; + + default: + return -EINVAL; + } + } else { st->mode =3D AD4030_OUT_DATA_MD_DIFF; + } =20 st->current_scan_type =3D iio_get_current_scan_type(indio_dev, st->chip->channels); @@ -538,11 +566,52 @@ static int ad4030_set_mode(struct iio_dev *indio_dev,= unsigned long mask) st->mode); } =20 +/* + * Descramble 2 32bits numbers out of a 64bits. The bits are interleaved: + * 1 bit for first number, 1 bit for the second, and so on... + */ +static void ad4030_extract_interleaved(u8 *src, u32 *ch0, u32 *ch1) +{ + u8 h0, h1, l0, l1; + u32 out0, out1; + u8 *out0_raw =3D (u8 *)&out0; + u8 *out1_raw =3D (u8 *)&out1; + + for (int i =3D 0; i < 4; i++) { + h0 =3D src[i * 2]; + l1 =3D src[i * 2 + 1]; + h1 =3D h0 << 1; + l0 =3D l1 >> 1; + + h0 &=3D 0xAA; + l0 &=3D 0x55; + h1 &=3D 0xAA; + l1 &=3D 0x55; + + h0 =3D (h0 | h0 << 001) & 0xCC; + h1 =3D (h1 | h1 << 001) & 0xCC; + l0 =3D (l0 | l0 >> 001) & 0x33; + l1 =3D (l1 | l1 >> 001) & 0x33; + h0 =3D (h0 | h0 << 002) & 0xF0; + h1 =3D (h1 | h1 << 002) & 0xF0; + l0 =3D (l0 | l0 >> 002) & 0x0F; + l1 =3D (l1 | l1 >> 002) & 0x0F; + + out0_raw[i] =3D h0 | l0; + out1_raw[i] =3D h1 | l1; + } + + *ch0 =3D out0; + *ch1 =3D out1; +} + static int ad4030_conversion(struct iio_dev *indio_dev) { struct ad4030_state *st =3D iio_priv(indio_dev); unsigned char diff_realbytes =3D BITS_TO_BYTES(st->current_scan_type->realbits); + unsigned char diff_storagebytes =3D + BITS_TO_BYTES(st->current_scan_type->storagebits); unsigned int bytes_to_read; unsigned long cnv_nb =3D BIT(st->avg_log2); unsigned int i; @@ -567,10 +636,23 @@ static int ad4030_conversion(struct iio_dev *indio_de= v) if (ret) return ret; =20 - if (st->mode !=3D AD4030_OUT_DATA_MD_24_DIFF_8_COM) + if (st->chip->num_voltage_inputs =3D=3D 2) + ad4030_extract_interleaved(st->rx_data.raw, + &st->rx_data.dual.diff[0], + &st->rx_data.dual.diff[1]); + + if (st->mode !=3D AD4030_OUT_DATA_MD_16_DIFF_8_COM && + st->mode !=3D AD4030_OUT_DATA_MD_24_DIFF_8_COM) + return 0; + + if (st->chip->num_voltage_inputs =3D=3D 1) { + st->rx_data.single.common =3D st->rx_data.raw[diff_realbytes]; return 0; + } =20 - st->rx_data.common =3D st->rx_data.raw[diff_realbytes]; + for (i =3D 0; i < st->chip->num_voltage_inputs; i++) + st->rx_data.dual.common[i] =3D + st->rx_data.raw[diff_storagebytes * i + diff_realbytes]; =20 return 0; } @@ -585,14 +667,25 @@ static int ad4030_single_conversion(struct iio_dev *i= ndio_dev, if (ret) return ret; =20 + st->current_scan_type =3D iio_get_current_scan_type(indio_dev, + st->chip->channels); + if (IS_ERR(st->current_scan_type)) + return PTR_ERR(st->current_scan_type); + ret =3D ad4030_conversion(indio_dev); if (ret) return ret; =20 if (chan->differential) - *val =3D st->rx_data.diff; + if (st->chip->num_voltage_inputs =3D=3D 1) + *val =3D st->rx_data.single.diff; + else + *val =3D st->rx_data.dual.diff[chan->address]; else - *val =3D st->rx_data.common; + if (st->chip->num_voltage_inputs =3D=3D 1) + *val =3D st->rx_data.single.common; + else + *val =3D st->rx_data.dual.common[chan->address]; =20 return IIO_VAL_INT; } @@ -874,10 +967,24 @@ static int ad4030_detect_chip_info(const struct ad403= 0_state *st) =20 static int ad4030_config(struct ad4030_state *st) { + int ret; + u8 reg_modes; + st->offset_avail[0] =3D (int)BIT(st->chip->precision_bits - 1) * -1; st->offset_avail[1] =3D 1; st->offset_avail[2] =3D BIT(st->chip->precision_bits - 1) - 1; =20 + if (st->chip->num_voltage_inputs > 1) + reg_modes =3D FIELD_PREP(AD4030_REG_MODES_MASK_LANE_MODE, + AD4030_LANE_MD_INTERLEAVED); + else + reg_modes =3D FIELD_PREP(AD4030_REG_MODES_MASK_LANE_MODE, + AD4030_LANE_MD_1_PER_CH); + + ret =3D regmap_write(st->regmap, AD4030_REG_MODES, reg_modes); + if (ret) + return ret; + if (st->vio_uv < AD4030_VIO_THRESHOLD_UV) return regmap_write(st->regmap, AD4030_REG_IO, AD4030_REG_IO_MASK_IO2X); @@ -966,6 +1073,14 @@ static const unsigned long ad4030_channel_masks[] =3D= { 0, }; =20 +static const unsigned long ad4630_channel_masks[] =3D { + /* Differential only */ + BIT(1) | BIT(0), + /* Differential with common byte */ + GENMASK(3, 0), + 0, +}; + static const struct iio_scan_type ad4030_24_scan_types[] =3D { [AD4030_SCAN_TYPE_NORMAL] =3D { .sign =3D 's', @@ -983,6 +1098,23 @@ static const struct iio_scan_type ad4030_24_scan_type= s[] =3D { }, }; =20 +static const struct iio_scan_type ad4030_16_scan_types[] =3D { + [AD4030_SCAN_TYPE_NORMAL] =3D { + .sign =3D 's', + .storagebits =3D 32, + .realbits =3D 16, + .shift =3D 16, + .endianness =3D IIO_BE, + }, + [AD4030_SCAN_TYPE_AVG] =3D { + .sign =3D 's', + .storagebits =3D 32, + .realbits =3D 30, + .shift =3D 2, + .endianness =3D IIO_BE, + } +}; + static const struct ad4030_chip_info ad4030_24_chip_info =3D { .name =3D "ad4030-24", .available_masks =3D ad4030_channel_masks, @@ -997,14 +1129,50 @@ static const struct ad4030_chip_info ad4030_24_chip_= info =3D { .tcyc_ns =3D AD4030_TCYC_ADJUSTED_NS, }; =20 +static const struct ad4030_chip_info ad4630_16_chip_info =3D { + .name =3D "ad4630-16", + .available_masks =3D ad4630_channel_masks, + .channels =3D { + AD4030_CHAN_DIFF(0, ad4030_16_scan_types), + AD4030_CHAN_DIFF(1, ad4030_16_scan_types), + AD4030_CHAN_CMO(2, 0), + AD4030_CHAN_CMO(3, 1), + IIO_CHAN_SOFT_TIMESTAMP(4), + }, + .grade =3D AD4030_REG_CHIP_GRADE_AD4630_16_GRADE, + .precision_bits =3D 16, + .num_voltage_inputs =3D 2, + .tcyc_ns =3D AD4030_TCYC_ADJUSTED_NS, +}; + +static const struct ad4030_chip_info ad4630_24_chip_info =3D { + .name =3D "ad4630-24", + .available_masks =3D ad4630_channel_masks, + .channels =3D { + AD4030_CHAN_DIFF(0, ad4030_24_scan_types), + AD4030_CHAN_DIFF(1, ad4030_24_scan_types), + AD4030_CHAN_CMO(2, 0), + AD4030_CHAN_CMO(3, 1), + IIO_CHAN_SOFT_TIMESTAMP(4), + }, + .grade =3D AD4030_REG_CHIP_GRADE_AD4630_24_GRADE, + .precision_bits =3D 24, + .num_voltage_inputs =3D 2, + .tcyc_ns =3D AD4030_TCYC_ADJUSTED_NS, +}; + static const struct spi_device_id ad4030_id_table[] =3D { { "ad4030-24", (kernel_ulong_t)&ad4030_24_chip_info }, + { "ad4630-16", (kernel_ulong_t)&ad4630_16_chip_info }, + { "ad4630-24", (kernel_ulong_t)&ad4630_24_chip_info }, { } }; MODULE_DEVICE_TABLE(spi, ad4030_id_table); =20 static const struct of_device_id ad4030_of_match[] =3D { { .compatible =3D "adi,ad4030-24", .data =3D &ad4030_24_chip_info }, + { .compatible =3D "adi,ad4630-16", .data =3D &ad4630_16_chip_info }, + { .compatible =3D "adi,ad4630-24", .data =3D &ad4630_24_chip_info }, { } }; MODULE_DEVICE_TABLE(of, ad4030_of_match); --=20 2.47.2 From nobody Thu Dec 18 18:05:48 2025 Received: from mail-wr1-f54.google.com (mail-wr1-f54.google.com [209.85.221.54]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 56ACC263F57 for ; Fri, 14 Feb 2025 12:23:20 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.54 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739535802; cv=none; b=pSw56VZ2Lup/emrQthVPSdkM1Y4Gf87+nULu6g0B3fcJ0W9eG2N3XO5qvSUT9iIFvkQug9faL96I0LeRdp+6qp7R9I+N5r3d/FiQlwLkuLkJaIR5W+J8/9KVq011LV8kAcNuQZHf9LJLIn8BmHPRnb30nhK+XbEtX/gTyP4AZiY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739535802; c=relaxed/simple; bh=8rrqwFgDTm2gA4mj7sVUgnMI6tZZuBU3XZP0x7fXgj4=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=aViY5//ekp8ruRrTn1cGAHrhjpDU1LMXhZcgXSxSKFajJRIGwUId0GZr4dlKCZTmHEpFmWD5WVzgCSG64MLZfXf6i+FnFlgfxrsL7yo02io3w0M+qXsql13xFTx18O5HyD5bNlWRBMnNl2EwH8EUl8bdOFMFTyqUhgKtYqww40o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com; spf=pass smtp.mailfrom=baylibre.com; dkim=pass (2048-bit key) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.b=j70F61ZL; arc=none smtp.client-ip=209.85.221.54 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=baylibre.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.b="j70F61ZL" Received: by mail-wr1-f54.google.com with SMTP id ffacd0b85a97d-38f2b7ce2f3so643095f8f.0 for ; Fri, 14 Feb 2025 04:23:20 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20230601.gappssmtp.com; s=20230601; t=1739535798; x=1740140598; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=BNzmNXyLsKOSVj8hEg1gf1L94StWzXv3dxfzugH3wL8=; b=j70F61ZLZS8wxJGfw1JPMa4jFBg7JiGSweIraISGJkFJxrTaK1DiyaxS/Shfc8bK/J rf67mjsmbJS8WnJANJ5LNQJwRmUF6YG4Dv+WwQKTsdz5tA4hR3pQP4p19I2XHrvKHea2 KvOFlHhoHL3aP7YBd6Oe5txPw7cCgl74nbJbbLPqtk4KW4/9amIWHoni3OR8RA0QpMBF PZ792Ddq9wPdhzI7VvcYQe6+KZK/+Te+ARTxuzQatnBgFnbwHuWLS7aU/tkMvfEcjrpH Rt8tEfQgeCqy/s7FqUWlA4adOtxrzz7lkqZ3gbyl0ZHW7MQg2U8T+jL7aPz6UkT9lsg7 B79g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1739535798; x=1740140598; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=BNzmNXyLsKOSVj8hEg1gf1L94StWzXv3dxfzugH3wL8=; b=vcKnPluU5wPTZorms1Ilen1pH227W80SZB/cC8iqB7eJo0sKgSzrrIBSFpEJT68P8k 5/Fo28rujU29i6ZZ2BKlddyeuI6WF5Rz8mCL1yVYr83prb2pb7io5mvezJXaJdHwFPiy UqxKPB8BobzdaeTHV2cKaZOqfSYRErDzk2vVFHZWbA6Y7J8oQyhiSXVUXaswa/S5mYCm Z4IShb4gBvXXrPsv62JjTegnsxIwUZ2cG+t3l+TXc4p8yCaEoCws8ZdIna5IrAoe/Gnb Kz3AIlsNgKJmWKlp5U7ib/ib9b4I9R5eRMbhGQ5TILlVej6AiLvBYRH8cEnUmGbF/yfS xVBQ== X-Forwarded-Encrypted: i=1; AJvYcCWVW0lUZvxIsYYxGIdJyO4NrSXyEpmyWJLjp7G3h4sb9BoSXDuDBHIxoG6IDdwxF5tA1psnLP6YrKqunb4=@vger.kernel.org X-Gm-Message-State: AOJu0YxwSIJBtO3VcO6ZWLbh/xm+eDQUw8FCAMQ5j5bmWkHfbSArYhc1 RwkD8YXpxavmHfhELMoNfXiGekmyZ+fDPfOxKfURZVlUFFVfqETnExIT6JF3vi8= X-Gm-Gg: ASbGncvfmxq8x7XBak9FPXHCFZNf6oiIG3xIF66tb21tmTFqx1a/SHxgcA6qpNz1ABS PH4Bwz5mCATYRzyS3hYxw7Z8MuRG+bOw1MLEHZZ80Ho7wWm3knIHwjKNfRCITGr8hfz0XOdMTPe bLqnSsTOrMLswqI3SzsP09A4Fofcqm1c0t/zzOXxaGM9Z4zzzz9nwNPXnSkU8j9eqsNgR6UIIIX ZfSMBNmCk5uo2CKI3+iANIii9/pJmGFKI3ISvar0WPdLIF9LuMw4fFeNJubg3XFJAIn8dLue3lZ kszkCCecSFPjjPJy2sne5FlP16Ut0XZsZpKrPq/TIlSjqkV21ch2fDi6cmnGItxrMGwBiS6Q X-Google-Smtp-Source: AGHT+IEiARyb0g8w3CmW73f7qJTgAK/p48+LYigBoS9IM1MgFpWYiwjxfppS2/mOLm+/lkksAauT0Q== X-Received: by 2002:a5d:64eb:0:b0:38f:2176:45a0 with SMTP id ffacd0b85a97d-38f2176496fmr12623833f8f.33.1739535798429; Fri, 14 Feb 2025 04:23:18 -0800 (PST) Received: from [127.0.0.1] (amontpellier-556-1-148-206.w109-210.abo.wanadoo.fr. [109.210.4.206]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-38f259f7b68sm4424654f8f.85.2025.02.14.04.23.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 14 Feb 2025 04:23:18 -0800 (PST) From: Esteban Blanc Date: Fri, 14 Feb 2025 13:22:35 +0100 Subject: [PATCH v4 5/6] iio: adc: ad4030: add support for ad4632-16 and ad4632-24 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: <20250214-eblanc-ad4630_v1-v4-5-135dd66cab6a@baylibre.com> References: <20250214-eblanc-ad4630_v1-v4-0-135dd66cab6a@baylibre.com> In-Reply-To: <20250214-eblanc-ad4630_v1-v4-0-135dd66cab6a@baylibre.com> To: Lars-Peter Clausen , Michael Hennerich , =?utf-8?q?Nuno_S=C3=A1?= , Jonathan Cameron , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet Cc: Michael Hennerich , linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org, Esteban Blanc X-Mailer: b4 0.14.2 AD4632-24 and AD4632-16 are 2 channels ADCs. Both channels are interleaved bit per bit on SDO line. Both of them do not have evaluation board. As such, the support added here can't be tested. Support is provided as best effort until someone get their hands on one. Signed-off-by: Esteban Blanc --- drivers/iio/adc/ad4030.c | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/drivers/iio/adc/ad4030.c b/drivers/iio/adc/ad4030.c index a5f08522175493b5574144352e71d3e70bb6ad3e..f1116e547ea3ca1cdeab7cbca09= 201710ad99c60 100644 --- a/drivers/iio/adc/ad4030.c +++ b/drivers/iio/adc/ad4030.c @@ -35,6 +35,8 @@ #define AD4030_REG_CHIP_GRADE_AD4030_24_GRADE 0x10 #define AD4030_REG_CHIP_GRADE_AD4630_16_GRADE 0x03 #define AD4030_REG_CHIP_GRADE_AD4630_24_GRADE 0x00 +#define AD4030_REG_CHIP_GRADE_AD4632_16_GRADE 0x05 +#define AD4030_REG_CHIP_GRADE_AD4632_24_GRADE 0x02 #define AD4030_REG_CHIP_GRADE_MASK_CHIP_GRADE GENMASK(7, 3) #define AD4030_REG_SCRATCH_PAD 0x0A #define AD4030_REG_SPI_REVISION 0x0B @@ -106,6 +108,9 @@ #define AD4030_TCYC_NS 500 #define AD4030_TCYC_ADJUSTED_NS (AD4030_TCYC_NS - AD4030_TCNVL_NS) #define AD4030_TRESET_PW_NS 50 +#define AD4632_TCYC_NS 2000 +#define AD4632_TCYC_ADJUSTED_NS (AD4632_TCYC_NS - AD4030_TCNVL_NS) +#define AD4030_TRESET_COM_DELAY_MS 750 =20 enum ad4030_out_mode { AD4030_OUT_DATA_MD_DIFF, @@ -1161,10 +1166,44 @@ static const struct ad4030_chip_info ad4630_24_chip= _info =3D { .tcyc_ns =3D AD4030_TCYC_ADJUSTED_NS, }; =20 +static const struct ad4030_chip_info ad4632_16_chip_info =3D { + .name =3D "ad4632-16", + .available_masks =3D ad4630_channel_masks, + .channels =3D { + AD4030_CHAN_DIFF(0, ad4030_16_scan_types), + AD4030_CHAN_DIFF(1, ad4030_16_scan_types), + AD4030_CHAN_CMO(2, 0), + AD4030_CHAN_CMO(3, 1), + IIO_CHAN_SOFT_TIMESTAMP(4), + }, + .grade =3D AD4030_REG_CHIP_GRADE_AD4632_16_GRADE, + .precision_bits =3D 16, + .num_voltage_inputs =3D 2, + .tcyc_ns =3D AD4632_TCYC_ADJUSTED_NS, +}; + +static const struct ad4030_chip_info ad4632_24_chip_info =3D { + .name =3D "ad4632-24", + .available_masks =3D ad4630_channel_masks, + .channels =3D { + AD4030_CHAN_DIFF(0, ad4030_24_scan_types), + AD4030_CHAN_DIFF(1, ad4030_24_scan_types), + AD4030_CHAN_CMO(2, 0), + AD4030_CHAN_CMO(3, 1), + IIO_CHAN_SOFT_TIMESTAMP(4), + }, + .grade =3D AD4030_REG_CHIP_GRADE_AD4632_24_GRADE, + .precision_bits =3D 24, + .num_voltage_inputs =3D 2, + .tcyc_ns =3D AD4632_TCYC_ADJUSTED_NS, +}; + static const struct spi_device_id ad4030_id_table[] =3D { { "ad4030-24", (kernel_ulong_t)&ad4030_24_chip_info }, { "ad4630-16", (kernel_ulong_t)&ad4630_16_chip_info }, { "ad4630-24", (kernel_ulong_t)&ad4630_24_chip_info }, + { "ad4632-16", (kernel_ulong_t)&ad4632_16_chip_info }, + { "ad4632-24", (kernel_ulong_t)&ad4632_24_chip_info }, { } }; MODULE_DEVICE_TABLE(spi, ad4030_id_table); @@ -1173,6 +1212,8 @@ static const struct of_device_id ad4030_of_match[] = =3D { { .compatible =3D "adi,ad4030-24", .data =3D &ad4030_24_chip_info }, { .compatible =3D "adi,ad4630-16", .data =3D &ad4630_16_chip_info }, { .compatible =3D "adi,ad4630-24", .data =3D &ad4630_24_chip_info }, + { .compatible =3D "adi,ad4632-16", .data =3D &ad4632_16_chip_info }, + { .compatible =3D "adi,ad4632-24", .data =3D &ad4632_24_chip_info }, { } }; MODULE_DEVICE_TABLE(of, ad4030_of_match); --=20 2.47.2 From nobody Thu Dec 18 18:05:48 2025 Received: from mail-wm1-f54.google.com (mail-wm1-f54.google.com [209.85.128.54]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6542E264A60 for ; Fri, 14 Feb 2025 12:23:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.54 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739535804; cv=none; b=MiWkN/S/pRyzkTkuRye0LF45jP1UfICCwjJtwALY0uG95GuXNewhiKDe5gS6UcNiUBbFFzrI98dkswiqUdj2xGw8CCcffbbBthEVZ0rQg46gnaYC2StEjAiSTGiGm4mKFSiGbSzNcOddoERptOzqJORH4IjVYTyY2M1EvHV8hKI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739535804; c=relaxed/simple; bh=hLiMZnuu+3C1+GXOKrJYlOPcy9O1KcJ4GWq7/HNkeVo=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=dveHGxuRnw+wX7wUKpnSGbSyvE6dmeTnA+YV47hjQ6vdsi62KlXDdea8AjTenyaiTc61TPj7lQdBElZPNY3tuBmlDMMM2rNYsakuiTq+SjdIOSZQr1vpnWD88tKOW4gqM4HGp647hhgKZIE80YIkeJ2hvTQnYLiCW/6qEyEG20s= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com; spf=pass smtp.mailfrom=baylibre.com; dkim=pass (2048-bit key) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.b=Lf164Ph0; arc=none smtp.client-ip=209.85.128.54 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=baylibre.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=baylibre-com.20230601.gappssmtp.com header.i=@baylibre-com.20230601.gappssmtp.com header.b="Lf164Ph0" Received: by mail-wm1-f54.google.com with SMTP id 5b1f17b1804b1-43948021a45so20819575e9.1 for ; Fri, 14 Feb 2025 04:23:20 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20230601.gappssmtp.com; s=20230601; t=1739535799; x=1740140599; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=8wsvYUn1m2oa3GrMllWdEUhN26YtAgD7V53pe75Koy0=; b=Lf164Ph0151nUn4EIIEZMqIa9wnJ2VZ6dxPr8nc7fe4LqYQjnL1/GyUlZ1Xb5greAF rWA9MXOLkIokLJVHB3gvDdSZNK2FHoxZNJv+e1P8UwAJuZDfHr9O/uLIlguxnHWKJ2f5 NM6WYEkCOx5escV5s9ihTfA2+qvdiNhNrDKjsgn+kQkWOJuzP3MkYciqxomy4Ph1lv5+ BTy1GqI5TBVcBF4raytOXaWvgIYsiOHKOhzNZmRHgKS20giC+FvP2Td1Thlu52pDuAfX I9D4AoHBEANOlCNYQg6r8Aq5T3XoTEQkVmVMNRgIeqZiBkJ86sNtPv2L4o+PQIgRswXZ kXjQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1739535799; x=1740140599; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=8wsvYUn1m2oa3GrMllWdEUhN26YtAgD7V53pe75Koy0=; b=Fsh30u44cil7P5DgLEqbdZVIH4EQq2LSCZMC1EZVEjvGpWYJWHFJvYEbvLVKh9VrvL KxRowKhwxHPOtOHOMz9JbRXCGq8rnyvnMucyRqIF8aNwonSYfYBk06AMfKQflGxKMobn IJaJjNcShBYZySUDKTBzjE8jTFTPKUxanGUSrvikYXV2tjPEaXQVQn9qHmlteB5AZUn4 MICVbiKiIOKOTJ0FLXAdZabgucMODsILh05hg4jMSS8n4A5BJjGfaJLzRwwPJVziy49d iAdCu+h4f5/qSYKwb65houhXKZzb35AphzgjHlbpIw0leKYNA3yw+tNAMJpR7G3+r+cX HLxA== X-Forwarded-Encrypted: i=1; AJvYcCXtgw4eqQv7TGHsbGqJjfkcbEPS8gAQkWEeXqIJYz+Bb9nMZXWHMn9L9VzGXxSaujftIZp5l5ApoY9FyB8=@vger.kernel.org X-Gm-Message-State: AOJu0YxNgDfYpGdwcHrWHsQm3WtS2qT4/Qv0f7WPACvfifjvZ/2ArAym pprXUveZWCs0AV7Bu2dHiquEMdYcuSZuJIJbJ+w0dV5UNA78J/wwPgZxgQ+s+9c= X-Gm-Gg: ASbGncvyk+iFu59QPMLBeMv1MckU+6tLptZoOH/BhsbyAUFse6x4dnD2SCqxOyIgyOf 30f2gVMPY3OypxkUrqQuAa7rLuVvbHHu1CzQWKKZNLe8C3kBdDYX6ElroN2kewvcDUWIaMXxC9G hLpDzTl7zULrCiLF0UPQ/TYU6UR2ppXPb6Kp+0zMN1i+NC3PdPXTOYFneLtEAend2QiTf7R7jD6 PgavQP3YMcicynRhKfUMGautTSdd2hjK+nhXkBmlOv8kw3G3Pj9Q3aX1wtXPK6LB8CBUXKYfcOv KfP9/RL0WQ6UoFcIE9uSi/F5BHmxccbPYtMT0YsZs/JmgC02icSOtFh5b/AfOT4I+115pAnL X-Google-Smtp-Source: AGHT+IEDQWC5tiIRz+2R7TgH92zpBtRkZ3QohO4W65JuSWaGXT5oTXw9QVJsqMSAksmdsVyR8mmEPw== X-Received: by 2002:adf:f28d:0:b0:38d:d8b2:cf0a with SMTP id ffacd0b85a97d-38dea288854mr10774854f8f.31.1739535799285; Fri, 14 Feb 2025 04:23:19 -0800 (PST) Received: from [127.0.0.1] (amontpellier-556-1-148-206.w109-210.abo.wanadoo.fr. [109.210.4.206]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-38f259f7b68sm4424654f8f.85.2025.02.14.04.23.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 14 Feb 2025 04:23:18 -0800 (PST) From: Esteban Blanc Date: Fri, 14 Feb 2025 13:22:36 +0100 Subject: [PATCH v4 6/6] docs: iio: ad4030: add documentation 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: <20250214-eblanc-ad4630_v1-v4-6-135dd66cab6a@baylibre.com> References: <20250214-eblanc-ad4630_v1-v4-0-135dd66cab6a@baylibre.com> In-Reply-To: <20250214-eblanc-ad4630_v1-v4-0-135dd66cab6a@baylibre.com> To: Lars-Peter Clausen , Michael Hennerich , =?utf-8?q?Nuno_S=C3=A1?= , Jonathan Cameron , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Jonathan Corbet Cc: Michael Hennerich , linux-iio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org, Esteban Blanc X-Mailer: b4 0.14.2 This adds a new page to document how to use the ad4030 ADC driver Signed-off-by: Esteban Blanc --- Documentation/iio/ad4030.rst | 181 +++++++++++++++++++++++++++++++++++++++= ++++ Documentation/iio/index.rst | 1 + MAINTAINERS | 1 + 3 files changed, 183 insertions(+) diff --git a/Documentation/iio/ad4030.rst b/Documentation/iio/ad4030.rst new file mode 100644 index 0000000000000000000000000000000000000000..41ce5ca5c710c46a0995d1b127f= a1c10fca4c1eb --- /dev/null +++ b/Documentation/iio/ad4030.rst @@ -0,0 +1,181 @@ +.. SPDX-License-Identifier: GPL-2.0-only + +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D +AD4030 driver +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +ADC driver for Analog Devices Inc. AD4030 and similar devices. The module = name +is ``ad4030``. + + +Supported devices +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +The following chips are supported by this driver: + +* `AD4030-24 `_ +* `AD4032-24 `_ +* `AD4630-16 `_ +* `AD4630-24 `_ +* `AD4632-16 `_ +* `AD4632-24 `_ + +IIO channels +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +Each "hardware" channel as described in the datasheet is split in 2 IIO +channels: + +- One channel for the differential data +- One channel for the common byte. + +The possible IIO channels depending on the numbers of "hardware" channel a= re: + ++------------------------------------+------------------------------------+ +| 1 channel ADC | 2 channels ADC | ++=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+ +| - voltage0-voltage1 (differential) | - voltage0-voltage1 (differential) | +| - voltage2 (common-mode) | - voltage2-voltage3 (differential) | +| | - voltage4 (common-mode) | +| | - voltage5 (common-mode) | ++------------------------------------+------------------------------------+ + +Labels +------ + +For ease of use, the IIO channels provide a label. For a differential chan= nel, +the label is ``differentialN`` where ``N`` is the "hardware" channel id. F= or a +common-mode channel, the label is ``common-modeN`` where ``N`` is the +"hardware" channel id. + +The possible labels are: + ++-----------------+-----------------+ +| 1 channel ADC | 2 channels ADC | ++=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+ +| - differential0 | - differential0 | +| - common-mode0 | - differential1 | +| | - common-mode0 | +| | - common-mode1 | ++-----------------+-----------------+ + +Supported features +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +SPI wiring modes +---------------- + +The driver currently supports the following SPI wiring configurations: + +One lane mode +^^^^^^^^^^^^^ + +In this mode, each channel has its own SDO line to send the conversion res= ults. +At the moment this mode can only be used on AD4030 which has one channel s= o only +one SDO line is used. + +.. code-block:: + + +-------------+ +-------------+ + | ADC | | HOST | + | | | | + | CNV |<--------| CNV | + | CS |<--------| CS | + | SDI |<--------| SDO | + | SDO0 |-------->| SDI | + | SCLK |<--------| SCLK | + +-------------+ +-------------+ + +Interleaved mode +^^^^^^^^^^^^^^^^ + +In this mode, both channels conversion results are bit interleaved one SDO= line. +As such the wiring is the same as `One lane mode`_. + +SPI Clock mode +-------------- + +Only the SPI clocking mode is supported. + +Output modes +------------ + +There are more exposed IIO channels than channels as describe in the devic= es +datasheet. This is due to the `Differential data + common-mode`_ encoding +2 types of information in one conversion result. As such a "device" channel +provides 2 IIO channels, one for the differential data and one for the com= mon +byte. + +Differential data +^^^^^^^^^^^^^^^^^ + +This mode is selected when: + +- Only differential channels are enabled in a buffered read +- Oversampling attribute is set to 1 + +Differential data + common-mode +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This mode is selected when: + +- Differential and common-mode channels are enabled in a buffered read +- Oversampling attribute is set to 1 + +For the 24-bits chips, this mode is also available with 16-bits differenti= al +data but is not selectable yet. + +Averaged differential data +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +This mode is selected when: + +- Only differential channels are selected enabled in a buffered read +- Oversampling attribute is greater than 1 + +Digital Gain and Offset +----------------------- + +Each differential data channel has a 16-bits unsigned configurable hardware +gain applied to it. By default it's equal to 1. Note that applying gain can +cause numerical saturation. + +Each differential data channel has a signed configurable hardware offset. +For the ADCs ending in ``-24``, the gain is encoded on 24-bits. +Likewise, the ADCs ending in ``-16`` have a gain encoded on 16-bits. Note = that +applying an offset can cause numerical saturation. + +The final differential data returned by the ADC is computed by first apply= ing +the gain, then the offset. + +The gain is controlled by the ``calibscale`` IIO attribute while the offse= t is +controlled by the ``calibbias`` attribute. + +Reference voltage +----------------- + +The chip supports an external reference voltage via the ``REF`` input or an +internal buffered reference voltage via the ``REFIN`` input. The driver lo= oks +at the device tree to determine which is being used. If ``ref-supply`` is +present, then the external reference voltage is used and the internal buff= er is +disabled. If ``refin-supply`` is present, then the internal buffered refer= ence +voltage is used. + +Reset +----- + +Both hardware and software reset are supported. The driver looks first at = the +device tree to see if the ``reset-gpio`` is populated. +If not present, the driver will fallback to a software reset by wiring to = the +device's registers. + +Unimplemented features +---------------------- + +- ``BUSY`` indication +- Additional wiring modes +- Additional clock modes +- Differential data 16-bits + common-mode for 24-bits chips +- Overrange events +- Test patterns + diff --git a/Documentation/iio/index.rst b/Documentation/iio/index.rst index 5710f5b9e9582befb6dfa9d72c4fae8cae8ddeb7..2d334be2b7f29a82916a03d808b= c0cb38e5a2252 100644 --- a/Documentation/iio/index.rst +++ b/Documentation/iio/index.rst @@ -19,6 +19,7 @@ Industrial I/O Kernel Drivers :maxdepth: 1 =20 ad4000 + ad4030 ad4695 ad7380 ad7606 diff --git a/MAINTAINERS b/MAINTAINERS index bfb739c2f5f4ef9182c9789c797e63a93ab08080..364cfc6e8cc6f99b32319e5344c= 66b2b578bc5d5 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1314,6 +1314,7 @@ L: linux-iio@vger.kernel.org S: Supported W: https://ez.analog.com/linux-software-drivers F: Documentation/devicetree/bindings/iio/adc/adi,ad4030.yaml +F: Documentation/iio/ad4030.rst F: drivers/iio/adc/ad4030.c =20 ANALOG DEVICES INC AD4130 DRIVER --=20 2.47.2