From nobody Fri Apr 3 00:56:16 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2E216C32771 for ; Sun, 18 Sep 2022 14:37:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229786AbiIROhB (ORCPT ); Sun, 18 Sep 2022 10:37:01 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50068 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229813AbiIROgp (ORCPT ); Sun, 18 Sep 2022 10:36:45 -0400 Received: from mail-qk1-x734.google.com (mail-qk1-x734.google.com [IPv6:2607:f8b0:4864:20::734]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 56C70220EE for ; Sun, 18 Sep 2022 07:36:44 -0700 (PDT) Received: by mail-qk1-x734.google.com with SMTP id d15so18943638qka.9 for ; Sun, 18 Sep 2022 07:36:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=aFLFcX0Ge1NaS+vS/PtWRb3M+OHkdYHPDl97KJAqEJg=; b=WmQiztou3FCfn/Hz1KGe1HZ1abdjEdJxRWsNN54qdxJ+aCYDS2Gvb+rvhEUYqiZdev eO1vpCS8B2Sbfv3IaxaKVs3r3PSoRAguCWllD/u1EuSWT5alec7ec4DWcaanJcdoKyd1 Bw4/OGAtQtcx9YmAMgCj8Vs+K2kxu10QKvW0w87NhAXcB/U+yqayovcMF3IkZik+oYPb CaR6qD2CfcqbmLcl/CdW1wVQSLTLJwwv2/rD1uSfUGclvVu7Eg1jMzEoVLwG375QIEGF p7EerXK1ut/AthOy5fwLn1WKvnAdBe99mh59x3tY8WKnswLN5s8+y2PtOJaghwL9Ur85 x+XA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=aFLFcX0Ge1NaS+vS/PtWRb3M+OHkdYHPDl97KJAqEJg=; b=tYIrJmBy8Xfe3ChIKZu/TisrZqK42zfC9mHFjlC9AwGPAWpkeCwfLDL4oHl3TnkU8b EJtjk/SHM6cwUqppUiIZpHwy91DlcC3KXFD5a/5mEbekq96gFc6c09uhhba0ikwwMv2+ NemCiUtX4GWrIa3CtOrlyggA5ryBZax2tN234dzT1Jq3XqVk2HZJDwAqXfhAj21U6a5N 6H/7mhiC/Jp3bn1YiBDlSofyK6RqUNqWrv0TpzMxIacP+kwCmUDK5AIBrOfyAJS57gP7 DX+50Xz0Pk0EkJaQCSRRweYyUq3Dw4AGvKEmkxffo4qyXLG56A6yWl4oS2/4JZiq4Jcw Kg7Q== X-Gm-Message-State: ACrzQf0Rm4SwcA9ezgi04A1v9gCVP+mGXzlXKP2j7wSUfl3bx8ZN2bND rVmLARalJDuArF061fVHuQk/gYcc57CBRw== X-Google-Smtp-Source: AMsMyM64Fbn0DNezINL7uBn/WUKg37RK5a4t1KOiMSSRJhl3qjD+05cUsHM3QMSmlODukfBEHyxmdw== X-Received: by 2002:a05:620a:280b:b0:6b6:5a6c:9acf with SMTP id f11-20020a05620a280b00b006b65a6c9acfmr10086348qkp.749.1663511803455; Sun, 18 Sep 2022 07:36:43 -0700 (PDT) Received: from fedora.attlocal.net (69-109-179-158.lightspeed.dybhfl.sbcglobal.net. [69.109.179.158]) by smtp.gmail.com with ESMTPSA id q31-20020a05620a2a5f00b006bb0e5ca4bbsm11456215qkp.85.2022.09.18.07.36.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 18 Sep 2022 07:36:43 -0700 (PDT) From: William Breathitt Gray To: linux-iio@vger.kernel.org Cc: linux-kernel@vger.kernel.org, mranostay@ti.com, jpanis@baylibre.com, gwendal@chromium.org, bleung@chromium.org, groeck@chromium.org, jic23@kernel.org, david@lechnology.com, robertcnelson@gmail.com, William Breathitt Gray Subject: [PATCH v3 1/4] counter: Introduce the Signal polarity component Date: Sun, 18 Sep 2022 10:36:31 -0400 Message-Id: X-Mailer: git-send-email 2.37.3 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" The Signal polarity component represents the active level of a respective Signal. There are two possible states: positive (rising edge) and negative (falling edge); enum counter_signal_polarity represents these states. A convenience macro COUNTER_COMP_POLARITY() is provided for driver authors to declare a Signal polarity component. Cc: Julien Panis Signed-off-by: William Breathitt Gray --- Documentation/ABI/testing/sysfs-bus-counter | 13 +++++++++++++ drivers/counter/counter-sysfs.c | 11 +++++++++++ include/linux/counter.h | 10 ++++++++++ include/uapi/linux/counter.h | 6 ++++++ 4 files changed, 40 insertions(+) diff --git a/Documentation/ABI/testing/sysfs-bus-counter b/Documentation/AB= I/testing/sysfs-bus-counter index 06c2b3e27e0b..a234022f9add 100644 --- a/Documentation/ABI/testing/sysfs-bus-counter +++ b/Documentation/ABI/testing/sysfs-bus-counter @@ -303,6 +303,19 @@ Description: Discrete set of available values for the respective Signal Y configuration are listed in this file. =20 +What: /sys/bus/counter/devices/counterX/signalY/polarity +KernelVersion: 6.1 +Contact: linux-iio@vger.kernel.org +Description: + Active level of Signal Y. The following polarity values are + available: + + positive: + Signal high state considered active level (rising edge). + + negative: + Signal low state considered active level (falling edge). + What: /sys/bus/counter/devices/counterX/signalY/name KernelVersion: 5.2 Contact: linux-iio@vger.kernel.org diff --git a/drivers/counter/counter-sysfs.c b/drivers/counter/counter-sysf= s.c index 04eac41dad33..92d3d4f549cb 100644 --- a/drivers/counter/counter-sysfs.c +++ b/drivers/counter/counter-sysfs.c @@ -91,6 +91,11 @@ static const char *const counter_count_mode_str[] =3D { [COUNTER_COUNT_MODE_MODULO_N] =3D "modulo-n" }; =20 +static const char *const counter_signal_polarity_str[] =3D { + [COUNTER_SIGNAL_POLARITY_POSITIVE] =3D "positive", + [COUNTER_SIGNAL_POLARITY_NEGATIVE] =3D "negative" +}; + static ssize_t counter_comp_u8_show(struct device *dev, struct device_attribute *attr, char *buf) { @@ -201,6 +206,8 @@ static ssize_t counter_comp_u32_show(struct device *dev, return sysfs_emit(buf, "%s\n", counter_count_direction_str[data]); case COUNTER_COMP_COUNT_MODE: return sysfs_emit(buf, "%s\n", counter_count_mode_str[data]); + case COUNTER_COMP_SIGNAL_POLARITY: + return sysfs_emit(buf, "%s\n", counter_signal_polarity_str[data]); default: return sysfs_emit(buf, "%u\n", (unsigned int)data); } @@ -252,6 +259,10 @@ static ssize_t counter_comp_u32_store(struct device *d= ev, err =3D counter_find_enum(&data, avail->enums, avail->num_items, buf, counter_count_mode_str); break; + case COUNTER_COMP_SIGNAL_POLARITY: + err =3D counter_find_enum(&data, avail->enums, avail->num_items, + buf, counter_signal_polarity_str); + break; default: err =3D kstrtou32(buf, 0, &data); break; diff --git a/include/linux/counter.h b/include/linux/counter.h index 1fe17f5adb09..d508b260aaca 100644 --- a/include/linux/counter.h +++ b/include/linux/counter.h @@ -31,6 +31,7 @@ enum counter_comp_type { COUNTER_COMP_ENUM, COUNTER_COMP_COUNT_DIRECTION, COUNTER_COMP_COUNT_MODE, + COUNTER_COMP_SIGNAL_POLARITY, }; =20 /** @@ -483,4 +484,13 @@ struct counter_available { #define COUNTER_COMP_PRESET_ENABLE(_read, _write) \ COUNTER_COMP_COUNT_BOOL("preset_enable", _read, _write) =20 +#define COUNTER_COMP_POLARITY(_read, _write, _available) \ +{ \ + .type =3D COUNTER_COMP_SIGNAL_POLARITY, \ + .name =3D "polarity", \ + .signal_u32_read =3D (_read), \ + .signal_u32_write =3D (_write), \ + .priv =3D &(_available), \ +} + #endif /* _COUNTER_H_ */ diff --git a/include/uapi/linux/counter.h b/include/uapi/linux/counter.h index 96c5ffd368ad..e9610e1944dc 100644 --- a/include/uapi/linux/counter.h +++ b/include/uapi/linux/counter.h @@ -153,4 +153,10 @@ enum counter_synapse_action { COUNTER_SYNAPSE_ACTION_BOTH_EDGES, }; =20 +/* Signal polarity values */ +enum counter_signal_polarity { + COUNTER_SIGNAL_POLARITY_POSITIVE, + COUNTER_SIGNAL_POLARITY_NEGATIVE, +}; + #endif /* _UAPI_COUNTER_H_ */ --=20 2.37.3 From nobody Fri Apr 3 00:56:16 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 13109C54EE9 for ; Sun, 18 Sep 2022 14:37:11 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229910AbiIROhH (ORCPT ); Sun, 18 Sep 2022 10:37:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49930 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229806AbiIROgq (ORCPT ); Sun, 18 Sep 2022 10:36:46 -0400 Received: from mail-qt1-x836.google.com (mail-qt1-x836.google.com [IPv6:2607:f8b0:4864:20::836]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4F19D13D1A for ; Sun, 18 Sep 2022 07:36:45 -0700 (PDT) Received: by mail-qt1-x836.google.com with SMTP id g12so18695926qts.1 for ; Sun, 18 Sep 2022 07:36:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=WopcYcPly2clGQMko18Z5Oo2qU5OZoDnJ7KQZMk3xww=; b=tI4tD8RPl2oob7yS7B2rTMvy9BfpBPxt26bpNWOxmk+Jxjv5UZ5hKkeNKeA1JlCBmS RaWvy44lCyTBVEd4mqV0UPYBPkvY93OXsfhRtnJbrrRnWK3XXUPQjdWNELgZoLj4MNSY /U7qo6P3YmsZZM1upYOGWKrdVK4aNPsveS0vq6qocF/DN98h1Y/09NwK5fYr7I1kzLTC kb0LfPNejxd/oWertlmtVAVO54vSGSDgj9W89MhienXl9HJ54FGWA/LQ1obCBVAuuSyS dxbMCIQOtWxltwgc1CuHSy3irsOpWWMVVGtPoraVi8q777s5Z4oLo9JEKOIGrxjWMJn/ idiw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=WopcYcPly2clGQMko18Z5Oo2qU5OZoDnJ7KQZMk3xww=; b=jzBlJbieESqVaoDLnVZO8l5ipm6RTDf7rt8iVbTkH5FZZSVYKPbs4rK49dmrfi+Fmv f6uvTP8OUDkDgaBH4ODDFYflHmlLFFvSlBwnTv/V/T+mHMplv8lx4O2+7YJIyIJnS6YD ZqjLQLM1dmHHo9q1O3bXJoHIWJrzuYW0pW9jFvOBh3EVUI2RrTILUONACp0O7ZgE3K+F eo7AgUCkNUlB7fCyY10pdNhR2XlTorfpv/5YxlOZ4w/pdSpFU0hQmc7e3TAHep99np8M 0RPWsQ8hHSzzd6TKlVrVIRFlswS8NHhZd8xpN0eboWwzBUwN5ZnCTkDfSXmnax7onoJH d6fQ== X-Gm-Message-State: ACrzQf3UZ9H9JWzySLCxsDp9gt8bjOnPaxvBBD2t1RYuvQUn3zBWkphc Dsn0i478aNpoPj8XIwds2Axnqg== X-Google-Smtp-Source: AMsMyM5MBRfQkd6UUPXXffWdULTSWQ473xld1ESHt0BdfxXuh39fdB8/vqoCgjcWZN0WiAc1Vy/PeA== X-Received: by 2002:ac8:7d0a:0:b0:35c:be89:fd65 with SMTP id g10-20020ac87d0a000000b0035cbe89fd65mr11847663qtb.99.1663511804373; Sun, 18 Sep 2022 07:36:44 -0700 (PDT) Received: from fedora.attlocal.net (69-109-179-158.lightspeed.dybhfl.sbcglobal.net. [69.109.179.158]) by smtp.gmail.com with ESMTPSA id q31-20020a05620a2a5f00b006bb0e5ca4bbsm11456215qkp.85.2022.09.18.07.36.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 18 Sep 2022 07:36:44 -0700 (PDT) From: William Breathitt Gray To: linux-iio@vger.kernel.org Cc: linux-kernel@vger.kernel.org, mranostay@ti.com, jpanis@baylibre.com, gwendal@chromium.org, bleung@chromium.org, groeck@chromium.org, jic23@kernel.org, david@lechnology.com, robertcnelson@gmail.com, William Breathitt Gray Subject: [PATCH v3 2/4] counter: 104-quad-8: Add Signal polarity component Date: Sun, 18 Sep 2022 10:36:32 -0400 Message-Id: <574b16ebbf993abbe9bcf1833e2cf74098486258.1663511054.git.william.gray@linaro.org> X-Mailer: git-send-email 2.37.3 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" The 104-quad-8 driver provides support for Index signal polarity modes via the "index_polarity" Signal component. This patch exposes the same functionality through the more standard "polarity" Signal component. Signed-off-by: William Breathitt Gray --- drivers/counter/104-quad-8.c | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/drivers/counter/104-quad-8.c b/drivers/counter/104-quad-8.c index 1323edfbe40c..2a9d8259ed4b 100644 --- a/drivers/counter/104-quad-8.c +++ b/drivers/counter/104-quad-8.c @@ -549,6 +549,32 @@ static int quad8_index_polarity_set(struct counter_dev= ice *counter, return 0; } =20 +static int quad8_polarity_read(struct counter_device *counter, + struct counter_signal *signal, + enum counter_signal_polarity *polarity) +{ + int err; + u32 index_polarity; + + err =3D quad8_index_polarity_get(counter, signal, &index_polarity); + if (err) + return err; + + *polarity =3D (index_polarity) ? COUNTER_SIGNAL_POLARITY_POSITIVE : + COUNTER_SIGNAL_POLARITY_NEGATIVE; + + return 0; +} + +static int quad8_polarity_write(struct counter_device *counter, + struct counter_signal *signal, + enum counter_signal_polarity polarity) +{ + const u32 pol =3D (polarity =3D=3D COUNTER_SIGNAL_POLARITY_POSITIVE) ? 1 = : 0; + + return quad8_index_polarity_set(counter, signal, pol); +} + static const char *const quad8_synchronous_modes[] =3D { "non-synchronous", "synchronous" @@ -977,6 +1003,13 @@ static struct counter_comp quad8_signal_ext[] =3D { quad8_signal_fck_prescaler_write) }; =20 +static const enum counter_signal_polarity quad8_polarities[] =3D { + COUNTER_SIGNAL_POLARITY_POSITIVE, + COUNTER_SIGNAL_POLARITY_NEGATIVE, +}; + +static DEFINE_COUNTER_AVAILABLE(quad8_polarity_available, quad8_polarities= ); + static DEFINE_COUNTER_ENUM(quad8_index_pol_enum, quad8_index_polarity_mode= s); static DEFINE_COUNTER_ENUM(quad8_synch_mode_enum, quad8_synchronous_modes); =20 @@ -984,6 +1017,8 @@ static struct counter_comp quad8_index_ext[] =3D { COUNTER_COMP_SIGNAL_ENUM("index_polarity", quad8_index_polarity_get, quad8_index_polarity_set, quad8_index_pol_enum), + COUNTER_COMP_POLARITY(quad8_polarity_read, quad8_polarity_write, + quad8_polarity_available), COUNTER_COMP_SIGNAL_ENUM("synchronous_mode", quad8_synchronous_mode_get, quad8_synchronous_mode_set, quad8_synch_mode_enum), --=20 2.37.3 From nobody Fri Apr 3 00:56:16 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 57EEDC54EE9 for ; Sun, 18 Sep 2022 14:37:17 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229896AbiIROhO (ORCPT ); Sun, 18 Sep 2022 10:37:14 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49888 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229825AbiIROgs (ORCPT ); Sun, 18 Sep 2022 10:36:48 -0400 Received: from mail-qk1-x732.google.com (mail-qk1-x732.google.com [IPv6:2607:f8b0:4864:20::732]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 58C25220EC for ; Sun, 18 Sep 2022 07:36:46 -0700 (PDT) Received: by mail-qk1-x732.google.com with SMTP id 3so18565051qka.5 for ; Sun, 18 Sep 2022 07:36:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=u9zxwUyjTnHb6dXIFQytfA/XLHMka2VsioSd5KiJT2E=; b=RY2Mr3NDbqAgsjX3zKMzgwQjcbJ72qukf8T92w9gtIFCtbkwlRlkaXaPVmEcz3hgRE cFwJ3ed38oAz2AC0a2DjY3BAzdNj4OXNDY4iuFyJNxwC7NxmlOpcJcFZ5SQr7GpIkUQJ XL11dqieC0VWaPPC/wKCTivFfnaPWl6CwDpNFLUVz2GKqmr5COcWESV6ENYAhzlzgqVC wA/6l400tjUBURU4+BGZ87Dpg5oo7OGLErGMgBVvVlURnfRxWERv8HH+zKFIl5hBhbVg j7Hj+oFVgGvFKDh7AACiVqY+WGkx9vgXrDGTLXgGL2XMySFW8zPXj5HjgrkekYtKutf4 ouWQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=u9zxwUyjTnHb6dXIFQytfA/XLHMka2VsioSd5KiJT2E=; b=TDSQpmpPcC3CDrCZ7OAMZezjDv6ZmVP8gMLZLN1Bhn+jMOByHnG2HGkczc5C9q+HCz ZRBRQ5EhBanU+yTe3UYk5ycblIQybuaAtZ1JatbK3kDBNK43QJBnlHSvxgWrv1nx8iKf 2f8OG1pRVZo1lLsgE88qmY1xTk8zNI+e13EOyMjivEnz183YEofAWhJk+2ZBkCyOKcyn rjDuyA/7u9lT2mmgSskrwLmsDG48ERh5cMh1QVRPEG3206nibQN+IXeWDLZf3EkgkaQX MA25CZhLqbQ64xI7MFS8RSilLVAYrpfP2pu+7fAeAegusiL04mCUyoRHBMfnqR72pJ+l 8Mvw== X-Gm-Message-State: ACrzQf3WN7ROssQbRdaFEE1j+oc2xPQp20vqESBJAV+C/WbH/gJkpSMu NodNMBplu+RT/dBZF1/B0Haxsg== X-Google-Smtp-Source: AMsMyM6HllhhFSEheppcL+yu/C1Uoet8wvrjV8iLcVLIyoJRks+syjJK/GNqjbyUW8i0odyAE2ZxgA== X-Received: by 2002:ae9:f302:0:b0:6bc:c42:e80d with SMTP id p2-20020ae9f302000000b006bc0c42e80dmr10389336qkg.426.1663511805488; Sun, 18 Sep 2022 07:36:45 -0700 (PDT) Received: from fedora.attlocal.net (69-109-179-158.lightspeed.dybhfl.sbcglobal.net. [69.109.179.158]) by smtp.gmail.com with ESMTPSA id q31-20020a05620a2a5f00b006bb0e5ca4bbsm11456215qkp.85.2022.09.18.07.36.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 18 Sep 2022 07:36:45 -0700 (PDT) From: William Breathitt Gray To: linux-iio@vger.kernel.org Cc: linux-kernel@vger.kernel.org, mranostay@ti.com, jpanis@baylibre.com, gwendal@chromium.org, bleung@chromium.org, groeck@chromium.org, jic23@kernel.org, david@lechnology.com, robertcnelson@gmail.com, William Breathitt Gray Subject: [PATCH v3 3/4] counter: Consolidate Counter extension sysfs attribute creation Date: Sun, 18 Sep 2022 10:36:33 -0400 Message-Id: <8c508570e1a2accc0d55abcae4cd508883952ec8.1663511054.git.william.gray@linaro.org> X-Mailer: git-send-email 2.37.3 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Counter extensions are handled for the Device, Counts, and Signals. The code loops through each Counter extension and creates the expected sysfs attributes. This patch consolidates that code into functions to reduce redundancy and make the intention of the code clearer. Signed-off-by: William Breathitt Gray --- drivers/counter/counter-sysfs.c | 98 ++++++++++++++++----------------- 1 file changed, 49 insertions(+), 49 deletions(-) diff --git a/drivers/counter/counter-sysfs.c b/drivers/counter/counter-sysf= s.c index 92d3d4f549cb..7ce7c51395da 100644 --- a/drivers/counter/counter-sysfs.c +++ b/drivers/counter/counter-sysfs.c @@ -591,6 +591,46 @@ static int counter_comp_id_attr_create(struct device *= const dev, return 0; } =20 +static int counter_ext_attrs_create(struct device *const dev, + struct counter_attribute_group *const group, + const struct counter_comp *const ext, + const enum counter_scope scope, + void *const parent, const size_t id) +{ + int err; + + /* Create main extension attribute */ + err =3D counter_attr_create(dev, group, ext, scope, parent); + if (err < 0) + return err; + + /* Create extension id attribute */ + return counter_comp_id_attr_create(dev, group, ext->name, id); +} + +static int counter_sysfs_exts_add(struct device *const dev, + struct counter_attribute_group *const group, + const struct counter_comp *const exts, + const size_t num_ext, + const enum counter_scope scope, + void *const parent) +{ + size_t i; + const struct counter_comp *ext; + int err; + + /* Create attributes for each extension */ + for (i =3D 0; i < num_ext; i++) { + ext =3D &exts[i]; + err =3D counter_ext_attrs_create(dev, group, ext, scope, parent, + i); + if (err < 0) + return err; + } + + return 0; +} + static struct counter_comp counter_signal_comp =3D { .type =3D COUNTER_COMP_SIGNAL_LEVEL, .name =3D "signal", @@ -604,8 +644,6 @@ static int counter_signal_attrs_create(struct counter_d= evice *const counter, struct device *const dev =3D &counter->dev; int err; struct counter_comp comp; - size_t i; - struct counter_comp *ext; =20 /* Create main Signal attribute */ comp =3D counter_signal_comp; @@ -619,21 +657,9 @@ static int counter_signal_attrs_create(struct counter_= device *const counter, if (err < 0) return err; =20 - /* Create an attribute for each extension */ - for (i =3D 0; i < signal->num_ext; i++) { - ext =3D &signal->ext[i]; - - err =3D counter_attr_create(dev, cattr_group, ext, scope, signal); - if (err < 0) - return err; - - err =3D counter_comp_id_attr_create(dev, cattr_group, ext->name, - i); - if (err < 0) - return err; - } - - return 0; + /* Add Signal extensions */ + return counter_sysfs_exts_add(dev, cattr_group, signal->ext, + signal->num_ext, scope, signal); } =20 static int counter_sysfs_signals_add(struct counter_device *const counter, @@ -718,8 +744,6 @@ static int counter_count_attrs_create(struct counter_de= vice *const counter, struct device *const dev =3D &counter->dev; int err; struct counter_comp comp; - size_t i; - struct counter_comp *ext; =20 /* Create main Count attribute */ comp =3D counter_count_comp; @@ -742,21 +766,9 @@ static int counter_count_attrs_create(struct counter_d= evice *const counter, if (err < 0) return err; =20 - /* Create an attribute for each extension */ - for (i =3D 0; i < count->num_ext; i++) { - ext =3D &count->ext[i]; - - err =3D counter_attr_create(dev, cattr_group, ext, scope, count); - if (err < 0) - return err; - - err =3D counter_comp_id_attr_create(dev, cattr_group, ext->name, - i); - if (err < 0) - return err; - } - - return 0; + /* Add Count extensions */ + return counter_sysfs_exts_add(dev, cattr_group, count->ext, + count->num_ext, scope, count); } =20 static int counter_sysfs_counts_add(struct counter_device *const counter, @@ -849,8 +861,6 @@ static int counter_sysfs_attr_add(struct counter_device= *const counter, const enum counter_scope scope =3D COUNTER_SCOPE_DEVICE; struct device *const dev =3D &counter->dev; int err; - size_t i; - struct counter_comp *ext; =20 /* Add Signals sysfs attributes */ err =3D counter_sysfs_signals_add(counter, cattr_group); @@ -887,19 +897,9 @@ static int counter_sysfs_attr_add(struct counter_devic= e *const counter, if (err < 0) return err; =20 - /* Create an attribute for each extension */ - for (i =3D 0; i < counter->num_ext; i++) { - ext =3D &counter->ext[i]; - - err =3D counter_attr_create(dev, cattr_group, ext, scope, NULL); - if (err < 0) - return err; - - err =3D counter_comp_id_attr_create(dev, cattr_group, ext->name, - i); - if (err < 0) - return err; - } + /* Add device extensions */ + return counter_sysfs_exts_add(dev, cattr_group, counter->ext, + counter->num_ext, scope, NULL); =20 return 0; } --=20 2.37.3 From nobody Fri Apr 3 00:56:16 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A92D5C32771 for ; Sun, 18 Sep 2022 14:37:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229938AbiIROhU (ORCPT ); Sun, 18 Sep 2022 10:37:20 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50030 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229663AbiIROgt (ORCPT ); Sun, 18 Sep 2022 10:36:49 -0400 Received: from mail-qt1-x830.google.com (mail-qt1-x830.google.com [IPv6:2607:f8b0:4864:20::830]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8CA4A2228A for ; Sun, 18 Sep 2022 07:36:47 -0700 (PDT) Received: by mail-qt1-x830.google.com with SMTP id b23so14160003qtr.13 for ; Sun, 18 Sep 2022 07:36:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=4Rdbej+Tr/VL/OYqsQQt/1Yt/tgK3Owp5JGl6pjmHEk=; b=UPtI5j/wpWia7Q4ejaldlklc3+zGIxOd2ieiJ71vJE2dL3AG/gp6qX2FRMa6EjGXsR 13mCOh/wR0UaoYP8cpN3R/FMon/m3IBPrOVS8oLBZ9lDWw1a/Bmu7gdwE4N/1jSwfIn+ JnF+FjlUmMmp+plbBdeKeutAW6dUN4sfPc7MPiZ5FrUyfvWGYt9+m9RAoM+qZ6vhii3p 3q7ME7BY/hXWH4+n6OzSYdRDnSF0ErbgEuAzNlBtI9H+xtKQQFRLGGYuM6SRlySf5Qmz hV/gltlorbJO+t/GPSZ4UeAzLPrbrHUlnjUZ3FsvQC4M5s9cM5QSwiQKbL73SVte/9Tg xcfA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=4Rdbej+Tr/VL/OYqsQQt/1Yt/tgK3Owp5JGl6pjmHEk=; b=A4j8U2RoSePZP7FEy/Kt66zLsMUduPNXEJLhUkKEQqx8NLg1ryNpIy+ed4tJSG7b7c GACoqiOb8Ecq6gr0lbNx3A/FFOO06r+thXgDs8MbQJUpnVCSYAxXAL0fLTj+X5rqVUIl 7KkyUjxKeI88zzrdAyW70i9SNA374EKUCcI1epNmh/X5q7WDebFPiQeUv5cBVDyjV+2e DdcDB0+/ZhIiPm9/2UfqOB2OnuL5tzmBPB3GE9Gw+RZyhKadEwrCPXhhhnlbmGugO5Ib gDC/2dK3J+gXrnZ0jwqcMeIvKLS8XyoYY9jYlRQpXun5joV9RX7yHd8Q033FMBQbWOwa nVtw== X-Gm-Message-State: ACrzQf1HYZy0tNE5LfxOHNR4546o3/iMpGNWKuEeEMqFwtrutmrOTYMq gYrmKyzWYf5wmFjgnE7KbQqwPQ== X-Google-Smtp-Source: AMsMyM4ugUCSQ01XoKn5/WGgmLdv6CIV/cZwNMzJx9wTwsoXwvRvMhj8w4bCfYDf8k8jlIInUPXSyA== X-Received: by 2002:ac8:5789:0:b0:35c:c045:f22a with SMTP id v9-20020ac85789000000b0035cc045f22amr11366934qta.257.1663511806451; Sun, 18 Sep 2022 07:36:46 -0700 (PDT) Received: from fedora.attlocal.net (69-109-179-158.lightspeed.dybhfl.sbcglobal.net. [69.109.179.158]) by smtp.gmail.com with ESMTPSA id q31-20020a05620a2a5f00b006bb0e5ca4bbsm11456215qkp.85.2022.09.18.07.36.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 18 Sep 2022 07:36:46 -0700 (PDT) From: William Breathitt Gray To: linux-iio@vger.kernel.org Cc: linux-kernel@vger.kernel.org, mranostay@ti.com, jpanis@baylibre.com, gwendal@chromium.org, bleung@chromium.org, groeck@chromium.org, jic23@kernel.org, david@lechnology.com, robertcnelson@gmail.com, William Breathitt Gray Subject: [PATCH v3 4/4] counter: Introduce the COUNTER_COMP_ARRAY component type Date: Sun, 18 Sep 2022 10:36:34 -0400 Message-Id: X-Mailer: git-send-email 2.37.3 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" The COUNTER_COMP_ARRAY Counter component type is introduced to enable support for Counter array components. With Counter array components, exposure for buffers on counter devices can be defined via new Counter array component macros. This should simplify code for driver authors who would otherwise need to define individual Counter components for each array element. Five Counter array component macros are introduced:: DEFINE_COUNTER_ARRAY(_name, _type, _available, _length) COUNTER_COMP_DEVICE_ARRAY_U64(_name, _read, _write, _array) COUNTER_COMP_COUNT_ARRAY_U64(_name, _read, _write, _array) COUNTER_COMP_SIGNAL_ARRAY_U64(_name, _read, _write, _array) COUNTER_COMP_ARRAY_POLARITY(_read, _write, _array) Eight Counter array callbacks are introduced as well:: int (*signal_array_u32_read)(struct counter_device *counter, struct counter_signal *signal, size_t idx, u32 *val); int (*signal_array_u32_write)(struct counter_device *counter, struct counter_signal *signal, size_t idx, u32 val); int (*device_array_u64_read)(struct counter_device *counter, size_t idx, u64 *val); int (*count_array_u64_read)(struct counter_device *counter, struct counter_count *count, size_t idx, u64 *val); int (*signal_array_u64_read)(struct counter_device *counter, struct counter_signal *signal, size_t idx, u64 *val); int (*device_array_u64_write)(struct counter_device *counter, size_t idx, u64 val); int (*count_array_u64_write)(struct counter_device *counter, struct counter_count *count, size_t idx, u64 val); int (*signal_array_u64_write)(struct counter_device *counter, struct counter_signal *signal, size_t idx, u64 val); Driver authors can handle reads/writes for an array component by receiving an element index via the `idx` parameter and processing the respective value via the `val` parameter. For example, suppose a driver wants to expose a Count's read-only capture buffer of four elements using a callback `foobar_capture_read()`:: DEFINE_COUNTER_ARRAY(foobar_capture_array, COUNTER_COMP_U64, NULL, 4) COUNTER_COMP_COUNT_ARRAY_U64("capture", foobar_capture_read, NULL, foobar_capture_array) Respective sysfs attributes for each array element would appear for the respective Count: * /sys/bus/counter/devices/counterX/countY/capture0 * /sys/bus/counter/devices/counterX/countY/capture1 * /sys/bus/counter/devices/counterX/countY/capture2 * /sys/bus/counter/devices/counterX/countY/capture3 If a user tries to read _capture2_ for example, `idx` will be `2` when passed to the `foobar_capture_read()` callback, and thus the driver knows which array element to handle. Cc: Julien Panis Signed-off-by: William Breathitt Gray --- drivers/counter/counter-chrdev.c | 47 +++++++- drivers/counter/counter-sysfs.c | 198 ++++++++++++++++++++++++++++++- include/linux/counter.h | 121 +++++++++++++++++++ 3 files changed, 361 insertions(+), 5 deletions(-) diff --git a/drivers/counter/counter-chrdev.c b/drivers/counter/counter-chr= dev.c index 4e71a19d7e6a..8df0360b0277 100644 --- a/drivers/counter/counter-chrdev.c +++ b/drivers/counter/counter-chrdev.c @@ -451,11 +451,49 @@ void counter_chrdev_remove(struct counter_device *con= st counter) kfifo_free(&counter->events); } =20 +static int counter_get_array_data(struct counter_device *const counter, + const enum counter_scope scope, + void *const parent, + const struct counter_comp *const comp, + u64 *const value) +{ + const struct counter_array *const element =3D comp->priv; + u32 value_u32 =3D 0; + int ret; + + switch (element->type) { + case COUNTER_COMP_SIGNAL_POLARITY: + if (scope !=3D COUNTER_SCOPE_SIGNAL) + return -EINVAL; + ret =3D comp->signal_array_u32_read(counter, parent, element->idx, + &value_u32); + *value =3D value_u32; + return ret; + case COUNTER_COMP_U64: + switch (scope) { + case COUNTER_SCOPE_DEVICE: + return comp->device_array_u64_read(counter, + element->idx, value); + case COUNTER_SCOPE_SIGNAL: + return comp->signal_array_u64_read(counter, parent, + element->idx, value); + case COUNTER_SCOPE_COUNT: + return comp->count_array_u64_read(counter, parent, + element->idx, value); + default: + return -EINVAL; + } + default: + return -EINVAL; + } +} + static int counter_get_data(struct counter_device *const counter, const struct counter_comp_node *const comp_node, u64 *const value) { const struct counter_comp *const comp =3D &comp_node->comp; + const enum counter_scope scope =3D comp_node->component.scope; void *const parent =3D comp_node->parent; u8 value_u8 =3D 0; u32 value_u32 =3D 0; @@ -467,7 +505,7 @@ static int counter_get_data(struct counter_device *cons= t counter, switch (comp->type) { case COUNTER_COMP_U8: case COUNTER_COMP_BOOL: - switch (comp_node->component.scope) { + switch (scope) { case COUNTER_SCOPE_DEVICE: ret =3D comp->device_u8_read(counter, &value_u8); break; @@ -487,7 +525,7 @@ static int counter_get_data(struct counter_device *cons= t counter, case COUNTER_COMP_ENUM: case COUNTER_COMP_COUNT_DIRECTION: case COUNTER_COMP_COUNT_MODE: - switch (comp_node->component.scope) { + switch (scope) { case COUNTER_SCOPE_DEVICE: ret =3D comp->device_u32_read(counter, &value_u32); break; @@ -504,7 +542,7 @@ static int counter_get_data(struct counter_device *cons= t counter, *value =3D value_u32; return ret; case COUNTER_COMP_U64: - switch (comp_node->component.scope) { + switch (scope) { case COUNTER_SCOPE_DEVICE: return comp->device_u64_read(counter, value); case COUNTER_SCOPE_SIGNAL: @@ -519,6 +557,9 @@ static int counter_get_data(struct counter_device *cons= t counter, &value_u32); *value =3D value_u32; return ret; + case COUNTER_COMP_ARRAY: + return counter_get_array_data(counter, scope, parent, comp, + value); default: return -EINVAL; } diff --git a/drivers/counter/counter-sysfs.c b/drivers/counter/counter-sysf= s.c index 7ce7c51395da..f337c542a5b6 100644 --- a/drivers/counter/counter-sysfs.c +++ b/drivers/counter/counter-sysfs.c @@ -352,6 +352,124 @@ static ssize_t counter_comp_u64_store(struct device *= dev, return len; } =20 +static ssize_t counter_comp_array_u32_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + const struct counter_attribute *const a =3D to_counter_attribute(attr); + struct counter_device *const counter =3D counter_from_dev(dev); + const struct counter_array *const element =3D a->comp.priv; + int err; + u32 data =3D 0; + + if (a->scope !=3D COUNTER_SCOPE_SIGNAL || + element->type !=3D COUNTER_COMP_SIGNAL_POLARITY) + return -EINVAL; + + err =3D a->comp.signal_array_u32_read(counter, a->parent, element->idx, + &data); + if (err < 0) + return err; + + return sysfs_emit(buf, "%s\n", counter_signal_polarity_str[data]); +} + +static ssize_t counter_comp_array_u32_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t len) +{ + const struct counter_attribute *const a =3D to_counter_attribute(attr); + struct counter_device *const counter =3D counter_from_dev(dev); + const struct counter_array *const element =3D a->comp.priv; + int err; + u32 data =3D 0; + + if (element->type !=3D COUNTER_COMP_SIGNAL_POLARITY || + a->scope !=3D COUNTER_SCOPE_SIGNAL) + return -EINVAL; + + err =3D counter_find_enum(&data, element->avail->enums, + element->avail->num_items, buf, + counter_signal_polarity_str); + if (err < 0) + return err; + + err =3D a->comp.signal_array_u32_write(counter, a->parent, element->idx, + data); + if (err < 0) + return err; + + return len; +} + +static ssize_t counter_comp_array_u64_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + const struct counter_attribute *const a =3D to_counter_attribute(attr); + struct counter_device *const counter =3D counter_from_dev(dev); + const struct counter_array *const element =3D a->comp.priv; + int err; + u64 data =3D 0; + + switch (a->scope) { + case COUNTER_SCOPE_DEVICE: + err =3D a->comp.device_array_u64_read(counter, element->idx, + &data); + break; + case COUNTER_SCOPE_SIGNAL: + err =3D a->comp.signal_array_u64_read(counter, a->parent, + element->idx, &data); + break; + case COUNTER_SCOPE_COUNT: + err =3D a->comp.count_array_u64_read(counter, a->parent, + element->idx, &data); + break; + default: + return -EINVAL; + } + if (err < 0) + return err; + + return sysfs_emit(buf, "%llu\n", (unsigned long long)data); +} + +static ssize_t counter_comp_array_u64_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t len) +{ + const struct counter_attribute *const a =3D to_counter_attribute(attr); + struct counter_device *const counter =3D counter_from_dev(dev); + const struct counter_array *const element =3D a->comp.priv; + int err; + u64 data =3D 0; + + err =3D kstrtou64(buf, 0, &data); + if (err < 0) + return err; + + switch (a->scope) { + case COUNTER_SCOPE_DEVICE: + err =3D a->comp.device_array_u64_write(counter, element->idx, + data); + break; + case COUNTER_SCOPE_SIGNAL: + err =3D a->comp.signal_array_u64_write(counter, a->parent, + element->idx, data); + break; + case COUNTER_SCOPE_COUNT: + err =3D a->comp.count_array_u64_write(counter, a->parent, + element->idx, data); + break; + default: + return -EINVAL; + } + if (err < 0) + return err; + + return len; +} + static ssize_t enums_available_show(const u32 *const enums, const size_t num_enums, const char *const strs[], char *buf) @@ -446,6 +564,7 @@ static int counter_attr_create(struct device *const dev, const enum counter_scope scope, void *const parent) { + const struct counter_array *const array =3D comp->priv; struct counter_attribute *counter_attr; struct device_attribute *dev_attr; =20 @@ -499,6 +618,32 @@ static int counter_attr_create(struct device *const de= v, dev_attr->store =3D counter_comp_u64_store; } break; + case COUNTER_COMP_ARRAY: + switch (array->type) { + case COUNTER_COMP_SIGNAL_POLARITY: + if (comp->signal_array_u32_read) { + dev_attr->attr.mode |=3D 0444; + dev_attr->show =3D counter_comp_array_u32_show; + } + if (comp->signal_array_u32_write) { + dev_attr->attr.mode |=3D 0200; + dev_attr->store =3D counter_comp_array_u32_store; + } + break; + case COUNTER_COMP_U64: + if (comp->device_array_u64_read) { + dev_attr->attr.mode |=3D 0444; + dev_attr->show =3D counter_comp_array_u64_show; + } + if (comp->device_array_u64_write) { + dev_attr->attr.mode |=3D 0200; + dev_attr->store =3D counter_comp_array_u64_store; + } + break; + default: + return -EINVAL; + } + break; default: return -EINVAL; } @@ -608,6 +753,45 @@ static int counter_ext_attrs_create(struct device *con= st dev, return counter_comp_id_attr_create(dev, group, ext->name, id); } =20 +static int counter_array_attrs_create(struct device *const dev, + struct counter_attribute_group *const group, + const struct counter_comp *const comp, + const enum counter_scope scope, + void *const parent, const size_t id) +{ + const struct counter_array *const array =3D comp->priv; + struct counter_comp ext =3D *comp; + struct counter_array *element; + size_t idx; + int err; + + /* Create an attribute for each array element */ + for (idx =3D 0; idx < array->length; idx++) { + /* Generate array element attribute name */ + ext.name =3D devm_kasprintf(dev, GFP_KERNEL, "%s%zu", comp->name, + idx); + if (!ext.name) + return -ENOMEM; + + /* Allocate and configure array element */ + element =3D devm_kzalloc(dev, sizeof(*element), GFP_KERNEL); + if (!element) + return -ENOMEM; + element->type =3D array->type; + element->avail =3D array->avail; + element->idx =3D idx; + ext.priv =3D element; + + /* Create all attributes associated with the array element */ + err =3D counter_ext_attrs_create(dev, group, &ext, scope, parent, + id + idx); + if (err < 0) + return err; + } + + return 0; +} + static int counter_sysfs_exts_add(struct device *const dev, struct counter_attribute_group *const group, const struct counter_comp *const exts, @@ -618,12 +802,22 @@ static int counter_sysfs_exts_add(struct device *cons= t dev, size_t i; const struct counter_comp *ext; int err; + size_t id =3D 0; + const struct counter_array *array; =20 /* Create attributes for each extension */ for (i =3D 0; i < num_ext; i++) { ext =3D &exts[i]; - err =3D counter_ext_attrs_create(dev, group, ext, scope, parent, - i); + if (ext->type =3D=3D COUNTER_COMP_ARRAY) { + err =3D counter_array_attrs_create(dev, group, ext, scope, + parent, id); + array =3D ext->priv; + id +=3D array->length; + } else { + err =3D counter_ext_attrs_create(dev, group, ext, scope, + parent, id); + id++; + } if (err < 0) return err; } diff --git a/include/linux/counter.h b/include/linux/counter.h index d508b260aaca..61fe38e30626 100644 --- a/include/linux/counter.h +++ b/include/linux/counter.h @@ -32,6 +32,7 @@ enum counter_comp_type { COUNTER_COMP_COUNT_DIRECTION, COUNTER_COMP_COUNT_MODE, COUNTER_COMP_SIGNAL_POLARITY, + COUNTER_COMP_ARRAY, }; =20 /** @@ -69,6 +70,30 @@ enum counter_comp_type { * @signal_u64_read: Signal u64 component read callback. The read value of * the respective Signal u64 component should be passed * back via the val parameter. + * @signal_array_u32_read: Signal u32 array component read callback. The + * index of the respective Count u32 array + * component element is passed via the idx + * parameter. The read value of the respective + * Count u32 array component element should be + * passed back via the val parameter. + * @device_array_u64_read: Device u64 array component read callback. The + * index of the respective Device u64 array + * component element is passed via the idx + * parameter. The read value of the respective + * Device u64 array component element should be + * passed back via the val parameter. + * @count_array_u64_read: Count u64 array component read callback. The + * index of the respective Count u64 array + * component element is passed via the idx + * parameter. The read value of the respective + * Count u64 array component element should be + * passed back via the val parameter. + * @signal_array_u64_read: Signal u64 array component read callback. The + * index of the respective Count u64 array + * component element is passed via the idx + * parameter. The read value of the respective + * Count u64 array component element should be + * passed back via the val parameter. * @action_write: Synapse action mode write callback. The write value of * the respective Synapse action mode is passed via the * action parameter. @@ -99,6 +124,30 @@ enum counter_comp_type { * @signal_u64_write: Signal u64 component write callback. The write valu= e of * the respective Signal u64 component is passed via the * val parameter. + * @signal_array_u32_write: Signal u32 array component write callback. The + * index of the respective Signal u32 array + * component element is passed via the idx + * parameter. The write value of the respective + * Signal u32 array component element is passed via + * the val parameter. + * @device_array_u64_write: Device u64 array component write callback. The + * index of the respective Device u64 array + * component element is passed via the idx + * parameter. The write value of the respective + * Device u64 array component element is passed via + * the val parameter. + * @count_array_u64_write: Count u64 array component write callback. The + * index of the respective Count u64 array + * component element is passed via the idx + * parameter. The write value of the respective + * Count u64 array component element is passed via + * the val parameter. + * @signal_array_u64_write: Signal u64 array component write callback. The + * index of the respective Signal u64 array + * component element is passed via the idx + * parameter. The write value of the respective + * Signal u64 array component element is passed via + * the val parameter. */ struct counter_comp { enum counter_comp_type type; @@ -126,6 +175,17 @@ struct counter_comp { struct counter_count *count, u64 *val); int (*signal_u64_read)(struct counter_device *counter, struct counter_signal *signal, u64 *val); + int (*signal_array_u32_read)(struct counter_device *counter, + struct counter_signal *signal, + size_t idx, u32 *val); + int (*device_array_u64_read)(struct counter_device *counter, + size_t idx, u64 *val); + int (*count_array_u64_read)(struct counter_device *counter, + struct counter_count *count, + size_t idx, u64 *val); + int (*signal_array_u64_read)(struct counter_device *counter, + struct counter_signal *signal, + size_t idx, u64 *val); }; union { int (*action_write)(struct counter_device *counter, @@ -149,6 +209,17 @@ struct counter_comp { struct counter_count *count, u64 val); int (*signal_u64_write)(struct counter_device *counter, struct counter_signal *signal, u64 val); + int (*signal_array_u32_write)(struct counter_device *counter, + struct counter_signal *signal, + size_t idx, u32 val); + int (*device_array_u64_write)(struct counter_device *counter, + size_t idx, u64 val); + int (*count_array_u64_write)(struct counter_device *counter, + struct counter_count *count, + size_t idx, u64 val); + int (*signal_array_u64_write)(struct counter_device *counter, + struct counter_signal *signal, + size_t idx, u64 val); }; }; =20 @@ -453,6 +524,47 @@ struct counter_available { .priv =3D &(_available), \ } =20 +struct counter_array { + enum counter_comp_type type; + const struct counter_available *avail; + union { + size_t length; + size_t idx; + }; +}; + +#define DEFINE_COUNTER_ARRAY(_name, _type, _available, _length) \ + struct counter_array _name =3D { \ + .type =3D (_type), \ + .avail =3D &(_available), \ + .length =3D (_length), \ + } + +#define COUNTER_COMP_DEVICE_ARRAY_U64(_name, _read, _write, _array) \ +{ \ + .type =3D COUNTER_COMP_ARRAY, \ + .name =3D (_name), \ + .device_array_u64_read =3D (_read), \ + .device_array_u64_write =3D (_write), \ + .priv =3D &(_array), \ +} +#define COUNTER_COMP_COUNT_ARRAY_U64(_name, _read, _write, _array) \ +{ \ + .type =3D COUNTER_COMP_ARRAY, \ + .name =3D (_name), \ + .count_array_u64_read =3D (_read), \ + .count_array_u64_write =3D (_write), \ + .priv =3D &(_array), \ +} +#define COUNTER_COMP_SIGNAL_ARRAY_U64(_name, _read, _write, _array) \ +{ \ + .type =3D COUNTER_COMP_ARRAY, \ + .name =3D (_name), \ + .signal_array_u64_read =3D (_read), \ + .signal_array_u64_write =3D (_write), \ + .priv =3D &(_array), \ +} + #define COUNTER_COMP_CEILING(_read, _write) \ COUNTER_COMP_COUNT_U64("ceiling", _read, _write) =20 @@ -493,4 +605,13 @@ struct counter_available { .priv =3D &(_available), \ } =20 +#define COUNTER_COMP_ARRAY_POLARITY(_read, _write, _array) \ +{ \ + .type =3D COUNTER_COMP_ARRAY, \ + .name =3D "polarity", \ + .signal_array_u32_read =3D (_read), \ + .signal_array_u32_write =3D (_write), \ + .priv =3D &(_array), \ +} + #endif /* _COUNTER_H_ */ --=20 2.37.3