lkml.org 
[lkml]   [2022]   [Sep]   [26]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    From
    Subject[PATCH v6 0/5] Add support for Counter array components
    Date
    Changes in v6:
    - Rebase on latest counter-next branch
    - Add ABI Documentation lines for capture_component_id and
    polarity_component_id

    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.

    Eight Counter array component macros are introduced::

    DEFINE_COUNTER_ARRAY_U64(_name, _length)
    DEFINE_COUNTER_ARRAY_CAPTURE(_name, _length)
    DEFINE_COUNTER_ARRAY_POLARITY(_name, _enums, _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_CAPTURE(_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_CAPTURE(foobar_capture_array, 4);
    COUNTER_COMP_ARRAY_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.

    In addition, this patchset introduces the Signal polarity component,
    which represents the active level of a respective Signal. There are two
    possible states: positive (rising edge) and negative (falling edge). The
    104-quad-8 driver is updated to expose its index_polarity functionality
    via this new polarity component.

    Counter arrays for polarity elements can be defined in a similar
    manner as u64 elements::

    const enum counter_signal_polarity foobar_polarity_states[] = {
    COUNTER_SIGNAL_POLARITY_POSITIVE,
    COUNTER_SIGNAL_POLARITY_NEGATIVE,
    };
    DEFINE_COUNTER_ARRAY_POLARITY(foobar_polarity_array,
    foobar_polarity_states, 4);
    COUNTER_COMP_ARRAY_POLARITY(foobar_polarity_read,
    foobar_polarity_write,
    foobar_polarity_array)

    The only component types supported for Counter arrays currently are
    COUNTER_COMP_U64 and COUNTER_COMP_SIGNAL_POLARITY.

    William Breathitt Gray (5):
    counter: Introduce the Signal polarity component
    counter: 104-quad-8: Add Signal polarity component
    counter: Introduce the Count capture component
    counter: Consolidate Counter extension sysfs attribute creation
    counter: Introduce the COUNTER_COMP_ARRAY component type

    Documentation/ABI/testing/sysfs-bus-counter | 21 ++
    drivers/counter/104-quad-8.c | 35 +++
    drivers/counter/counter-chrdev.c | 135 +++++++--
    drivers/counter/counter-sysfs.c | 304 ++++++++++++++++----
    include/linux/counter.h | 147 ++++++++++
    include/uapi/linux/counter.h | 8 +
    6 files changed, 583 insertions(+), 67 deletions(-)


    base-commit: 7d333188e1d048457572d3a7d0630cd7b91f902d
    --
    2.37.3

    \
     
     \ /
      Last update: 2022-09-26 19:17    [W:8.827 / U:0.208 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site