Over the past couple years we have noticed some shortcomings with the
Counter sysfs interface. Although useful in the majority of situations,
there are certain use-cases where interacting through sysfs attributes
can become cumbersome and inefficient. A desire to support more advanced
functionality such as timestamps, multi-axis positioning tables, and
other such latency-sensitive applications, has motivated a reevaluation
of the Counter subsystem. I believe a character device interface will be
helpful for this more niche area of counter device use.
To quell any concerns from the offset: this patchset makes no changes to
the existing Counter sysfs userspace interface -- existing userspace
applications will continue to work with no modifications necessary. I
request that driver maintainers please test their applications to verify
that this is true, and report any discrepancies if they arise.
However, this patchset does contain a major reimplementation of the
Counter subsystem core and driver API. A reimplementation was necessary
in order to separate the sysfs code from the counter device drivers and
internalize it as a dedicated component of the core Counter subsystem
module. A minor benefit from all of this is that the sysfs interface is
now ensured a certain amount of consistency because the translation is
performed outside of individual counter device drivers.
Essentially, the reimplementation has enabled counter device drivers to
pass and handle data as native C datatypes now rather than the sysfs
strings from before. A high-level view of how a count value is passed
down from a counter device driver can be exemplified by the following:
----------------------
/ Counter device \
+----------------------+
| Count register: 0x28 |
+----------------------+
|
-----------------
/ raw count data /
-----------------
|
V
+----------------------------+
| Counter device driver |----------+
+----------------------------+ |
| Processes data from device | -------------------
|----------------------------| / driver callbacks /
| Type: unsigned long | -------------------
| Value: 42 | |
+----------------------------+ |
| |
---------------- |
/ unsigned long / |
---------------- |
| |
| V
| +----------------------+
| | Counter core |
| +----------------------+
| | Routes device driver |
| | callbacks to the |
| | userspace interfaces |
| +----------------------+
| |
| -------------------
| / driver callbacks /
| -------------------
| |
+-------+---------------+ |
| | |
| +-------|-------+
| | |
V | V
+--------------------+ | +---------------------+
| Counter sysfs |<-+->| Counter chrdev |
+--------------------+ +---------------------+
| Translates to the | | Translates to the |
| standard Counter | | standard Counter |
| sysfs output | | character device |
|--------------------| |---------------------+
| Type: const char * | | Type: unsigned long |
| Value: "42" | | Value: 42 |
+--------------------+ +---------------------+
| |
--------------- ----------------
/ const char * / / unsigned long /
--------------- ----------------
| |
| V
| +-----------+
| | ioctl |
| +-----------+
| \ Count: 42 /
| -----------
|
V
+--------------------------------------------------+
| `/sys/bus/counter/devices/counterX/countY/count` |
+--------------------------------------------------+
\ Count: "42" /
--------------------------------------------------
I am aware that an in-kernel API can simplify the data transfer between
counter device drivers and the userspace interfaces, but I want to
postpone that development until after the new Counter character device
ioctl commands are solidified. A userspace ABI is effectively immutable
so I want to make sure we get that right before working on an in-kernel
API that is more flexible to change. However, when we do develop an
in-kernel API, it will likely be housed as part of the Counter core
component, through which the userspace interfaces will then communicate.
Interaction with Counter character devices occurs via ioctl commands.
This allows userspace applications to access and set counter data using
native C datatypes rather than working through string translations.
Regarding the organization of this patchset, I have combined the counter
device driver changes with the first patch because the changes must all
be taken together in order to avoid compilation errors. I can see how
this can end up making it difficult to review so many changes at once,
so alternatively I can separate out the counter device driver changes
into their own dedicated patches -- with the understanding that the
patches must all be taken together.
In addition, I anticipate the Microchip TCB capture counter driver to
break with this patchset. I'm not sure how that driver will be picked
up yet so I have avoided adding it to this patchset right now. But the
changes to support that driver are simple to make so I can add them in a
later revision of this patchset.
The following are some questions I have about this patchset:
1. Should enums be used to represent standard counter component states
(e.g. COUNTER_SIGNAL_LOW), or would these be better defined as int?
These standard counter component states are defined in the
counter-types.h file and serve as constants used by counter device
drivers and Counter subsystem components in order to ensure a
consistent interface.
My concern is whether enum constants will cause problems when passed
to userspace via the Counter character device ioctl calls. Along the
same lines is whether the C bool datatype is safe to pass as well,
given that it is a more modern C datatype.
2. Should device driver callbacks return int or long? I sometimes see
error values returned as long (e.g. PTR_ERR(), the file_operations
structure's ioctl callbacks, etc.); when is it necessary to return
long as opposed to int?
3. I only implemented the unlocked_ioctl callback. Should I implement a
compat_ioctl callback as well?
4. How much space should allot for name strings? Name strings hold the
names of components (ideally as they appear on datasheets), so I've
arbitrarily chosen a size of 32 for the character device interface.
5. Should the owning component of an extension be determined by the
device driver or Counter subsystem?
A lot of the complexity in the counters-function-types.h file and the
sysfs-callbacks.c file is due to the function pointer casts required
in order to support three different ownership scenarios: the owning
component is the device, the owning component is a Count, the owning
component is a Signal.
Because the Counter subsystem doesn't not know which scenario is
valid, it must manually check and provide for all three ownership
cases. On the other hand, device drivers do know exactly which case
applies because they are the ones providing the callbacks.
The complexity in the Counter subsystem code can be eliminated if the
owning component is simply passed down to the callbacks as a void
pointer. The device drivers will then be responsible for casting to
the appropriate component type, but this should in theory not be a
problem since the device driver assigned the callback to the owning
component in the first place.
William Breathitt Gray (4):
counter: Internalize sysfs interface code
docs: counter: Update to reflect sysfs internalization
counter: Add character device interface
docs: counter: Document character device interface
Documentation/driver-api/generic-counter.rst | 259 ++-
.../userspace-api/ioctl/ioctl-number.rst | 1 +
MAINTAINERS | 3 +-
drivers/counter/104-quad-8.c | 437 +++--
drivers/counter/Makefile | 2 +
drivers/counter/counter-chrdev.c | 1134 +++++++++++++
drivers/counter/counter-chrdev.h | 16 +
drivers/counter/counter-core.c | 220 +++
drivers/counter/counter-function-types.h | 81 +
drivers/counter/counter-strings.h | 46 +
drivers/counter/counter-sysfs-callbacks.c | 566 +++++++
drivers/counter/counter-sysfs-callbacks.h | 28 +
drivers/counter/counter-sysfs.c | 524 ++++++
drivers/counter/counter-sysfs.h | 14 +
drivers/counter/counter.c | 1496 -----------------
drivers/counter/ftm-quaddec.c | 46 +-
drivers/counter/stm32-lptimer-cnt.c | 159 +-
drivers/counter/stm32-timer-cnt.c | 132 +-
drivers/counter/ti-eqep.c | 170 +-
include/linux/counter.h | 547 +++---
include/linux/counter_enum.h | 45 -
include/uapi/linux/counter-types.h | 67 +
include/uapi/linux/counter.h | 313 ++++
23 files changed, 3816 insertions(+), 2490 deletions(-)
create mode 100644 drivers/counter/counter-chrdev.c
create mode 100644 drivers/counter/counter-chrdev.h
create mode 100644 drivers/counter/counter-core.c
create mode 100644 drivers/counter/counter-function-types.h
create mode 100644 drivers/counter/counter-strings.h
create mode 100644 drivers/counter/counter-sysfs-callbacks.c
create mode 100644 drivers/counter/counter-sysfs-callbacks.h
create mode 100644 drivers/counter/counter-sysfs.c
create mode 100644 drivers/counter/counter-sysfs.h
delete mode 100644 drivers/counter/counter.c
delete mode 100644 include/linux/counter_enum.h
create mode 100644 include/uapi/linux/counter-types.h
create mode 100644 include/uapi/linux/counter.h
base-commit: 00edef1ac058b3c754d29bcfd35ea998d9e7a339
--
2.26.2
This patch adds high-level documentation about the Counter subsystem
character device interface. The 0x3E major number and respective minor
number range is reserved for Counter character device interface ioctl
calls.
Signed-off-by: William Breathitt Gray <[email protected]>
---
Documentation/driver-api/generic-counter.rst | 87 ++++++++++++-------
.../userspace-api/ioctl/ioctl-number.rst | 1 +
2 files changed, 56 insertions(+), 32 deletions(-)
diff --git a/Documentation/driver-api/generic-counter.rst b/Documentation/driver-api/generic-counter.rst
index 3ab8125b9c05..959c4074078c 100644
--- a/Documentation/driver-api/generic-counter.rst
+++ b/Documentation/driver-api/generic-counter.rst
@@ -223,19 +223,6 @@ whether an input line is differential or single-ended) and instead focus
on the core idea of what the data and process represent (e.g. position
as interpreted from quadrature encoding data).
-Userspace Interface
-===================
-
-Several sysfs attributes are generated by the Generic Counter interface,
-and reside under the /sys/bus/counter/devices/counterX directory, where
-counterX refers to the respective counter device. Please see
-Documentation/ABI/testing/sysfs-bus-counter for detailed
-information on each Generic Counter interface sysfs attribute.
-
-Through these sysfs attributes, programs and scripts may interact with
-the Generic Counter paradigm Counts, Signals, and Synapses of respective
-counter devices.
-
Driver API
==========
@@ -409,25 +396,32 @@ driver can be exemplified by the following::
| / driver callbacks /
| -------------------
| |
- +-------+ |
+ +-------+---------------+ |
+ | | |
+ | +-------|-------+
+ | | |
+ V | V
+ +--------------------+ | +---------------------+
+ | Counter sysfs |<-+->| Counter chrdev |
+ +--------------------+ +---------------------+
+ | Translates to the | | Translates to the |
+ | standard Counter | | standard Counter |
+ | sysfs output | | character device |
+ |--------------------| |---------------------+
+ | Type: const char * | | Type: unsigned long |
+ | Value: "42" | | Value: 42 |
+ +--------------------+ +---------------------+
| |
- | +---------------+
- | |
- V |
- +--------------------+ |
- | Counter sysfs |<-+
- +--------------------+
- | Translates to the |
- | standard Counter |
- | sysfs output |
- |--------------------|
- | Type: const char * |
- | Value: "42" |
- +--------------------+
- |
- ---------------
- / const char * /
- ---------------
+ --------------- ----------------
+ / const char * / / unsigned long /
+ --------------- ----------------
+ | |
+ | V
+ | +-----------+
+ | | ioctl |
+ | +-----------+
+ | \ Count: 42 /
+ | -----------
|
V
+--------------------------------------------------+
@@ -436,7 +430,7 @@ driver can be exemplified by the following::
\ Count: "42" /
--------------------------------------------------
-There are three primary components involved:
+There are four primary components involved:
Counter device driver
---------------------
@@ -456,3 +450,32 @@ and vice versa.
Please refer to the `Documentation/ABI/testing/sysfs-bus-counter` file
for a detailed breakdown of the available Generic Counter interface
sysfs attributes.
+
+Counter chrdev
+--------------
+Translates counter data to the standard Counter character device; data
+is transferred via ioctl calls.
+
+Sysfs Interface
+===============
+
+Several sysfs attributes are generated by the Generic Counter interface,
+and reside under the `/sys/bus/counter/devices/counterX` directory,
+where `X` is to the respective counter device id. Please see
+Documentation/ABI/testing/sysfs-bus-counter for detailed information on
+each Generic Counter interface sysfs attribute.
+
+Through these sysfs attributes, programs and scripts may interact with
+the Generic Counter paradigm Counts, Signals, and Synapses of respective
+counter devices.
+
+Counter Character Device
+========================
+
+Counter character device nodes are created under the `/dev` directory as
+`counterX`, where `X` is the respective counter device id. Device
+information and control is exposed via a set of standard Counter
+subsystem ioctl commands.
+
+.. kernel-doc:: include/uapi/linux/counter.h
+ :internal:
diff --git a/Documentation/userspace-api/ioctl/ioctl-number.rst b/Documentation/userspace-api/ioctl/ioctl-number.rst
index f759edafd938..8136a26fb81c 100644
--- a/Documentation/userspace-api/ioctl/ioctl-number.rst
+++ b/Documentation/userspace-api/ioctl/ioctl-number.rst
@@ -88,6 +88,7 @@ Code Seq# Include File Comments
<http://infiniband.sourceforge.net/>
0x20 all drivers/cdrom/cm206.h
0x22 all scsi/sg.h
+0x3E 00-1F linux/counter.h <mailto:[email protected]>
'!' 00-1F uapi/linux/seccomp.h
'#' 00-3F IEEE 1394 Subsystem
Block for the entire subsystem
--
2.26.2
The Counter subsystem architecture and driver implementations have
changed in order to handle Counter sysfs interactions in a more
consistent way. This patch updates the Generic Counter interface
documentation to reflect the changes.
Signed-off-by: William Breathitt Gray <[email protected]>
---
Documentation/driver-api/generic-counter.rst | 220 +++++++++++++------
1 file changed, 157 insertions(+), 63 deletions(-)
diff --git a/Documentation/driver-api/generic-counter.rst b/Documentation/driver-api/generic-counter.rst
index e622f8f6e56a..3ab8125b9c05 100644
--- a/Documentation/driver-api/generic-counter.rst
+++ b/Documentation/driver-api/generic-counter.rst
@@ -250,8 +250,8 @@ for defining a counter device.
.. kernel-doc:: drivers/counter/counter.c
:export:
-Implementation
-==============
+Driver Implementation
+=====================
To support a counter device, a driver must first allocate the available
Counter Signals via counter_signal structures. These Signals should
@@ -267,11 +267,10 @@ respective counter_count structure. These counter_count structures are
set to the counts array member of an allocated counter_device structure
before the Counter is registered to the system.
-Driver callbacks should be provided to the counter_device structure via
-a constant counter_ops structure in order to communicate with the
-device: to read and write various Signals and Counts, and to set and get
-the "action mode" and "function mode" for various Synapses and Counts
-respectively.
+Driver callbacks must be provided to the counter_device structure in
+order to communicate with the device: to read and write various Signals
+and Counts, and to set and get the "action mode" and "function mode" for
+various Synapses and Counts respectively.
A defined counter_device structure may be registered to the system by
passing it to the counter_register function, and unregistered by passing
@@ -279,13 +278,58 @@ it to the counter_unregister function. Similarly, the
devm_counter_register and devm_counter_unregister functions may be used
if device memory-managed registration is desired.
-Extension sysfs attributes can be created for auxiliary functionality
-and data by passing in defined counter_device_ext, counter_count_ext,
-and counter_signal_ext structures. In these cases, the
-counter_device_ext structure is used for global/miscellaneous exposure
-and configuration of the respective Counter device, while the
-counter_count_ext and counter_signal_ext structures allow for auxiliary
-exposure and configuration of a specific Count or Signal respectively.
+The struct counter_data structure is used to define counter extensions
+for Signals, Synapses, and Counts::
+
+ struct counter_data {
+ enum counter_data_type type;
+ const char *name;
+ void *read;
+ void *write;
+ void *priv;
+ };
+
+The "type" member specifies the type of data (e.g. unsigned long,
+boolean, etc.) handled by this extension. The "read" and "write" members
+can then be set by the counter device driver with callbacks to handle
+that data.
+
+Convenience macros such as COUNTER_DATA_UNSIGNED_LONG are provided for
+use by driver authors. In particular, driver authors are expected to use
+the provided macros for standard Counter subsystem attributes in order
+to maintain a consistent interface for userspace. For example, a counter
+device driver may define several standard attributes like so::
+
+ struct counter_data count_ext[] = {
+ COUNTER_DATA_DIRECTION(count_direction_read),
+ COUNTER_DATA_ENABLE(count_enable_read, count_enable_write),
+ COUNTER_DATA_CEILING(count_ceiling_read, count_ceiling_write),
+ };
+
+This makes it intuitive to see, add, and modify the attributes that are
+supported by this driver ("direction", "enable", and "ceiling") and to
+maintain this code without getting lost in a web of struct braces.
+
+Callbacks must match the function type expected for the respective
+component or extension. These types are defined in the
+`drivers/counter/counter-function-types.h` file.
+
+The corresponding prototypes for the callbacks mentioned in the previous
+example would be::
+
+ int count_direction_read(struct counter_device *counter,
+ struct counter_count *count,
+ enum counter_count_direction *direction);
+ int count_enable_read(struct counter_device *counter,
+ struct counter_count *count, bool *enable);
+ int count_enable_write(struct counter_device *counter,
+ struct counter_count *count, bool enable);
+ int count_ceiling_read(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long *ceiling);
+ int count_ceiling_write(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long ceiling);
Determining the type of extension to create is a matter of scope.
@@ -313,52 +357,102 @@ Determining the type of extension to create is a matter of scope.
chip overheated via a device extension called "error_overtemp":
/sys/bus/counter/devices/counterX/error_overtemp
-Architecture
-============
-
-When the Generic Counter interface counter module is loaded, the
-counter_init function is called which registers a bus_type named
-"counter" to the system. Subsequently, when the module is unloaded, the
-counter_exit function is called which unregisters the bus_type named
-"counter" from the system.
-
-Counter devices are registered to the system via the counter_register
-function, and later removed via the counter_unregister function. The
-counter_register function establishes a unique ID for the Counter
-device and creates a respective sysfs directory, where X is the
-mentioned unique ID:
-
- /sys/bus/counter/devices/counterX
-
-Sysfs attributes are created within the counterX directory to expose
-functionality, configurations, and data relating to the Counts, Signals,
-and Synapses of the Counter device, as well as options and information
-for the Counter device itself.
-
-Each Signal has a directory created to house its relevant sysfs
-attributes, where Y is the unique ID of the respective Signal:
-
- /sys/bus/counter/devices/counterX/signalY
-
-Similarly, each Count has a directory created to house its relevant
-sysfs attributes, where Y is the unique ID of the respective Count:
-
- /sys/bus/counter/devices/counterX/countY
-
-For a more detailed breakdown of the available Generic Counter interface
-sysfs attributes, please refer to the
-Documentation/ABI/testing/sysfs-bus-counter file.
-
-The Signals and Counts associated with the Counter device are registered
-to the system as well by the counter_register function. The
-signal_read/signal_write driver callbacks are associated with their
-respective Signal attributes, while the count_read/count_write and
-function_get/function_set driver callbacks are associated with their
-respective Count attributes; similarly, the same is true for the
-action_get/action_set driver callbacks and their respective Synapse
-attributes. If a driver callback is left undefined, then the respective
-read/write permission is left disabled for the relevant attributes.
-
-Similarly, extension sysfs attributes are created for the defined
-counter_device_ext, counter_count_ext, and counter_signal_ext
-structures that are passed in.
+Subsystem Architecture
+======================
+
+Counter drivers pass and take data natively (i.e. unsigned long, bool,
+size_t, etc.) and the shared counter module handles the translation
+between the driver callbacks and userspace interfaces. This gurantees a
+standard userspace interface for all counter drivers, and helps
+generalize the Generic Counter driver ABI in order to support various
+userspace interfaces without changes to the existing counter drivers.
+
+A high-level view of how a count value is passed down from a counter
+driver can be exemplified by the following::
+
+ Count data request:
+ ~~~~~~~~~~~~~~~~~~~
+ ----------------------
+ / Counter device \
+ +----------------------+
+ | Count register: 0x28 |
+ +----------------------+
+ |
+ -----------------
+ / raw count data /
+ -----------------
+ |
+ V
+ +----------------------------+
+ | Counter device driver |----------+
+ +----------------------------+ |
+ | Processes data from device | -------------------
+ |----------------------------| / driver callbacks /
+ | Type: unsigned long | -------------------
+ | Value: 42 | |
+ +----------------------------+ |
+ | |
+ ---------------- |
+ / unsigned long / |
+ ---------------- |
+ | |
+ | V
+ | +----------------------+
+ | | Counter core |
+ | +----------------------+
+ | | Routes device driver |
+ | | callbacks to the |
+ | | userspace interfaces |
+ | +----------------------+
+ | |
+ | -------------------
+ | / driver callbacks /
+ | -------------------
+ | |
+ +-------+ |
+ | |
+ | +---------------+
+ | |
+ V |
+ +--------------------+ |
+ | Counter sysfs |<-+
+ +--------------------+
+ | Translates to the |
+ | standard Counter |
+ | sysfs output |
+ |--------------------|
+ | Type: const char * |
+ | Value: "42" |
+ +--------------------+
+ |
+ ---------------
+ / const char * /
+ ---------------
+ |
+ V
+ +--------------------------------------------------+
+ | `/sys/bus/counter/devices/counterX/countY/count` |
+ +--------------------------------------------------+
+ \ Count: "42" /
+ --------------------------------------------------
+
+There are three primary components involved:
+
+Counter device driver
+---------------------
+Communicates with the hardware device to read/write data; e.g. counter
+drivers for quadrature encoders, timers, etc.
+
+Counter core
+------------
+Registers the counter device driver to the system so that the respective
+callbacks are called during userspace interaction.
+
+Counter sysfs
+-------------
+Translates counter data to the standard Counter sysfs interface format
+and vice versa.
+
+Please refer to the `Documentation/ABI/testing/sysfs-bus-counter` file
+for a detailed breakdown of the available Generic Counter interface
+sysfs attributes.
--
2.26.2
This patch introduces a character device interface for the Counter
subsystem. Device information and control is exposed through a standard
set of ioctl commands.
A high-level view of how a count value is passed down from a counter
driver can be exemplified by the following:
----------------------
/ Counter device \
+----------------------+
| Count register: 0x28 |
+----------------------+
|
-----------------
/ raw count data /
-----------------
|
V
+----------------------------+
| Counter device driver |----------+
+----------------------------+ |
| Processes data from device | -------------------
|----------------------------| / driver callbacks /
| Type: unsigned long | -------------------
| Value: 42 | |
+----------------------------+ |
| |
---------------- |
/ unsigned long / |
---------------- |
| |
| V
| +----------------------+
| | Counter core |
| +----------------------+
| | Routes device driver |
| | callbacks to the |
| | userspace interfaces |
| +----------------------+
| |
| -------------------
| / driver callbacks /
| -------------------
| |
+-------+---------------+ |
| | |
| +-------|-------+
| | |
V | V
+--------------------+ | +---------------------+
| Counter sysfs |<-+->| Counter chrdev |
+--------------------+ +---------------------+
| Translates to the | | Translates to the |
| standard Counter | | standard Counter |
| sysfs output | | character device |
|--------------------| |---------------------+
| Type: const char * | | Type: unsigned long |
| Value: "42" | | Value: 42 |
+--------------------+ +---------------------+
| |
--------------- ----------------
/ const char * / / unsigned long /
--------------- ----------------
| |
| V
| +-----------+
| | ioctl |
| +-----------+
| \ Count: 42 /
| -----------
|
V
+--------------------------------------------------+
| `/sys/bus/counter/devices/counterX/countY/count` |
+--------------------------------------------------+
\ Count: "42" /
--------------------------------------------------
Signed-off-by: William Breathitt Gray <[email protected]>
---
MAINTAINERS | 1 +
drivers/counter/Makefile | 3 +-
drivers/counter/counter-chrdev.c | 1134 ++++++++++++++++++++++++++++++
drivers/counter/counter-chrdev.h | 16 +
drivers/counter/counter-core.c | 34 +-
include/linux/counter.h | 2 +
include/uapi/linux/counter.h | 313 +++++++++
7 files changed, 1500 insertions(+), 3 deletions(-)
create mode 100644 drivers/counter/counter-chrdev.c
create mode 100644 drivers/counter/counter-chrdev.h
create mode 100644 include/uapi/linux/counter.h
diff --git a/MAINTAINERS b/MAINTAINERS
index 89def3fe1c76..b8c7677e6564 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -4367,6 +4367,7 @@ F: Documentation/ABI/testing/sysfs-bus-counter*
F: Documentation/driver-api/generic-counter.rst
F: drivers/counter/
F: include/linux/counter.h
+F: include/uapi/linux/counter.h
F: include/uapi/linux/counter-types.h
CPMAC ETHERNET DRIVER
diff --git a/drivers/counter/Makefile b/drivers/counter/Makefile
index 2d2644bd7777..86a93100e3f6 100644
--- a/drivers/counter/Makefile
+++ b/drivers/counter/Makefile
@@ -4,7 +4,8 @@
#
obj-$(CONFIG_COUNTER) += counter.o
-counter-y := counter-core.o counter-sysfs.o counter-sysfs-callbacks.o
+counter-y := counter-core.o counter-sysfs.o counter-sysfs-callbacks.o \
+ counter-chrdev.o
obj-$(CONFIG_104_QUAD_8) += 104-quad-8.o
obj-$(CONFIG_STM32_TIMER_CNT) += stm32-timer-cnt.o
diff --git a/drivers/counter/counter-chrdev.c b/drivers/counter/counter-chrdev.c
new file mode 100644
index 000000000000..00b1d9f62527
--- /dev/null
+++ b/drivers/counter/counter-chrdev.c
@@ -0,0 +1,1134 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Generic Counter character device interface
+ * Copyright (C) 2020 William Breathitt Gray
+ */
+
+#include <linux/cdev.h>
+#include <linux/counter.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kdev_t.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <linux/uaccess.h>
+#include <uapi/linux/counter.h>
+
+#include "counter-function-types.h"
+
+static long counter_device_info_ioctl(const unsigned long arg,
+ const struct counter_device *const counter)
+{
+ struct counter_device_info info;
+ void __user *const uinfo = (void __user *)arg;
+
+ snprintf(info.name, sizeof(info.name), "%s", counter->name);
+ info.num_signals = counter->num_signals;
+ info.num_counts = counter->num_counts;
+ info.num_ext = counter->num_ext;
+
+ if (copy_to_user(uinfo, &info, sizeof(info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_signal_info_ioctl(const unsigned long arg,
+ const struct counter_device *const counter)
+{
+ struct counter_signal_info info;
+ void __user *const uinfo = (void __user *)arg;
+ const struct counter_signal *signal;
+
+ if (copy_from_user(&info, uinfo, sizeof(info)))
+ return -EFAULT;
+
+ if (info.index >= counter->num_signals)
+ return -EINVAL;
+
+ signal = counter->signals + info.index;
+
+ info.id = signal->id;
+ snprintf(info.name, sizeof(info.name), "%s", signal->name);
+ info.num_ext = signal->num_ext;
+
+ if (copy_to_user(uinfo, &info, sizeof(info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_synapse_info_ioctl(const unsigned long arg,
+ const struct counter_device *const counter)
+{
+ struct counter_synapse_info info;
+ void __user *const uinfo = (void __user *)arg;
+ const struct counter_synapse *synapse;
+
+ if (copy_from_user(&info, uinfo, sizeof(info)))
+ return -EFAULT;
+
+ if (info.count_index >= counter->num_counts)
+ return -EINVAL;
+
+ if (info.index >= counter->counts[info.count_index].num_synapses)
+ return -EINVAL;
+
+ synapse = counter->counts[info.count_index].synapses + info.index;
+
+ info.num_actions = synapse->num_actions;
+ info.signal_index = synapse->signal - counter->signals;
+
+ if (copy_to_user(uinfo, &info, sizeof(info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_count_info_ioctl(const unsigned long arg,
+ const struct counter_device *const counter)
+{
+ struct counter_count_info info;
+ void __user *const uinfo = (void __user *)arg;
+ const struct counter_count *count;
+
+ if (copy_from_user(&info, uinfo, sizeof(info)))
+ return -EFAULT;
+
+ if (info.index >= counter->num_counts)
+ return -EINVAL;
+
+ count = counter->counts + info.index;
+
+ info.id = count->id;
+ snprintf(info.name, sizeof(info.name), "%s", count->name);
+ info.num_functions = count->num_functions;
+ info.num_synapses = count->num_synapses;
+ info.num_ext = count->num_ext;
+
+ if (copy_to_user(uinfo, &info, sizeof(info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static const struct counter_data *counter_get_ext(
+ const enum counter_owner_type type, const size_t owner_index,
+ const size_t index, const struct counter_device *const counter)
+{
+ const struct counter_data *ext;
+
+ switch (type) {
+ case COUNTER_OWNER_TYPE_DEVICE:
+ if (index >= counter->num_ext)
+ return ERR_PTR(-EINVAL);
+
+ ext = counter->ext + index;
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ if (owner_index >= counter->num_signals)
+ return ERR_PTR(-EINVAL);
+
+ if (index >= counter->signals[owner_index].num_ext)
+ return ERR_PTR(-EINVAL);
+
+ ext = counter->signals[owner_index].ext + index;
+ break;
+ case COUNTER_OWNER_TYPE_COUNT:
+ if (owner_index >= counter->num_counts)
+ return ERR_PTR(-EINVAL);
+
+ if (index >= counter->counts[owner_index].num_ext)
+ return ERR_PTR(-EINVAL);
+
+ ext = counter->counts[owner_index].ext + index;
+ break;
+ default:
+ return ERR_PTR(-EINVAL);
+ }
+
+ return ext;
+}
+
+static long counter_ext_info_ioctl(const unsigned long arg,
+ const struct counter_device *const counter)
+{
+ struct counter_ext_info info;
+ void __user *const uinfo = (void __user *)arg;
+ const struct counter_data *ext;
+
+ if (copy_from_user(&info, uinfo, sizeof(info)))
+ return -EFAULT;
+
+ ext = counter_get_ext(info.owner_type, info.owner_index, info.index,
+ counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ info.type = ext->type;
+ snprintf(info.name, sizeof(info.name), "%s", ext->name);
+
+ if (copy_to_user(uinfo, &info, sizeof(info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_signal_get_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ const counter_signal_signal_read signal_read = counter->signal_read;
+ struct counter_signal_request req;
+ void __user *const ureq = (void __user *)arg;
+ int err;
+
+ if (!signal_read)
+ return -EINVAL;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ if (req.index >= counter->num_signals)
+ return -EINVAL;
+
+ err = signal_read(counter, counter->signals + req.index, &req.value);
+ if (err)
+ return err;
+
+ if (copy_to_user(ureq, &req, sizeof(req)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_count_get_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ const counter_count_lu_read count_read = counter->count_read;
+ struct counter_count_request req;
+ void __user *const ureq = (void __user *)arg;
+ int err;
+
+ if (!count_read)
+ return -EINVAL;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ if (req.index >= counter->num_counts)
+ return -EINVAL;
+
+ err = count_read(counter, counter->counts + req.index, &req.value);
+ if (err)
+ return err;
+
+ if (copy_to_user(ureq, &req, sizeof(req)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_count_set_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ const counter_count_lu_write count_write = counter->count_write;
+ struct counter_count_request req;
+ void __user *const ureq = (void __user *)arg;
+ int err;
+
+ if (!count_write)
+ return -EINVAL;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ if (req.index >= counter->num_counts)
+ return -EINVAL;
+
+ err = count_write(counter, counter->counts + req.index, req.value);
+ if (err)
+ return err;
+
+ return 0;
+}
+
+static long counter_count_function_get_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ const counter_count_function_read func_read = counter->function_read;
+ struct counter_count_function_request req;
+ void __user *const ureq = (void __user *)arg;
+ int err;
+
+ if (!func_read)
+ return -EINVAL;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ if (req.index >= counter->num_counts)
+ return -EINVAL;
+
+ err = func_read(counter, counter->counts + req.index, &req.function);
+ if (err)
+ return err;
+
+ if (copy_to_user(ureq, &req, sizeof(req)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_count_function_set_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ const counter_count_function_write func_write = counter->function_write;
+ struct counter_count_function_request req;
+ void __user *const ureq = (void __user *)arg;
+ struct counter_count *count;
+ size_t i;
+ int err;
+
+ if (!func_write)
+ return -EINVAL;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ if (req.index >= counter->num_counts)
+ return -EINVAL;
+
+ count = counter->counts + req.index;
+
+ /* Find requested function mode */
+ for (i = 0; i < count->num_functions; i++)
+ if (req.function == count->functions_list[i])
+ break;
+
+ /* If requested function mode is not found */
+ if (i >= count->num_functions)
+ return -EINVAL;
+
+ err = func_write(counter, count, req.function);
+ if (err)
+ return err;
+
+ return 0;
+}
+
+static long counter_synapse_action_get_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ const counter_synapse_action_read action_read = counter->action_read;
+ struct counter_synapse_action_request req;
+ void __user *const ureq = (void __user *)arg;
+ struct counter_count *count;
+ struct counter_synapse *synapse;
+ int err;
+
+ if (!action_read)
+ return -EINVAL;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ if (req.count_index >= counter->num_counts)
+ return -EINVAL;
+
+ count = counter->counts + req.count_index;
+
+ if (req.index >= count->num_synapses)
+ return -EINVAL;
+
+ synapse = count->synapses + req.index;
+
+ err = action_read(counter, count, synapse, &req.action);
+ if (err)
+ return err;
+
+ if (copy_to_user(ureq, &req, sizeof(req)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_synapse_action_set_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ const counter_synapse_action_write action_write = counter->action_write;
+ struct counter_synapse_action_request req;
+ void __user *const ureq = (void __user *)arg;
+ struct counter_count *count;
+ struct counter_synapse *synapse;
+ size_t i;
+ int err;
+
+ if (!action_write)
+ return -EINVAL;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ if (req.count_index >= counter->num_counts)
+ return -EINVAL;
+
+ count = counter->counts + req.count_index;
+
+ if (req.index >= count->num_synapses)
+ return -EINVAL;
+
+ synapse = count->synapses + req.index;
+
+ /* Find requested action mode */
+ for (i = 0; i < synapse->num_actions; i++)
+ if (req.action == synapse->actions_list[i])
+ break;
+
+ /* If requested action mode is not found */
+ if (i >= synapse->num_actions)
+ return -EINVAL;
+
+ err = action_write(counter, count, synapse, req.action);
+ if (err)
+ return err;
+
+ return 0;
+}
+
+static long counter_count_function_info_ioctl(const unsigned long arg,
+ const struct counter_device *const counter)
+{
+ struct counter_count_function_info info;
+ void __user *const uinfo = (void __user *)arg;
+ const struct counter_count *count;
+
+ if (copy_from_user(&info, uinfo, sizeof(info)))
+ return -EFAULT;
+
+ if (info.count_index >= counter->num_counts)
+ return -EINVAL;
+
+ count = counter->counts + info.count_index;
+
+ if (info.index >= count->num_functions)
+ return -EINVAL;
+
+ info.function = count->functions_list[info.index];
+
+ if (copy_to_user(uinfo, &info, sizeof(info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_synapse_action_info_ioctl(const unsigned long arg,
+ const struct counter_device *const counter)
+{
+ struct counter_synapse_action_info info;
+ void __user *const uinfo = (void __user *)arg;
+ const struct counter_count *count;
+ const struct counter_synapse *synapse;
+
+ if (copy_from_user(&info, uinfo, sizeof(info)))
+ return -EFAULT;
+
+ if (info.count_index >= counter->num_counts)
+ return -EINVAL;
+
+ count = counter->counts + info.count_index;
+
+ if (info.synapse_index >= count->num_synapses)
+ return -EINVAL;
+
+ synapse = count->synapses + info.synapse_index;
+
+ if (info.index >= synapse->num_actions)
+ return -EINVAL;
+
+ info.action = synapse->actions_list[info.index];
+
+ if (copy_to_user(uinfo, &info, sizeof(info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_ext_bool_get_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ counter_device_bool_read device_bool_read;
+ counter_signal_bool_read signal_bool_read;
+ counter_count_bool_read count_bool_read;
+ struct counter_ext_bool_request req;
+ void __user *const ureq = (void __user *)arg;
+ const struct counter_data *ext;
+ int err = 0;
+ struct counter_count *count;
+ struct counter_signal *signal;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ ext = counter_get_ext(req.owner_type, req.owner_index, req.index,
+ counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ if (!ext->read)
+ return -EINVAL;
+
+ switch (req.owner_type) {
+ case COUNTER_OWNER_TYPE_DEVICE:
+ device_bool_read = ext->read;
+ err = device_bool_read(counter, &req.data);
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ signal_bool_read = ext->read;
+ signal = counter->signals + req.owner_index;
+ err = signal_bool_read(counter, signal, &req.data);
+ break;
+ case COUNTER_OWNER_TYPE_COUNT:
+ count_bool_read = ext->read;
+ count = counter->counts + req.owner_index;
+ err = count_bool_read(counter, count, &req.data);
+ break;
+ }
+ if (err)
+ return err;
+
+ if (copy_to_user(ureq, &req, sizeof(req)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_ext_bool_set_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ counter_device_bool_write device_bool_write;
+ counter_signal_bool_write signal_bool_write;
+ counter_count_bool_write count_bool_write;
+ struct counter_ext_bool_request req;
+ void __user *const ureq = (void __user *)arg;
+ const struct counter_data *ext;
+ int retval = 0;
+ struct counter_count *count;
+ struct counter_signal *signal;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ ext = counter_get_ext(req.owner_type, req.owner_index, req.index,
+ counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ if (!ext->write)
+ return -EINVAL;
+
+ switch (req.owner_type) {
+ case COUNTER_OWNER_TYPE_DEVICE:
+ device_bool_write = ext->write;
+ retval = device_bool_write(counter, req.data);
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ signal_bool_write = ext->write;
+ signal = counter->signals + req.owner_index;
+ retval = signal_bool_write(counter, signal, req.data);
+ break;
+ case COUNTER_OWNER_TYPE_COUNT:
+ count_bool_write = ext->write;
+ count = counter->counts + req.owner_index;
+ retval = count_bool_write(counter, count, req.data);
+ break;
+ }
+
+ return retval;
+}
+
+static long counter_ext_lu_get_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ counter_device_lu_read device_lu_read;
+ counter_signal_lu_read signal_lu_read;
+ counter_count_lu_read count_lu_read;
+ struct counter_ext_lu_request req;
+ void __user *const ureq = (void __user *)arg;
+ const struct counter_data *ext;
+ int err = 0;
+ struct counter_count *count;
+ struct counter_signal *signal;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ ext = counter_get_ext(req.owner_type, req.owner_index, req.index,
+ counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ if (!ext->read)
+ return -EINVAL;
+
+ switch (req.owner_type) {
+ case COUNTER_OWNER_TYPE_DEVICE:
+ device_lu_read = ext->read;
+ err = device_lu_read(counter, &req.data);
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ signal_lu_read = ext->read;
+ signal = counter->signals + req.owner_index;
+ err = signal_lu_read(counter, signal, &req.data);
+ break;
+ case COUNTER_OWNER_TYPE_COUNT:
+ count_lu_read = ext->read;
+ count = counter->counts + req.owner_index;
+ err = count_lu_read(counter, count, &req.data);
+ break;
+ }
+ if (err)
+ return err;
+
+ if (copy_to_user(ureq, &req, sizeof(req)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_ext_lu_set_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ counter_device_lu_write device_lu_write;
+ counter_signal_lu_write signal_lu_write;
+ counter_count_lu_write count_lu_write;
+ struct counter_ext_lu_request req;
+ void __user *const ureq = (void __user *)arg;
+ const struct counter_data *ext;
+ int retval = 0;
+ struct counter_count *count;
+ struct counter_signal *signal;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ ext = counter_get_ext(req.owner_type, req.owner_index, req.index,
+ counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ if (!ext->write)
+ return -EINVAL;
+
+ switch (req.owner_type) {
+ case COUNTER_OWNER_TYPE_DEVICE:
+ device_lu_write = ext->write;
+ retval = device_lu_write(counter, req.data);
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ signal_lu_write = ext->write;
+ signal = counter->signals + req.owner_index;
+ retval = signal_lu_write(counter, signal, req.data);
+ break;
+ case COUNTER_OWNER_TYPE_COUNT:
+ count_lu_write = ext->write;
+ count = counter->counts + req.owner_index;
+ retval = count_lu_write(counter, count, req.data);
+ break;
+ }
+
+ return retval;
+}
+
+static long counter_ext_string_get_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ counter_device_s_read device_s_read;
+ counter_signal_s_read signal_s_read;
+ counter_count_s_read count_s_read;
+ struct counter_ext_string_request req;
+ void __user *const ureq = (void __user *)arg;
+ const struct counter_data *ext;
+ ssize_t len = 0;
+ struct counter_count *count;
+ struct counter_signal *signal;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ ext = counter_get_ext(req.owner_type, req.owner_index, req.index,
+ counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ if (!ext->read)
+ return -EINVAL;
+
+ switch (req.owner_type) {
+ case COUNTER_OWNER_TYPE_DEVICE:
+ device_s_read = ext->read;
+ len = device_s_read(counter, req.data, sizeof(req.data));
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ signal_s_read = ext->read;
+ signal = counter->signals + req.owner_index;
+ len = signal_s_read(counter, signal, req.data,
+ sizeof(req.data));
+ break;
+ case COUNTER_OWNER_TYPE_COUNT:
+ count_s_read = ext->read;
+ count = counter->counts + req.owner_index;
+ len = count_s_read(counter, count, req.data, sizeof(req.data));
+ break;
+ }
+ if (len < 0)
+ return len;
+
+ if (copy_to_user(ureq, &req, sizeof(req)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_ext_string_set_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ counter_device_s_write device_s_write;
+ counter_signal_s_write signal_s_write;
+ counter_count_s_write count_s_write;
+ struct counter_ext_string_request req;
+ void __user *const ureq = (void __user *)arg;
+ const struct counter_data *ext;
+ ssize_t len = 0;
+ struct counter_count *count;
+ struct counter_signal *signal;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ ext = counter_get_ext(req.owner_type, req.owner_index, req.index,
+ counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ if (!ext->write)
+ return -EINVAL;
+
+ switch (req.owner_type) {
+ case COUNTER_OWNER_TYPE_DEVICE:
+ device_s_write = ext->write;
+ len = device_s_write(counter, req.data, sizeof(req.data));
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ signal_s_write = ext->write;
+ signal = counter->signals + req.owner_index;
+ len = signal_s_write(counter, signal, req.data,
+ sizeof(req.data));
+ break;
+ case COUNTER_OWNER_TYPE_COUNT:
+ count_s_write = ext->write;
+ count = counter->counts + req.owner_index;
+ len = count_s_write(counter, count, req.data, sizeof(req.data));
+ break;
+ }
+ if (len < 0)
+ return len;
+
+ return 0;
+}
+
+static long counter_ext_enum_get_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ counter_device_zu_read device_enum_read;
+ counter_signal_zu_read signal_enum_read;
+ counter_count_zu_read count_enum_read;
+ struct counter_ext_enum_request req;
+ void __user *const ureq = (void __user *)arg;
+ const struct counter_data *ext;
+ int err = 0;
+ size_t enum_index;
+ struct counter_count *count;
+ struct counter_signal *signal;
+ const struct counter_enum *cntr_enum;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ ext = counter_get_ext(req.owner_type, req.owner_index, req.index,
+ counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ if (!ext->read)
+ return -EINVAL;
+
+ switch (req.owner_type) {
+ case COUNTER_OWNER_TYPE_DEVICE:
+ device_enum_read = ext->read;
+ err = device_enum_read(counter, &enum_index);
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ signal_enum_read = ext->read;
+ signal = counter->signals + req.owner_index;
+ err = signal_enum_read(counter, signal, &enum_index);
+ break;
+ case COUNTER_OWNER_TYPE_COUNT:
+ count_enum_read = ext->read;
+ count = counter->counts + req.owner_index;
+ err = count_enum_read(counter, count, &enum_index);
+ break;
+ }
+ if (err)
+ return err;
+
+ cntr_enum = ext->priv;
+
+ if (enum_index >= cntr_enum->num_items)
+ return -EINVAL;
+
+ req.enum_index = enum_index;
+
+ if (copy_to_user(ureq, &req, sizeof(req)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_ext_enum_set_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ counter_device_zu_write device_enum_write;
+ counter_signal_zu_write signal_enum_write;
+ counter_count_zu_write count_enum_write;
+ struct counter_ext_enum_request req;
+ void __user *const ureq = (void __user *)arg;
+ const struct counter_data *ext;
+ int retval = 0;
+ struct counter_count *count;
+ struct counter_signal *signal;
+ const struct counter_enum *cntr_enum;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ ext = counter_get_ext(req.owner_type, req.owner_index, req.index,
+ counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ if (!ext->write)
+ return -EINVAL;
+
+ cntr_enum = ext->priv;
+ if (req.enum_index >= cntr_enum->num_items)
+ return -EINVAL;
+
+ switch (req.owner_type) {
+ case COUNTER_OWNER_TYPE_DEVICE:
+ device_enum_write = ext->write;
+ retval = device_enum_write(counter, req.enum_index);
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ signal_enum_write = ext->write;
+ signal = counter->signals + req.owner_index;
+ retval = signal_enum_write(counter, signal, req.enum_index);
+ break;
+ case COUNTER_OWNER_TYPE_COUNT:
+ count_enum_write = ext->write;
+ count = counter->counts + req.owner_index;
+ retval = count_enum_write(counter, count, req.enum_index);
+ break;
+ }
+
+ return retval;
+}
+
+static long counter_ext_enum_info_ioctl(const unsigned long arg,
+ const struct counter_device *const counter)
+{
+ struct counter_ext_enum_info info;
+ void __user *const uinfo = (void __user *)arg;
+ const struct counter_data *ext;
+ const struct counter_enum *cntr_enum;
+
+ if (copy_from_user(&info, uinfo, sizeof(info)))
+ return -EFAULT;
+
+ ext = counter_get_ext(info.owner_type, info.owner_index, info.ext_index,
+ counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ cntr_enum = ext->priv;
+
+ if (info.index >= cntr_enum->num_items)
+ return -EINVAL;
+
+ snprintf(info.value, sizeof(info.value), "%s",
+ cntr_enum->items[info.index]);
+
+ if (copy_to_user(uinfo, &info, sizeof(info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_count_direction_get_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ counter_count_direction_read count_direction_read;
+ struct counter_count_direction_request req;
+ void __user *const ureq = (void __user *)arg;
+ const struct counter_data *ext;
+ struct counter_count *count;
+ int err;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ ext = counter_get_ext(COUNTER_OWNER_TYPE_COUNT, req.count_index,
+ req.index, counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ if (!ext->read)
+ return -EINVAL;
+
+ count_direction_read = ext->read;
+ count = counter->counts + req.count_index;
+ err = count_direction_read(counter, count, &req.direction);
+ if (err)
+ return err;
+
+ if (copy_to_user(ureq, &req, sizeof(req)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_count_mode_get_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ counter_count_mode_read count_mode_read;
+ struct counter_count_mode_request req;
+ void __user *const ureq = (void __user *)arg;
+ const struct counter_data *ext;
+ struct counter_count *count;
+ int err;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ ext = counter_get_ext(COUNTER_OWNER_TYPE_COUNT, req.count_index,
+ req.index, counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ if (!ext->read)
+ return -EINVAL;
+
+ count_mode_read = ext->read;
+ count = counter->counts + req.count_index;
+ err = count_mode_read(counter, count, &req.count_mode);
+ if (err)
+ return err;
+
+ if (copy_to_user(ureq, &req, sizeof(req)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_count_mode_set_ioctl(const unsigned long arg,
+ struct counter_device *const counter)
+{
+ counter_count_mode_write count_mode_write;
+ struct counter_count_mode_request req;
+ void __user *const ureq = (void __user *)arg;
+ const struct counter_data *ext;
+ const struct counter_available *available;
+ const enum counter_count_mode *count_modes;
+ size_t i;
+ struct counter_count *count;
+ int err;
+
+ if (copy_from_user(&req, ureq, sizeof(req)))
+ return -EFAULT;
+
+ ext = counter_get_ext(COUNTER_OWNER_TYPE_COUNT, req.count_index,
+ req.index, counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ if (!ext->write)
+ return -EINVAL;
+
+ available = ext->priv;
+ count_modes = available->items;
+
+ /* Find requested count mode */
+ for (i = 0; i < available->num_items; i++) {
+ if (req.count_mode == count_modes[i])
+ break;
+ }
+ /* If requested count mode not found */
+ if (i >= available->num_items)
+ return -EINVAL;
+
+ count_mode_write = ext->write;
+ count = counter->counts + req.count_index;
+ err = count_mode_write(counter, count, req.count_mode);
+ if (err)
+ return err;
+
+ return 0;
+}
+
+static long counter_count_mode_info_ioctl(const unsigned long arg,
+ const struct counter_device *const counter)
+{
+ struct counter_count_mode_info info;
+ void __user *const uinfo = (void __user *)arg;
+ const struct counter_data *ext;
+ const struct counter_available *available;
+ const enum counter_count_mode *count_modes;
+
+ if (copy_from_user(&info, uinfo, sizeof(info)))
+ return -EFAULT;
+
+ ext = counter_get_ext(COUNTER_OWNER_TYPE_COUNT, info.count_index,
+ info.ext_index, counter);
+ if (IS_ERR(ext))
+ return PTR_ERR(ext);
+
+ available = ext->priv;
+
+ if (info.index >= available->num_items)
+ return -EINVAL;
+
+ count_modes = available->items;
+ info.count_mode = count_modes[info.index];
+
+ if (copy_to_user(uinfo, &info, sizeof(info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long counter_chrdev_ioctl(struct file *filp, unsigned int cmd,
+ unsigned long arg)
+{
+ struct counter_device *const counter = filp->private_data;
+
+ switch (cmd) {
+ case COUNTER_DEVICE_INFO_IOCTL:
+ return counter_device_info_ioctl(arg, counter);
+ case COUNTER_SIGNAL_INFO_IOCTL:
+ return counter_signal_info_ioctl(arg, counter);
+ case COUNTER_SYNAPSE_INFO_IOCTL:
+ return counter_synapse_info_ioctl(arg, counter);
+ case COUNTER_COUNT_INFO_IOCTL:
+ return counter_count_info_ioctl(arg, counter);
+ case COUNTER_EXT_INFO_IOCTL:
+ return counter_ext_info_ioctl(arg, counter);
+ case COUNTER_SIGNAL_GET_IOCTL:
+ return counter_signal_get_ioctl(arg, counter);
+ case COUNTER_COUNT_GET_IOCTL:
+ return counter_count_get_ioctl(arg, counter);
+ case COUNTER_COUNT_SET_IOCTL:
+ return counter_count_set_ioctl(arg, counter);
+ case COUNTER_COUNT_FUNCTION_GET_IOCTL:
+ return counter_count_function_get_ioctl(arg, counter);
+ case COUNTER_COUNT_FUNCTION_SET_IOCTL:
+ return counter_count_function_set_ioctl(arg, counter);
+ case COUNTER_SYNAPSE_ACTION_GET_IOCTL:
+ return counter_synapse_action_get_ioctl(arg, counter);
+ case COUNTER_SYNAPSE_ACTION_SET_IOCTL:
+ return counter_synapse_action_set_ioctl(arg, counter);
+ case COUNTER_COUNT_FUNCTION_INFO_IOCTL:
+ return counter_count_function_info_ioctl(arg, counter);
+ case COUNTER_SYNAPSE_ACTION_INFO_IOCTL:
+ return counter_synapse_action_info_ioctl(arg, counter);
+ case COUNTER_EXT_BOOL_GET_IOCTL:
+ return counter_ext_bool_get_ioctl(arg, counter);
+ case COUNTER_EXT_BOOL_SET_IOCTL:
+ return counter_ext_bool_set_ioctl(arg, counter);
+ case COUNTER_EXT_LU_GET_IOCTL:
+ return counter_ext_lu_get_ioctl(arg, counter);
+ case COUNTER_EXT_LU_SET_IOCTL:
+ return counter_ext_lu_set_ioctl(arg, counter);
+ case COUNTER_EXT_STRING_GET_IOCTL:
+ return counter_ext_string_get_ioctl(arg, counter);
+ case COUNTER_EXT_STRING_SET_IOCTL:
+ return counter_ext_string_set_ioctl(arg, counter);
+ case COUNTER_EXT_ENUM_GET_IOCTL:
+ return counter_ext_enum_get_ioctl(arg, counter);
+ case COUNTER_EXT_ENUM_SET_IOCTL:
+ return counter_ext_enum_set_ioctl(arg, counter);
+ case COUNTER_EXT_ENUM_INFO_IOCTL:
+ return counter_ext_enum_info_ioctl(arg, counter);
+ case COUNTER_COUNT_DIRECTION_GET_IOCTL:
+ return counter_count_direction_get_ioctl(arg, counter);
+ case COUNTER_COUNT_MODE_GET_IOCTL:
+ return counter_count_mode_get_ioctl(arg, counter);
+ case COUNTER_COUNT_MODE_SET_IOCTL:
+ return counter_count_mode_set_ioctl(arg, counter);
+ case COUNTER_COUNT_MODE_INFO_IOCTL:
+ return counter_count_mode_info_ioctl(arg, counter);
+ default:
+ break;
+ }
+
+ return -ENOIOCTLCMD;
+}
+
+static int counter_chrdev_open(struct inode *inode, struct file *filp)
+{
+ struct counter_device *const counter = container_of(inode->i_cdev,
+ struct counter_device,
+ chrdev);
+
+ get_device(&counter->dev);
+ filp->private_data = counter;
+
+ return nonseekable_open(inode, filp);
+}
+
+static int counter_chrdev_release(struct inode *inode, struct file *filp)
+{
+ struct counter_device *const counter = container_of(inode->i_cdev,
+ struct counter_device,
+ chrdev);
+
+ put_device(&counter->dev);
+
+ return 0;
+}
+
+static const struct file_operations counter_fops = {
+ .llseek = no_llseek,
+ .unlocked_ioctl = counter_chrdev_ioctl,
+ .open = counter_chrdev_open,
+ .release = counter_chrdev_release,
+};
+
+int counter_chrdev_add(struct counter_device *const counter,
+ const dev_t counter_devt)
+{
+ struct device *const dev = &counter->dev;
+ struct cdev *const chrdev = &counter->chrdev;
+
+ cdev_init(chrdev, &counter_fops);
+ dev->devt = MKDEV(MAJOR(counter_devt), counter->id);
+ cdev_set_parent(chrdev, &dev->kobj);
+
+ return cdev_add(chrdev, dev->devt, 1);
+}
+
+void counter_chrdev_free(struct counter_device *const counter)
+{
+ cdev_del(&counter->chrdev);
+}
diff --git a/drivers/counter/counter-chrdev.h b/drivers/counter/counter-chrdev.h
new file mode 100644
index 000000000000..7ab0797d3857
--- /dev/null
+++ b/drivers/counter/counter-chrdev.h
@@ -0,0 +1,16 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Counter character device interface
+ * Copyright (C) 2020 William Breathitt Gray
+ */
+#ifndef _COUNTER_CHRDEV_H_
+#define _COUNTER_CHRDEV_H_
+
+#include <linux/counter.h>
+#include <linux/types.h>
+
+int counter_chrdev_add(struct counter_device *const counter,
+ const dev_t counter_devt);
+void counter_chrdev_free(struct counter_device *const counter);
+
+#endif /* _COUNTER_CHRDEV_H_ */
diff --git a/drivers/counter/counter-core.c b/drivers/counter/counter-core.c
index 008d51284a2c..a345d3273ccd 100644
--- a/drivers/counter/counter-core.c
+++ b/drivers/counter/counter-core.c
@@ -7,12 +7,15 @@
#include <linux/device.h>
#include <linux/err.h>
#include <linux/export.h>
+#include <linux/fs.h>
#include <linux/gfp.h>
#include <linux/idr.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
+#include <linux/types.h>
+#include "counter-chrdev.h"
#include "counter-sysfs.h"
/* Provides a unique ID for each counter device */
@@ -36,6 +39,8 @@ static struct bus_type counter_bus_type = {
.name = "counter"
};
+static dev_t counter_devt;
+
/**
* counter_register - register Counter to the system
* @counter: pointer to Counter to register
@@ -65,10 +70,15 @@ int counter_register(struct counter_device *const counter)
device_initialize(dev);
dev_set_drvdata(dev, counter);
+ /* Add Counter character device */
+ err = counter_chrdev_add(counter, counter_devt);
+ if (err)
+ goto err_free_id;
+
/* Add Counter sysfs attributes */
err = counter_sysfs_add(counter);
if (err)
- goto err_free_id;
+ goto err_free_chrdev;
/* Add device to system */
err = device_add(dev);
@@ -79,6 +89,8 @@ int counter_register(struct counter_device *const counter)
err_free_sysfs:
counter_sysfs_free(counter);
+err_free_chrdev:
+ counter_chrdev_free(counter);
err_free_id:
ida_simple_remove(&counter_ida, counter->id);
return err;
@@ -96,6 +108,7 @@ void counter_unregister(struct counter_device *const counter)
if (counter) {
device_del(&counter->dev);
counter_sysfs_free(counter);
+ counter_chrdev_free(counter);
}
}
EXPORT_SYMBOL_GPL(counter_unregister);
@@ -172,13 +185,30 @@ void devm_counter_unregister(struct device *dev,
}
EXPORT_SYMBOL_GPL(devm_counter_unregister);
+#define COUNTER_DEV_MAX 256
+
static int __init counter_init(void)
{
- return bus_register(&counter_bus_type);
+ int err;
+
+ err = bus_register(&counter_bus_type);
+ if (err < 0)
+ return err;
+
+ err = alloc_chrdev_region(&counter_devt, 0, COUNTER_DEV_MAX, "counter");
+ if (err < 0)
+ goto err_unregister_bus;
+
+ return 0;
+
+err_unregister_bus:
+ bus_unregister(&counter_bus_type);
+ return err;
}
static void __exit counter_exit(void)
{
+ unregister_chrdev_region(counter_devt, COUNTER_DEV_MAX);
bus_unregister(&counter_bus_type);
}
diff --git a/include/linux/counter.h b/include/linux/counter.h
index d628c7eaf754..2ae361b4734c 100644
--- a/include/linux/counter.h
+++ b/include/linux/counter.h
@@ -6,6 +6,7 @@
#ifndef _COUNTER_H_
#define _COUNTER_H_
+#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/list.h>
@@ -162,6 +163,7 @@ struct counter_device {
int id;
struct device dev;
+ struct cdev chrdev;
struct list_head synapse_names_list;
struct counter_attribute_group *groups_list;
size_t num_groups;
diff --git a/include/uapi/linux/counter.h b/include/uapi/linux/counter.h
new file mode 100644
index 000000000000..7e4b1f158d57
--- /dev/null
+++ b/include/uapi/linux/counter.h
@@ -0,0 +1,313 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * Userspace ABI for Counter character devices
+ * Copyright (C) 2020 William Breathitt Gray
+ */
+#ifndef _UAPI_COUNTER_H_
+#define _UAPI_COUNTER_H_
+
+#include <linux/counter-types.h>
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+/**
+ * struct counter_device_info - Counter device information
+ * @name: name of the device
+ * @num_signals: number of Signals
+ * @num_counts: number of Counts
+ * @num_ext: number of Counter device extensions
+ */
+struct counter_device_info {
+ char name[32];
+ size_t num_signals;
+ size_t num_counts;
+ size_t num_ext;
+};
+
+/**
+ * struct counter_signal_info - Signal information
+ * @index: index of the Signal
+ * @id: unique ID used to identify the Signal
+ * @name: device-specific Signal name
+ * @num_ext: number of Signal extensions
+ */
+struct counter_signal_info {
+ size_t index;
+
+ int id;
+ char name[32];
+ size_t num_ext;
+};
+
+/**
+ * struct counter_synapse_info - Synapse information
+ * @count_index: index of the Count
+ * @index: index of the Synapse
+ * @num_actions: number of action modes
+ * @signal_index: index of the associated Signal
+ */
+struct counter_synapse_info {
+ size_t count_index;
+ size_t index;
+
+ size_t num_actions;
+ size_t signal_index;
+};
+
+/**
+ * struct counter_count_info - Count information
+ * @index: index of the Count
+ * @id: unique ID used to identify Count
+ * @name: device-specific Count name
+ * @num_functions: number of function modes
+ * @num_synapses: number of synapses
+ * @num_ext: number of Count extensions
+ */
+struct counter_count_info {
+ size_t index;
+
+ int id;
+ char name[32];
+ size_t num_functions;
+ size_t num_synapses;
+ size_t num_ext;
+};
+
+/**
+ * struct counter_ext_info - Counter extension information
+ * @owner_type: component type of the owner
+ * @owner_index: index of the owning Count or Signal
+ * @index: index of the extension
+ * @type: data type of the extension
+ * @name: name of the extension
+ */
+struct counter_ext_info {
+ enum counter_owner_type owner_type;
+ size_t owner_index;
+ size_t index;
+
+ enum counter_data_type type;
+ char name[32];
+};
+
+/**
+ * struct counter_signal_request - Signal request
+ * @index: index of the Signal
+ * @value: Signal value
+ */
+struct counter_signal_request {
+ size_t index;
+
+ enum counter_signal_value value;
+};
+
+/**
+ * struct counter_count_request - Count request
+ * @index: index of the Count
+ * @value: Count value
+ */
+struct counter_count_request {
+ size_t index;
+
+ unsigned long value;
+};
+
+/**
+ * struct counter_count_function_request - Count function mode request
+ * @index: index of the Count
+ * @function: Count function mode
+ */
+struct counter_count_function_request {
+ size_t index;
+
+ enum counter_count_function function;
+};
+
+/**
+ * struct counter_synapse_action_request - Synapse action mode request
+ * @count_index: index of the Count
+ * @index: index of the Synapse
+ * @action: Synapse action mode
+ */
+struct counter_synapse_action_request {
+ size_t count_index;
+ size_t index;
+
+ enum counter_synapse_action action;
+};
+
+/**
+ * struct counter_count_function_info - Count function mode information
+ * @count_index: index of the Count
+ * @index: index of the Count function mode
+ * @function: Count function mode
+ */
+struct counter_count_function_info {
+ size_t count_index;
+ size_t index;
+
+ enum counter_count_function function;
+};
+
+/**
+ * struct counter_synapse_action_info - Synapse action mode information
+ * @count_index: index of the Count
+ * @synapse_index: index of the Synapse
+ * @index: index of the Synapse action mode
+ * @action: Synapse action mode
+ */
+struct counter_synapse_action_info {
+ size_t count_index;
+ size_t synapse_index;
+ size_t index;
+
+ enum counter_synapse_action action;
+};
+
+/**
+ * struct counter_ext_bool_request - Counter extension bool data request
+ * @owner_type: component type of the owner
+ * @owner_index: index of the owning Count or Signal
+ * @index: index of the extension
+ * @data: extension data
+ */
+struct counter_ext_bool_request {
+ enum counter_owner_type owner_type;
+ size_t owner_index;
+ size_t index;
+
+ bool data;
+};
+
+/**
+ * struct counter_ext_lu_request - Counter extension unsigned long data request
+ * @owner_type: component type of the owner
+ * @owner_index: index of the owning Count or Signal
+ * @index: index of the extension
+ * @data: extension data
+ */
+struct counter_ext_lu_request {
+ enum counter_owner_type owner_type;
+ size_t owner_index;
+ size_t index;
+
+ unsigned long data;
+};
+
+/**
+ * struct counter_ext_string_request - Counter extension string data request
+ * @owner_type: component type of the owner
+ * @owner_index: index of the owning Count or Signal
+ * @index: index of the extension
+ * @data: extension data
+ */
+struct counter_ext_string_request {
+ enum counter_owner_type owner_type;
+ size_t owner_index;
+ size_t index;
+
+ char data[32];
+};
+
+/**
+ * struct counter_ext_enum_request - Counter extension enum request
+ * @owner_type: component type of the owner
+ * @owner_index: index of the owning Count or Signal
+ * @index: index of the extension
+ * @enum_index: index of the extension enum
+ */
+struct counter_ext_enum_request {
+ enum counter_owner_type owner_type;
+ size_t owner_index;
+ size_t index;
+
+ size_t enum_index;
+};
+
+/**
+ * struct counter_ext_enum_info - Counter extension enum information
+ * @owner_type: component type of the owner
+ * @owner_index: index of the owning Count or Signal
+ * @ext_index: index of the extension
+ * @index: index of the extension enum
+ * @data: extension enum value
+ */
+struct counter_ext_enum_info {
+ enum counter_owner_type owner_type;
+ size_t owner_index;
+ size_t ext_index;
+ size_t index;
+
+ char value[32];
+};
+
+/**
+ * struct counter_count_direction_request - Counter count direction request
+ * @count_index: index of the Count
+ * @index: index of the extension
+ * @direction: Count direction
+ */
+struct counter_count_direction_request {
+ size_t count_index;
+ size_t index;
+
+ enum counter_count_direction direction;
+};
+
+/**
+ * struct counter_count_mode_request - Counter count mode request
+ * @count_index: index of the Count
+ * @index: index of the extension
+ * @count_mode: count mode
+ */
+struct counter_count_mode_request {
+ size_t count_index;
+ size_t index;
+
+ enum counter_count_mode count_mode;
+};
+
+/**
+ * struct counter_count_mode_info - Counter count mode information
+ * @count_index: index of the Count
+ * @ext_index: index of the extension
+ * @index: index of the count mode
+ * @count_mode: count mode
+ */
+struct counter_count_mode_info {
+ size_t count_index;
+ size_t ext_index;
+ size_t index;
+
+ enum counter_count_mode count_mode;
+};
+
+#define COUNTER_DEVICE_INFO_IOCTL _IOR(0x3E, 0x00, struct counter_device_info)
+#define COUNTER_SIGNAL_INFO_IOCTL _IOWR(0x3E, 0x01, struct counter_signal_info)
+#define COUNTER_SYNAPSE_INFO_IOCTL _IOWR(0x3E, 0x02, struct counter_synapse_info)
+#define COUNTER_COUNT_INFO_IOCTL _IOWR(0x3E, 0x03, struct counter_count_info)
+#define COUNTER_EXT_INFO_IOCTL _IOWR(0x3E, 0x04, struct counter_ext_info)
+#define COUNTER_SIGNAL_GET_IOCTL _IOWR(0x3E, 0x05, struct counter_signal_request)
+#define COUNTER_COUNT_GET_IOCTL _IOWR(0x3E, 0x06, struct counter_count_request)
+#define COUNTER_COUNT_SET_IOCTL _IOW(0x3E, 0x07, struct counter_count_request)
+#define COUNTER_COUNT_FUNCTION_GET_IOCTL _IOWR(0x3E, 0x08, struct counter_count_function_request)
+#define COUNTER_COUNT_FUNCTION_SET_IOCTL _IOW(0x3E, 0x09, struct counter_count_function_request)
+#define COUNTER_SYNAPSE_ACTION_GET_IOCTL _IOWR(0x3E, 0x0A, struct counter_synapse_action_request)
+#define COUNTER_SYNAPSE_ACTION_SET_IOCTL _IOW(0x3E, 0x0B, struct counter_synapse_action_request)
+#define COUNTER_COUNT_FUNCTION_INFO_IOCTL _IOWR(0x3E, 0x0C, struct counter_count_function_info)
+#define COUNTER_SYNAPSE_ACTION_INFO_IOCTL _IOWR(0x3E, 0x0D, struct counter_synapse_action_info)
+#define COUNTER_EXT_BOOL_GET_IOCTL _IOWR(0x3E, 0x0E, struct counter_ext_bool_request)
+#define COUNTER_EXT_BOOL_SET_IOCTL _IOW(0x3E, 0x0F, struct counter_ext_bool_request)
+#define COUNTER_EXT_LU_GET_IOCTL _IOWR(0x3E, 0x10, struct counter_ext_lu_request)
+#define COUNTER_EXT_LU_SET_IOCTL _IOW(0x3E, 0x11, struct counter_ext_lu_request)
+#define COUNTER_EXT_STRING_GET_IOCTL _IOWR(0x3E, 0x12, struct counter_ext_string_request)
+#define COUNTER_EXT_STRING_SET_IOCTL _IOW(0x3E, 0x13, struct counter_ext_string_request)
+#define COUNTER_EXT_ENUM_GET_IOCTL _IOWR(0x3E, 0x14, struct counter_ext_enum_request)
+#define COUNTER_EXT_ENUM_SET_IOCTL _IOW(0x3E, 0x15, struct counter_ext_enum_request)
+#define COUNTER_EXT_ENUM_INFO_IOCTL _IOWR(0x3E, 0x16, struct counter_ext_enum_info)
+#define COUNTER_COUNT_DIRECTION_GET_IOCTL _IOWR(0x3E, 0x17, struct counter_count_direction_request)
+#define COUNTER_COUNT_MODE_GET_IOCTL _IOWR(0x3E, 0x18, struct counter_count_mode_request)
+#define COUNTER_COUNT_MODE_SET_IOCTL _IOW(0x3E, 0x19, struct counter_count_mode_request)
+#define COUNTER_COUNT_MODE_INFO_IOCTL _IOWR(0x3E, 0x1A, struct counter_count_mode_info)
+
+#endif /* _UAPI_COUNTER_H_ */
--
2.26.2
This is a reimplementation of the Generic Counter driver interface.
There are no modifications to the Counter subsystem userspace interface,
so existing userspace applications should continue to run seamlessly.
Overview
========
The purpose of this patch is to internalize the sysfs interface code
among the various counter drivers into a shared module. Counter drivers
pass and take data natively (i.e. unsigned long, bool, size_t, etc.) and
the shared counter module handles the translation between the sysfs
interface. This gurantees a standard userspace interface for all counter
drivers, and helps generalize the Generic Counter driver ABI in order to
support the Generic Counter chardev interface (introduced in a
subsequent patch) without changes to the existing counter drivers.
A high-level view of how a count value is passed down from a counter
driver can be exemplified by the following:
----------------------
/ Counter device \
+----------------------+
| Count register: 0x28 |
+----------------------+
|
-----------------
/ raw count data /
-----------------
|
V
+----------------------------+
| Counter device driver |----------+
+----------------------------+ |
| Processes data from device | -------------------
|----------------------------| / driver callbacks /
| Type: unsigned long | -------------------
| Value: 42 | |
+----------------------------+ |
| |
---------------- |
/ unsigned long / |
---------------- |
| |
| V
| +----------------------+
| | Counter core |
| +----------------------+
| | Routes device driver |
| | callbacks to the |
| | userspace interfaces |
| +----------------------+
| |
| -------------------
| / driver callbacks /
| -------------------
| |
+-------+ |
| |
| +---------------+
| |
V |
+--------------------+ |
| Counter sysfs |<-+
+--------------------+
| Translates to the |
| standard Counter |
| sysfs output |
|--------------------|
| Type: const char * |
| Value: "42" |
+--------------------+
|
---------------
/ const char * /
---------------
|
V
+--------------------------------------------------+
| `/sys/bus/counter/devices/counterX/countY/count` |
+--------------------------------------------------+
\ Count: "42" /
--------------------------------------------------
There are three primary components involved:
Counter device driver
---------------------
Communicates with the hardware device to read/write data; e.g.
counter drivers for 104-quad-8, stm32-timer, etc.
Counter core
------------
Registers the counter device driver to the system so that the
respective callbacks are called during userspace interaction
Counter sysfs
-------------
Translates counter data to the standard Counter sysfs interface
format and vice versa
Driver ABI
==========
This reimplementation entails several changes to the driver ABI. In
particular, the device driver callbacks are now expected to handle
standard C datatypes rather than translating the sysfs I/O directly.
To that end, the struct counter_data structure is introduced to
establish counter extensions for Signals, Synapses, and Counts:
struct counter_data {
enum counter_data_type type;
const char *name;
void *read;
void *write;
void *priv;
};
The "type" member specifies the type of data (e.g. unsigned long,
boolean, etc.) handled by this extension. The "read" and "write" members
can then be set by the counter device driver with callbacks to handle
that data.
Convenience macros such as COUNTER_DATA_UNSIGNED_LONG are provided for
use by driver authors. In particular, driver authors are expected to use
the provided macros for standard Counter subsystem attributes in order
to maintain a consistent interface for userspace. For example, a counter
device driver may define several standard attributes like so:
struct counter_data count_ext[] = {
COUNTER_DATA_DIRECTION(count_direction_read),
COUNTER_DATA_ENABLE(count_enable_read, count_enable_write),
COUNTER_DATA_CEILING(count_ceiling_read, count_ceiling_write),
};
This makes it intuitive to see, add, and modify the attributes that are
supported by this driver ("direction", "enable", and "ceiling") and to
maintain this code without getting lost in a web of struct braces.
Callbacks must match the function type expected for the respective
component or extension. These types are defined in the
drivers/counter/counter-function-types.h file.
The corresponding prototypes for the callbacks would be:
int count_direction_read(struct counter_device *counter,
struct counter_count *count,
enum counter_count_direction *direction);
int count_enable_read(struct counter_device *counter,
struct counter_count *count, bool *enable);
int count_enable_write(struct counter_device *counter,
struct counter_count *count, bool enable);
int count_ceiling_read(struct counter_device *counter,
struct counter_count *count,
unsigned long *ceiling);
int count_ceiling_write(struct counter_device *counter,
struct counter_count *count,
unsigned long ceiling);
In this way, driver authors no longer need to mess with sysfs strings
and are instead able to focus on what they actually care about doing --
getting data to/from the devices -- while the Generic Counter interface
handles the translation of that data for them between the various
userspace interfaces (e.g. sysfs and chardev).
Architecture
============
Counter device registration is the same as before: drivers populate a
struct counter_device with components and callbacks, then pass the
structure to the devm_counter_register function. However, what's
different now is how the Counter subsystem code handles this
registration internally.
Whereas before callbacks would interact directly with sysfs data, this
interaction is now abstracted and instead callbacks interact with native
C data types. The counter_data structure forms the basis for Counter
extentions.
The counter-sysfs.c file contains the code to parse through the
counter_device structure and register the requested components and
extensions. Attributes are created and populated based on type, with
respective translation functions to handle the mapping between sysfs and
the counter driver callbacks.
The counter-sysfs-callbacks.c file contains the code to map between the
abstract read and write callbacks of the counter driver and the more
specific show and store callbacks expected for sysfs. This mapping is
represented by the counter_data_sysfs_show and counter_data_sysfs_store
arrays, which point to the show and store translation functions for each
attribute.
The translation performed for each attribute is straightforward: the
attribute type and data is parsed from the counter_attribute structure,
the respective counter driver read/write callback is cast, and sysfs
I/O is handled before or after the driver read/write function is called.
The counter-function-types.h file contains the typedefs to simplify this
casting code. The counter-strings.h file contains the standard Counter
sysfs I/O string constants to maintain a consistent interface for
userspace.
Cc: Syed Nayyar Waris <[email protected]>
Cc: Patrick Havelange <[email protected]>
Cc: Fabrice Gasnier <[email protected]>
Cc: Maxime Coquelin <[email protected]>
Cc: Alexandre Torgue <[email protected]>
Cc: David Lechner <[email protected]>
Signed-off-by: William Breathitt Gray <[email protected]>
---
MAINTAINERS | 2 +-
drivers/counter/104-quad-8.c | 437 +++---
drivers/counter/Makefile | 1 +
drivers/counter/counter-core.c | 190 +++
drivers/counter/counter-function-types.h | 81 ++
drivers/counter/counter-strings.h | 46 +
drivers/counter/counter-sysfs-callbacks.c | 566 ++++++++
drivers/counter/counter-sysfs-callbacks.h | 28 +
drivers/counter/counter-sysfs.c | 524 ++++++++
drivers/counter/counter-sysfs.h | 14 +
drivers/counter/counter.c | 1496 ---------------------
drivers/counter/ftm-quaddec.c | 46 +-
drivers/counter/stm32-lptimer-cnt.c | 159 +--
drivers/counter/stm32-timer-cnt.c | 132 +-
drivers/counter/ti-eqep.c | 170 +--
include/linux/counter.h | 545 +++-----
include/linux/counter_enum.h | 45 -
include/uapi/linux/counter-types.h | 67 +
18 files changed, 2130 insertions(+), 2419 deletions(-)
create mode 100644 drivers/counter/counter-core.c
create mode 100644 drivers/counter/counter-function-types.h
create mode 100644 drivers/counter/counter-strings.h
create mode 100644 drivers/counter/counter-sysfs-callbacks.c
create mode 100644 drivers/counter/counter-sysfs-callbacks.h
create mode 100644 drivers/counter/counter-sysfs.c
create mode 100644 drivers/counter/counter-sysfs.h
delete mode 100644 drivers/counter/counter.c
delete mode 100644 include/linux/counter_enum.h
create mode 100644 include/uapi/linux/counter-types.h
diff --git a/MAINTAINERS b/MAINTAINERS
index 10eb348c801c..89def3fe1c76 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -4367,7 +4367,7 @@ F: Documentation/ABI/testing/sysfs-bus-counter*
F: Documentation/driver-api/generic-counter.rst
F: drivers/counter/
F: include/linux/counter.h
-F: include/linux/counter_enum.h
+F: include/uapi/linux/counter-types.h
CPMAC ETHERNET DRIVER
M: Florian Fainelli <[email protected]>
diff --git a/drivers/counter/104-quad-8.c b/drivers/counter/104-quad-8.c
index 9dab190c49b0..bc1801e1bce9 100644
--- a/drivers/counter/104-quad-8.c
+++ b/drivers/counter/104-quad-8.c
@@ -651,21 +651,22 @@ static int quad8_count_write(struct counter_device *counter,
}
enum quad8_count_function {
- QUAD8_COUNT_FUNCTION_PULSE_DIRECTION = 0,
- QUAD8_COUNT_FUNCTION_QUADRATURE_X1,
- QUAD8_COUNT_FUNCTION_QUADRATURE_X2,
- QUAD8_COUNT_FUNCTION_QUADRATURE_X4
+ QUAD8_COUNT_FUNCTION_PULSE_DIRECTION = COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
+ QUAD8_COUNT_FUNCTION_QUADRATURE_X1 = COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A,
+ QUAD8_COUNT_FUNCTION_QUADRATURE_X2 = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
+ QUAD8_COUNT_FUNCTION_QUADRATURE_X4 = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
};
-static enum counter_count_function quad8_count_functions_list[] = {
- [QUAD8_COUNT_FUNCTION_PULSE_DIRECTION] = COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
- [QUAD8_COUNT_FUNCTION_QUADRATURE_X1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A,
- [QUAD8_COUNT_FUNCTION_QUADRATURE_X2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
- [QUAD8_COUNT_FUNCTION_QUADRATURE_X4] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4
+static const enum counter_count_function quad8_count_functions_list[] = {
+ QUAD8_COUNT_FUNCTION_PULSE_DIRECTION,
+ QUAD8_COUNT_FUNCTION_QUADRATURE_X1,
+ QUAD8_COUNT_FUNCTION_QUADRATURE_X2,
+ QUAD8_COUNT_FUNCTION_QUADRATURE_X4,
};
-static int quad8_function_get(struct counter_device *counter,
- struct counter_count *count, size_t *function)
+static int quad8_function_read(struct counter_device *counter,
+ struct counter_count *count,
+ enum counter_count_function *function)
{
const struct quad8_iio *const priv = counter->priv;
const int id = count->id;
@@ -690,11 +691,13 @@ static int quad8_function_get(struct counter_device *counter,
return 0;
}
-static int quad8_function_set(struct counter_device *counter,
- struct counter_count *count, size_t function)
+static int quad8_function_write(struct counter_device *counter,
+ struct counter_count *count,
+ enum counter_count_function function)
{
struct quad8_iio *const priv = counter->priv;
const int id = count->id;
+ const enum quad8_count_function cnt_function = function;
unsigned int *const quadrature_mode = priv->quadrature_mode + id;
unsigned int *const scale = priv->quadrature_scale + id;
unsigned int mode_cfg = priv->count_mode[id] << 1;
@@ -702,7 +705,7 @@ static int quad8_function_set(struct counter_device *counter,
const unsigned int idr_cfg = priv->index_polarity[id] << 1;
const int base_offset = priv->base + 2 * id + 1;
- if (function == QUAD8_COUNT_FUNCTION_PULSE_DIRECTION) {
+ if (cnt_function == QUAD8_COUNT_FUNCTION_PULSE_DIRECTION) {
*quadrature_mode = 0;
/* Quadrature scaling only available in quadrature mode */
@@ -717,7 +720,7 @@ static int quad8_function_set(struct counter_device *counter,
} else {
*quadrature_mode = 1;
- switch (function) {
+ switch (cnt_function) {
case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
*scale = 0;
mode_cfg |= QUAD8_CMR_QUADRATURE_X1;
@@ -730,6 +733,7 @@ static int quad8_function_set(struct counter_device *counter,
*scale = 2;
mode_cfg |= QUAD8_CMR_QUADRATURE_X4;
break;
+ default: return -EINVAL;
}
}
@@ -739,8 +743,9 @@ static int quad8_function_set(struct counter_device *counter,
return 0;
}
-static void quad8_direction_get(struct counter_device *counter,
- struct counter_count *count, enum counter_count_direction *direction)
+static int quad8_direction_read(struct counter_device *counter,
+ struct counter_count *count,
+ enum counter_count_direction *direction)
{
const struct quad8_iio *const priv = counter->priv;
unsigned int ud_flag;
@@ -751,91 +756,81 @@ static void quad8_direction_get(struct counter_device *counter,
*direction = (ud_flag) ? COUNTER_COUNT_DIRECTION_FORWARD :
COUNTER_COUNT_DIRECTION_BACKWARD;
-}
-enum quad8_synapse_action {
- QUAD8_SYNAPSE_ACTION_NONE = 0,
- QUAD8_SYNAPSE_ACTION_RISING_EDGE,
- QUAD8_SYNAPSE_ACTION_FALLING_EDGE,
- QUAD8_SYNAPSE_ACTION_BOTH_EDGES
-};
+ return 0;
+}
-static enum counter_synapse_action quad8_index_actions_list[] = {
- [QUAD8_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
- [QUAD8_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE
+static const enum counter_synapse_action quad8_index_actions_list[] = {
+ COUNTER_SYNAPSE_ACTION_NONE,
+ COUNTER_SYNAPSE_ACTION_RISING_EDGE,
};
-static enum counter_synapse_action quad8_synapse_actions_list[] = {
- [QUAD8_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
- [QUAD8_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
- [QUAD8_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
- [QUAD8_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES
+static const enum counter_synapse_action quad8_synapse_actions_list[] = {
+ COUNTER_SYNAPSE_ACTION_NONE,
+ COUNTER_SYNAPSE_ACTION_RISING_EDGE,
+ COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
+ COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
};
-static int quad8_action_get(struct counter_device *counter,
- struct counter_count *count, struct counter_synapse *synapse,
- size_t *action)
+static int quad8_action_read(struct counter_device *counter,
+ struct counter_count *count,
+ struct counter_synapse *synapse,
+ enum counter_synapse_action *action)
{
struct quad8_iio *const priv = counter->priv;
int err;
- size_t function = 0;
+ enum counter_count_function function = 0;
const size_t signal_a_id = count->synapses[0].signal->id;
enum counter_count_direction direction;
/* Handle Index signals */
if (synapse->signal->id >= 16) {
if (priv->preset_enable[count->id])
- *action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
+ *action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
else
- *action = QUAD8_SYNAPSE_ACTION_NONE;
+ *action = COUNTER_SYNAPSE_ACTION_NONE;
return 0;
}
- err = quad8_function_get(counter, count, &function);
+ err = quad8_function_read(counter, count, &function);
if (err)
return err;
/* Default action mode */
- *action = QUAD8_SYNAPSE_ACTION_NONE;
+ *action = COUNTER_SYNAPSE_ACTION_NONE;
/* Determine action mode based on current count function mode */
switch (function) {
case QUAD8_COUNT_FUNCTION_PULSE_DIRECTION:
if (synapse->signal->id == signal_a_id)
- *action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
+ *action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
break;
case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
if (synapse->signal->id == signal_a_id) {
- quad8_direction_get(counter, count, &direction);
+ err = quad8_direction_read(counter, count, &direction);
+ if (err)
+ return err;
if (direction == COUNTER_COUNT_DIRECTION_FORWARD)
- *action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
+ *action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
else
- *action = QUAD8_SYNAPSE_ACTION_FALLING_EDGE;
+ *action = COUNTER_SYNAPSE_ACTION_FALLING_EDGE;
}
break;
case QUAD8_COUNT_FUNCTION_QUADRATURE_X2:
if (synapse->signal->id == signal_a_id)
- *action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
+ *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
break;
case QUAD8_COUNT_FUNCTION_QUADRATURE_X4:
- *action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
+ *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
break;
+ default: return -EINVAL;
}
return 0;
}
-static const struct counter_ops quad8_ops = {
- .signal_read = quad8_signal_read,
- .count_read = quad8_count_read,
- .count_write = quad8_count_write,
- .function_get = quad8_function_get,
- .function_set = quad8_function_set,
- .action_get = quad8_action_get
-};
-
static int quad8_index_polarity_get(struct counter_device *counter,
struct counter_signal *signal, size_t *index_polarity)
{
@@ -864,12 +859,7 @@ static int quad8_index_polarity_set(struct counter_device *counter,
return 0;
}
-static struct counter_signal_enum_ext quad8_index_pol_enum = {
- .items = quad8_index_polarity_modes,
- .num_items = ARRAY_SIZE(quad8_index_polarity_modes),
- .get = quad8_index_polarity_get,
- .set = quad8_index_polarity_set
-};
+static DEFINE_COUNTER_ENUM(quad8_index_pol_enum, quad8_index_polarity_modes);
static int quad8_synchronous_mode_get(struct counter_device *counter,
struct counter_signal *signal, size_t *synchronous_mode)
@@ -903,22 +893,21 @@ static int quad8_synchronous_mode_set(struct counter_device *counter,
return 0;
}
-static struct counter_signal_enum_ext quad8_syn_mode_enum = {
- .items = quad8_synchronous_modes,
- .num_items = ARRAY_SIZE(quad8_synchronous_modes),
- .get = quad8_synchronous_mode_get,
- .set = quad8_synchronous_mode_set
-};
+static DEFINE_COUNTER_ENUM(quad8_syn_mode_enum, quad8_synchronous_modes);
-static ssize_t quad8_count_floor_read(struct counter_device *counter,
- struct counter_count *count, void *private, char *buf)
+static int quad8_count_floor_read(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long *floor)
{
/* Only a floor of 0 is supported */
- return sprintf(buf, "0\n");
+ *floor = 0;
+
+ return 0;
}
-static int quad8_count_mode_get(struct counter_device *counter,
- struct counter_count *count, size_t *cnt_mode)
+static int quad8_count_mode_read(struct counter_device *counter,
+ struct counter_count *count,
+ enum counter_count_mode *cnt_mode)
{
const struct quad8_iio *const priv = counter->priv;
@@ -941,33 +930,35 @@ static int quad8_count_mode_get(struct counter_device *counter,
return 0;
}
-static int quad8_count_mode_set(struct counter_device *counter,
- struct counter_count *count, size_t cnt_mode)
+static int quad8_count_mode_write(struct counter_device *counter,
+ struct counter_count *count,
+ enum counter_count_mode cnt_mode)
{
struct quad8_iio *const priv = counter->priv;
+ unsigned int count_mode = 0;
unsigned int mode_cfg;
const int base_offset = priv->base + 2 * count->id + 1;
/* Map Generic Counter count mode to 104-QUAD-8 count mode */
switch (cnt_mode) {
case COUNTER_COUNT_MODE_NORMAL:
- cnt_mode = 0;
+ count_mode = 0;
break;
case COUNTER_COUNT_MODE_RANGE_LIMIT:
- cnt_mode = 1;
+ count_mode = 1;
break;
case COUNTER_COUNT_MODE_NON_RECYCLE:
- cnt_mode = 2;
+ count_mode = 2;
break;
case COUNTER_COUNT_MODE_MODULO_N:
- cnt_mode = 3;
+ count_mode = 3;
break;
}
- priv->count_mode[count->id] = cnt_mode;
+ priv->count_mode[count->id] = count_mode;
/* Set count mode configuration value */
- mode_cfg = cnt_mode << 1;
+ mode_cfg = count_mode << 1;
/* Add quadrature mode configuration */
if (priv->quadrature_mode[count->id])
@@ -979,92 +970,89 @@ static int quad8_count_mode_set(struct counter_device *counter,
return 0;
}
-static struct counter_count_enum_ext quad8_cnt_mode_enum = {
- .items = counter_count_mode_str,
- .num_items = ARRAY_SIZE(counter_count_mode_str),
- .get = quad8_count_mode_get,
- .set = quad8_count_mode_set
+static enum counter_count_mode quad8_cnt_modes[] = {
+ COUNTER_COUNT_MODE_NORMAL,
+ COUNTER_COUNT_MODE_RANGE_LIMIT,
+ COUNTER_COUNT_MODE_NON_RECYCLE,
+ COUNTER_COUNT_MODE_MODULO_N,
};
-static ssize_t quad8_count_direction_read(struct counter_device *counter,
- struct counter_count *count, void *priv, char *buf)
-{
- enum counter_count_direction dir;
-
- quad8_direction_get(counter, count, &dir);
-
- return sprintf(buf, "%s\n", counter_count_direction_str[dir]);
-}
+static DEFINE_COUNTER_AVAILABLE(quad8_count_mode_available, quad8_cnt_modes);
-static ssize_t quad8_count_enable_read(struct counter_device *counter,
- struct counter_count *count, void *private, char *buf)
+static int quad8_count_enable_read(struct counter_device *counter,
+ struct counter_count *count, bool *enable)
{
const struct quad8_iio *const priv = counter->priv;
- return sprintf(buf, "%u\n", priv->ab_enable[count->id]);
+ *enable = priv->ab_enable[count->id];
+
+ return 0;
}
-static ssize_t quad8_count_enable_write(struct counter_device *counter,
- struct counter_count *count, void *private, const char *buf, size_t len)
+static int quad8_count_enable_write(struct counter_device *counter,
+ struct counter_count *count, bool enable)
{
struct quad8_iio *const priv = counter->priv;
const int base_offset = priv->base + 2 * count->id;
- int err;
- bool ab_enable;
unsigned int ior_cfg;
- err = kstrtobool(buf, &ab_enable);
- if (err)
- return err;
+ priv->ab_enable[count->id] = enable;
- priv->ab_enable[count->id] = ab_enable;
-
- ior_cfg = ab_enable | priv->preset_enable[count->id] << 1;
+ ior_cfg = enable | priv->preset_enable[count->id] << 1;
/* Load I/O control configuration */
outb(QUAD8_CTR_IOR | ior_cfg, base_offset + 1);
- return len;
+ return 0;
}
-static int quad8_error_noise_get(struct counter_device *counter,
- struct counter_count *count, size_t *noise_error)
+static ssize_t quad8_error_noise_read(struct counter_device *counter,
+ struct counter_count *count, char *buf,
+ size_t size)
{
const struct quad8_iio *const priv = counter->priv;
const int base_offset = priv->base + 2 * count->id + 1;
+ size_t noise_error;
- *noise_error = !!(inb(base_offset) & QUAD8_FLAG_E);
+ noise_error = !!(inb(base_offset) & QUAD8_FLAG_E);
- return 0;
+ return snprintf(buf, size, "%s\n",
+ quad8_noise_error_states[noise_error]);
}
-static struct counter_count_enum_ext quad8_error_noise_enum = {
- .items = quad8_noise_error_states,
- .num_items = ARRAY_SIZE(quad8_noise_error_states),
- .get = quad8_error_noise_get
-};
+static ssize_t quad8_error_noise_available_read(struct counter_device *counter,
+ struct counter_count *count,
+ char *buf, size_t size)
+{
+ size_t i;
+ size_t len = 0;
-static ssize_t quad8_count_preset_read(struct counter_device *counter,
- struct counter_count *count, void *private, char *buf)
+ for (i = 0; i < ARRAY_SIZE(quad8_noise_error_states) && size > 1; i++)
+ len += scnprintf(buf + len, size - len, "%s\n",
+ quad8_noise_error_states[i]);
+
+ return len;
+}
+
+static int quad8_count_preset_read(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long *preset)
{
const struct quad8_iio *const priv = counter->priv;
- return sprintf(buf, "%u\n", priv->preset[count->id]);
+ *preset = priv->preset[count->id];
+
+ return 0;
}
-static ssize_t quad8_count_preset_write(struct counter_device *counter,
- struct counter_count *count, void *private, const char *buf, size_t len)
+static int quad8_count_preset_write(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long preset)
{
struct quad8_iio *const priv = counter->priv;
const int base_offset = priv->base + 2 * count->id;
- unsigned int preset;
- int ret;
int i;
- ret = kstrtouint(buf, 0, &preset);
- if (ret)
- return ret;
-
/* Only 24-bit values are supported */
if (preset > 0xFFFFFF)
return -EINVAL;
@@ -1078,11 +1066,12 @@ static ssize_t quad8_count_preset_write(struct counter_device *counter,
for (i = 0; i < 3; i++)
outb(preset >> (8 * i), base_offset);
- return len;
+ return 0;
}
-static ssize_t quad8_count_ceiling_read(struct counter_device *counter,
- struct counter_count *count, void *private, char *buf)
+static int quad8_count_ceiling_read(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long *ceiling)
{
const struct quad8_iio *const priv = counter->priv;
@@ -1090,15 +1079,18 @@ static ssize_t quad8_count_ceiling_read(struct counter_device *counter,
switch (priv->count_mode[count->id]) {
case 1:
case 3:
- return quad8_count_preset_read(counter, count, private, buf);
+ return quad8_count_preset_read(counter, count, ceiling);
}
/* By default 0x1FFFFFF (25 bits unsigned) is maximum count */
- return sprintf(buf, "33554431\n");
+ *ceiling = 0x1FFFFFF;
+
+ return 0;
}
-static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
- struct counter_count *count, void *private, const char *buf, size_t len)
+static int quad8_count_ceiling_write(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long ceiling)
{
struct quad8_iio *const priv = counter->priv;
@@ -1106,34 +1098,31 @@ static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
switch (priv->count_mode[count->id]) {
case 1:
case 3:
- return quad8_count_preset_write(counter, count, private, buf,
- len);
+ return quad8_count_preset_write(counter, count, ceiling);
}
- return len;
+ return -EINVAL;
}
-static ssize_t quad8_count_preset_enable_read(struct counter_device *counter,
- struct counter_count *count, void *private, char *buf)
+static int quad8_count_preset_enable_read(struct counter_device *counter,
+ struct counter_count *count,
+ bool *preset_enable)
{
const struct quad8_iio *const priv = counter->priv;
- return sprintf(buf, "%u\n", !priv->preset_enable[count->id]);
+ *preset_enable = !priv->preset_enable[count->id];
+
+ return 0;
}
-static ssize_t quad8_count_preset_enable_write(struct counter_device *counter,
- struct counter_count *count, void *private, const char *buf, size_t len)
+static int quad8_count_preset_enable_write(struct counter_device *counter,
+ struct counter_count *count,
+ bool preset_enable)
{
struct quad8_iio *const priv = counter->priv;
const int base_offset = priv->base + 2 * count->id + 1;
- bool preset_enable;
- int ret;
unsigned int ior_cfg;
- ret = kstrtobool(buf, &preset_enable);
- if (ret)
- return ret;
-
/* Preset enable is active low in Input/Output Control register */
preset_enable = !preset_enable;
@@ -1144,18 +1133,16 @@ static ssize_t quad8_count_preset_enable_write(struct counter_device *counter,
/* Load I/O control configuration to Input / Output Control Register */
outb(QUAD8_CTR_IOR | ior_cfg, base_offset);
- return len;
+ return 0;
}
-static ssize_t quad8_signal_cable_fault_read(struct counter_device *counter,
- struct counter_signal *signal,
- void *private, char *buf)
+static int quad8_signal_cable_fault_read(struct counter_device *counter,
+ struct counter_signal *signal, bool *cable_fault)
{
const struct quad8_iio *const priv = counter->priv;
const size_t channel_id = signal->id / 2;
const bool disabled = !(priv->cable_fault_enable & BIT(channel_id));
unsigned int status;
- unsigned int fault;
if (disabled)
return -EINVAL;
@@ -1164,36 +1151,29 @@ static ssize_t quad8_signal_cable_fault_read(struct counter_device *counter,
status = inb(priv->base + QUAD8_DIFF_ENCODER_CABLE_STATUS);
/* Mask respective channel and invert logic */
- fault = !(status & BIT(channel_id));
+ *cable_fault = !(status & BIT(channel_id));
- return sprintf(buf, "%u\n", fault);
+ return 0;
}
-static ssize_t quad8_signal_cable_fault_enable_read(
- struct counter_device *counter, struct counter_signal *signal,
- void *private, char *buf)
+static int quad8_signal_cable_fault_enable_read(struct counter_device *counter,
+ struct counter_signal *signal, bool *enable)
{
const struct quad8_iio *const priv = counter->priv;
const size_t channel_id = signal->id / 2;
- const unsigned int enb = !!(priv->cable_fault_enable & BIT(channel_id));
- return sprintf(buf, "%u\n", enb);
+ *enable = !!(priv->cable_fault_enable & BIT(channel_id));
+
+ return 0;
}
-static ssize_t quad8_signal_cable_fault_enable_write(
- struct counter_device *counter, struct counter_signal *signal,
- void *private, const char *buf, size_t len)
+static int quad8_signal_cable_fault_enable_write(struct counter_device *counter,
+ struct counter_signal *signal, bool enable)
{
struct quad8_iio *const priv = counter->priv;
const size_t channel_id = signal->id / 2;
- bool enable;
- int ret;
unsigned int cable_fault_enable;
- ret = kstrtobool(buf, &enable);
- if (ret)
- return ret;
-
if (enable)
priv->cable_fault_enable |= BIT(channel_id);
else
@@ -1204,31 +1184,29 @@ static ssize_t quad8_signal_cable_fault_enable_write(
outb(cable_fault_enable, priv->base + QUAD8_DIFF_ENCODER_CABLE_STATUS);
- return len;
+ return 0;
}
-static ssize_t quad8_signal_fck_prescaler_read(struct counter_device *counter,
- struct counter_signal *signal, void *private, char *buf)
+static int quad8_signal_fck_prescaler_read(struct counter_device *counter,
+ struct counter_signal *signal, unsigned long *prescaler)
{
const struct quad8_iio *const priv = counter->priv;
- const size_t channel_id = signal->id / 2;
- return sprintf(buf, "%u\n", priv->fck_prescaler[channel_id]);
+ *prescaler = priv->fck_prescaler[signal->id / 2];
+
+ return 0;
}
-static ssize_t quad8_signal_fck_prescaler_write(struct counter_device *counter,
- struct counter_signal *signal, void *private, const char *buf,
- size_t len)
+static int quad8_signal_fck_prescaler_write(struct counter_device *counter,
+ struct counter_signal *signal, unsigned long prescaler)
{
struct quad8_iio *const priv = counter->priv;
const size_t channel_id = signal->id / 2;
const int base_offset = priv->base + 2 * channel_id;
- u8 prescaler;
- int ret;
- ret = kstrtou8(buf, 0, &prescaler);
- if (ret)
- return ret;
+ /* prescaler is an 8-bit value */
+ if (prescaler > 255)
+ return -ERANGE;
priv->fck_prescaler[channel_id] = prescaler;
@@ -1240,31 +1218,28 @@ static ssize_t quad8_signal_fck_prescaler_write(struct counter_device *counter,
outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_BP | QUAD8_RLD_PRESET_PSC,
base_offset + 1);
- return len;
+ return 0;
}
-static const struct counter_signal_ext quad8_signal_ext[] = {
- {
- .name = "cable_fault",
- .read = quad8_signal_cable_fault_read
- },
- {
- .name = "cable_fault_enable",
- .read = quad8_signal_cable_fault_enable_read,
- .write = quad8_signal_cable_fault_enable_write
- },
- {
- .name = "filter_clock_prescaler",
- .read = quad8_signal_fck_prescaler_read,
- .write = quad8_signal_fck_prescaler_write
- }
+static struct counter_data quad8_signal_ext[] = {
+ COUNTER_DATA_BOOL("cable_fault", quad8_signal_cable_fault_read, NULL),
+ COUNTER_DATA_BOOL("cable_fault_enable",
+ quad8_signal_cable_fault_enable_read,
+ quad8_signal_cable_fault_enable_write),
+ COUNTER_DATA_UNSIGNED_LONG("filter_clock_prescaler",
+ quad8_signal_fck_prescaler_read,
+ quad8_signal_fck_prescaler_write)
};
-static const struct counter_signal_ext quad8_index_ext[] = {
- COUNTER_SIGNAL_ENUM("index_polarity", &quad8_index_pol_enum),
- COUNTER_SIGNAL_ENUM_AVAILABLE("index_polarity", &quad8_index_pol_enum),
- COUNTER_SIGNAL_ENUM("synchronous_mode", &quad8_syn_mode_enum),
- COUNTER_SIGNAL_ENUM_AVAILABLE("synchronous_mode", &quad8_syn_mode_enum)
+static struct counter_data quad8_index_ext[] = {
+ COUNTER_DATA_ENUM_AND_AVAILABLE("index_polarity",
+ quad8_index_polarity_get,
+ quad8_index_polarity_set,
+ quad8_index_pol_enum),
+ COUNTER_DATA_ENUM_AND_AVAILABLE("synchronous_mode",
+ quad8_synchronous_mode_get,
+ quad8_synchronous_mode_set,
+ quad8_syn_mode_enum),
};
#define QUAD8_QUAD_SIGNAL(_id, _name) { \
@@ -1333,39 +1308,20 @@ static struct counter_synapse quad8_count_synapses[][3] = {
QUAD8_COUNT_SYNAPSES(6), QUAD8_COUNT_SYNAPSES(7)
};
-static const struct counter_count_ext quad8_count_ext[] = {
- {
- .name = "ceiling",
- .read = quad8_count_ceiling_read,
- .write = quad8_count_ceiling_write
- },
- {
- .name = "floor",
- .read = quad8_count_floor_read
- },
- COUNTER_COUNT_ENUM("count_mode", &quad8_cnt_mode_enum),
- COUNTER_COUNT_ENUM_AVAILABLE("count_mode", &quad8_cnt_mode_enum),
- {
- .name = "direction",
- .read = quad8_count_direction_read
- },
- {
- .name = "enable",
- .read = quad8_count_enable_read,
- .write = quad8_count_enable_write
- },
- COUNTER_COUNT_ENUM("error_noise", &quad8_error_noise_enum),
- COUNTER_COUNT_ENUM_AVAILABLE("error_noise", &quad8_error_noise_enum),
- {
- .name = "preset",
- .read = quad8_count_preset_read,
- .write = quad8_count_preset_write
- },
- {
- .name = "preset_enable",
- .read = quad8_count_preset_enable_read,
- .write = quad8_count_preset_enable_write
- }
+static struct counter_data quad8_count_ext[] = {
+ COUNTER_DATA_CEILING(quad8_count_ceiling_read,
+ quad8_count_ceiling_write),
+ COUNTER_DATA_FLOOR(quad8_count_floor_read, NULL),
+ COUNTER_DATA_COUNT_MODE_AND_AVAILABLE(quad8_count_mode_read,
+ quad8_count_mode_write,
+ quad8_count_mode_available),
+ COUNTER_DATA_DIRECTION(quad8_direction_read),
+ COUNTER_DATA_ENABLE(quad8_count_enable_read, quad8_count_enable_write),
+ COUNTER_DATA_ERROR_NOISE_AND_AVAILABLE(quad8_error_noise_read,
+ quad8_error_noise_available_read),
+ COUNTER_DATA_PRESET(quad8_count_preset_read, quad8_count_preset_write),
+ COUNTER_DATA_PRESET_ENABLE(quad8_count_preset_enable_read,
+ quad8_count_preset_enable_write),
};
#define QUAD8_COUNT(_id, _cntname) { \
@@ -1421,7 +1377,12 @@ static int quad8_probe(struct device *dev, unsigned int id)
quad8iio = iio_priv(indio_dev);
quad8iio->counter.name = dev_name(dev);
quad8iio->counter.parent = dev;
- quad8iio->counter.ops = &quad8_ops;
+ quad8iio->counter.signal_read = quad8_signal_read;
+ quad8iio->counter.count_read = quad8_count_read;
+ quad8iio->counter.count_write = quad8_count_write;
+ quad8iio->counter.function_read = quad8_function_read;
+ quad8iio->counter.function_write = quad8_function_write;
+ quad8iio->counter.action_read = quad8_action_read;
quad8iio->counter.counts = quad8_counts;
quad8iio->counter.num_counts = ARRAY_SIZE(quad8_counts);
quad8iio->counter.signals = quad8_signals;
diff --git a/drivers/counter/Makefile b/drivers/counter/Makefile
index 55142d1f4c43..2d2644bd7777 100644
--- a/drivers/counter/Makefile
+++ b/drivers/counter/Makefile
@@ -4,6 +4,7 @@
#
obj-$(CONFIG_COUNTER) += counter.o
+counter-y := counter-core.o counter-sysfs.o counter-sysfs-callbacks.o
obj-$(CONFIG_104_QUAD_8) += 104-quad-8.o
obj-$(CONFIG_STM32_TIMER_CNT) += stm32-timer-cnt.o
diff --git a/drivers/counter/counter-core.c b/drivers/counter/counter-core.c
new file mode 100644
index 000000000000..008d51284a2c
--- /dev/null
+++ b/drivers/counter/counter-core.c
@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Generic Counter interface
+ * Copyright (C) 2020 William Breathitt Gray
+ */
+#include <linux/counter.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/export.h>
+#include <linux/gfp.h>
+#include <linux/idr.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include "counter-sysfs.h"
+
+/* Provides a unique ID for each counter device */
+static DEFINE_IDA(counter_ida);
+
+static void counter_device_release(struct device *dev)
+{
+ struct counter_device *const counter = dev_get_drvdata(dev);
+
+ counter_sysfs_free(counter);
+ kfree(&counter->dev);
+ ida_simple_remove(&counter_ida, counter->id);
+}
+
+static struct device_type counter_device_type = {
+ .name = "counter_device",
+ .release = counter_device_release
+};
+
+static struct bus_type counter_bus_type = {
+ .name = "counter"
+};
+
+/**
+ * counter_register - register Counter to the system
+ * @counter: pointer to Counter to register
+ *
+ * This function registers a Counter to the system. A sysfs "counter" directory
+ * will be created and populated with sysfs attributes correlating with the
+ * Counter Signals, Synapses, and Counts respectively.
+ */
+int counter_register(struct counter_device *const counter)
+{
+ struct device *const dev = &counter->dev;
+ int err;
+
+ /* Acquire unique ID */
+ counter->id = ida_simple_get(&counter_ida, 0, 0, GFP_KERNEL);
+ if (counter->id < 0)
+ return counter->id;
+
+ /* Configure device structure for Counter */
+ dev->type = &counter_device_type;
+ dev->bus = &counter_bus_type;
+ if (counter->parent) {
+ dev->parent = counter->parent;
+ dev->of_node = counter->parent->of_node;
+ }
+ dev_set_name(dev, "counter%d", counter->id);
+ device_initialize(dev);
+ dev_set_drvdata(dev, counter);
+
+ /* Add Counter sysfs attributes */
+ err = counter_sysfs_add(counter);
+ if (err)
+ goto err_free_id;
+
+ /* Add device to system */
+ err = device_add(dev);
+ if (err)
+ goto err_free_sysfs;
+
+ return 0;
+
+err_free_sysfs:
+ counter_sysfs_free(counter);
+err_free_id:
+ ida_simple_remove(&counter_ida, counter->id);
+ return err;
+}
+EXPORT_SYMBOL_GPL(counter_register);
+
+/**
+ * counter_unregister - unregister Counter from the system
+ * @counter: pointer to Counter to unregister
+ *
+ * The Counter is unregistered from the system; all allocated memory is freed.
+ */
+void counter_unregister(struct counter_device *const counter)
+{
+ if (counter) {
+ device_del(&counter->dev);
+ counter_sysfs_free(counter);
+ }
+}
+EXPORT_SYMBOL_GPL(counter_unregister);
+
+static void devm_counter_unreg(struct device *dev, void *res)
+{
+ counter_unregister(*(struct counter_device **)res);
+}
+
+/**
+ * devm_counter_register - Resource-managed counter_register
+ * @dev: device to allocate counter_device for
+ * @counter: pointer to Counter to register
+ *
+ * Managed counter_register. The Counter registered with this function is
+ * automatically unregistered on driver detach. This function calls
+ * counter_register internally. Refer to that function for more information.
+ *
+ * If an Counter registered with this function needs to be unregistered
+ * separately, devm_counter_unregister must be used.
+ *
+ * RETURNS:
+ * 0 on success, negative error number on failure.
+ */
+int devm_counter_register(struct device *dev,
+ struct counter_device *const counter)
+{
+ struct counter_device **ptr;
+ int ret;
+
+ ptr = devres_alloc(devm_counter_unreg, sizeof(*ptr), GFP_KERNEL);
+ if (!ptr)
+ return -ENOMEM;
+
+ ret = counter_register(counter);
+ if (!ret) {
+ *ptr = counter;
+ devres_add(dev, ptr);
+ } else {
+ devres_free(ptr);
+ }
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(devm_counter_register);
+
+static int devm_counter_match(struct device *dev, void *res, void *data)
+{
+ struct counter_device **r = res;
+
+ if (!r || !*r) {
+ WARN_ON(!r || !*r);
+ return 0;
+ }
+
+ return *r == data;
+}
+
+/**
+ * devm_counter_unregister - Resource-managed counter_unregister
+ * @dev: device this counter_device belongs to
+ * @counter: pointer to Counter associated with the device
+ *
+ * Unregister Counter registered with devm_counter_register.
+ */
+void devm_counter_unregister(struct device *dev,
+ struct counter_device *const counter)
+{
+ int rc;
+
+ rc = devres_release(dev, devm_counter_unreg, devm_counter_match,
+ counter);
+ WARN_ON(rc);
+}
+EXPORT_SYMBOL_GPL(devm_counter_unregister);
+
+static int __init counter_init(void)
+{
+ return bus_register(&counter_bus_type);
+}
+
+static void __exit counter_exit(void)
+{
+ bus_unregister(&counter_bus_type);
+}
+
+subsys_initcall(counter_init);
+module_exit(counter_exit);
+
+MODULE_AUTHOR("William Breathitt Gray <[email protected]>");
+MODULE_DESCRIPTION("Generic Counter interface");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/counter/counter-function-types.h b/drivers/counter/counter-function-types.h
new file mode 100644
index 000000000000..1a67b3904193
--- /dev/null
+++ b/drivers/counter/counter-function-types.h
@@ -0,0 +1,81 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Counter callback function types
+ * Copyright (C) 2020 William Breathitt Gray
+ */
+#ifndef _COUNTER_FUNCTION_TYPES_H_
+#define _COUNTER_FUNCTION_TYPES_H_
+
+#include <linux/counter.h>
+#include <linux/types.h>
+
+#define COUNTER_DATA_CALLBACKS(_name, _type) \
+ typedef int (*counter_count_##_name##_read)(struct counter_device *, \
+ struct counter_count *, \
+ _type *); \
+ typedef int (*counter_count_##_name##_write)(struct counter_device *, \
+ struct counter_count *, \
+ _type); \
+ typedef int (*counter_device_##_name##_read)(struct counter_device *, \
+ _type *); \
+ typedef int (*counter_device_##_name##_write)(struct counter_device *, \
+ _type); \
+ typedef int (*counter_signal_##_name##_read)(struct counter_device *, \
+ struct counter_signal *, \
+ _type *); \
+ typedef int (*counter_signal_##_name##_write)(struct counter_device *, \
+ struct counter_signal *, \
+ _type)
+
+COUNTER_DATA_CALLBACKS(bool, bool);
+COUNTER_DATA_CALLBACKS(lu, unsigned long);
+COUNTER_DATA_CALLBACKS(zu, size_t);
+
+typedef ssize_t (*counter_count_s_read)(struct counter_device *,
+ struct counter_count *, char *, size_t);
+typedef ssize_t (*counter_count_s_write)(struct counter_device *,
+ struct counter_count *, const char *,
+ size_t);
+typedef ssize_t (*counter_device_s_read)(struct counter_device *, char *,
+ size_t);
+typedef ssize_t (*counter_device_s_write)(struct counter_device *, const char *,
+ size_t);
+typedef ssize_t (*counter_signal_s_read)(struct counter_device *,
+ struct counter_signal *, char *,
+ size_t);
+typedef ssize_t (*counter_signal_s_write)(struct counter_device *,
+ struct counter_signal *, const char *,
+ size_t);
+
+typedef int (*counter_count_function_read)(struct counter_device *,
+ struct counter_count *,
+ enum counter_count_function *);
+typedef int (*counter_count_function_write)(struct counter_device *,
+ struct counter_count *,
+ enum counter_count_function);
+
+typedef int (*counter_signal_signal_read)(struct counter_device *,
+ struct counter_signal *,
+ enum counter_signal_value *);
+
+typedef int (*counter_synapse_action_read)(struct counter_device *,
+ struct counter_count *,
+ struct counter_synapse *,
+ enum counter_synapse_action *);
+typedef int (*counter_synapse_action_write)(struct counter_device *,
+ struct counter_count *,
+ struct counter_synapse *,
+ enum counter_synapse_action);
+
+typedef int (*counter_count_direction_read)(struct counter_device *,
+ struct counter_count *,
+ enum counter_count_direction *);
+
+typedef int (*counter_count_mode_read)(struct counter_device *,
+ struct counter_count *,
+ enum counter_count_mode *);
+typedef int (*counter_count_mode_write)(struct counter_device *,
+ struct counter_count *,
+ enum counter_count_mode);
+
+#endif /* _COUNTER_FUNCTION_TYPES_H_ */
diff --git a/drivers/counter/counter-strings.h b/drivers/counter/counter-strings.h
new file mode 100644
index 000000000000..d67788e01bb9
--- /dev/null
+++ b/drivers/counter/counter-strings.h
@@ -0,0 +1,46 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Generic Counter strings
+ * Copyright (C) 2020 William Breathitt Gray
+ */
+#ifndef _COUNTER_STRINGS_H_
+#define _COUNTER_STRINGS_H_
+
+#include <linux/counter.h>
+
+const char *const counter_count_direction_str[] = {
+ [COUNTER_COUNT_DIRECTION_FORWARD] = "forward",
+ [COUNTER_COUNT_DIRECTION_BACKWARD] = "backward"
+};
+
+const char *const counter_count_function_str[] = {
+ [COUNTER_COUNT_FUNCTION_INCREASE] = "increase",
+ [COUNTER_COUNT_FUNCTION_DECREASE] = "decrease",
+ [COUNTER_COUNT_FUNCTION_PULSE_DIRECTION] = "pulse-direction",
+ [COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A] = "quadrature x1 a",
+ [COUNTER_COUNT_FUNCTION_QUADRATURE_X1_B] = "quadrature x1 b",
+ [COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A] = "quadrature x2 a",
+ [COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B] = "quadrature x2 b",
+ [COUNTER_COUNT_FUNCTION_QUADRATURE_X4] = "quadrature x4"
+};
+
+const char *const counter_count_mode_str[] = {
+ [COUNTER_COUNT_MODE_NORMAL] = "normal",
+ [COUNTER_COUNT_MODE_RANGE_LIMIT] = "range limit",
+ [COUNTER_COUNT_MODE_NON_RECYCLE] = "non-recycle",
+ [COUNTER_COUNT_MODE_MODULO_N] = "modulo-n"
+};
+
+const char *const counter_signal_value_str[] = {
+ [COUNTER_SIGNAL_LOW] = "low",
+ [COUNTER_SIGNAL_HIGH] = "high"
+};
+
+const char *const counter_synapse_action_str[] = {
+ [COUNTER_SYNAPSE_ACTION_NONE] = "none",
+ [COUNTER_SYNAPSE_ACTION_RISING_EDGE] = "rising edge",
+ [COUNTER_SYNAPSE_ACTION_FALLING_EDGE] = "falling edge",
+ [COUNTER_SYNAPSE_ACTION_BOTH_EDGES] = "both edges"
+};
+
+#endif /* _COUNTER_STRINGS_H_ */
diff --git a/drivers/counter/counter-sysfs-callbacks.c b/drivers/counter/counter-sysfs-callbacks.c
new file mode 100644
index 000000000000..5740d61e999b
--- /dev/null
+++ b/drivers/counter/counter-sysfs-callbacks.c
@@ -0,0 +1,566 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Generic Counter sysfs callbacks
+ * Copyright (C) 2020 William Breathitt Gray
+ */
+#include <linux/counter.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/types.h>
+
+#include "counter-function-types.h"
+#include "counter-strings.h"
+#include "counter-sysfs-callbacks.h"
+
+#define to_counter_attribute(_dev_attr) \
+ container_of(_dev_attr, struct counter_attribute, dev_attr)
+
+static ssize_t counter_data_bool_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_count_bool_read count_bool_read = a->data.read;
+ const counter_device_bool_read device_bool_read = a->data.read;
+ const counter_signal_bool_read signal_bool_read = a->data.read;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ void *const owner = a->owner;
+ int err = 0;
+ bool data;
+
+ switch (a->type) {
+ case COUNTER_OWNER_TYPE_COUNT:
+ err = count_bool_read(counter, owner, &data);
+ break;
+ case COUNTER_OWNER_TYPE_DEVICE:
+ err = device_bool_read(counter, &data);
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ err = signal_bool_read(counter, owner, &data);
+ break;
+ }
+ if (err)
+ return err;
+
+ return sprintf(buf, "%u\n", (unsigned int)data);
+}
+
+static ssize_t counter_data_bool_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_count_bool_write count_bool_write = a->data.write;
+ const counter_device_bool_write device_bool_write = a->data.write;
+ const counter_signal_bool_write signal_bool_write = a->data.write;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ void *const owner = a->owner;
+ int err;
+ bool data;
+
+ err = kstrtobool(buf, &data);
+ if (err)
+ return err;
+
+ switch (a->type) {
+ case COUNTER_OWNER_TYPE_COUNT:
+ err = count_bool_write(counter, owner, data);
+ break;
+ case COUNTER_OWNER_TYPE_DEVICE:
+ err = device_bool_write(counter, data);
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ err = signal_bool_write(counter, owner, data);
+ break;
+ }
+ if (err)
+ return err;
+
+ return len;
+}
+
+static ssize_t counter_data_lu_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_count_lu_read count_lu_read = a->data.read;
+ const counter_device_lu_read device_lu_read = a->data.read;
+ const counter_signal_lu_read signal_lu_read = a->data.read;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ void *const owner = a->owner;
+ int err = 0;
+ unsigned long data;
+
+ switch (a->type) {
+ case COUNTER_OWNER_TYPE_COUNT:
+ err = count_lu_read(counter, owner, &data);
+ break;
+ case COUNTER_OWNER_TYPE_DEVICE:
+ err = device_lu_read(counter, &data);
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ err = signal_lu_read(counter, owner, &data);
+ break;
+ }
+ if (err)
+ return err;
+
+ return sprintf(buf, "%lu\n", data);
+}
+
+static ssize_t counter_data_lu_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_count_lu_write count_lu_write = a->data.write;
+ const counter_device_lu_write device_lu_write = a->data.write;
+ const counter_signal_lu_write signal_lu_write = a->data.write;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ void *const owner = a->owner;
+ int err;
+ unsigned long data;
+
+ err = kstrtoul(buf, 0, &data);
+ if (err)
+ return err;
+
+ switch (a->type) {
+ case COUNTER_OWNER_TYPE_COUNT:
+ err = count_lu_write(counter, owner, data);
+ break;
+ case COUNTER_OWNER_TYPE_DEVICE:
+ err = device_lu_write(counter, data);
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ err = signal_lu_write(counter, owner, data);
+ break;
+ }
+ if (err)
+ return err;
+
+ return len;
+}
+
+static ssize_t counter_data_zu_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_device_zu_read zu_read = a->data.read;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ int err;
+ size_t data;
+
+ err = zu_read(counter, &data);
+ if (err)
+ return err;
+
+ return sprintf(buf, "%zu\n", data);
+}
+
+static ssize_t counter_data_s_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_count_s_read count_s_read = a->data.read;
+ const counter_device_s_read device_s_read = a->data.read;
+ const counter_signal_s_read signal_s_read = a->data.read;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ void *const owner = a->owner;
+
+ switch (a->type) {
+ case COUNTER_OWNER_TYPE_COUNT:
+ return count_s_read(counter, owner, buf, PAGE_SIZE);
+ case COUNTER_OWNER_TYPE_DEVICE:
+ return device_s_read(counter, buf, PAGE_SIZE);
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ return signal_s_read(counter, owner, buf, PAGE_SIZE);
+ }
+
+ return -EINVAL;
+}
+
+static ssize_t counter_data_s_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_count_s_write count_s_write = a->data.write;
+ const counter_device_s_write device_s_write = a->data.write;
+ const counter_signal_s_write signal_s_write = a->data.write;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ void *const owner = a->owner;
+
+ switch (a->type) {
+ case COUNTER_OWNER_TYPE_COUNT:
+ return count_s_write(counter, owner, buf, len);
+ case COUNTER_OWNER_TYPE_DEVICE:
+ return device_s_write(counter, buf, len);
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ return signal_s_write(counter, owner, buf, len);
+ }
+
+ return -EINVAL;
+}
+
+static ssize_t counter_data_count_function_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_count_function_read function_read = a->data.read;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ struct counter_count *const count = a->owner;
+ int err;
+ enum counter_count_function function;
+
+ err = function_read(counter, count, &function);
+ if (err)
+ return err;
+
+ return sprintf(buf, "%s\n", counter_count_function_str[function]);
+}
+
+static ssize_t counter_data_count_function_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_count_function_write function_write = a->data.write;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ struct counter_count *const count = a->owner;
+ const size_t num_functions = count->num_functions;
+ int err;
+ size_t index;
+ enum counter_count_function function;
+
+ /* Find requested function mode */
+ for (index = 0; index < num_functions; index++) {
+ function = count->functions_list[index];
+ if (sysfs_streq(buf, counter_count_function_str[function]))
+ break;
+ }
+ /* If requested function mode not found */
+ if (index >= num_functions)
+ return -EINVAL;
+
+ err = function_write(counter, count, function);
+ if (err)
+ return err;
+
+ return len;
+}
+
+static ssize_t counter_data_count_function_available_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const struct counter_count *const count = a->owner;
+ size_t i;
+ enum counter_count_function function;
+ ssize_t len = 0;
+
+ for (i = 0; i < count->num_functions; i++) {
+ function = count->functions_list[i];
+ len += sprintf(buf + len, "%s\n",
+ counter_count_function_str[function]);
+ }
+
+ return len;
+}
+
+static ssize_t counter_data_signal_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_signal_signal_read signal_read = a->data.read;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ struct counter_signal *const signal = a->owner;
+ int err;
+ enum counter_signal_value value;
+
+ err = signal_read(counter, signal, &value);
+ if (err)
+ return err;
+
+ return sprintf(buf, "%s\n", counter_signal_value_str[value]);
+}
+
+static ssize_t counter_data_synapse_action_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_synapse_action_read action_read = a->data.read;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ struct counter_count *const count = a->owner;
+ struct counter_synapse *const synapse = a->data.priv;
+ int err;
+ enum counter_synapse_action action;
+
+ err = action_read(counter, count, synapse, &action);
+ if (err)
+ return err;
+
+ return sprintf(buf, "%s\n", counter_synapse_action_str[action]);
+}
+
+static ssize_t counter_data_synapse_action_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_synapse_action_write action_write = a->data.write;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ struct counter_count *const count = a->owner;
+ struct counter_synapse *const synapse = a->data.priv;
+ const size_t num_actions = synapse->num_actions;
+ int err;
+ size_t index;
+ enum counter_synapse_action action;
+
+ /* Find requested action mode */
+ for (index = 0; index < num_actions; index++) {
+ action = synapse->actions_list[index];
+ if (sysfs_streq(buf, counter_synapse_action_str[action]))
+ break;
+ }
+ /* If requested action mode not found */
+ if (index >= num_actions)
+ return -EINVAL;
+
+ err = action_write(counter, count, synapse, action);
+ if (err)
+ return err;
+
+ return len;
+}
+
+static ssize_t counter_data_synapse_action_available_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const struct counter_synapse *const synapse = a->data.priv;
+ size_t i;
+ enum counter_synapse_action action;
+ ssize_t len = 0;
+
+ for (i = 0; i < synapse->num_actions; i++) {
+ action = synapse->actions_list[i];
+ len += sprintf(buf + len, "%s\n",
+ counter_synapse_action_str[action]);
+ }
+
+ return len;
+}
+
+static ssize_t counter_data_enum_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_count_zu_read count_enum_read = a->data.read;
+ const counter_device_zu_read device_enum_read = a->data.read;
+ const counter_signal_zu_read signal_enum_read = a->data.read;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ void *const owner = a->owner;
+ struct counter_enum *const cntr_enum = a->data.priv;
+ int err = 0;
+ size_t index;
+
+ switch (a->type) {
+ case COUNTER_OWNER_TYPE_COUNT:
+ err = count_enum_read(counter, owner, &index);
+ break;
+ case COUNTER_OWNER_TYPE_DEVICE:
+ err = device_enum_read(counter, &index);
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ err = signal_enum_read(counter, owner, &index);
+ break;
+ }
+ if (err)
+ return err;
+
+ if (index >= cntr_enum->num_items)
+ return -EINVAL;
+
+ return sprintf(buf, "%s\n", cntr_enum->items[index]);
+}
+
+static ssize_t counter_data_enum_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ struct counter_enum *const cntr_enum = a->data.priv;
+ const size_t num_items = cntr_enum->num_items;
+ const counter_count_zu_write count_enum_write = a->data.write;
+ const counter_device_zu_write device_enum_write = a->data.write;
+ const counter_signal_zu_write signal_enum_write = a->data.write;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ void *const owner = a->owner;
+ ssize_t index;
+ int err = 0;
+
+ index = __sysfs_match_string(cntr_enum->items, num_items, buf);
+ if (index < 0)
+ return index;
+
+ switch (a->type) {
+ case COUNTER_OWNER_TYPE_COUNT:
+ err = count_enum_write(counter, owner, index);
+ break;
+ case COUNTER_OWNER_TYPE_DEVICE:
+ err = device_enum_write(counter, index);
+ break;
+ case COUNTER_OWNER_TYPE_SIGNAL:
+ err = signal_enum_write(counter, owner, index);
+ break;
+ }
+ if (err)
+ return err;
+
+ return len;
+}
+
+static ssize_t counter_data_enum_available_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ struct counter_enum *const cntr_enum = a->data.priv;
+ size_t i;
+ size_t len = 0;
+
+ for (i = 0; i < cntr_enum->num_items; i++)
+ len += sprintf(buf + len, "%s\n", cntr_enum->items[i]);
+
+ return len;
+}
+
+static ssize_t counter_data_count_direction_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_count_direction_read direction_read = a->data.read;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ struct counter_count *const count = a->owner;
+ int err;
+ enum counter_count_direction direction;
+
+ err = direction_read(counter, count, &direction);
+ if (err)
+ return err;
+
+ return sprintf(buf, "%s\n", counter_count_direction_str[direction]);
+}
+
+static ssize_t counter_data_count_mode_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_count_mode_read count_mode_read = a->data.read;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ struct counter_count *const count = a->owner;
+ int err;
+ enum counter_count_mode count_mode;
+
+ err = count_mode_read(counter, count, &count_mode);
+ if (err)
+ return err;
+
+ return sprintf(buf, "%s\n", counter_count_mode_str[count_mode]);
+}
+
+static ssize_t counter_data_count_mode_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const counter_count_mode_write count_mode_write = a->data.write;
+ struct counter_device *const counter = dev_get_drvdata(dev);
+ struct counter_count *const count = a->owner;
+ const struct counter_available *const available = a->data.priv;
+ const enum counter_count_mode *const items = available->items;
+ const size_t num_count_modes = available->num_items;
+ int err;
+ size_t index;
+ enum counter_count_mode count_mode;
+
+ /* Find requested count mode */
+ for (index = 0; index < num_count_modes; index++) {
+ count_mode = items[index];
+ if (sysfs_streq(buf, counter_count_mode_str[count_mode]))
+ break;
+ }
+ /* If requested count mode not found */
+ if (index >= num_count_modes)
+ return -EINVAL;
+
+ err = count_mode_write(counter, count, count_mode);
+ if (err)
+ return err;
+
+ return len;
+}
+
+static ssize_t counter_data_count_mode_available_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ const struct counter_attribute *const a = to_counter_attribute(attr);
+ const struct counter_available *const available = a->data.priv;
+ const enum counter_count_mode *const items = available->items;
+ size_t i;
+ enum counter_count_mode count_mode;
+ ssize_t len = 0;
+
+ for (i = 0; i < available->num_items; i++) {
+ count_mode = items[i];
+ len += sprintf(buf + len, "%s\n",
+ counter_count_mode_str[count_mode]);
+ }
+
+ return len;
+}
+
+ssize_t (*counter_data_sysfs_show[])(struct device *, struct device_attribute *,
+ char *) = {
+ [COUNTER_DATA_TYPE_BOOL] = counter_data_bool_show,
+ [COUNTER_DATA_TYPE_UNSIGNED_LONG] = counter_data_lu_show,
+ [COUNTER_DATA_TYPE_SIZE] = counter_data_zu_show,
+ [COUNTER_DATA_TYPE_STRING] = counter_data_s_show,
+ [COUNTER_DATA_TYPE_COUNT_FUNCTION] = counter_data_count_function_show,
+ [COUNTER_DATA_TYPE_COUNT_FUNCTION_AVAILABLE] = counter_data_count_function_available_show,
+ [COUNTER_DATA_TYPE_SIGNAL] = counter_data_signal_show,
+ [COUNTER_DATA_TYPE_SYNAPSE_ACTION] = counter_data_synapse_action_show,
+ [COUNTER_DATA_TYPE_SYNAPSE_ACTION_AVAILABLE] = counter_data_synapse_action_available_show,
+ [COUNTER_DATA_TYPE_ENUM] = counter_data_enum_show,
+ [COUNTER_DATA_TYPE_ENUM_AVAILABLE] = counter_data_enum_available_show,
+ [COUNTER_DATA_TYPE_COUNT_DIRECTION] = counter_data_count_direction_show,
+ [COUNTER_DATA_TYPE_COUNT_MODE] = counter_data_count_mode_show,
+ [COUNTER_DATA_TYPE_COUNT_MODE_AVAILABLE] = counter_data_count_mode_available_show,
+};
+
+ssize_t (*counter_data_sysfs_store[])(struct device *,
+ struct device_attribute *, const char *,
+ size_t) = {
+ [COUNTER_DATA_TYPE_BOOL] = counter_data_bool_store,
+ [COUNTER_DATA_TYPE_UNSIGNED_LONG] = counter_data_lu_store,
+ [COUNTER_DATA_TYPE_SIZE] = NULL,
+ [COUNTER_DATA_TYPE_STRING] = counter_data_s_store,
+ [COUNTER_DATA_TYPE_COUNT_FUNCTION] = counter_data_count_function_store,
+ [COUNTER_DATA_TYPE_COUNT_FUNCTION_AVAILABLE] = NULL,
+ [COUNTER_DATA_TYPE_SIGNAL] = NULL,
+ [COUNTER_DATA_TYPE_SYNAPSE_ACTION] = counter_data_synapse_action_store,
+ [COUNTER_DATA_TYPE_SYNAPSE_ACTION_AVAILABLE] = NULL,
+ [COUNTER_DATA_TYPE_ENUM] = counter_data_enum_store,
+ [COUNTER_DATA_TYPE_ENUM_AVAILABLE] = NULL,
+ [COUNTER_DATA_TYPE_COUNT_DIRECTION] = NULL,
+ [COUNTER_DATA_TYPE_COUNT_MODE] = counter_data_count_mode_store,
+ [COUNTER_DATA_TYPE_COUNT_MODE_AVAILABLE] = NULL,
+};
diff --git a/drivers/counter/counter-sysfs-callbacks.h b/drivers/counter/counter-sysfs-callbacks.h
new file mode 100644
index 000000000000..cf44e7c6ed18
--- /dev/null
+++ b/drivers/counter/counter-sysfs-callbacks.h
@@ -0,0 +1,28 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Generic Counter sysfs callbacks
+ * Copyright (C) 2020 William Breathitt Gray
+ */
+#ifndef _COUNTER_SYSFS_CALLBACKS_H_
+#define _COUNTER_SYSFS_CALLBACKS_H_
+
+#include <linux/counter.h>
+#include <linux/types.h>
+
+struct counter_attribute {
+ struct device_attribute dev_attr;
+ struct list_head l;
+
+ struct counter_data data;
+ enum counter_owner_type type;
+ void *owner;
+};
+
+extern ssize_t (*counter_data_sysfs_show[])(struct device *,
+ struct device_attribute *, char *);
+
+extern ssize_t (*counter_data_sysfs_store[])(struct device *,
+ struct device_attribute *,
+ const char *, size_t);
+
+#endif /* _COUNTER_SYSFS_CALLBACKS_H_ */
diff --git a/drivers/counter/counter-sysfs.c b/drivers/counter/counter-sysfs.c
new file mode 100644
index 000000000000..ed56c6b52490
--- /dev/null
+++ b/drivers/counter/counter-sysfs.c
@@ -0,0 +1,524 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Generic Counter sysfs interface
+ * Copyright (C) 2020 William Breathitt Gray
+ */
+#include <linux/counter.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/gfp.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/slab.h>
+#include <linux/sysfs.h>
+#include <linux/types.h>
+
+#include "counter-sysfs-callbacks.h"
+
+static int counter_attribute_create(struct counter_attribute_group *const group,
+ const struct counter_data *const data,
+ const enum counter_owner_type type,
+ void *const owner)
+{
+ struct counter_attribute *counter_attr;
+ struct device_attribute *dev_attr;
+
+ /* Allocate and initialize Counter attribute */
+ counter_attr = kzalloc(sizeof(*counter_attr), GFP_KERNEL);
+ if (!counter_attr)
+ return -ENOMEM;
+ counter_attr->data = *data;
+ counter_attr->type = type;
+ counter_attr->owner = owner;
+
+ /* Configure device attribute */
+ dev_attr = &counter_attr->dev_attr;
+ sysfs_attr_init(&dev_attr->attr);
+ dev_attr->attr.name = data->name;
+ if (data->read) {
+ dev_attr->attr.mode |= 0444;
+ dev_attr->show = counter_data_sysfs_show[data->type];
+ }
+ if (data->write) {
+ dev_attr->attr.mode |= 0200;
+ dev_attr->store = counter_data_sysfs_store[data->type];
+ }
+
+ /* Keep track of the attribute for later cleanup */
+ list_add(&counter_attr->l, &group->attr_list);
+ group->num_attr++;
+
+ return 0;
+}
+
+static struct counter_data counter_signal_data = {
+ .type = COUNTER_DATA_TYPE_SIGNAL,
+ .name = "signal",
+};
+
+static struct counter_data counter_name_data =
+ COUNTER_DATA_STRING("name", NULL, NULL);
+
+static ssize_t counter_signal_name_read(struct counter_device *counter,
+ struct counter_signal *signal,
+ char *buf, size_t size)
+{
+ return snprintf(buf, size, "%s\n", signal->name);
+}
+
+static int counter_signal_attributes_create(
+ struct counter_attribute_group *const group,
+ struct counter_signal *const signal, void *const signal_read)
+{
+ const enum counter_owner_type type = COUNTER_OWNER_TYPE_SIGNAL;
+ int err;
+ struct counter_data data;
+ size_t i;
+ const struct counter_data *ext;
+
+ /* Create main Signal attribute */
+ data = counter_signal_data;
+ data.read = signal_read;
+ err = counter_attribute_create(group, &data, type, signal);
+ if (err)
+ return err;
+
+ /* Create Signal name attribute */
+ data = counter_name_data;
+ data.read = counter_signal_name_read;
+ err = counter_attribute_create(group, &data, type, signal);
+ if (err)
+ return err;
+
+ /* Create an attribute for each extension */
+ for (i = 0; i < signal->num_ext; i++) {
+ ext = signal->ext + i;
+ err = counter_attribute_create(group, ext, type, signal);
+ if (err)
+ return err;
+ }
+
+ return 0;
+}
+
+static int counter_signals_register(
+ struct counter_attribute_group *const groups_list,
+ const struct counter_device *const counter)
+{
+ void *const signal_read = counter->signal_read;
+ size_t i;
+ struct counter_signal *signal;
+ const char *name;
+ int err;
+
+ /* Register each Signal */
+ for (i = 0; i < counter->num_signals; i++) {
+ signal = counter->signals + i;
+
+ /* Generate Signal attribute directory name */
+ name = kasprintf(GFP_KERNEL, "signal%d", signal->id);
+ if (!name)
+ return -ENOMEM;
+ groups_list[i].attr_group.name = name;
+
+ /* Create all attributes associated with Signal */
+ err = counter_signal_attributes_create(groups_list + i, signal,
+ signal_read);
+ if (err)
+ return err;
+ }
+
+ return 0;
+}
+
+struct counter_synapse_name {
+ struct list_head l;
+ const char *name;
+};
+
+static int counter_synapses_register(
+ struct counter_attribute_group *const group,
+ struct counter_device *const counter, struct counter_count *const count)
+{
+ const enum counter_owner_type type = COUNTER_OWNER_TYPE_COUNT;
+ size_t i;
+ struct counter_synapse *synapse;
+ int id;
+ struct counter_synapse_name *name;
+ struct counter_data data;
+ int err;
+
+ /* Register each Synapse */
+ for (i = 0; i < count->num_synapses; i++) {
+ synapse = count->synapses + i;
+ id = synapse->signal->id;
+
+ /* Generate Synapse name list item */
+ name = kmalloc(sizeof(*name), GFP_KERNEL);
+ if (!name)
+ return -ENOMEM;
+ list_add(&name->l, &counter->synapse_names_list);
+
+ /* Generate Synapse action name */
+ name->name = kasprintf(GFP_KERNEL, "signal%d_action", id);
+ if (!name->name)
+ return -ENOMEM;
+
+ /* Create action attribute */
+ data.type = COUNTER_DATA_TYPE_SYNAPSE_ACTION;
+ data.name = name->name;
+ data.read = counter->action_read;
+ data.write = counter->action_write;
+ data.priv = synapse;
+ err = counter_attribute_create(group, &data, type, count);
+ if (err)
+ return err;
+
+ /* Generate Synapse action_available name */
+ name->name = kasprintf(GFP_KERNEL, "signal%d_action_available",
+ id);
+ if (!name->name)
+ return -ENOMEM;
+
+ /* Create action_available attribute */
+ data.type = COUNTER_DATA_TYPE_SYNAPSE_ACTION_AVAILABLE;
+ data.name = name->name;
+ data.read = counter->action_read;
+ data.priv = synapse;
+ err = counter_attribute_create(group, &data, type, count);
+ if (err)
+ return err;
+ }
+
+ return 0;
+}
+
+static struct counter_data counter_count_data =
+ COUNTER_DATA_UNSIGNED_LONG("count", NULL, NULL);
+
+static ssize_t counter_count_name_read(struct counter_device *counter,
+ struct counter_count *count, char *buf,
+ size_t size)
+{
+ return snprintf(buf, size, "%s\n", count->name);
+}
+
+static struct counter_data counter_count_function_data = {
+ .type = COUNTER_DATA_TYPE_COUNT_FUNCTION,
+ .name = "function",
+};
+
+static struct counter_data counter_count_function_available_data = {
+ .type = COUNTER_DATA_TYPE_COUNT_FUNCTION_AVAILABLE,
+ .name = "function_available",
+};
+
+static int counter_count_attributes_create(
+ struct counter_attribute_group *const group,
+ const struct counter_device *const counter,
+ struct counter_count *const count)
+{
+ const enum counter_owner_type type = COUNTER_OWNER_TYPE_COUNT;
+ int err;
+ struct counter_data data;
+ size_t i;
+ const struct counter_data *ext;
+
+ /* Create main Count attribute */
+ data = counter_count_data;
+ data.read = counter->count_read;
+ data.write = counter->count_write;
+ err = counter_attribute_create(group, &data, type, count);
+ if (err)
+ return err;
+
+ /* Create Count name attribute */
+ data = counter_name_data;
+ data.read = counter_count_name_read;
+ err = counter_attribute_create(group, &data, type, count);
+ if (err)
+ return err;
+
+ /* Create Count function attribute */
+ data = counter_count_function_data;
+ data.read = counter->function_read;
+ data.write = counter->function_write;
+ err = counter_attribute_create(group, &data, type, count);
+ if (err)
+ return err;
+
+ /* Create Count function_available attribute */
+ data = counter_count_function_available_data;
+ data.read = counter->function_read;
+ err = counter_attribute_create(group, &data, type, count);
+ if (err)
+ return err;
+
+ /* Create an attribute for each extension */
+ for (i = 0; i < count->num_ext; i++) {
+ ext = count->ext + i;
+ err = counter_attribute_create(group, ext, type, count);
+ if (err)
+ return err;
+ }
+
+ return 0;
+}
+
+static int counter_counts_register(
+ struct counter_attribute_group *const groups_list,
+ struct counter_device *const counter)
+{
+ size_t i;
+ struct counter_count *count;
+ const char *name;
+ int err;
+
+ /* Register each Count */
+ for (i = 0; i < counter->num_counts; i++) {
+ count = counter->counts + i;
+
+ /* Generate Count attribute directory name */
+ name = kasprintf(GFP_KERNEL, "count%d", count->id);
+ if (!name)
+ return -ENOMEM;
+ groups_list[i].attr_group.name = name;
+
+ /* Register the Synapses associated with each Count */
+ err = counter_synapses_register(groups_list + i, counter,
+ count);
+ if (err)
+ return err;
+
+ /* Create all attributes associated with Count */
+ err = counter_count_attributes_create(groups_list + i, counter,
+ count);
+ if (err)
+ return err;
+ }
+
+ return 0;
+}
+
+static ssize_t counter_name_read(struct counter_device *counter, char *buf,
+ size_t size)
+{
+ return snprintf(buf, size, "%s\n", counter->name);
+}
+
+static int counter_num_signals_read(struct counter_device *counter, size_t *val)
+{
+ *val = counter->num_signals;
+ return 0;
+}
+
+static int counter_num_counts_read(struct counter_device *counter, size_t *val)
+{
+ *val = counter->num_counts;
+ return 0;
+}
+
+#define COUNTER_DATA_SIZE(_name, _read) \
+{ \
+ .type = COUNTER_DATA_TYPE_SIZE, \
+ .name = (_name), \
+ .read = (_read), \
+}
+
+static struct counter_data counter_num_signals_data =
+ COUNTER_DATA_SIZE("num_signals", counter_num_signals_read);
+
+static struct counter_data counter_num_counts_data =
+ COUNTER_DATA_SIZE("num_counts", counter_num_counts_read);
+
+static void counter_groups_list_free(struct counter_device *const counter)
+{
+ struct counter_attribute_group *group;
+ struct counter_attribute *p, *n;
+
+ /* Loop through all attribute groups (signals, counts, device, etc.) */
+ while (counter->num_groups--) {
+ group = counter->groups_list + counter->num_groups;
+
+ /* Free all attribute group and associated attributes memory */
+ kfree(group->attr_group.name);
+ kfree(group->attr_group.attrs);
+
+ /* Free attribute list */
+ list_for_each_entry_safe(p, n, &group->attr_list, l)
+ kfree(p);
+ }
+
+ kfree(counter->groups_list);
+}
+
+static int counter_device_register(struct counter_attribute_group *group,
+ struct counter_device *const counter)
+{
+ const enum counter_owner_type type = COUNTER_OWNER_TYPE_DEVICE;
+ struct counter_data data;
+ int err;
+ size_t i;
+ const struct counter_data *ext;
+
+ /* Register Signals */
+ err = counter_signals_register(group, counter);
+ if (err)
+ goto err_free_groups_list;
+ group += counter->num_signals;
+
+ /* Register Counts and respective Synapses */
+ err = counter_counts_register(group, counter);
+ if (err)
+ goto err_free_groups_list;
+ group += counter->num_counts;
+
+ /* Create name attribute */
+ data = counter_name_data;
+ data.read = counter_name_read;
+ err = counter_attribute_create(group, &data, type, NULL);
+ if (err)
+ goto err_free_groups_list;
+
+ /* Create num_signals attribute */
+ data = counter_num_signals_data;
+ err = counter_attribute_create(group, &data, type, NULL);
+ if (err)
+ goto err_free_groups_list;
+
+ /* Create num_counts attribute */
+ data = counter_num_counts_data;
+ err = counter_attribute_create(group, &data, type, NULL);
+ if (err)
+ goto err_free_groups_list;
+
+ /* Create an attribute for each extension */
+ for (i = 0; i < counter->num_ext; i++) {
+ ext = counter->ext + i;
+ err = counter_attribute_create(group, ext, type, NULL);
+ if (err)
+ goto err_free_groups_list;
+ }
+
+ return 0;
+
+err_free_groups_list:
+ counter_groups_list_free(counter);
+ return err;
+}
+
+static int counter_groups_list_prepare(struct counter_device *const counter)
+{
+ const size_t num_grps = counter->num_signals + counter->num_counts + 1;
+ struct counter_attribute_group *groups_list;
+ size_t i;
+ int err;
+
+ /* Allocate space for attribute groups (signals, counts, and ext) */
+ groups_list = kcalloc(num_grps, sizeof(*groups_list), GFP_KERNEL);
+ if (!groups_list)
+ return -ENOMEM;
+
+ /* Store groups_list in counter structure */
+ counter->groups_list = groups_list;
+ counter->num_groups = num_grps;
+
+ /* Initialize attribute lists */
+ for (i = 0; i < num_grps; i++)
+ INIT_LIST_HEAD(&groups_list[i].attr_list);
+
+ /* Register Counter device attributes */
+ err = counter_device_register(groups_list, counter);
+ if (err)
+ return err;
+
+ return 0;
+}
+
+static int counter_groups_prepare(struct counter_device *const counter)
+{
+ size_t i, j;
+ struct counter_attribute_group *group;
+ struct attribute **attrs;
+ int err;
+ struct counter_attribute *p;
+
+ /* Allocate attribute groups for association with device */
+ counter->groups = kcalloc(counter->num_groups + 1,
+ sizeof(*counter->groups), GFP_KERNEL);
+ if (!counter->groups)
+ return -ENOMEM;
+
+ /* Prepare each group of attributes for association */
+ for (i = 0; i < counter->num_groups; i++) {
+ group = counter->groups_list + i;
+
+ /* Allocate space for attribute pointers */
+ attrs = kcalloc(group->num_attr + 1, sizeof(*attrs),
+ GFP_KERNEL);
+ if (!attrs) {
+ err = -ENOMEM;
+ goto err_free_groups;
+ }
+ group->attr_group.attrs = attrs;
+
+ /* Add attribute pointers to attribute group */
+ j = 0;
+ list_for_each_entry(p, &group->attr_list, l)
+ attrs[j++] = &p->dev_attr.attr;
+
+ /* Group attributes in attribute group */
+ counter->groups[i] = &group->attr_group;
+ }
+ /* Associate attributes with device */
+ counter->dev.groups = counter->groups;
+
+ return 0;
+
+err_free_groups:
+ kfree(counter->groups);
+ return err;
+}
+
+static void counter_synapse_names_free(struct list_head *const names_list)
+{
+ struct counter_synapse_name *p, *n;
+
+ list_for_each_entry_safe(p, n, names_list, l) {
+ kfree(p->name);
+ kfree(p);
+ }
+}
+
+int counter_sysfs_add(struct counter_device *const counter)
+{
+ int err;
+
+ /* Initialize Synapse names list */
+ INIT_LIST_HEAD(&counter->synapse_names_list);
+
+ /* Prepare device attributes */
+ err = counter_groups_list_prepare(counter);
+ if (err)
+ goto err_free_synapse_names;
+
+ /* Organize device attributes to groups and match to device */
+ err = counter_groups_prepare(counter);
+ if (err)
+ goto err_free_groups_list;
+
+ return 0;
+
+err_free_groups_list:
+ counter_groups_list_free(counter);
+err_free_synapse_names:
+ counter_synapse_names_free(&counter->synapse_names_list);
+ return err;
+}
+
+void counter_sysfs_free(struct counter_device *const counter)
+{
+ kfree(counter->groups);
+ counter_groups_list_free(counter);
+ counter_synapse_names_free(&counter->synapse_names_list);
+}
diff --git a/drivers/counter/counter-sysfs.h b/drivers/counter/counter-sysfs.h
new file mode 100644
index 000000000000..00e7cd6ea083
--- /dev/null
+++ b/drivers/counter/counter-sysfs.h
@@ -0,0 +1,14 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Counter sysfs interface
+ * Copyright (C) 2020 William Breathitt Gray
+ */
+#ifndef _COUNTER_SYSFS_H_
+#define _COUNTER_SYSFS_H_
+
+#include <linux/counter.h>
+
+int counter_sysfs_add(struct counter_device *const counter);
+void counter_sysfs_free(struct counter_device *const counter);
+
+#endif /* _COUNTER_SYSFS_H_ */
diff --git a/drivers/counter/counter.c b/drivers/counter/counter.c
deleted file mode 100644
index 6a683d086008..000000000000
--- a/drivers/counter/counter.c
+++ /dev/null
@@ -1,1496 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Generic Counter interface
- * Copyright (C) 2018 William Breathitt Gray
- */
-#include <linux/counter.h>
-#include <linux/device.h>
-#include <linux/err.h>
-#include <linux/export.h>
-#include <linux/fs.h>
-#include <linux/gfp.h>
-#include <linux/idr.h>
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/list.h>
-#include <linux/module.h>
-#include <linux/printk.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/sysfs.h>
-#include <linux/types.h>
-
-const char *const counter_count_direction_str[2] = {
- [COUNTER_COUNT_DIRECTION_FORWARD] = "forward",
- [COUNTER_COUNT_DIRECTION_BACKWARD] = "backward"
-};
-EXPORT_SYMBOL_GPL(counter_count_direction_str);
-
-const char *const counter_count_mode_str[4] = {
- [COUNTER_COUNT_MODE_NORMAL] = "normal",
- [COUNTER_COUNT_MODE_RANGE_LIMIT] = "range limit",
- [COUNTER_COUNT_MODE_NON_RECYCLE] = "non-recycle",
- [COUNTER_COUNT_MODE_MODULO_N] = "modulo-n"
-};
-EXPORT_SYMBOL_GPL(counter_count_mode_str);
-
-ssize_t counter_signal_enum_read(struct counter_device *counter,
- struct counter_signal *signal, void *priv,
- char *buf)
-{
- const struct counter_signal_enum_ext *const e = priv;
- int err;
- size_t index;
-
- if (!e->get)
- return -EINVAL;
-
- err = e->get(counter, signal, &index);
- if (err)
- return err;
-
- if (index >= e->num_items)
- return -EINVAL;
-
- return sprintf(buf, "%s\n", e->items[index]);
-}
-EXPORT_SYMBOL_GPL(counter_signal_enum_read);
-
-ssize_t counter_signal_enum_write(struct counter_device *counter,
- struct counter_signal *signal, void *priv,
- const char *buf, size_t len)
-{
- const struct counter_signal_enum_ext *const e = priv;
- ssize_t index;
- int err;
-
- if (!e->set)
- return -EINVAL;
-
- index = __sysfs_match_string(e->items, e->num_items, buf);
- if (index < 0)
- return index;
-
- err = e->set(counter, signal, index);
- if (err)
- return err;
-
- return len;
-}
-EXPORT_SYMBOL_GPL(counter_signal_enum_write);
-
-ssize_t counter_signal_enum_available_read(struct counter_device *counter,
- struct counter_signal *signal,
- void *priv, char *buf)
-{
- const struct counter_signal_enum_ext *const e = priv;
- size_t i;
- size_t len = 0;
-
- if (!e->num_items)
- return 0;
-
- for (i = 0; i < e->num_items; i++)
- len += sprintf(buf + len, "%s\n", e->items[i]);
-
- return len;
-}
-EXPORT_SYMBOL_GPL(counter_signal_enum_available_read);
-
-ssize_t counter_count_enum_read(struct counter_device *counter,
- struct counter_count *count, void *priv,
- char *buf)
-{
- const struct counter_count_enum_ext *const e = priv;
- int err;
- size_t index;
-
- if (!e->get)
- return -EINVAL;
-
- err = e->get(counter, count, &index);
- if (err)
- return err;
-
- if (index >= e->num_items)
- return -EINVAL;
-
- return sprintf(buf, "%s\n", e->items[index]);
-}
-EXPORT_SYMBOL_GPL(counter_count_enum_read);
-
-ssize_t counter_count_enum_write(struct counter_device *counter,
- struct counter_count *count, void *priv,
- const char *buf, size_t len)
-{
- const struct counter_count_enum_ext *const e = priv;
- ssize_t index;
- int err;
-
- if (!e->set)
- return -EINVAL;
-
- index = __sysfs_match_string(e->items, e->num_items, buf);
- if (index < 0)
- return index;
-
- err = e->set(counter, count, index);
- if (err)
- return err;
-
- return len;
-}
-EXPORT_SYMBOL_GPL(counter_count_enum_write);
-
-ssize_t counter_count_enum_available_read(struct counter_device *counter,
- struct counter_count *count,
- void *priv, char *buf)
-{
- const struct counter_count_enum_ext *const e = priv;
- size_t i;
- size_t len = 0;
-
- if (!e->num_items)
- return 0;
-
- for (i = 0; i < e->num_items; i++)
- len += sprintf(buf + len, "%s\n", e->items[i]);
-
- return len;
-}
-EXPORT_SYMBOL_GPL(counter_count_enum_available_read);
-
-ssize_t counter_device_enum_read(struct counter_device *counter, void *priv,
- char *buf)
-{
- const struct counter_device_enum_ext *const e = priv;
- int err;
- size_t index;
-
- if (!e->get)
- return -EINVAL;
-
- err = e->get(counter, &index);
- if (err)
- return err;
-
- if (index >= e->num_items)
- return -EINVAL;
-
- return sprintf(buf, "%s\n", e->items[index]);
-}
-EXPORT_SYMBOL_GPL(counter_device_enum_read);
-
-ssize_t counter_device_enum_write(struct counter_device *counter, void *priv,
- const char *buf, size_t len)
-{
- const struct counter_device_enum_ext *const e = priv;
- ssize_t index;
- int err;
-
- if (!e->set)
- return -EINVAL;
-
- index = __sysfs_match_string(e->items, e->num_items, buf);
- if (index < 0)
- return index;
-
- err = e->set(counter, index);
- if (err)
- return err;
-
- return len;
-}
-EXPORT_SYMBOL_GPL(counter_device_enum_write);
-
-ssize_t counter_device_enum_available_read(struct counter_device *counter,
- void *priv, char *buf)
-{
- const struct counter_device_enum_ext *const e = priv;
- size_t i;
- size_t len = 0;
-
- if (!e->num_items)
- return 0;
-
- for (i = 0; i < e->num_items; i++)
- len += sprintf(buf + len, "%s\n", e->items[i]);
-
- return len;
-}
-EXPORT_SYMBOL_GPL(counter_device_enum_available_read);
-
-struct counter_attr_parm {
- struct counter_device_attr_group *group;
- const char *prefix;
- const char *name;
- ssize_t (*show)(struct device *dev, struct device_attribute *attr,
- char *buf);
- ssize_t (*store)(struct device *dev, struct device_attribute *attr,
- const char *buf, size_t len);
- void *component;
-};
-
-struct counter_device_attr {
- struct device_attribute dev_attr;
- struct list_head l;
- void *component;
-};
-
-static int counter_attribute_create(const struct counter_attr_parm *const parm)
-{
- struct counter_device_attr *counter_attr;
- struct device_attribute *dev_attr;
- int err;
- struct list_head *const attr_list = &parm->group->attr_list;
-
- /* Allocate a Counter device attribute */
- counter_attr = kzalloc(sizeof(*counter_attr), GFP_KERNEL);
- if (!counter_attr)
- return -ENOMEM;
- dev_attr = &counter_attr->dev_attr;
-
- sysfs_attr_init(&dev_attr->attr);
-
- /* Configure device attribute */
- dev_attr->attr.name = kasprintf(GFP_KERNEL, "%s%s", parm->prefix,
- parm->name);
- if (!dev_attr->attr.name) {
- err = -ENOMEM;
- goto err_free_counter_attr;
- }
- if (parm->show) {
- dev_attr->attr.mode |= 0444;
- dev_attr->show = parm->show;
- }
- if (parm->store) {
- dev_attr->attr.mode |= 0200;
- dev_attr->store = parm->store;
- }
-
- /* Store associated Counter component with attribute */
- counter_attr->component = parm->component;
-
- /* Keep track of the attribute for later cleanup */
- list_add(&counter_attr->l, attr_list);
- parm->group->num_attr++;
-
- return 0;
-
-err_free_counter_attr:
- kfree(counter_attr);
- return err;
-}
-
-#define to_counter_attr(_dev_attr) \
- container_of(_dev_attr, struct counter_device_attr, dev_attr)
-
-struct counter_signal_unit {
- struct counter_signal *signal;
-};
-
-static const char *const counter_signal_value_str[] = {
- [COUNTER_SIGNAL_LOW] = "low",
- [COUNTER_SIGNAL_HIGH] = "high"
-};
-
-static ssize_t counter_signal_show(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- struct counter_device *const counter = dev_get_drvdata(dev);
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_signal_unit *const component = devattr->component;
- struct counter_signal *const signal = component->signal;
- int err;
- enum counter_signal_value val;
-
- err = counter->ops->signal_read(counter, signal, &val);
- if (err)
- return err;
-
- return sprintf(buf, "%s\n", counter_signal_value_str[val]);
-}
-
-struct counter_name_unit {
- const char *name;
-};
-
-static ssize_t counter_device_attr_name_show(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- const struct counter_name_unit *const comp = to_counter_attr(attr)->component;
-
- return sprintf(buf, "%s\n", comp->name);
-}
-
-static int counter_name_attribute_create(
- struct counter_device_attr_group *const group,
- const char *const name)
-{
- struct counter_name_unit *name_comp;
- struct counter_attr_parm parm;
- int err;
-
- /* Skip if no name */
- if (!name)
- return 0;
-
- /* Allocate name attribute component */
- name_comp = kmalloc(sizeof(*name_comp), GFP_KERNEL);
- if (!name_comp)
- return -ENOMEM;
- name_comp->name = name;
-
- /* Allocate Signal name attribute */
- parm.group = group;
- parm.prefix = "";
- parm.name = "name";
- parm.show = counter_device_attr_name_show;
- parm.store = NULL;
- parm.component = name_comp;
- err = counter_attribute_create(&parm);
- if (err)
- goto err_free_name_comp;
-
- return 0;
-
-err_free_name_comp:
- kfree(name_comp);
- return err;
-}
-
-struct counter_signal_ext_unit {
- struct counter_signal *signal;
- const struct counter_signal_ext *ext;
-};
-
-static ssize_t counter_signal_ext_show(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_signal_ext_unit *const comp = devattr->component;
- const struct counter_signal_ext *const ext = comp->ext;
-
- return ext->read(dev_get_drvdata(dev), comp->signal, ext->priv, buf);
-}
-
-static ssize_t counter_signal_ext_store(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_signal_ext_unit *const comp = devattr->component;
- const struct counter_signal_ext *const ext = comp->ext;
-
- return ext->write(dev_get_drvdata(dev), comp->signal, ext->priv, buf,
- len);
-}
-
-static void counter_device_attr_list_free(struct list_head *attr_list)
-{
- struct counter_device_attr *p, *n;
-
- list_for_each_entry_safe(p, n, attr_list, l) {
- /* free attribute name and associated component memory */
- kfree(p->dev_attr.attr.name);
- kfree(p->component);
- list_del(&p->l);
- kfree(p);
- }
-}
-
-static int counter_signal_ext_register(
- struct counter_device_attr_group *const group,
- struct counter_signal *const signal)
-{
- const size_t num_ext = signal->num_ext;
- size_t i;
- const struct counter_signal_ext *ext;
- struct counter_signal_ext_unit *signal_ext_comp;
- struct counter_attr_parm parm;
- int err;
-
- /* Create an attribute for each extension */
- for (i = 0 ; i < num_ext; i++) {
- ext = signal->ext + i;
-
- /* Allocate signal_ext attribute component */
- signal_ext_comp = kmalloc(sizeof(*signal_ext_comp), GFP_KERNEL);
- if (!signal_ext_comp) {
- err = -ENOMEM;
- goto err_free_attr_list;
- }
- signal_ext_comp->signal = signal;
- signal_ext_comp->ext = ext;
-
- /* Allocate a Counter device attribute */
- parm.group = group;
- parm.prefix = "";
- parm.name = ext->name;
- parm.show = (ext->read) ? counter_signal_ext_show : NULL;
- parm.store = (ext->write) ? counter_signal_ext_store : NULL;
- parm.component = signal_ext_comp;
- err = counter_attribute_create(&parm);
- if (err) {
- kfree(signal_ext_comp);
- goto err_free_attr_list;
- }
- }
-
- return 0;
-
-err_free_attr_list:
- counter_device_attr_list_free(&group->attr_list);
- return err;
-}
-
-static int counter_signal_attributes_create(
- struct counter_device_attr_group *const group,
- const struct counter_device *const counter,
- struct counter_signal *const signal)
-{
- struct counter_signal_unit *signal_comp;
- struct counter_attr_parm parm;
- int err;
-
- /* Allocate Signal attribute component */
- signal_comp = kmalloc(sizeof(*signal_comp), GFP_KERNEL);
- if (!signal_comp)
- return -ENOMEM;
- signal_comp->signal = signal;
-
- /* Create main Signal attribute */
- parm.group = group;
- parm.prefix = "";
- parm.name = "signal";
- parm.show = (counter->ops->signal_read) ? counter_signal_show : NULL;
- parm.store = NULL;
- parm.component = signal_comp;
- err = counter_attribute_create(&parm);
- if (err) {
- kfree(signal_comp);
- return err;
- }
-
- /* Create Signal name attribute */
- err = counter_name_attribute_create(group, signal->name);
- if (err)
- goto err_free_attr_list;
-
- /* Register Signal extension attributes */
- err = counter_signal_ext_register(group, signal);
- if (err)
- goto err_free_attr_list;
-
- return 0;
-
-err_free_attr_list:
- counter_device_attr_list_free(&group->attr_list);
- return err;
-}
-
-static int counter_signals_register(
- struct counter_device_attr_group *const groups_list,
- const struct counter_device *const counter)
-{
- const size_t num_signals = counter->num_signals;
- size_t i;
- struct counter_signal *signal;
- const char *name;
- int err;
-
- /* Register each Signal */
- for (i = 0; i < num_signals; i++) {
- signal = counter->signals + i;
-
- /* Generate Signal attribute directory name */
- name = kasprintf(GFP_KERNEL, "signal%d", signal->id);
- if (!name) {
- err = -ENOMEM;
- goto err_free_attr_groups;
- }
- groups_list[i].attr_group.name = name;
-
- /* Create all attributes associated with Signal */
- err = counter_signal_attributes_create(groups_list + i, counter,
- signal);
- if (err)
- goto err_free_attr_groups;
- }
-
- return 0;
-
-err_free_attr_groups:
- do {
- kfree(groups_list[i].attr_group.name);
- counter_device_attr_list_free(&groups_list[i].attr_list);
- } while (i--);
- return err;
-}
-
-static const char *const counter_synapse_action_str[] = {
- [COUNTER_SYNAPSE_ACTION_NONE] = "none",
- [COUNTER_SYNAPSE_ACTION_RISING_EDGE] = "rising edge",
- [COUNTER_SYNAPSE_ACTION_FALLING_EDGE] = "falling edge",
- [COUNTER_SYNAPSE_ACTION_BOTH_EDGES] = "both edges"
-};
-
-struct counter_action_unit {
- struct counter_synapse *synapse;
- struct counter_count *count;
-};
-
-static ssize_t counter_action_show(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- int err;
- struct counter_device *const counter = dev_get_drvdata(dev);
- const struct counter_action_unit *const component = devattr->component;
- struct counter_count *const count = component->count;
- struct counter_synapse *const synapse = component->synapse;
- size_t action_index;
- enum counter_synapse_action action;
-
- err = counter->ops->action_get(counter, count, synapse, &action_index);
- if (err)
- return err;
-
- synapse->action = action_index;
-
- action = synapse->actions_list[action_index];
- return sprintf(buf, "%s\n", counter_synapse_action_str[action]);
-}
-
-static ssize_t counter_action_store(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_action_unit *const component = devattr->component;
- struct counter_synapse *const synapse = component->synapse;
- size_t action_index;
- const size_t num_actions = synapse->num_actions;
- enum counter_synapse_action action;
- int err;
- struct counter_device *const counter = dev_get_drvdata(dev);
- struct counter_count *const count = component->count;
-
- /* Find requested action mode */
- for (action_index = 0; action_index < num_actions; action_index++) {
- action = synapse->actions_list[action_index];
- if (sysfs_streq(buf, counter_synapse_action_str[action]))
- break;
- }
- /* If requested action mode not found */
- if (action_index >= num_actions)
- return -EINVAL;
-
- err = counter->ops->action_set(counter, count, synapse, action_index);
- if (err)
- return err;
-
- synapse->action = action_index;
-
- return len;
-}
-
-struct counter_action_avail_unit {
- const enum counter_synapse_action *actions_list;
- size_t num_actions;
-};
-
-static ssize_t counter_synapse_action_available_show(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_action_avail_unit *const component = devattr->component;
- size_t i;
- enum counter_synapse_action action;
- ssize_t len = 0;
-
- for (i = 0; i < component->num_actions; i++) {
- action = component->actions_list[i];
- len += sprintf(buf + len, "%s\n",
- counter_synapse_action_str[action]);
- }
-
- return len;
-}
-
-static int counter_synapses_register(
- struct counter_device_attr_group *const group,
- const struct counter_device *const counter,
- struct counter_count *const count, const char *const count_attr_name)
-{
- size_t i;
- struct counter_synapse *synapse;
- const char *prefix;
- struct counter_action_unit *action_comp;
- struct counter_attr_parm parm;
- int err;
- struct counter_action_avail_unit *avail_comp;
-
- /* Register each Synapse */
- for (i = 0; i < count->num_synapses; i++) {
- synapse = count->synapses + i;
-
- /* Generate attribute prefix */
- prefix = kasprintf(GFP_KERNEL, "signal%d_",
- synapse->signal->id);
- if (!prefix) {
- err = -ENOMEM;
- goto err_free_attr_list;
- }
-
- /* Allocate action attribute component */
- action_comp = kmalloc(sizeof(*action_comp), GFP_KERNEL);
- if (!action_comp) {
- err = -ENOMEM;
- goto err_free_prefix;
- }
- action_comp->synapse = synapse;
- action_comp->count = count;
-
- /* Create action attribute */
- parm.group = group;
- parm.prefix = prefix;
- parm.name = "action";
- parm.show = (counter->ops->action_get) ? counter_action_show : NULL;
- parm.store = (counter->ops->action_set) ? counter_action_store : NULL;
- parm.component = action_comp;
- err = counter_attribute_create(&parm);
- if (err) {
- kfree(action_comp);
- goto err_free_prefix;
- }
-
- /* Allocate action available attribute component */
- avail_comp = kmalloc(sizeof(*avail_comp), GFP_KERNEL);
- if (!avail_comp) {
- err = -ENOMEM;
- goto err_free_prefix;
- }
- avail_comp->actions_list = synapse->actions_list;
- avail_comp->num_actions = synapse->num_actions;
-
- /* Create action_available attribute */
- parm.group = group;
- parm.prefix = prefix;
- parm.name = "action_available";
- parm.show = counter_synapse_action_available_show;
- parm.store = NULL;
- parm.component = avail_comp;
- err = counter_attribute_create(&parm);
- if (err) {
- kfree(avail_comp);
- goto err_free_prefix;
- }
-
- kfree(prefix);
- }
-
- return 0;
-
-err_free_prefix:
- kfree(prefix);
-err_free_attr_list:
- counter_device_attr_list_free(&group->attr_list);
- return err;
-}
-
-struct counter_count_unit {
- struct counter_count *count;
-};
-
-static ssize_t counter_count_show(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- struct counter_device *const counter = dev_get_drvdata(dev);
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_count_unit *const component = devattr->component;
- struct counter_count *const count = component->count;
- int err;
- unsigned long val;
-
- err = counter->ops->count_read(counter, count, &val);
- if (err)
- return err;
-
- return sprintf(buf, "%lu\n", val);
-}
-
-static ssize_t counter_count_store(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- struct counter_device *const counter = dev_get_drvdata(dev);
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_count_unit *const component = devattr->component;
- struct counter_count *const count = component->count;
- int err;
- unsigned long val;
-
- err = kstrtoul(buf, 0, &val);
- if (err)
- return err;
-
- err = counter->ops->count_write(counter, count, val);
- if (err)
- return err;
-
- return len;
-}
-
-static const char *const counter_count_function_str[] = {
- [COUNTER_COUNT_FUNCTION_INCREASE] = "increase",
- [COUNTER_COUNT_FUNCTION_DECREASE] = "decrease",
- [COUNTER_COUNT_FUNCTION_PULSE_DIRECTION] = "pulse-direction",
- [COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A] = "quadrature x1 a",
- [COUNTER_COUNT_FUNCTION_QUADRATURE_X1_B] = "quadrature x1 b",
- [COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A] = "quadrature x2 a",
- [COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B] = "quadrature x2 b",
- [COUNTER_COUNT_FUNCTION_QUADRATURE_X4] = "quadrature x4"
-};
-
-static ssize_t counter_function_show(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- int err;
- struct counter_device *const counter = dev_get_drvdata(dev);
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_count_unit *const component = devattr->component;
- struct counter_count *const count = component->count;
- size_t func_index;
- enum counter_count_function function;
-
- err = counter->ops->function_get(counter, count, &func_index);
- if (err)
- return err;
-
- count->function = func_index;
-
- function = count->functions_list[func_index];
- return sprintf(buf, "%s\n", counter_count_function_str[function]);
-}
-
-static ssize_t counter_function_store(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_count_unit *const component = devattr->component;
- struct counter_count *const count = component->count;
- const size_t num_functions = count->num_functions;
- size_t func_index;
- enum counter_count_function function;
- int err;
- struct counter_device *const counter = dev_get_drvdata(dev);
-
- /* Find requested Count function mode */
- for (func_index = 0; func_index < num_functions; func_index++) {
- function = count->functions_list[func_index];
- if (sysfs_streq(buf, counter_count_function_str[function]))
- break;
- }
- /* Return error if requested Count function mode not found */
- if (func_index >= num_functions)
- return -EINVAL;
-
- err = counter->ops->function_set(counter, count, func_index);
- if (err)
- return err;
-
- count->function = func_index;
-
- return len;
-}
-
-struct counter_count_ext_unit {
- struct counter_count *count;
- const struct counter_count_ext *ext;
-};
-
-static ssize_t counter_count_ext_show(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_count_ext_unit *const comp = devattr->component;
- const struct counter_count_ext *const ext = comp->ext;
-
- return ext->read(dev_get_drvdata(dev), comp->count, ext->priv, buf);
-}
-
-static ssize_t counter_count_ext_store(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_count_ext_unit *const comp = devattr->component;
- const struct counter_count_ext *const ext = comp->ext;
-
- return ext->write(dev_get_drvdata(dev), comp->count, ext->priv, buf,
- len);
-}
-
-static int counter_count_ext_register(
- struct counter_device_attr_group *const group,
- struct counter_count *const count)
-{
- size_t i;
- const struct counter_count_ext *ext;
- struct counter_count_ext_unit *count_ext_comp;
- struct counter_attr_parm parm;
- int err;
-
- /* Create an attribute for each extension */
- for (i = 0 ; i < count->num_ext; i++) {
- ext = count->ext + i;
-
- /* Allocate count_ext attribute component */
- count_ext_comp = kmalloc(sizeof(*count_ext_comp), GFP_KERNEL);
- if (!count_ext_comp) {
- err = -ENOMEM;
- goto err_free_attr_list;
- }
- count_ext_comp->count = count;
- count_ext_comp->ext = ext;
-
- /* Allocate count_ext attribute */
- parm.group = group;
- parm.prefix = "";
- parm.name = ext->name;
- parm.show = (ext->read) ? counter_count_ext_show : NULL;
- parm.store = (ext->write) ? counter_count_ext_store : NULL;
- parm.component = count_ext_comp;
- err = counter_attribute_create(&parm);
- if (err) {
- kfree(count_ext_comp);
- goto err_free_attr_list;
- }
- }
-
- return 0;
-
-err_free_attr_list:
- counter_device_attr_list_free(&group->attr_list);
- return err;
-}
-
-struct counter_func_avail_unit {
- const enum counter_count_function *functions_list;
- size_t num_functions;
-};
-
-static ssize_t counter_count_function_available_show(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_func_avail_unit *const component = devattr->component;
- const enum counter_count_function *const func_list = component->functions_list;
- const size_t num_functions = component->num_functions;
- size_t i;
- enum counter_count_function function;
- ssize_t len = 0;
-
- for (i = 0; i < num_functions; i++) {
- function = func_list[i];
- len += sprintf(buf + len, "%s\n",
- counter_count_function_str[function]);
- }
-
- return len;
-}
-
-static int counter_count_attributes_create(
- struct counter_device_attr_group *const group,
- const struct counter_device *const counter,
- struct counter_count *const count)
-{
- struct counter_count_unit *count_comp;
- struct counter_attr_parm parm;
- int err;
- struct counter_count_unit *func_comp;
- struct counter_func_avail_unit *avail_comp;
-
- /* Allocate count attribute component */
- count_comp = kmalloc(sizeof(*count_comp), GFP_KERNEL);
- if (!count_comp)
- return -ENOMEM;
- count_comp->count = count;
-
- /* Create main Count attribute */
- parm.group = group;
- parm.prefix = "";
- parm.name = "count";
- parm.show = (counter->ops->count_read) ? counter_count_show : NULL;
- parm.store = (counter->ops->count_write) ? counter_count_store : NULL;
- parm.component = count_comp;
- err = counter_attribute_create(&parm);
- if (err) {
- kfree(count_comp);
- return err;
- }
-
- /* Allocate function attribute component */
- func_comp = kmalloc(sizeof(*func_comp), GFP_KERNEL);
- if (!func_comp) {
- err = -ENOMEM;
- goto err_free_attr_list;
- }
- func_comp->count = count;
-
- /* Create Count function attribute */
- parm.group = group;
- parm.prefix = "";
- parm.name = "function";
- parm.show = (counter->ops->function_get) ? counter_function_show : NULL;
- parm.store = (counter->ops->function_set) ? counter_function_store : NULL;
- parm.component = func_comp;
- err = counter_attribute_create(&parm);
- if (err) {
- kfree(func_comp);
- goto err_free_attr_list;
- }
-
- /* Allocate function available attribute component */
- avail_comp = kmalloc(sizeof(*avail_comp), GFP_KERNEL);
- if (!avail_comp) {
- err = -ENOMEM;
- goto err_free_attr_list;
- }
- avail_comp->functions_list = count->functions_list;
- avail_comp->num_functions = count->num_functions;
-
- /* Create Count function_available attribute */
- parm.group = group;
- parm.prefix = "";
- parm.name = "function_available";
- parm.show = counter_count_function_available_show;
- parm.store = NULL;
- parm.component = avail_comp;
- err = counter_attribute_create(&parm);
- if (err) {
- kfree(avail_comp);
- goto err_free_attr_list;
- }
-
- /* Create Count name attribute */
- err = counter_name_attribute_create(group, count->name);
- if (err)
- goto err_free_attr_list;
-
- /* Register Count extension attributes */
- err = counter_count_ext_register(group, count);
- if (err)
- goto err_free_attr_list;
-
- return 0;
-
-err_free_attr_list:
- counter_device_attr_list_free(&group->attr_list);
- return err;
-}
-
-static int counter_counts_register(
- struct counter_device_attr_group *const groups_list,
- const struct counter_device *const counter)
-{
- size_t i;
- struct counter_count *count;
- const char *name;
- int err;
-
- /* Register each Count */
- for (i = 0; i < counter->num_counts; i++) {
- count = counter->counts + i;
-
- /* Generate Count attribute directory name */
- name = kasprintf(GFP_KERNEL, "count%d", count->id);
- if (!name) {
- err = -ENOMEM;
- goto err_free_attr_groups;
- }
- groups_list[i].attr_group.name = name;
-
- /* Register the Synapses associated with each Count */
- err = counter_synapses_register(groups_list + i, counter, count,
- name);
- if (err)
- goto err_free_attr_groups;
-
- /* Create all attributes associated with Count */
- err = counter_count_attributes_create(groups_list + i, counter,
- count);
- if (err)
- goto err_free_attr_groups;
- }
-
- return 0;
-
-err_free_attr_groups:
- do {
- kfree(groups_list[i].attr_group.name);
- counter_device_attr_list_free(&groups_list[i].attr_list);
- } while (i--);
- return err;
-}
-
-struct counter_size_unit {
- size_t size;
-};
-
-static ssize_t counter_device_attr_size_show(struct device *dev,
- struct device_attribute *attr,
- char *buf)
-{
- const struct counter_size_unit *const comp = to_counter_attr(attr)->component;
-
- return sprintf(buf, "%zu\n", comp->size);
-}
-
-static int counter_size_attribute_create(
- struct counter_device_attr_group *const group,
- const size_t size, const char *const name)
-{
- struct counter_size_unit *size_comp;
- struct counter_attr_parm parm;
- int err;
-
- /* Allocate size attribute component */
- size_comp = kmalloc(sizeof(*size_comp), GFP_KERNEL);
- if (!size_comp)
- return -ENOMEM;
- size_comp->size = size;
-
- parm.group = group;
- parm.prefix = "";
- parm.name = name;
- parm.show = counter_device_attr_size_show;
- parm.store = NULL;
- parm.component = size_comp;
- err = counter_attribute_create(&parm);
- if (err)
- goto err_free_size_comp;
-
- return 0;
-
-err_free_size_comp:
- kfree(size_comp);
- return err;
-}
-
-struct counter_ext_unit {
- const struct counter_device_ext *ext;
-};
-
-static ssize_t counter_device_ext_show(struct device *dev,
- struct device_attribute *attr, char *buf)
-{
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_ext_unit *const component = devattr->component;
- const struct counter_device_ext *const ext = component->ext;
-
- return ext->read(dev_get_drvdata(dev), ext->priv, buf);
-}
-
-static ssize_t counter_device_ext_store(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t len)
-{
- const struct counter_device_attr *const devattr = to_counter_attr(attr);
- const struct counter_ext_unit *const component = devattr->component;
- const struct counter_device_ext *const ext = component->ext;
-
- return ext->write(dev_get_drvdata(dev), ext->priv, buf, len);
-}
-
-static int counter_device_ext_register(
- struct counter_device_attr_group *const group,
- struct counter_device *const counter)
-{
- size_t i;
- struct counter_ext_unit *ext_comp;
- struct counter_attr_parm parm;
- int err;
-
- /* Create an attribute for each extension */
- for (i = 0 ; i < counter->num_ext; i++) {
- /* Allocate extension attribute component */
- ext_comp = kmalloc(sizeof(*ext_comp), GFP_KERNEL);
- if (!ext_comp) {
- err = -ENOMEM;
- goto err_free_attr_list;
- }
-
- ext_comp->ext = counter->ext + i;
-
- /* Allocate extension attribute */
- parm.group = group;
- parm.prefix = "";
- parm.name = counter->ext[i].name;
- parm.show = (counter->ext[i].read) ? counter_device_ext_show : NULL;
- parm.store = (counter->ext[i].write) ? counter_device_ext_store : NULL;
- parm.component = ext_comp;
- err = counter_attribute_create(&parm);
- if (err) {
- kfree(ext_comp);
- goto err_free_attr_list;
- }
- }
-
- return 0;
-
-err_free_attr_list:
- counter_device_attr_list_free(&group->attr_list);
- return err;
-}
-
-static int counter_global_attr_register(
- struct counter_device_attr_group *const group,
- struct counter_device *const counter)
-{
- int err;
-
- /* Create name attribute */
- err = counter_name_attribute_create(group, counter->name);
- if (err)
- return err;
-
- /* Create num_counts attribute */
- err = counter_size_attribute_create(group, counter->num_counts,
- "num_counts");
- if (err)
- goto err_free_attr_list;
-
- /* Create num_signals attribute */
- err = counter_size_attribute_create(group, counter->num_signals,
- "num_signals");
- if (err)
- goto err_free_attr_list;
-
- /* Register Counter device extension attributes */
- err = counter_device_ext_register(group, counter);
- if (err)
- goto err_free_attr_list;
-
- return 0;
-
-err_free_attr_list:
- counter_device_attr_list_free(&group->attr_list);
- return err;
-}
-
-static void counter_device_groups_list_free(
- struct counter_device_attr_group *const groups_list,
- const size_t num_groups)
-{
- struct counter_device_attr_group *group;
- size_t i;
-
- /* loop through all attribute groups (signals, counts, global, etc.) */
- for (i = 0; i < num_groups; i++) {
- group = groups_list + i;
-
- /* free all attribute group and associated attributes memory */
- kfree(group->attr_group.name);
- kfree(group->attr_group.attrs);
- counter_device_attr_list_free(&group->attr_list);
- }
-
- kfree(groups_list);
-}
-
-static int counter_device_groups_list_prepare(
- struct counter_device *const counter)
-{
- const size_t total_num_groups =
- counter->num_signals + counter->num_counts + 1;
- struct counter_device_attr_group *groups_list;
- size_t i;
- int err;
- size_t num_groups = 0;
-
- /* Allocate space for attribute groups (signals, counts, and ext) */
- groups_list = kcalloc(total_num_groups, sizeof(*groups_list),
- GFP_KERNEL);
- if (!groups_list)
- return -ENOMEM;
-
- /* Initialize attribute lists */
- for (i = 0; i < total_num_groups; i++)
- INIT_LIST_HEAD(&groups_list[i].attr_list);
-
- /* Register Signals */
- err = counter_signals_register(groups_list, counter);
- if (err)
- goto err_free_groups_list;
- num_groups += counter->num_signals;
-
- /* Register Counts and respective Synapses */
- err = counter_counts_register(groups_list + num_groups, counter);
- if (err)
- goto err_free_groups_list;
- num_groups += counter->num_counts;
-
- /* Register Counter global attributes */
- err = counter_global_attr_register(groups_list + num_groups, counter);
- if (err)
- goto err_free_groups_list;
- num_groups++;
-
- /* Store groups_list in device_state */
- counter->device_state->groups_list = groups_list;
- counter->device_state->num_groups = num_groups;
-
- return 0;
-
-err_free_groups_list:
- counter_device_groups_list_free(groups_list, num_groups);
- return err;
-}
-
-static int counter_device_groups_prepare(
- struct counter_device_state *const device_state)
-{
- size_t i, j;
- struct counter_device_attr_group *group;
- int err;
- struct counter_device_attr *p;
-
- /* Allocate attribute groups for association with device */
- device_state->groups = kcalloc(device_state->num_groups + 1,
- sizeof(*device_state->groups),
- GFP_KERNEL);
- if (!device_state->groups)
- return -ENOMEM;
-
- /* Prepare each group of attributes for association */
- for (i = 0; i < device_state->num_groups; i++) {
- group = device_state->groups_list + i;
-
- /* Allocate space for attribute pointers in attribute group */
- group->attr_group.attrs = kcalloc(group->num_attr + 1,
- sizeof(*group->attr_group.attrs), GFP_KERNEL);
- if (!group->attr_group.attrs) {
- err = -ENOMEM;
- goto err_free_groups;
- }
-
- /* Add attribute pointers to attribute group */
- j = 0;
- list_for_each_entry(p, &group->attr_list, l)
- group->attr_group.attrs[j++] = &p->dev_attr.attr;
-
- /* Group attributes in attribute group */
- device_state->groups[i] = &group->attr_group;
- }
- /* Associate attributes with device */
- device_state->dev.groups = device_state->groups;
-
- return 0;
-
-err_free_groups:
- do {
- group = device_state->groups_list + i;
- kfree(group->attr_group.attrs);
- group->attr_group.attrs = NULL;
- } while (i--);
- kfree(device_state->groups);
- return err;
-}
-
-/* Provides a unique ID for each counter device */
-static DEFINE_IDA(counter_ida);
-
-static void counter_device_release(struct device *dev)
-{
- struct counter_device *const counter = dev_get_drvdata(dev);
- struct counter_device_state *const device_state = counter->device_state;
-
- kfree(device_state->groups);
- counter_device_groups_list_free(device_state->groups_list,
- device_state->num_groups);
- ida_simple_remove(&counter_ida, device_state->id);
- kfree(device_state);
-}
-
-static struct device_type counter_device_type = {
- .name = "counter_device",
- .release = counter_device_release
-};
-
-static struct bus_type counter_bus_type = {
- .name = "counter"
-};
-
-/**
- * counter_register - register Counter to the system
- * @counter: pointer to Counter to register
- *
- * This function registers a Counter to the system. A sysfs "counter" directory
- * will be created and populated with sysfs attributes correlating with the
- * Counter Signals, Synapses, and Counts respectively.
- */
-int counter_register(struct counter_device *const counter)
-{
- struct counter_device_state *device_state;
- int err;
-
- /* Allocate internal state container for Counter device */
- device_state = kzalloc(sizeof(*device_state), GFP_KERNEL);
- if (!device_state)
- return -ENOMEM;
- counter->device_state = device_state;
-
- /* Acquire unique ID */
- device_state->id = ida_simple_get(&counter_ida, 0, 0, GFP_KERNEL);
- if (device_state->id < 0) {
- err = device_state->id;
- goto err_free_device_state;
- }
-
- /* Configure device structure for Counter */
- device_state->dev.type = &counter_device_type;
- device_state->dev.bus = &counter_bus_type;
- if (counter->parent) {
- device_state->dev.parent = counter->parent;
- device_state->dev.of_node = counter->parent->of_node;
- }
- dev_set_name(&device_state->dev, "counter%d", device_state->id);
- device_initialize(&device_state->dev);
- dev_set_drvdata(&device_state->dev, counter);
-
- /* Prepare device attributes */
- err = counter_device_groups_list_prepare(counter);
- if (err)
- goto err_free_id;
-
- /* Organize device attributes to groups and match to device */
- err = counter_device_groups_prepare(device_state);
- if (err)
- goto err_free_groups_list;
-
- /* Add device to system */
- err = device_add(&device_state->dev);
- if (err)
- goto err_free_groups;
-
- return 0;
-
-err_free_groups:
- kfree(device_state->groups);
-err_free_groups_list:
- counter_device_groups_list_free(device_state->groups_list,
- device_state->num_groups);
-err_free_id:
- ida_simple_remove(&counter_ida, device_state->id);
-err_free_device_state:
- kfree(device_state);
- return err;
-}
-EXPORT_SYMBOL_GPL(counter_register);
-
-/**
- * counter_unregister - unregister Counter from the system
- * @counter: pointer to Counter to unregister
- *
- * The Counter is unregistered from the system; all allocated memory is freed.
- */
-void counter_unregister(struct counter_device *const counter)
-{
- if (counter)
- device_del(&counter->device_state->dev);
-}
-EXPORT_SYMBOL_GPL(counter_unregister);
-
-static void devm_counter_unreg(struct device *dev, void *res)
-{
- counter_unregister(*(struct counter_device **)res);
-}
-
-/**
- * devm_counter_register - Resource-managed counter_register
- * @dev: device to allocate counter_device for
- * @counter: pointer to Counter to register
- *
- * Managed counter_register. The Counter registered with this function is
- * automatically unregistered on driver detach. This function calls
- * counter_register internally. Refer to that function for more information.
- *
- * If an Counter registered with this function needs to be unregistered
- * separately, devm_counter_unregister must be used.
- *
- * RETURNS:
- * 0 on success, negative error number on failure.
- */
-int devm_counter_register(struct device *dev,
- struct counter_device *const counter)
-{
- struct counter_device **ptr;
- int ret;
-
- ptr = devres_alloc(devm_counter_unreg, sizeof(*ptr), GFP_KERNEL);
- if (!ptr)
- return -ENOMEM;
-
- ret = counter_register(counter);
- if (!ret) {
- *ptr = counter;
- devres_add(dev, ptr);
- } else {
- devres_free(ptr);
- }
-
- return ret;
-}
-EXPORT_SYMBOL_GPL(devm_counter_register);
-
-static int devm_counter_match(struct device *dev, void *res, void *data)
-{
- struct counter_device **r = res;
-
- if (!r || !*r) {
- WARN_ON(!r || !*r);
- return 0;
- }
-
- return *r == data;
-}
-
-/**
- * devm_counter_unregister - Resource-managed counter_unregister
- * @dev: device this counter_device belongs to
- * @counter: pointer to Counter associated with the device
- *
- * Unregister Counter registered with devm_counter_register.
- */
-void devm_counter_unregister(struct device *dev,
- struct counter_device *const counter)
-{
- int rc;
-
- rc = devres_release(dev, devm_counter_unreg, devm_counter_match,
- counter);
- WARN_ON(rc);
-}
-EXPORT_SYMBOL_GPL(devm_counter_unregister);
-
-static int __init counter_init(void)
-{
- return bus_register(&counter_bus_type);
-}
-
-static void __exit counter_exit(void)
-{
- bus_unregister(&counter_bus_type);
-}
-
-subsys_initcall(counter_init);
-module_exit(counter_exit);
-
-MODULE_AUTHOR("William Breathitt Gray <[email protected]>");
-MODULE_DESCRIPTION("Generic Counter interface");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/counter/ftm-quaddec.c b/drivers/counter/ftm-quaddec.c
index c2b3fdfd8b77..450353f495a2 100644
--- a/drivers/counter/ftm-quaddec.c
+++ b/drivers/counter/ftm-quaddec.c
@@ -151,29 +151,19 @@ static const char * const ftm_quaddec_prescaler[] = {
"1", "2", "4", "8", "16", "32", "64", "128"
};
-static struct counter_count_enum_ext ftm_quaddec_prescaler_enum = {
- .items = ftm_quaddec_prescaler,
- .num_items = ARRAY_SIZE(ftm_quaddec_prescaler),
- .get = ftm_quaddec_get_prescaler,
- .set = ftm_quaddec_set_prescaler
-};
-
-enum ftm_quaddec_synapse_action {
- FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES,
-};
+static DEFINE_COUNTER_ENUM(ftm_quaddec_prescaler_enum, ftm_quaddec_prescaler);
-static enum counter_synapse_action ftm_quaddec_synapse_actions[] = {
- [FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES] =
+static const enum counter_synapse_action ftm_quaddec_synapse_actions[] = {
COUNTER_SYNAPSE_ACTION_BOTH_EDGES
};
enum ftm_quaddec_count_function {
- FTM_QUADDEC_COUNT_ENCODER_MODE_1,
+ FTM_QUADDEC_COUNT_ENCODER_MODE_1 =
+ COUNTER_COUNT_FUNCTION_QUADRATURE_X4
};
static const enum counter_count_function ftm_quaddec_count_functions[] = {
- [FTM_QUADDEC_COUNT_ENCODER_MODE_1] =
- COUNTER_COUNT_FUNCTION_QUADRATURE_X4
+ FTM_QUADDEC_COUNT_ENCODER_MODE_1
};
static int ftm_quaddec_count_read(struct counter_device *counter,
@@ -208,7 +198,7 @@ static int ftm_quaddec_count_write(struct counter_device *counter,
static int ftm_quaddec_count_function_get(struct counter_device *counter,
struct counter_count *count,
- size_t *function)
+ enum counter_count_function *function)
{
*function = FTM_QUADDEC_COUNT_ENCODER_MODE_1;
@@ -218,20 +208,13 @@ static int ftm_quaddec_count_function_get(struct counter_device *counter,
static int ftm_quaddec_action_get(struct counter_device *counter,
struct counter_count *count,
struct counter_synapse *synapse,
- size_t *action)
+ enum counter_synapse_action *action)
{
- *action = FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES;
+ *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
return 0;
}
-static const struct counter_ops ftm_quaddec_cnt_ops = {
- .count_read = ftm_quaddec_count_read,
- .count_write = ftm_quaddec_count_write,
- .function_get = ftm_quaddec_count_function_get,
- .action_get = ftm_quaddec_action_get,
-};
-
static struct counter_signal ftm_quaddec_signals[] = {
{
.id = 0,
@@ -256,9 +239,11 @@ static struct counter_synapse ftm_quaddec_count_synapses[] = {
}
};
-static const struct counter_count_ext ftm_quaddec_count_ext[] = {
- COUNTER_COUNT_ENUM("prescaler", &ftm_quaddec_prescaler_enum),
- COUNTER_COUNT_ENUM_AVAILABLE("prescaler", &ftm_quaddec_prescaler_enum),
+static struct counter_data ftm_quaddec_count_ext[] = {
+ COUNTER_DATA_ENUM_AND_AVAILABLE("prescaler",
+ ftm_quaddec_get_prescaler,
+ ftm_quaddec_set_prescaler,
+ ftm_quaddec_prescaler_enum),
};
static struct counter_count ftm_quaddec_counts = {
@@ -302,7 +287,10 @@ static int ftm_quaddec_probe(struct platform_device *pdev)
}
ftm->counter.name = dev_name(&pdev->dev);
ftm->counter.parent = &pdev->dev;
- ftm->counter.ops = &ftm_quaddec_cnt_ops;
+ ftm->counter.count_read = ftm_quaddec_count_read;
+ ftm->counter.count_write = ftm_quaddec_count_write;
+ ftm->counter.function_read = ftm_quaddec_count_function_get;
+ ftm->counter.action_read = ftm_quaddec_action_get;
ftm->counter.counts = &ftm_quaddec_counts;
ftm->counter.num_counts = 1;
ftm->counter.signals = ftm_quaddec_signals;
diff --git a/drivers/counter/stm32-lptimer-cnt.c b/drivers/counter/stm32-lptimer-cnt.c
index 8e276eb655f5..53ca88533831 100644
--- a/drivers/counter/stm32-lptimer-cnt.c
+++ b/drivers/counter/stm32-lptimer-cnt.c
@@ -352,30 +352,44 @@ static const struct iio_chan_spec stm32_lptim_cnt_channels = {
* @STM32_LPTIM_ENCODER_BOTH_EDGE: count on both edges (IN1 & IN2 quadrature)
*/
enum stm32_lptim_cnt_function {
- STM32_LPTIM_COUNTER_INCREASE,
- STM32_LPTIM_ENCODER_BOTH_EDGE,
+ STM32_LPTIM_COUNTER_INCREASE = COUNTER_COUNT_FUNCTION_INCREASE,
+ STM32_LPTIM_ENCODER_BOTH_EDGE = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
};
static enum counter_count_function stm32_lptim_cnt_functions[] = {
- [STM32_LPTIM_COUNTER_INCREASE] = COUNTER_COUNT_FUNCTION_INCREASE,
- [STM32_LPTIM_ENCODER_BOTH_EDGE] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
+ STM32_LPTIM_COUNTER_INCREASE,
+ STM32_LPTIM_ENCODER_BOTH_EDGE,
};
enum stm32_lptim_synapse_action {
+ /* Index must match with stm32_lptim_cnt_polarity[] (priv->polarity) */
STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE,
STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE,
STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES,
STM32_LPTIM_SYNAPSE_ACTION_NONE,
};
-static enum counter_synapse_action stm32_lptim_cnt_synapse_actions[] = {
- /* Index must match with stm32_lptim_cnt_polarity[] (priv->polarity) */
+static const enum stm32_lptim_synapse_action stm32_lptim_c2l_actions_map[] = {
+ [COUNTER_SYNAPSE_ACTION_RISING_EDGE] = STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE,
+ [COUNTER_SYNAPSE_ACTION_FALLING_EDGE] = STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE,
+ [COUNTER_SYNAPSE_ACTION_BOTH_EDGES] = STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES,
+ [COUNTER_SYNAPSE_ACTION_NONE] = STM32_LPTIM_SYNAPSE_ACTION_NONE,
+};
+
+static const enum counter_synapse_action stm32_lptim_l2c_actions_map[] = {
[STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
[STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
[STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
[STM32_LPTIM_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
};
+static const enum counter_synapse_action stm32_lptim_cnt_synapse_actions[] = {
+ stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE],
+ stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE],
+ stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES],
+ stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_NONE],
+};
+
static int stm32_lptim_cnt_read(struct counter_device *counter,
struct counter_count *count, unsigned long *val)
{
@@ -394,7 +408,7 @@ static int stm32_lptim_cnt_read(struct counter_device *counter,
static int stm32_lptim_cnt_function_get(struct counter_device *counter,
struct counter_count *count,
- size_t *function)
+ enum counter_count_function *function)
{
struct stm32_lptim_cnt *const priv = counter->priv;
@@ -413,7 +427,7 @@ static int stm32_lptim_cnt_function_get(struct counter_device *counter,
static int stm32_lptim_cnt_function_set(struct counter_device *counter,
struct counter_count *count,
- size_t function)
+ enum counter_count_function function)
{
struct stm32_lptim_cnt *const priv = counter->priv;
@@ -423,19 +437,20 @@ static int stm32_lptim_cnt_function_set(struct counter_device *counter,
switch (function) {
case STM32_LPTIM_COUNTER_INCREASE:
priv->quadrature_mode = 0;
- return 0;
+ break;
case STM32_LPTIM_ENCODER_BOTH_EDGE:
priv->quadrature_mode = 1;
priv->polarity = STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES;
- return 0;
+ break;
+ default: return -EINVAL;
}
- return -EINVAL;
+ return 0;
}
-static ssize_t stm32_lptim_cnt_enable_read(struct counter_device *counter,
- struct counter_count *count,
- void *private, char *buf)
+static int stm32_lptim_cnt_enable_read(struct counter_device *counter,
+ struct counter_count *count,
+ bool *enable)
{
struct stm32_lptim_cnt *const priv = counter->priv;
int ret;
@@ -444,22 +459,18 @@ static ssize_t stm32_lptim_cnt_enable_read(struct counter_device *counter,
if (ret < 0)
return ret;
- return scnprintf(buf, PAGE_SIZE, "%u\n", ret);
+ *enable = ret;
+
+ return 0;
}
-static ssize_t stm32_lptim_cnt_enable_write(struct counter_device *counter,
- struct counter_count *count,
- void *private,
- const char *buf, size_t len)
+static int stm32_lptim_cnt_enable_write(struct counter_device *counter,
+ struct counter_count *count,
+ bool enable)
{
struct stm32_lptim_cnt *const priv = counter->priv;
- bool enable;
int ret;
- ret = kstrtobool(buf, &enable);
- if (ret)
- return ret;
-
/* Check nobody uses the timer, or already disabled/enabled */
ret = stm32_lptim_is_enabled(priv);
if ((ret < 0) || (!ret && !enable))
@@ -475,48 +486,51 @@ static ssize_t stm32_lptim_cnt_enable_write(struct counter_device *counter,
if (ret)
return ret;
- return len;
+ return 0;
}
-static ssize_t stm32_lptim_cnt_ceiling_read(struct counter_device *counter,
- struct counter_count *count,
- void *private, char *buf)
+static int stm32_lptim_cnt_ceiling_read(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long *ceiling)
{
struct stm32_lptim_cnt *const priv = counter->priv;
- return stm32_lptim_cnt_get_ceiling(priv, buf);
+ *ceiling = priv->ceiling;
+
+ return 0;
}
-static ssize_t stm32_lptim_cnt_ceiling_write(struct counter_device *counter,
- struct counter_count *count,
- void *private,
- const char *buf, size_t len)
+static int stm32_lptim_cnt_ceiling_write(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long ceiling)
{
struct stm32_lptim_cnt *const priv = counter->priv;
- return stm32_lptim_cnt_set_ceiling(priv, buf, len);
+ if (stm32_lptim_is_enabled(priv))
+ return -EBUSY;
+
+ priv->ceiling = ceiling;
+
+ if (ceiling > STM32_LPTIM_MAX_ARR)
+ return -EINVAL;
+
+ return 0;
}
-static const struct counter_count_ext stm32_lptim_cnt_ext[] = {
- {
- .name = "enable",
- .read = stm32_lptim_cnt_enable_read,
- .write = stm32_lptim_cnt_enable_write
- },
- {
- .name = "ceiling",
- .read = stm32_lptim_cnt_ceiling_read,
- .write = stm32_lptim_cnt_ceiling_write
- },
+static struct counter_data stm32_lptim_cnt_ext[] = {
+ COUNTER_DATA_ENABLE(stm32_lptim_cnt_enable_read,
+ stm32_lptim_cnt_enable_write),
+ COUNTER_DATA_CEILING(stm32_lptim_cnt_ceiling_read,
+ stm32_lptim_cnt_ceiling_write),
};
static int stm32_lptim_cnt_action_get(struct counter_device *counter,
struct counter_count *count,
struct counter_synapse *synapse,
- size_t *action)
+ enum counter_synapse_action *action)
{
struct stm32_lptim_cnt *const priv = counter->priv;
- size_t function;
+ enum counter_count_function function;
int err;
err = stm32_lptim_cnt_function_get(counter, count, &function);
@@ -527,25 +541,27 @@ static int stm32_lptim_cnt_action_get(struct counter_device *counter,
case STM32_LPTIM_COUNTER_INCREASE:
/* LP Timer acts as up-counter on input 1 */
if (synapse->signal->id == count->synapses[0].signal->id)
- *action = priv->polarity;
+ *action = stm32_lptim_l2c_actions_map[priv->polarity];
else
- *action = STM32_LPTIM_SYNAPSE_ACTION_NONE;
- return 0;
+ *action = COUNTER_SYNAPSE_ACTION_NONE;
+ break;
case STM32_LPTIM_ENCODER_BOTH_EDGE:
- *action = priv->polarity;
- return 0;
+ *action = stm32_lptim_l2c_actions_map[priv->polarity];
+ break;
+ default: return -EINVAL;
}
- return -EINVAL;
+ return 0;
}
static int stm32_lptim_cnt_action_set(struct counter_device *counter,
struct counter_count *count,
struct counter_synapse *synapse,
- size_t action)
+ enum counter_synapse_action action)
{
struct stm32_lptim_cnt *const priv = counter->priv;
- size_t function;
+ enum counter_count_function function;
+ enum stm32_lptim_cnt_function cnt_function;
int err;
if (stm32_lptim_is_enabled(priv))
@@ -554,29 +570,18 @@ static int stm32_lptim_cnt_action_set(struct counter_device *counter,
err = stm32_lptim_cnt_function_get(counter, count, &function);
if (err)
return err;
+ cnt_function = function;
/* only set polarity when in counter mode (on input 1) */
- if (function == STM32_LPTIM_COUNTER_INCREASE
- && synapse->signal->id == count->synapses[0].signal->id) {
- switch (action) {
- case STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE:
- case STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE:
- case STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES:
- priv->polarity = action;
- return 0;
- }
- }
+ if (cnt_function != STM32_LPTIM_COUNTER_INCREASE
+ || synapse->signal->id != count->synapses[0].signal->id
+ || action == COUNTER_SYNAPSE_ACTION_NONE)
+ return -EINVAL;
- return -EINVAL;
-}
+ priv->polarity = stm32_lptim_c2l_actions_map[action];
-static const struct counter_ops stm32_lptim_cnt_ops = {
- .count_read = stm32_lptim_cnt_read,
- .function_get = stm32_lptim_cnt_function_get,
- .function_set = stm32_lptim_cnt_function_set,
- .action_get = stm32_lptim_cnt_action_get,
- .action_set = stm32_lptim_cnt_action_set,
-};
+ return 0;
+}
static struct counter_signal stm32_lptim_cnt_signals[] = {
{
@@ -660,7 +665,11 @@ static int stm32_lptim_cnt_probe(struct platform_device *pdev)
/* Initialize Counter device */
priv->counter.name = dev_name(&pdev->dev);
priv->counter.parent = &pdev->dev;
- priv->counter.ops = &stm32_lptim_cnt_ops;
+ priv->counter.count_read = stm32_lptim_cnt_read;
+ priv->counter.function_read = stm32_lptim_cnt_function_get;
+ priv->counter.function_write = stm32_lptim_cnt_function_set;
+ priv->counter.action_read = stm32_lptim_cnt_action_get;
+ priv->counter.action_write = stm32_lptim_cnt_action_set;
if (ddata->has_encoder) {
priv->counter.counts = &stm32_lptim_enc_counts;
priv->counter.num_signals = ARRAY_SIZE(stm32_lptim_cnt_signals);
diff --git a/drivers/counter/stm32-timer-cnt.c b/drivers/counter/stm32-timer-cnt.c
index ef2a974a2f10..09e87cf79ce9 100644
--- a/drivers/counter/stm32-timer-cnt.c
+++ b/drivers/counter/stm32-timer-cnt.c
@@ -45,17 +45,17 @@ struct stm32_timer_cnt {
*/
enum stm32_count_function {
STM32_COUNT_SLAVE_MODE_DISABLED = -1,
+ STM32_COUNT_ENCODER_MODE_1 = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
+ STM32_COUNT_ENCODER_MODE_2 = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,
+ STM32_COUNT_ENCODER_MODE_3 = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
+};
+
+static const enum counter_count_function stm32_count_functions[] = {
STM32_COUNT_ENCODER_MODE_1,
STM32_COUNT_ENCODER_MODE_2,
STM32_COUNT_ENCODER_MODE_3,
};
-static enum counter_count_function stm32_count_functions[] = {
- [STM32_COUNT_ENCODER_MODE_1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
- [STM32_COUNT_ENCODER_MODE_2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,
- [STM32_COUNT_ENCODER_MODE_3] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
-};
-
static int stm32_count_read(struct counter_device *counter,
struct counter_count *count, unsigned long *val)
{
@@ -82,7 +82,7 @@ static int stm32_count_write(struct counter_device *counter,
static int stm32_count_function_get(struct counter_device *counter,
struct counter_count *count,
- size_t *function)
+ enum counter_count_function *function)
{
struct stm32_timer_cnt *const priv = counter->priv;
u32 smcr;
@@ -106,7 +106,7 @@ static int stm32_count_function_get(struct counter_device *counter,
static int stm32_count_function_set(struct counter_device *counter,
struct counter_count *count,
- size_t function)
+ enum counter_count_function function)
{
struct stm32_timer_cnt *const priv = counter->priv;
u32 cr1, sms;
@@ -146,78 +146,66 @@ static int stm32_count_function_set(struct counter_device *counter,
return 0;
}
-static ssize_t stm32_count_direction_read(struct counter_device *counter,
+static int stm32_count_direction_read(struct counter_device *counter,
struct counter_count *count,
- void *private, char *buf)
+ enum counter_count_direction *direction)
{
struct stm32_timer_cnt *const priv = counter->priv;
- const char *direction;
u32 cr1;
regmap_read(priv->regmap, TIM_CR1, &cr1);
- direction = (cr1 & TIM_CR1_DIR) ? "backward" : "forward";
+ *direction = (cr1 & TIM_CR1_DIR) ? COUNTER_COUNT_DIRECTION_BACKWARD :
+ COUNTER_COUNT_DIRECTION_FORWARD;
- return scnprintf(buf, PAGE_SIZE, "%s\n", direction);
+ return 0;
}
-static ssize_t stm32_count_ceiling_read(struct counter_device *counter,
- struct counter_count *count,
- void *private, char *buf)
+static int stm32_count_ceiling_read(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long *ceiling)
{
struct stm32_timer_cnt *const priv = counter->priv;
u32 arr;
regmap_read(priv->regmap, TIM_ARR, &arr);
- return snprintf(buf, PAGE_SIZE, "%u\n", arr);
+ *ceiling = arr;
+
+ return 0;
}
-static ssize_t stm32_count_ceiling_write(struct counter_device *counter,
- struct counter_count *count,
- void *private,
- const char *buf, size_t len)
+static int stm32_count_ceiling_write(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long ceiling)
{
struct stm32_timer_cnt *const priv = counter->priv;
- unsigned int ceiling;
- int ret;
-
- ret = kstrtouint(buf, 0, &ceiling);
- if (ret)
- return ret;
/* TIMx_ARR register shouldn't be buffered (ARPE=0) */
regmap_update_bits(priv->regmap, TIM_CR1, TIM_CR1_ARPE, 0);
regmap_write(priv->regmap, TIM_ARR, ceiling);
priv->ceiling = ceiling;
- return len;
+ return 0;
}
-static ssize_t stm32_count_enable_read(struct counter_device *counter,
- struct counter_count *count,
- void *private, char *buf)
+static int stm32_count_enable_read(struct counter_device *counter,
+ struct counter_count *count, bool *enable)
{
struct stm32_timer_cnt *const priv = counter->priv;
u32 cr1;
regmap_read(priv->regmap, TIM_CR1, &cr1);
- return scnprintf(buf, PAGE_SIZE, "%d\n", (bool)(cr1 & TIM_CR1_CEN));
+ *enable = cr1 & TIM_CR1_CEN;
+
+ return 0;
}
-static ssize_t stm32_count_enable_write(struct counter_device *counter,
- struct counter_count *count,
- void *private,
- const char *buf, size_t len)
+static int stm32_count_enable_write(struct counter_device *counter,
+ struct counter_count *count, bool enable)
{
struct stm32_timer_cnt *const priv = counter->priv;
- int err;
u32 cr1;
- bool enable;
-
- err = kstrtobool(buf, &enable);
- if (err)
- return err;
if (enable) {
regmap_read(priv->regmap, TIM_CR1, &cr1);
@@ -236,46 +224,31 @@ static ssize_t stm32_count_enable_write(struct counter_device *counter,
/* Keep enabled state to properly handle low power states */
priv->enabled = enable;
- return len;
+ return 0;
}
-static const struct counter_count_ext stm32_count_ext[] = {
- {
- .name = "direction",
- .read = stm32_count_direction_read,
- },
- {
- .name = "enable",
- .read = stm32_count_enable_read,
- .write = stm32_count_enable_write
- },
- {
- .name = "ceiling",
- .read = stm32_count_ceiling_read,
- .write = stm32_count_ceiling_write
- },
-};
-
-enum stm32_synapse_action {
- STM32_SYNAPSE_ACTION_NONE,
- STM32_SYNAPSE_ACTION_BOTH_EDGES
+static struct counter_data stm32_count_ext[] = {
+ COUNTER_DATA_DIRECTION(stm32_count_direction_read),
+ COUNTER_DATA_ENABLE(stm32_count_enable_read, stm32_count_enable_write),
+ COUNTER_DATA_CEILING(stm32_count_ceiling_read,
+ stm32_count_ceiling_write),
};
-static enum counter_synapse_action stm32_synapse_actions[] = {
- [STM32_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
- [STM32_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES
+static const enum counter_synapse_action stm32_synapse_actions[] = {
+ COUNTER_SYNAPSE_ACTION_NONE,
+ COUNTER_SYNAPSE_ACTION_BOTH_EDGES
};
static int stm32_action_get(struct counter_device *counter,
struct counter_count *count,
struct counter_synapse *synapse,
- size_t *action)
+ enum counter_synapse_action *action)
{
- size_t function;
+ enum counter_count_function function;
int err;
/* Default action mode (e.g. STM32_COUNT_SLAVE_MODE_DISABLED) */
- *action = STM32_SYNAPSE_ACTION_NONE;
+ *action = COUNTER_SYNAPSE_ACTION_NONE;
err = stm32_count_function_get(counter, count, &function);
if (err)
@@ -285,30 +258,23 @@ static int stm32_action_get(struct counter_device *counter,
case STM32_COUNT_ENCODER_MODE_1:
/* counts up/down on TI1FP1 edge depending on TI2FP2 level */
if (synapse->signal->id == count->synapses[0].signal->id)
- *action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
+ *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
break;
case STM32_COUNT_ENCODER_MODE_2:
/* counts up/down on TI2FP2 edge depending on TI1FP1 level */
if (synapse->signal->id == count->synapses[1].signal->id)
- *action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
+ *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
break;
case STM32_COUNT_ENCODER_MODE_3:
/* counts up/down on both TI1FP1 and TI2FP2 edges */
- *action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
+ *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
break;
+ default: return -EINVAL;
}
return 0;
}
-static const struct counter_ops stm32_timer_cnt_ops = {
- .count_read = stm32_count_read,
- .count_write = stm32_count_write,
- .function_get = stm32_count_function_get,
- .function_set = stm32_count_function_set,
- .action_get = stm32_action_get,
-};
-
static struct counter_signal stm32_signals[] = {
{
.id = 0,
@@ -363,7 +329,11 @@ static int stm32_timer_cnt_probe(struct platform_device *pdev)
priv->counter.name = dev_name(dev);
priv->counter.parent = dev;
- priv->counter.ops = &stm32_timer_cnt_ops;
+ priv->counter.count_read = stm32_count_read;
+ priv->counter.count_write = stm32_count_write;
+ priv->counter.function_read = stm32_count_function_get;
+ priv->counter.function_write = stm32_count_function_set;
+ priv->counter.action_read = stm32_action_get;
priv->counter.counts = &stm32_counts;
priv->counter.num_counts = 1;
priv->counter.signals = stm32_signals;
diff --git a/drivers/counter/ti-eqep.c b/drivers/counter/ti-eqep.c
index 1ff07faef27f..b1fac22a0a4f 100644
--- a/drivers/counter/ti-eqep.c
+++ b/drivers/counter/ti-eqep.c
@@ -74,16 +74,10 @@ enum {
/* Position Counter Input Modes */
enum {
- TI_EQEP_COUNT_FUNC_QUAD_COUNT,
- TI_EQEP_COUNT_FUNC_DIR_COUNT,
- TI_EQEP_COUNT_FUNC_UP_COUNT,
- TI_EQEP_COUNT_FUNC_DOWN_COUNT,
-};
-
-enum {
- TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES,
- TI_EQEP_SYNAPSE_ACTION_RISING_EDGE,
- TI_EQEP_SYNAPSE_ACTION_NONE,
+ TI_EQEP_COUNT_FUNC_QUAD_COUNT = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
+ TI_EQEP_COUNT_FUNC_DIR_COUNT = COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
+ TI_EQEP_COUNT_FUNC_UP_COUNT = COUNTER_COUNT_FUNCTION_INCREASE,
+ TI_EQEP_COUNT_FUNC_DOWN_COUNT = COUNTER_COUNT_FUNCTION_DECREASE,
};
struct ti_eqep_cnt {
@@ -118,7 +112,8 @@ static int ti_eqep_count_write(struct counter_device *counter,
}
static int ti_eqep_function_get(struct counter_device *counter,
- struct counter_count *count, size_t *function)
+ struct counter_count *count,
+ enum counter_count_function *function)
{
struct ti_eqep_cnt *priv = counter->priv;
u32 qdecctl;
@@ -130,7 +125,8 @@ static int ti_eqep_function_get(struct counter_device *counter,
}
static int ti_eqep_function_set(struct counter_device *counter,
- struct counter_count *count, size_t function)
+ struct counter_count *count,
+ enum counter_count_function function)
{
struct ti_eqep_cnt *priv = counter->priv;
@@ -140,10 +136,11 @@ static int ti_eqep_function_set(struct counter_device *counter,
static int ti_eqep_action_get(struct counter_device *counter,
struct counter_count *count,
- struct counter_synapse *synapse, size_t *action)
+ struct counter_synapse *synapse,
+ enum counter_synapse_action *action)
{
struct ti_eqep_cnt *priv = counter->priv;
- size_t function;
+ enum counter_count_function function;
u32 qdecctl;
int err;
@@ -156,7 +153,7 @@ static int ti_eqep_action_get(struct counter_device *counter,
/* In quadrature mode, the rising and falling edge of both
* QEPA and QEPB trigger QCLK.
*/
- *action = TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES;
+ *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
break;
case TI_EQEP_COUNT_FUNC_DIR_COUNT:
/* In direction-count mode only rising edge of QEPA is counted
@@ -164,10 +161,10 @@ static int ti_eqep_action_get(struct counter_device *counter,
*/
switch (synapse->signal->id) {
case TI_EQEP_SIGNAL_QEPA:
- *action = TI_EQEP_SYNAPSE_ACTION_RISING_EDGE;
+ *action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
break;
default:
- *action = TI_EQEP_SYNAPSE_ACTION_NONE;
+ *action = COUNTER_SYNAPSE_ACTION_NONE;
break;
}
break;
@@ -183,134 +180,103 @@ static int ti_eqep_action_get(struct counter_device *counter,
return err;
if (qdecctl & QDECCTL_XCR)
- *action = TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES;
+ *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
else
- *action = TI_EQEP_SYNAPSE_ACTION_RISING_EDGE;
+ *action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
break;
default:
- *action = TI_EQEP_SYNAPSE_ACTION_NONE;
+ *action = COUNTER_SYNAPSE_ACTION_NONE;
break;
}
break;
+ default: return -EINVAL;
}
return 0;
}
-static const struct counter_ops ti_eqep_counter_ops = {
- .count_read = ti_eqep_count_read,
- .count_write = ti_eqep_count_write,
- .function_get = ti_eqep_function_get,
- .function_set = ti_eqep_function_set,
- .action_get = ti_eqep_action_get,
-};
-
-static ssize_t ti_eqep_position_ceiling_read(struct counter_device *counter,
- struct counter_count *count,
- void *ext_priv, char *buf)
+static int ti_eqep_position_ceiling_read(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long *ceiling)
{
struct ti_eqep_cnt *priv = counter->priv;
u32 qposmax;
regmap_read(priv->regmap32, QPOSMAX, &qposmax);
- return sprintf(buf, "%u\n", qposmax);
+ *ceiling = qposmax;
+
+ return 0;
}
-static ssize_t ti_eqep_position_ceiling_write(struct counter_device *counter,
- struct counter_count *count,
- void *ext_priv, const char *buf,
- size_t len)
+static int ti_eqep_position_ceiling_write(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long ceiling)
{
struct ti_eqep_cnt *priv = counter->priv;
- int err;
- u32 res;
- err = kstrtouint(buf, 0, &res);
- if (err < 0)
- return err;
+ regmap_write(priv->regmap32, QPOSMAX, ceiling);
- regmap_write(priv->regmap32, QPOSMAX, res);
-
- return len;
+ return 0;
}
-static ssize_t ti_eqep_position_floor_read(struct counter_device *counter,
- struct counter_count *count,
- void *ext_priv, char *buf)
+static int ti_eqep_position_floor_read(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long *floor)
{
struct ti_eqep_cnt *priv = counter->priv;
u32 qposinit;
regmap_read(priv->regmap32, QPOSINIT, &qposinit);
- return sprintf(buf, "%u\n", qposinit);
+ *floor = qposinit;
+
+ return 0;
}
-static ssize_t ti_eqep_position_floor_write(struct counter_device *counter,
- struct counter_count *count,
- void *ext_priv, const char *buf,
- size_t len)
+static int ti_eqep_position_floor_write(struct counter_device *counter,
+ struct counter_count *count,
+ unsigned long floor)
{
struct ti_eqep_cnt *priv = counter->priv;
- int err;
- u32 res;
- err = kstrtouint(buf, 0, &res);
- if (err < 0)
- return err;
+ regmap_write(priv->regmap32, QPOSINIT, floor);
- regmap_write(priv->regmap32, QPOSINIT, res);
-
- return len;
+ return 0;
}
-static ssize_t ti_eqep_position_enable_read(struct counter_device *counter,
- struct counter_count *count,
- void *ext_priv, char *buf)
+static int ti_eqep_position_enable_read(struct counter_device *counter,
+ struct counter_count *count,
+ bool *enable)
{
struct ti_eqep_cnt *priv = counter->priv;
u32 qepctl;
regmap_read(priv->regmap16, QEPCTL, &qepctl);
- return sprintf(buf, "%u\n", !!(qepctl & QEPCTL_PHEN));
+ *enable = !!(qepctl & QEPCTL_PHEN);
+
+ return 0;
}
-static ssize_t ti_eqep_position_enable_write(struct counter_device *counter,
- struct counter_count *count,
- void *ext_priv, const char *buf,
- size_t len)
+static int ti_eqep_position_enable_write(struct counter_device *counter,
+ struct counter_count *count,
+ bool enable)
{
struct ti_eqep_cnt *priv = counter->priv;
- int err;
- bool res;
- err = kstrtobool(buf, &res);
- if (err < 0)
- return err;
-
- regmap_write_bits(priv->regmap16, QEPCTL, QEPCTL_PHEN, res ? -1 : 0);
+ regmap_write_bits(priv->regmap16, QEPCTL, QEPCTL_PHEN, enable ? -1 : 0);
- return len;
+ return 0;
}
-static struct counter_count_ext ti_eqep_position_ext[] = {
- {
- .name = "ceiling",
- .read = ti_eqep_position_ceiling_read,
- .write = ti_eqep_position_ceiling_write,
- },
- {
- .name = "floor",
- .read = ti_eqep_position_floor_read,
- .write = ti_eqep_position_floor_write,
- },
- {
- .name = "enable",
- .read = ti_eqep_position_enable_read,
- .write = ti_eqep_position_enable_write,
- },
+static struct counter_data ti_eqep_position_ext[] = {
+ COUNTER_DATA_CEILING(ti_eqep_position_ceiling_read,
+ ti_eqep_position_ceiling_write),
+ COUNTER_DATA_FLOOR(ti_eqep_position_floor_read,
+ ti_eqep_position_floor_write),
+ COUNTER_DATA_ENABLE(ti_eqep_position_enable_read,
+ ti_eqep_position_enable_write),
};
static struct counter_signal ti_eqep_signals[] = {
@@ -325,16 +291,16 @@ static struct counter_signal ti_eqep_signals[] = {
};
static const enum counter_count_function ti_eqep_position_functions[] = {
- [TI_EQEP_COUNT_FUNC_QUAD_COUNT] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
- [TI_EQEP_COUNT_FUNC_DIR_COUNT] = COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
- [TI_EQEP_COUNT_FUNC_UP_COUNT] = COUNTER_COUNT_FUNCTION_INCREASE,
- [TI_EQEP_COUNT_FUNC_DOWN_COUNT] = COUNTER_COUNT_FUNCTION_DECREASE,
+ TI_EQEP_COUNT_FUNC_QUAD_COUNT,
+ TI_EQEP_COUNT_FUNC_DIR_COUNT,
+ TI_EQEP_COUNT_FUNC_UP_COUNT,
+ TI_EQEP_COUNT_FUNC_DOWN_COUNT,
};
static const enum counter_synapse_action ti_eqep_position_synapse_actions[] = {
- [TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
- [TI_EQEP_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
- [TI_EQEP_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
+ COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
+ COUNTER_SYNAPSE_ACTION_RISING_EDGE,
+ COUNTER_SYNAPSE_ACTION_NONE,
};
static struct counter_synapse ti_eqep_position_synapses[] = {
@@ -406,7 +372,11 @@ static int ti_eqep_probe(struct platform_device *pdev)
priv->counter.name = dev_name(dev);
priv->counter.parent = dev;
- priv->counter.ops = &ti_eqep_counter_ops;
+ priv->counter.count_read = ti_eqep_count_read;
+ priv->counter.count_write = ti_eqep_count_write;
+ priv->counter.function_read = ti_eqep_function_get;
+ priv->counter.function_write = ti_eqep_function_set;
+ priv->counter.action_read = ti_eqep_action_get;
priv->counter.counts = ti_eqep_counts;
priv->counter.num_counts = ARRAY_SIZE(ti_eqep_counts);
priv->counter.signals = ti_eqep_signals;
diff --git a/include/linux/counter.h b/include/linux/counter.h
index 9dbd5df4cd34..d628c7eaf754 100644
--- a/include/linux/counter.h
+++ b/include/linux/counter.h
@@ -6,449 +6,286 @@
#ifndef _COUNTER_H_
#define _COUNTER_H_
-#include <linux/counter_enum.h>
#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
#include <linux/types.h>
+#include <uapi/linux/counter-types.h>
-enum counter_count_direction {
- COUNTER_COUNT_DIRECTION_FORWARD = 0,
- COUNTER_COUNT_DIRECTION_BACKWARD
-};
-extern const char *const counter_count_direction_str[2];
-
-enum counter_count_mode {
- COUNTER_COUNT_MODE_NORMAL = 0,
- COUNTER_COUNT_MODE_RANGE_LIMIT,
- COUNTER_COUNT_MODE_NON_RECYCLE,
- COUNTER_COUNT_MODE_MODULO_N
-};
-extern const char *const counter_count_mode_str[4];
-
-struct counter_device;
-struct counter_signal;
-
-/**
- * struct counter_signal_ext - Counter Signal extensions
- * @name: attribute name
- * @read: read callback for this attribute; may be NULL
- * @write: write callback for this attribute; may be NULL
- * @priv: data private to the driver
- */
-struct counter_signal_ext {
+struct counter_data {
+ enum counter_data_type type;
const char *name;
- ssize_t (*read)(struct counter_device *counter,
- struct counter_signal *signal, void *priv, char *buf);
- ssize_t (*write)(struct counter_device *counter,
- struct counter_signal *signal, void *priv,
- const char *buf, size_t len);
+ void *read;
+ void *write;
void *priv;
};
/**
* struct counter_signal - Counter Signal node
- * @id: unique ID used to identify signal
- * @name: device-specific Signal name; ideally, this should match the name
- * as it appears in the datasheet documentation
- * @ext: optional array of Counter Signal extensions
- * @num_ext: number of Counter Signal extensions specified in @ext
- * @priv: optional private data supplied by driver
+ * @id: unique ID used to identify the Signal
+ * @name: device-specific Signal name
+ * @ext: optional array of Signal extensions
+ * @num_ext: number of Signal extensions specified in @ext
*/
struct counter_signal {
int id;
const char *name;
- const struct counter_signal_ext *ext;
+ struct counter_data *ext;
size_t num_ext;
-
- void *priv;
-};
-
-/**
- * struct counter_signal_enum_ext - Signal enum extension attribute
- * @items: Array of strings
- * @num_items: Number of items specified in @items
- * @set: Set callback function; may be NULL
- * @get: Get callback function; may be NULL
- *
- * The counter_signal_enum_ext structure can be used to implement enum style
- * Signal extension attributes. Enum style attributes are those which have a set
- * of strings that map to unsigned integer values. The Generic Counter Signal
- * enum extension helper code takes care of mapping between value and string, as
- * well as generating a "_available" file which contains a list of all available
- * items. The get callback is used to query the currently active item; the index
- * of the item within the respective items array is returned via the 'item'
- * parameter. The set callback is called when the attribute is updated; the
- * 'item' parameter contains the index of the newly activated item within the
- * respective items array.
- */
-struct counter_signal_enum_ext {
- const char * const *items;
- size_t num_items;
- int (*get)(struct counter_device *counter,
- struct counter_signal *signal, size_t *item);
- int (*set)(struct counter_device *counter,
- struct counter_signal *signal, size_t item);
-};
-
-/**
- * COUNTER_SIGNAL_ENUM() - Initialize Signal enum extension
- * @_name: Attribute name
- * @_e: Pointer to a counter_signal_enum_ext structure
- *
- * This should usually be used together with COUNTER_SIGNAL_ENUM_AVAILABLE()
- */
-#define COUNTER_SIGNAL_ENUM(_name, _e) \
-{ \
- .name = (_name), \
- .read = counter_signal_enum_read, \
- .write = counter_signal_enum_write, \
- .priv = (_e) \
-}
-
-/**
- * COUNTER_SIGNAL_ENUM_AVAILABLE() - Initialize Signal enum available extension
- * @_name: Attribute name ("_available" will be appended to the name)
- * @_e: Pointer to a counter_signal_enum_ext structure
- *
- * Creates a read only attribute that lists all the available enum items in a
- * newline separated list. This should usually be used together with
- * COUNTER_SIGNAL_ENUM()
- */
-#define COUNTER_SIGNAL_ENUM_AVAILABLE(_name, _e) \
-{ \
- .name = (_name "_available"), \
- .read = counter_signal_enum_available_read, \
- .priv = (_e) \
-}
-
-enum counter_synapse_action {
- COUNTER_SYNAPSE_ACTION_NONE = 0,
- COUNTER_SYNAPSE_ACTION_RISING_EDGE,
- COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
- COUNTER_SYNAPSE_ACTION_BOTH_EDGES
};
/**
* struct counter_synapse - Counter Synapse node
- * @action: index of current action mode
* @actions_list: array of available action modes
* @num_actions: number of action modes specified in @actions_list
- * @signal: pointer to associated signal
+ * @signal: pointer to the associated Signal
*/
struct counter_synapse {
- size_t action;
const enum counter_synapse_action *actions_list;
size_t num_actions;
struct counter_signal *signal;
};
-struct counter_count;
-
-/**
- * struct counter_count_ext - Counter Count extension
- * @name: attribute name
- * @read: read callback for this attribute; may be NULL
- * @write: write callback for this attribute; may be NULL
- * @priv: data private to the driver
- */
-struct counter_count_ext {
- const char *name;
- ssize_t (*read)(struct counter_device *counter,
- struct counter_count *count, void *priv, char *buf);
- ssize_t (*write)(struct counter_device *counter,
- struct counter_count *count, void *priv,
- const char *buf, size_t len);
- void *priv;
-};
-
-enum counter_count_function {
- COUNTER_COUNT_FUNCTION_INCREASE = 0,
- COUNTER_COUNT_FUNCTION_DECREASE,
- COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
- COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A,
- COUNTER_COUNT_FUNCTION_QUADRATURE_X1_B,
- COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
- COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,
- COUNTER_COUNT_FUNCTION_QUADRATURE_X4
-};
-
/**
* struct counter_count - Counter Count node
- * @id: unique ID used to identify Count
- * @name: device-specific Count name; ideally, this should match
- * the name as it appears in the datasheet documentation
- * @function: index of current function mode
- * @functions_list: array available function modes
+ * @id: unique ID used to identify the Count
+ * @name: device-specific Count name
+ * @functions_list: array of available function modes
* @num_functions: number of function modes specified in @functions_list
- * @synapses: array of synapses for initialization
- * @num_synapses: number of synapses specified in @synapses
- * @ext: optional array of Counter Count extensions
- * @num_ext: number of Counter Count extensions specified in @ext
- * @priv: optional private data supplied by driver
+ * @synapses: array of Synapses for initialization
+ * @num_synapses: number of Synapses specified in @synapses
+ * @ext: optional array of Count extensions
+ * @num_ext: number of Count extensions specified in @ext
*/
struct counter_count {
int id;
const char *name;
- size_t function;
const enum counter_count_function *functions_list;
size_t num_functions;
struct counter_synapse *synapses;
size_t num_synapses;
- const struct counter_count_ext *ext;
+ struct counter_data *ext;
size_t num_ext;
-
- void *priv;
-};
-
-/**
- * struct counter_count_enum_ext - Count enum extension attribute
- * @items: Array of strings
- * @num_items: Number of items specified in @items
- * @set: Set callback function; may be NULL
- * @get: Get callback function; may be NULL
- *
- * The counter_count_enum_ext structure can be used to implement enum style
- * Count extension attributes. Enum style attributes are those which have a set
- * of strings that map to unsigned integer values. The Generic Counter Count
- * enum extension helper code takes care of mapping between value and string, as
- * well as generating a "_available" file which contains a list of all available
- * items. The get callback is used to query the currently active item; the index
- * of the item within the respective items array is returned via the 'item'
- * parameter. The set callback is called when the attribute is updated; the
- * 'item' parameter contains the index of the newly activated item within the
- * respective items array.
- */
-struct counter_count_enum_ext {
- const char * const *items;
- size_t num_items;
- int (*get)(struct counter_device *counter, struct counter_count *count,
- size_t *item);
- int (*set)(struct counter_device *counter, struct counter_count *count,
- size_t item);
};
/**
- * COUNTER_COUNT_ENUM() - Initialize Count enum extension
- * @_name: Attribute name
- * @_e: Pointer to a counter_count_enum_ext structure
- *
- * This should usually be used together with COUNTER_COUNT_ENUM_AVAILABLE()
- */
-#define COUNTER_COUNT_ENUM(_name, _e) \
-{ \
- .name = (_name), \
- .read = counter_count_enum_read, \
- .write = counter_count_enum_write, \
- .priv = (_e) \
-}
-
-/**
- * COUNTER_COUNT_ENUM_AVAILABLE() - Initialize Count enum available extension
- * @_name: Attribute name ("_available" will be appended to the name)
- * @_e: Pointer to a counter_count_enum_ext structure
- *
- * Creates a read only attribute that lists all the available enum items in a
- * newline separated list. This should usually be used together with
- * COUNTER_COUNT_ENUM()
- */
-#define COUNTER_COUNT_ENUM_AVAILABLE(_name, _e) \
-{ \
- .name = (_name "_available"), \
- .read = counter_count_enum_available_read, \
- .priv = (_e) \
-}
-
-/**
- * struct counter_device_attr_group - internal container for attribute group
+ * struct counter_attribute_group - internal container for attribute group
* @attr_group: Counter sysfs attributes group
* @attr_list: list to keep track of created Counter sysfs attributes
* @num_attr: number of Counter sysfs attributes
*/
-struct counter_device_attr_group {
+struct counter_attribute_group {
struct attribute_group attr_group;
struct list_head attr_list;
size_t num_attr;
};
/**
- * struct counter_device_state - internal state container for a Counter device
+ * struct counter_device - Counter data structure
+ * @name: name of the device
+ * @parent: optional parent device providing the counters
+ * @signal_read: optional read callback for Signals. The read value of
+ * the respective Signal should be passed back via the
+ * value parameter.
+ * @count_read: optional read callback for Counts. The read value of the
+ * respective Count should be passed back via the value
+ * parameter.
+ * @count_write: optional write callback for Counts. The write value for
+ * the respective Count is passed in via the value
+ * parameter.
+ * @function_read: optional read callback the Count function modes. The
+ * read function mode of the respective Count should be
+ * passed back via the function parameter.
+ * @function_write: option write callback for Count function modes. The
+ * function mode to write for the respective Count is
+ * passed in via the function parameter.
+ * @action_read: optional read callback the Synapse action modes. The
+ * read action mode of the respective Synapse should be
+ * passed back via the action parameter.
+ * @action_write: option write callback for Synapse action modes. The
+ * action mode to write for the respective Synapse is
+ * passed in via the action parameter.
+ * @signals: array of Signals
+ * @num_signals: number of Signals specified in @signals
+ * @counts: array of Counts
+ * @num_counts: number of Counts specified in @counts
+ * @ext: optional array of Counter device extensions
+ * @num_ext: number of Counter device extensions specified in @ext
+ * @priv: optional private data supplied by driver
* @id: unique ID used to identify the Counter
* @dev: internal device structure
+ * @synapse_names_list: Synapse names list
* @groups_list: attribute groups list (for Signals, Counts, and ext)
* @num_groups: number of attribute groups containers
* @groups: Counter sysfs attribute groups (to populate @dev.groups)
*/
-struct counter_device_state {
+struct counter_device {
+ const char *name;
+ struct device *parent;
+
+ int (*signal_read)(struct counter_device *counter,
+ struct counter_signal *signal,
+ enum counter_signal_value *value);
+ int (*count_read)(struct counter_device *counter,
+ struct counter_count *count, unsigned long *value);
+ int (*count_write)(struct counter_device *counter,
+ struct counter_count *count, unsigned long value);
+ int (*function_read)(struct counter_device *counter,
+ struct counter_count *count,
+ enum counter_count_function *function);
+ int (*function_write)(struct counter_device *counter,
+ struct counter_count *count,
+ enum counter_count_function function);
+ int (*action_read)(struct counter_device *counter,
+ struct counter_count *count,
+ struct counter_synapse *synapse,
+ enum counter_synapse_action *action);
+ int (*action_write)(struct counter_device *counter,
+ struct counter_count *count,
+ struct counter_synapse *synapse,
+ enum counter_synapse_action action);
+
+ struct counter_signal *signals;
+ size_t num_signals;
+ struct counter_count *counts;
+ size_t num_counts;
+
+ struct counter_data *ext;
+ size_t num_ext;
+
+ void *priv;
+
int id;
struct device dev;
- struct counter_device_attr_group *groups_list;
+ struct list_head synapse_names_list;
+ struct counter_attribute_group *groups_list;
size_t num_groups;
const struct attribute_group **groups;
};
-enum counter_signal_value {
- COUNTER_SIGNAL_LOW = 0,
- COUNTER_SIGNAL_HIGH
-};
+int counter_register(struct counter_device *const counter);
+void counter_unregister(struct counter_device *const counter);
+int devm_counter_register(struct device *dev,
+ struct counter_device *const counter);
+void devm_counter_unregister(struct device *dev,
+ struct counter_device *const counter);
-/**
- * struct counter_ops - Callbacks from driver
- * @signal_read: optional read callback for Signal attribute. The read
- * value of the respective Signal should be passed back via
- * the val parameter.
- * @count_read: optional read callback for Count attribute. The read
- * value of the respective Count should be passed back via
- * the val parameter.
- * @count_write: optional write callback for Count attribute. The write
- * value for the respective Count is passed in via the val
- * parameter.
- * @function_get: function to get the current count function mode. Returns
- * 0 on success and negative error code on error. The index
- * of the respective Count's returned function mode should
- * be passed back via the function parameter.
- * @function_set: function to set the count function mode. function is the
- * index of the requested function mode from the respective
- * Count's functions_list array.
- * @action_get: function to get the current action mode. Returns 0 on
- * success and negative error code on error. The index of
- * the respective Synapse's returned action mode should be
- * passed back via the action parameter.
- * @action_set: function to set the action mode. action is the index of
- * the requested action mode from the respective Synapse's
- * actions_list array.
- */
-struct counter_ops {
- int (*signal_read)(struct counter_device *counter,
- struct counter_signal *signal,
- enum counter_signal_value *val);
- int (*count_read)(struct counter_device *counter,
- struct counter_count *count, unsigned long *val);
- int (*count_write)(struct counter_device *counter,
- struct counter_count *count, unsigned long val);
- int (*function_get)(struct counter_device *counter,
- struct counter_count *count, size_t *function);
- int (*function_set)(struct counter_device *counter,
- struct counter_count *count, size_t function);
- int (*action_get)(struct counter_device *counter,
- struct counter_count *count,
- struct counter_synapse *synapse, size_t *action);
- int (*action_set)(struct counter_device *counter,
- struct counter_count *count,
- struct counter_synapse *synapse, size_t action);
-};
+#define COUNTER_DATA_BOOL(_name, _read, _write) \
+{ \
+ .type = COUNTER_DATA_TYPE_BOOL, \
+ .name = (_name), \
+ .read = (_read), \
+ .write = (_write), \
+}
-/**
- * struct counter_device_ext - Counter device extension
- * @name: attribute name
- * @read: read callback for this attribute; may be NULL
- * @write: write callback for this attribute; may be NULL
- * @priv: data private to the driver
- */
-struct counter_device_ext {
- const char *name;
- ssize_t (*read)(struct counter_device *counter, void *priv, char *buf);
- ssize_t (*write)(struct counter_device *counter, void *priv,
- const char *buf, size_t len);
- void *priv;
+#define COUNTER_DATA_UNSIGNED_LONG(_name, _read, _write) \
+{ \
+ .type = COUNTER_DATA_TYPE_UNSIGNED_LONG, \
+ .name = (_name), \
+ .read = (_read), \
+ .write = (_write), \
+}
+
+#define COUNTER_DATA_STRING(_name, _read, _write) \
+{ \
+ .type = COUNTER_DATA_TYPE_STRING, \
+ .name = (_name), \
+ .read = (_read), \
+ .write = (_write), \
+}
+
+struct counter_available {
+ void *items;
+ size_t num_items;
};
-/**
- * struct counter_device_enum_ext - Counter enum extension attribute
- * @items: Array of strings
- * @num_items: Number of items specified in @items
- * @set: Set callback function; may be NULL
- * @get: Get callback function; may be NULL
- *
- * The counter_device_enum_ext structure can be used to implement enum style
- * Counter extension attributes. Enum style attributes are those which have a
- * set of strings that map to unsigned integer values. The Generic Counter enum
- * extension helper code takes care of mapping between value and string, as well
- * as generating a "_available" file which contains a list of all available
- * items. The get callback is used to query the currently active item; the index
- * of the item within the respective items array is returned via the 'item'
- * parameter. The set callback is called when the attribute is updated; the
- * 'item' parameter contains the index of the newly activated item within the
- * respective items array.
- */
-struct counter_device_enum_ext {
+#define DEFINE_COUNTER_AVAILABLE(_name, _items) \
+ struct counter_available _name = { \
+ .items = (_items), \
+ .num_items = ARRAY_SIZE(_items), \
+ }
+
+struct counter_enum {
const char * const *items;
size_t num_items;
- int (*get)(struct counter_device *counter, size_t *item);
- int (*set)(struct counter_device *counter, size_t item);
};
-/**
- * COUNTER_DEVICE_ENUM() - Initialize Counter enum extension
- * @_name: Attribute name
- * @_e: Pointer to a counter_device_enum_ext structure
- *
- * This should usually be used together with COUNTER_DEVICE_ENUM_AVAILABLE()
- */
-#define COUNTER_DEVICE_ENUM(_name, _e) \
+#define DEFINE_COUNTER_ENUM(_name, _items) \
+ struct counter_enum _name = { \
+ .items = (_items), \
+ .num_items = ARRAY_SIZE(_items), \
+ }
+
+#define COUNTER_DATA_ENUM(_name, _get, _set, _enum) \
{ \
+ .type = COUNTER_DATA_TYPE_ENUM, \
.name = (_name), \
- .read = counter_device_enum_read, \
- .write = counter_device_enum_write, \
- .priv = (_e) \
+ .read = (_get), \
+ .write = (_set), \
+ .priv = &(_enum), \
}
-/**
- * COUNTER_DEVICE_ENUM_AVAILABLE() - Initialize Counter enum available extension
- * @_name: Attribute name ("_available" will be appended to the name)
- * @_e: Pointer to a counter_device_enum_ext structure
- *
- * Creates a read only attribute that lists all the available enum items in a
- * newline separated list. This should usually be used together with
- * COUNTER_DEVICE_ENUM()
- */
-#define COUNTER_DEVICE_ENUM_AVAILABLE(_name, _e) \
+#define COUNTER_DATA_ENUM_AVAILABLE(_name, _read, _enum) \
{ \
+ .type = COUNTER_DATA_TYPE_ENUM_AVAILABLE, \
.name = (_name "_available"), \
- .read = counter_device_enum_available_read, \
- .priv = (_e) \
+ .read = (_read), \
+ .priv = &(_enum), \
}
-/**
- * struct counter_device - Counter data structure
- * @name: name of the device as it appears in the datasheet
- * @parent: optional parent device providing the counters
- * @device_state: internal device state container
- * @ops: callbacks from driver
- * @signals: array of Signals
- * @num_signals: number of Signals specified in @signals
- * @counts: array of Counts
- * @num_counts: number of Counts specified in @counts
- * @ext: optional array of Counter device extensions
- * @num_ext: number of Counter device extensions specified in @ext
- * @priv: optional private data supplied by driver
- */
-struct counter_device {
- const char *name;
- struct device *parent;
- struct counter_device_state *device_state;
+#define COUNTER_DATA_ENUM_AND_AVAILABLE(_name, _get, _set, _enum) \
+ COUNTER_DATA_ENUM(_name, _get, _set, _enum), \
+ COUNTER_DATA_ENUM_AVAILABLE(_name, _get, _enum)
- const struct counter_ops *ops;
+#define COUNTER_DATA_CEILING(_read, _write) \
+ COUNTER_DATA_UNSIGNED_LONG("ceiling", _read, _write)
- struct counter_signal *signals;
- size_t num_signals;
- struct counter_count *counts;
- size_t num_counts;
+#define COUNTER_DATA_COUNT_MODE(_read, _write) \
+{ \
+ .type = COUNTER_DATA_TYPE_COUNT_MODE, \
+ .name = "count_mode", \
+ .read = (_read), \
+ .write = (_write), \
+}
- const struct counter_device_ext *ext;
- size_t num_ext;
+#define COUNTER_DATA_COUNT_MODE_AVAILABLE(_read, _available) \
+{ \
+ .type = COUNTER_DATA_TYPE_COUNT_MODE_AVAILABLE, \
+ .name = "count_mode_available", \
+ .read = (_read), \
+ .priv = &(_available), \
+}
- void *priv;
-};
+#define COUNTER_DATA_COUNT_MODE_AND_AVAILABLE(_read, _write, _available) \
+ COUNTER_DATA_COUNT_MODE(_read, _write), \
+ COUNTER_DATA_COUNT_MODE_AVAILABLE(_read, _available)
-int counter_register(struct counter_device *const counter);
-void counter_unregister(struct counter_device *const counter);
-int devm_counter_register(struct device *dev,
- struct counter_device *const counter);
-void devm_counter_unregister(struct device *dev,
- struct counter_device *const counter);
+#define COUNTER_DATA_DIRECTION(_read) \
+{ \
+ .type = COUNTER_DATA_TYPE_COUNT_DIRECTION, \
+ .name = "direction", \
+ .read = (_read), \
+}
+
+#define COUNTER_DATA_ENABLE(_read, _write) \
+ COUNTER_DATA_BOOL("enable", _read, _write)
+
+#define COUNTER_DATA_ERROR_NOISE_AND_AVAILABLE(_read, _available) \
+ COUNTER_DATA_STRING("error_noise", _read, NULL), \
+ COUNTER_DATA_STRING("error_noise_available", _available, NULL)
+
+#define COUNTER_DATA_FLOOR(_read, _write) \
+ COUNTER_DATA_UNSIGNED_LONG("floor", _read, _write)
+
+#define COUNTER_DATA_PRESET(_read, _write) \
+ COUNTER_DATA_UNSIGNED_LONG("preset", _read, _write)
+
+#define COUNTER_DATA_PRESET_ENABLE(_read, _write) \
+ COUNTER_DATA_BOOL("preset_enable", _read, _write)
#endif /* _COUNTER_H_ */
diff --git a/include/linux/counter_enum.h b/include/linux/counter_enum.h
deleted file mode 100644
index 9f917298a88f..000000000000
--- a/include/linux/counter_enum.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-/*
- * Counter interface enum functions
- * Copyright (C) 2018 William Breathitt Gray
- */
-#ifndef _COUNTER_ENUM_H_
-#define _COUNTER_ENUM_H_
-
-#include <linux/types.h>
-
-struct counter_device;
-struct counter_signal;
-struct counter_count;
-
-ssize_t counter_signal_enum_read(struct counter_device *counter,
- struct counter_signal *signal, void *priv,
- char *buf);
-ssize_t counter_signal_enum_write(struct counter_device *counter,
- struct counter_signal *signal, void *priv,
- const char *buf, size_t len);
-
-ssize_t counter_signal_enum_available_read(struct counter_device *counter,
- struct counter_signal *signal,
- void *priv, char *buf);
-
-ssize_t counter_count_enum_read(struct counter_device *counter,
- struct counter_count *count, void *priv,
- char *buf);
-ssize_t counter_count_enum_write(struct counter_device *counter,
- struct counter_count *count, void *priv,
- const char *buf, size_t len);
-
-ssize_t counter_count_enum_available_read(struct counter_device *counter,
- struct counter_count *count,
- void *priv, char *buf);
-
-ssize_t counter_device_enum_read(struct counter_device *counter, void *priv,
- char *buf);
-ssize_t counter_device_enum_write(struct counter_device *counter, void *priv,
- const char *buf, size_t len);
-
-ssize_t counter_device_enum_available_read(struct counter_device *counter,
- void *priv, char *buf);
-
-#endif /* _COUNTER_ENUM_H_ */
diff --git a/include/uapi/linux/counter-types.h b/include/uapi/linux/counter-types.h
new file mode 100644
index 000000000000..757256775949
--- /dev/null
+++ b/include/uapi/linux/counter-types.h
@@ -0,0 +1,67 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * Counter interface data types
+ * Copyright (C) 2020 William Breathitt Gray
+ */
+#ifndef _UAPI_COUNTER_TYPES_H_
+#define _UAPI_COUNTER_TYPES_H_
+
+enum counter_count_direction {
+ COUNTER_COUNT_DIRECTION_FORWARD = 0,
+ COUNTER_COUNT_DIRECTION_BACKWARD
+};
+
+enum counter_count_mode {
+ COUNTER_COUNT_MODE_NORMAL = 0,
+ COUNTER_COUNT_MODE_RANGE_LIMIT,
+ COUNTER_COUNT_MODE_NON_RECYCLE,
+ COUNTER_COUNT_MODE_MODULO_N
+};
+
+enum counter_count_function {
+ COUNTER_COUNT_FUNCTION_INCREASE = 0,
+ COUNTER_COUNT_FUNCTION_DECREASE,
+ COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
+ COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A,
+ COUNTER_COUNT_FUNCTION_QUADRATURE_X1_B,
+ COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
+ COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,
+ COUNTER_COUNT_FUNCTION_QUADRATURE_X4
+};
+
+enum counter_signal_value {
+ COUNTER_SIGNAL_LOW = 0,
+ COUNTER_SIGNAL_HIGH
+};
+
+enum counter_synapse_action {
+ COUNTER_SYNAPSE_ACTION_NONE = 0,
+ COUNTER_SYNAPSE_ACTION_RISING_EDGE,
+ COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
+ COUNTER_SYNAPSE_ACTION_BOTH_EDGES
+};
+
+enum counter_data_type {
+ COUNTER_DATA_TYPE_BOOL = 0,
+ COUNTER_DATA_TYPE_UNSIGNED_LONG,
+ COUNTER_DATA_TYPE_SIZE,
+ COUNTER_DATA_TYPE_STRING,
+ COUNTER_DATA_TYPE_COUNT_FUNCTION,
+ COUNTER_DATA_TYPE_COUNT_FUNCTION_AVAILABLE,
+ COUNTER_DATA_TYPE_SIGNAL,
+ COUNTER_DATA_TYPE_SYNAPSE_ACTION,
+ COUNTER_DATA_TYPE_SYNAPSE_ACTION_AVAILABLE,
+ COUNTER_DATA_TYPE_ENUM,
+ COUNTER_DATA_TYPE_ENUM_AVAILABLE,
+ COUNTER_DATA_TYPE_COUNT_DIRECTION,
+ COUNTER_DATA_TYPE_COUNT_MODE,
+ COUNTER_DATA_TYPE_COUNT_MODE_AVAILABLE,
+};
+
+enum counter_owner_type {
+ COUNTER_OWNER_TYPE_DEVICE,
+ COUNTER_OWNER_TYPE_SIGNAL,
+ COUNTER_OWNER_TYPE_COUNT,
+};
+
+#endif /* _UAPI_COUNTER_TYPES_H_ */
--
2.26.2
On 4/29/20 1:11 PM, William Breathitt Gray wrote:
> Over the past couple years we have noticed some shortcomings with the
> Counter sysfs interface. Although useful in the majority of situations,
> there are certain use-cases where interacting through sysfs attributes
> can become cumbersome and inefficient. A desire to support more advanced
> functionality such as timestamps, multi-axis positioning tables, and
> other such latency-sensitive applications, has motivated a reevaluation
> of the Counter subsystem. I believe a character device interface will be
> helpful for this more niche area of counter device use.
Nice to see some progress being made. :-)
>
> Interaction with Counter character devices occurs via ioctl commands.
> This allows userspace applications to access and set counter data using
> native C datatypes rather than working through string translations.
For most aspects of the counter subsystem, this is not an issue since
configuring a counter is not a time-sensitive operation. Instead of
ioctls, I was expecting to just be able to read the character device
and receive counter events or poll to wait for events similar to how
the input subsystem works or how buffers work in the iio subsystem.
I'm afraid I don't really see much use in having ioctls that do
exactly what sysfs already does. And my intuition tells me that the
extra work needed to maintain it will probably cost more than any
benefit gained. (Maybe other have a different experience that leads
to a different conclusion?)
Hi William,
I love your patch! Yet something to improve:
[auto build test ERROR on stm32/stm32-next]
[cannot apply to linus/master linux/master v5.7-rc3 next-20200429]
[if your patch is applied to the wrong git tree, please drop us a note to help
improve the system. BTW, we also suggest to use '--base' option to specify the
base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/William-Breathitt-Gray/Introduce-the-Counter-character-device-interface/20200430-051734
base: https://git.kernel.org/pub/scm/linux/kernel/git/atorgue/stm32.git stm32-next
config: x86_64-allyesconfig (attached as .config)
compiler: gcc-7 (Ubuntu 7.5.0-6ubuntu2) 7.5.0
reproduce:
# save the attached .config to linux build tree
make ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
Reported-by: kbuild test robot <[email protected]>
All errors (new ones prefixed by >>):
>> drivers/counter/stm32-lptimer-cnt.c:387:2: error: initializer element is not constant
stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE],
^~~~~~~~~~~~~~~~~~~~~~~~~~~
drivers/counter/stm32-lptimer-cnt.c:387:2: note: (near initialization for 'stm32_lptim_cnt_synapse_actions[0]')
drivers/counter/stm32-lptimer-cnt.c:388:2: error: initializer element is not constant
stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE],
^~~~~~~~~~~~~~~~~~~~~~~~~~~
drivers/counter/stm32-lptimer-cnt.c:388:2: note: (near initialization for 'stm32_lptim_cnt_synapse_actions[1]')
drivers/counter/stm32-lptimer-cnt.c:389:2: error: initializer element is not constant
stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES],
^~~~~~~~~~~~~~~~~~~~~~~~~~~
drivers/counter/stm32-lptimer-cnt.c:389:2: note: (near initialization for 'stm32_lptim_cnt_synapse_actions[2]')
drivers/counter/stm32-lptimer-cnt.c:390:2: error: initializer element is not constant
stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_NONE],
^~~~~~~~~~~~~~~~~~~~~~~~~~~
drivers/counter/stm32-lptimer-cnt.c:390:2: note: (near initialization for 'stm32_lptim_cnt_synapse_actions[3]')
vim +387 drivers/counter/stm32-lptimer-cnt.c
385
386 static const enum counter_synapse_action stm32_lptim_cnt_synapse_actions[] = {
> 387 stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE],
388 stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE],
389 stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES],
390 stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_NONE],
391 };
392
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]
On Thu, Apr 30, 2020 at 03:41:26PM +0800, kbuild test robot wrote:
> Hi William,
>
> I love your patch! Yet something to improve:
>
> [auto build test ERROR on stm32/stm32-next]
> [cannot apply to linus/master linux/master v5.7-rc3 next-20200429]
> [if your patch is applied to the wrong git tree, please drop us a note to help
> improve the system. BTW, we also suggest to use '--base' option to specify the
> base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
>
> url: https://github.com/0day-ci/linux/commits/William-Breathitt-Gray/Introduce-the-Counter-character-device-interface/20200430-051734
> base: https://git.kernel.org/pub/scm/linux/kernel/git/atorgue/stm32.git stm32-next
> config: x86_64-allyesconfig (attached as .config)
> compiler: gcc-7 (Ubuntu 7.5.0-6ubuntu2) 7.5.0
> reproduce:
> # save the attached .config to linux build tree
> make ARCH=x86_64
>
> If you fix the issue, kindly add following tag as appropriate
> Reported-by: kbuild test robot <[email protected]>
>
> All errors (new ones prefixed by >>):
>
> >> drivers/counter/stm32-lptimer-cnt.c:387:2: error: initializer element is not constant
> stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE],
> ^~~~~~~~~~~~~~~~~~~~~~~~~~~
> drivers/counter/stm32-lptimer-cnt.c:387:2: note: (near initialization for 'stm32_lptim_cnt_synapse_actions[0]')
> drivers/counter/stm32-lptimer-cnt.c:388:2: error: initializer element is not constant
> stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE],
> ^~~~~~~~~~~~~~~~~~~~~~~~~~~
> drivers/counter/stm32-lptimer-cnt.c:388:2: note: (near initialization for 'stm32_lptim_cnt_synapse_actions[1]')
> drivers/counter/stm32-lptimer-cnt.c:389:2: error: initializer element is not constant
> stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES],
> ^~~~~~~~~~~~~~~~~~~~~~~~~~~
> drivers/counter/stm32-lptimer-cnt.c:389:2: note: (near initialization for 'stm32_lptim_cnt_synapse_actions[2]')
> drivers/counter/stm32-lptimer-cnt.c:390:2: error: initializer element is not constant
> stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_NONE],
> ^~~~~~~~~~~~~~~~~~~~~~~~~~~
> drivers/counter/stm32-lptimer-cnt.c:390:2: note: (near initialization for 'stm32_lptim_cnt_synapse_actions[3]')
>
> vim +387 drivers/counter/stm32-lptimer-cnt.c
>
> 385
> 386 static const enum counter_synapse_action stm32_lptim_cnt_synapse_actions[] = {
> > 387 stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE],
> 388 stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE],
> 389 stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES],
> 390 stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_NONE],
> 391 };
> 392
>
> ---
> 0-DAY CI Kernel Test Service, Intel Corporation
> https://lists.01.org/hyperkitty/list/[email protected]
This array must be initialized with constants. I'll fix this up in v2.
Thanks,
William Breathitt Gray
Hi,
On 29/04/2020 14:11:34-0400, William Breathitt Gray wrote:
> Over the past couple years we have noticed some shortcomings with the
> Counter sysfs interface. Although useful in the majority of situations,
> there are certain use-cases where interacting through sysfs attributes
> can become cumbersome and inefficient. A desire to support more advanced
> functionality such as timestamps, multi-axis positioning tables, and
> other such latency-sensitive applications, has motivated a reevaluation
> of the Counter subsystem. I believe a character device interface will be
> helpful for this more niche area of counter device use.
>
> To quell any concerns from the offset: this patchset makes no changes to
> the existing Counter sysfs userspace interface -- existing userspace
> applications will continue to work with no modifications necessary. I
> request that driver maintainers please test their applications to verify
> that this is true, and report any discrepancies if they arise.
>
On that topic, I'm wondering why the counter subsystem uses /sys/bus
instead of /sys/class that would be more natural for a class of devices.
I can't see how counters would be considered busses. I think you should
consider moving it over to /sys/class (even if deprecating
/sys/bus/counter will be long).
> Interaction with Counter character devices occurs via ioctl commands.
> This allows userspace applications to access and set counter data using
> native C datatypes rather than working through string translations.
>
I agree with David that you should consider using read to retrieve the
counter data as this will simplify interrupt handling/polling and
blocking/non-blocking reads can be used by an application. ABI wise,
this can also be a good move as you could always consider having an
ioctl requesting a specific format when reading the device so you are
not stuck with the initial format you are going to choose.
> 2. Should device driver callbacks return int or long? I sometimes see
> error values returned as long (e.g. PTR_ERR(), the file_operations
> structure's ioctl callbacks, etc.); when is it necessary to return
> long as opposed to int?
>
You should use a long if you ever have to return a point as it is
guaranteed to have the correct size. Else, just stick to an int if you
are not going to overflow it.
> 3. I only implemented the unlocked_ioctl callback. Should I implement a
> compat_ioctl callback as well?
>
The compat_ioctl is to handle 32bit userspace running on a 64bit kernel.
If your structures have the same size in both cases, then you don't have
to implement compat_ioctl.
Have a look at Documentation/driver-api/ioctl.rst
--
Alexandre Belloni, Bootlin
Embedded Linux and Kernel engineering
https://bootlin.com
Hi William,
I love your patch! Yet something to improve:
[auto build test ERROR on stm32/stm32-next]
[cannot apply to linus/master linux/master v5.7-rc3 next-20200430]
[if your patch is applied to the wrong git tree, please drop us a note to help
improve the system. BTW, we also suggest to use '--base' option to specify the
base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/William-Breathitt-Gray/Introduce-the-Counter-character-device-interface/20200430-051734
base: https://git.kernel.org/pub/scm/linux/kernel/git/atorgue/stm32.git stm32-next
config: x86_64-randconfig-d003-20200501 (attached as .config)
compiler: gcc-7 (Ubuntu 7.5.0-6ubuntu2) 7.5.0
reproduce:
# save the attached .config to linux build tree
make ARCH=x86_64
If you fix the issue, kindly add following tag as appropriate
Reported-by: kbuild test robot <[email protected]>
All errors (new ones prefixed by >>):
In file included from <command-line>:32:0:
>> ./usr/include/linux/counter.h:22:2: error: unknown type name 'size_t'
size_t num_signals;
^~~~~~
./usr/include/linux/counter.h:23:2: error: unknown type name 'size_t'
size_t num_counts;
^~~~~~
./usr/include/linux/counter.h:24:2: error: unknown type name 'size_t'
size_t num_ext;
^~~~~~
./usr/include/linux/counter.h:35:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:39:2: error: unknown type name 'size_t'
size_t num_ext;
^~~~~~
./usr/include/linux/counter.h:50:2: error: unknown type name 'size_t'
size_t count_index;
^~~~~~
./usr/include/linux/counter.h:51:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:53:2: error: unknown type name 'size_t'
size_t num_actions;
^~~~~~
./usr/include/linux/counter.h:54:2: error: unknown type name 'size_t'
size_t signal_index;
^~~~~~
./usr/include/linux/counter.h:67:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:71:2: error: unknown type name 'size_t'
size_t num_functions;
^~~~~~
./usr/include/linux/counter.h:72:2: error: unknown type name 'size_t'
size_t num_synapses;
^~~~~~
./usr/include/linux/counter.h:73:2: error: unknown type name 'size_t'
size_t num_ext;
^~~~~~
./usr/include/linux/counter.h:86:2: error: unknown type name 'size_t'
size_t owner_index;
^~~~~~
./usr/include/linux/counter.h:87:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:99:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:110:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:121:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:133:2: error: unknown type name 'size_t'
size_t count_index;
^~~~~~
./usr/include/linux/counter.h:134:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:146:2: error: unknown type name 'size_t'
size_t count_index;
^~~~~~
./usr/include/linux/counter.h:147:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:160:2: error: unknown type name 'size_t'
size_t count_index;
^~~~~~
./usr/include/linux/counter.h:161:2: error: unknown type name 'size_t'
size_t synapse_index;
^~~~~~
./usr/include/linux/counter.h:162:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:176:2: error: unknown type name 'size_t'
size_t owner_index;
^~~~~~
./usr/include/linux/counter.h:177:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
>> ./usr/include/linux/counter.h:179:2: error: unknown type name 'bool'
bool data;
^~~~
./usr/include/linux/counter.h:191:2: error: unknown type name 'size_t'
size_t owner_index;
^~~~~~
./usr/include/linux/counter.h:192:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:206:2: error: unknown type name 'size_t'
size_t owner_index;
^~~~~~
./usr/include/linux/counter.h:207:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:221:2: error: unknown type name 'size_t'
size_t owner_index;
^~~~~~
./usr/include/linux/counter.h:222:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:224:2: error: unknown type name 'size_t'
size_t enum_index;
^~~~~~
./usr/include/linux/counter.h:237:2: error: unknown type name 'size_t'
size_t owner_index;
^~~~~~
./usr/include/linux/counter.h:238:2: error: unknown type name 'size_t'
size_t ext_index;
^~~~~~
./usr/include/linux/counter.h:239:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:251:2: error: unknown type name 'size_t'
size_t count_index;
^~~~~~
./usr/include/linux/counter.h:252:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:264:2: error: unknown type name 'size_t'
size_t count_index;
^~~~~~
./usr/include/linux/counter.h:265:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
./usr/include/linux/counter.h:278:2: error: unknown type name 'size_t'
size_t count_index;
^~~~~~
./usr/include/linux/counter.h:279:2: error: unknown type name 'size_t'
size_t ext_index;
^~~~~~
./usr/include/linux/counter.h:280:2: error: unknown type name 'size_t'
size_t index;
^~~~~~
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]
Hi William,
I love your patch! Perhaps something to improve:
[auto build test WARNING on stm32/stm32-next]
[cannot apply to linus/master linux/master v5.7-rc3 next-20200430]
[if your patch is applied to the wrong git tree, please drop us a note to help
improve the system. BTW, we also suggest to use '--base' option to specify the
base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/William-Breathitt-Gray/Introduce-the-Counter-character-device-interface/20200430-051734
base: https://git.kernel.org/pub/scm/linux/kernel/git/atorgue/stm32.git stm32-next
reproduce:
# apt-get install sparse
# sparse version: v0.6.1-191-gc51a0382-dirty
make ARCH=x86_64 allmodconfig
make C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__'
If you fix the issue, kindly add following tag as appropriate
Reported-by: kbuild test robot <[email protected]>
sparse warnings: (new ones prefixed by >>)
>> drivers/counter/104-quad-8.c:700:56: sparse: sparse: mixing different enum types:
>> drivers/counter/104-quad-8.c:700:56: sparse: unsigned int enum counter_count_function
>> drivers/counter/104-quad-8.c:700:56: sparse: unsigned int enum quad8_count_function
--
>> drivers/counter/stm32-lptimer-cnt.c:573:24: sparse: sparse: mixing different enum types:
>> drivers/counter/stm32-lptimer-cnt.c:573:24: sparse: unsigned int enum counter_count_function
>> drivers/counter/stm32-lptimer-cnt.c:573:24: sparse: unsigned int enum stm32_lptim_cnt_function
vim +700 drivers/counter/104-quad-8.c
693
694 static int quad8_function_write(struct counter_device *counter,
695 struct counter_count *count,
696 enum counter_count_function function)
697 {
698 struct quad8_iio *const priv = counter->priv;
699 const int id = count->id;
> 700 const enum quad8_count_function cnt_function = function;
701 unsigned int *const quadrature_mode = priv->quadrature_mode + id;
702 unsigned int *const scale = priv->quadrature_scale + id;
703 unsigned int mode_cfg = priv->count_mode[id] << 1;
704 unsigned int *const synchronous_mode = priv->synchronous_mode + id;
705 const unsigned int idr_cfg = priv->index_polarity[id] << 1;
706 const int base_offset = priv->base + 2 * id + 1;
707
708 if (cnt_function == QUAD8_COUNT_FUNCTION_PULSE_DIRECTION) {
709 *quadrature_mode = 0;
710
711 /* Quadrature scaling only available in quadrature mode */
712 *scale = 0;
713
714 /* Synchronous function not supported in non-quadrature mode */
715 if (*synchronous_mode) {
716 *synchronous_mode = 0;
717 /* Disable synchronous function mode */
718 outb(QUAD8_CTR_IDR | idr_cfg, base_offset);
719 }
720 } else {
721 *quadrature_mode = 1;
722
723 switch (cnt_function) {
724 case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
725 *scale = 0;
726 mode_cfg |= QUAD8_CMR_QUADRATURE_X1;
727 break;
728 case QUAD8_COUNT_FUNCTION_QUADRATURE_X2:
729 *scale = 1;
730 mode_cfg |= QUAD8_CMR_QUADRATURE_X2;
731 break;
732 case QUAD8_COUNT_FUNCTION_QUADRATURE_X4:
733 *scale = 2;
734 mode_cfg |= QUAD8_CMR_QUADRATURE_X4;
735 break;
736 default: return -EINVAL;
737 }
738 }
739
740 /* Load mode configuration to Counter Mode Register */
741 outb(QUAD8_CTR_CMR | mode_cfg, base_offset);
742
743 return 0;
744 }
745
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]
On Thu, Apr 30, 2020 at 10:13:45PM +0200, Alexandre Belloni wrote:
> Hi,
>
> On 29/04/2020 14:11:34-0400, William Breathitt Gray wrote:
> > Over the past couple years we have noticed some shortcomings with the
> > Counter sysfs interface. Although useful in the majority of situations,
> > there are certain use-cases where interacting through sysfs attributes
> > can become cumbersome and inefficient. A desire to support more advanced
> > functionality such as timestamps, multi-axis positioning tables, and
> > other such latency-sensitive applications, has motivated a reevaluation
> > of the Counter subsystem. I believe a character device interface will be
> > helpful for this more niche area of counter device use.
> >
> > To quell any concerns from the offset: this patchset makes no changes to
> > the existing Counter sysfs userspace interface -- existing userspace
> > applications will continue to work with no modifications necessary. I
> > request that driver maintainers please test their applications to verify
> > that this is true, and report any discrepancies if they arise.
> >
>
> On that topic, I'm wondering why the counter subsystem uses /sys/bus
> instead of /sys/class that would be more natural for a class of devices.
> I can't see how counters would be considered busses. I think you should
> consider moving it over to /sys/class (even if deprecating
> /sys/bus/counter will be long).
At the time I wasn't quite familiar with sysfs development so I was
following the iio sysfs code rather closely. However, I see now that
you're probably right: this isn't really a bus but rather a collection
of various types of counters -- i.e. a class of devices.
Perhaps I should migrate this then to /sys/class/counter. Of course, the
/sys/bus/counter location will have to remain for compatibility with
existing applications, but I think a simple symlink to the new
/sys/class/counter location should suffice for that.
If anyone sees an issue with this give me a heads up.
> > Interaction with Counter character devices occurs via ioctl commands.
> > This allows userspace applications to access and set counter data using
> > native C datatypes rather than working through string translations.
> >
>
> I agree with David that you should consider using read to retrieve the
> counter data as this will simplify interrupt handling/polling and
> blocking/non-blocking reads can be used by an application. ABI wise,
> this can also be a good move as you could always consider having an
> ioctl requesting a specific format when reading the device so you are
> not stuck with the initial format you are going to choose.
My hesitation to implement support for read/write calls is due to a
concern that we will end up with various incompatible formats between
counter drivers (thus requiring users to have intimate knowledge of the
drivers and therefore defeating the purpose of a subsystem). However, if
we can standardize on a format that is flexible enough to work for all
counter drivers, then read/write calls should not be a problem.
I think a general format could be possible. For example, the counter
character device can return a standard header data at the start which
provides general information about the counter device: number of
counters, number or signals, number of extensions, etc. From this
information, offsets can be computed (or perhaps provided by the device)
to where the binary data for the count, extension, etc., can be read or
written. Interrupts can then be handled as blocking reads, as could
other types of events we implement.
Would something like this work well?
William Breathitt Gray
> > 2. Should device driver callbacks return int or long? I sometimes see
> > error values returned as long (e.g. PTR_ERR(), the file_operations
> > structure's ioctl callbacks, etc.); when is it necessary to return
> > long as opposed to int?
> >
>
> You should use a long if you ever have to return a point as it is
> guaranteed to have the correct size. Else, just stick to an int if you
> are not going to overflow it.
>
> > 3. I only implemented the unlocked_ioctl callback. Should I implement a
> > compat_ioctl callback as well?
> >
>
> The compat_ioctl is to handle 32bit userspace running on a 64bit kernel.
> If your structures have the same size in both cases, then you don't have
> to implement compat_ioctl.
>
> Have a look at Documentation/driver-api/ioctl.rst
>
>
> --
> Alexandre Belloni, Bootlin
> Embedded Linux and Kernel engineering
> https://bootlin.com
On Fri, 1 May 2020 11:46:10 -0400
William Breathitt Gray <[email protected]> wrote:
> On Thu, Apr 30, 2020 at 10:13:45PM +0200, Alexandre Belloni wrote:
> > Hi,
> >
> > On 29/04/2020 14:11:34-0400, William Breathitt Gray wrote:
> > > Over the past couple years we have noticed some shortcomings with the
> > > Counter sysfs interface. Although useful in the majority of situations,
> > > there are certain use-cases where interacting through sysfs attributes
> > > can become cumbersome and inefficient. A desire to support more advanced
> > > functionality such as timestamps, multi-axis positioning tables, and
> > > other such latency-sensitive applications, has motivated a reevaluation
> > > of the Counter subsystem. I believe a character device interface will be
> > > helpful for this more niche area of counter device use.
> > >
> > > To quell any concerns from the offset: this patchset makes no changes to
> > > the existing Counter sysfs userspace interface -- existing userspace
> > > applications will continue to work with no modifications necessary. I
> > > request that driver maintainers please test their applications to verify
> > > that this is true, and report any discrepancies if they arise.
> > >
> >
> > On that topic, I'm wondering why the counter subsystem uses /sys/bus
> > instead of /sys/class that would be more natural for a class of devices.
> > I can't see how counters would be considered busses. I think you should
> > consider moving it over to /sys/class (even if deprecating
> > /sys/bus/counter will be long).
>
> At the time I wasn't quite familiar with sysfs development so I was
> following the iio sysfs code rather closely. However, I see now that
> you're probably right: this isn't really a bus but rather a collection
> of various types of counters -- i.e. a class of devices.
>
> Perhaps I should migrate this then to /sys/class/counter. Of course, the
> /sys/bus/counter location will have to remain for compatibility with
> existing applications, but I think a simple symlink to the new
> /sys/class/counter location should suffice for that.
>
> If anyone sees an issue with this give me a heads up.
To just address this point as I've not read the rest of the thread yet...
I would resist moving it. This one is an old argument.
Some info in https://lwn.net/Articles/645810/
As that puts it a "bus" is better known as a "subsystem".
When we originally considered class vs bus for IIO, the view expressed
at the times was that the whole separation of the two didn't mean anything
and for non trivial cases bus was always preferred. It's nothing to do
with with whether the thing is a bus or not. Now I suppose it's possible
opinion has moved on this topic... However, I'd say there
is really 0 advantage in moving an existing subsystem even if opinion
has changed.
+CC Greg in case he wants to add anything.
>
> > > Interaction with Counter character devices occurs via ioctl commands.
> > > This allows userspace applications to access and set counter data using
> > > native C datatypes rather than working through string translations.
> > >
> >
> > I agree with David that you should consider using read to retrieve the
> > counter data as this will simplify interrupt handling/polling and
> > blocking/non-blocking reads can be used by an application. ABI wise,
> > this can also be a good move as you could always consider having an
> > ioctl requesting a specific format when reading the device so you are
> > not stuck with the initial format you are going to choose.
>
> My hesitation to implement support for read/write calls is due to a
> concern that we will end up with various incompatible formats between
> counter drivers (thus requiring users to have intimate knowledge of the
> drivers and therefore defeating the purpose of a subsystem). However, if
> we can standardize on a format that is flexible enough to work for all
> counter drivers, then read/write calls should not be a problem.
>
> I think a general format could be possible. For example, the counter
> character device can return a standard header data at the start which
> provides general information about the counter device: number of
> counters, number or signals, number of extensions, etc. From this
> information, offsets can be computed (or perhaps provided by the device)
> to where the binary data for the count, extension, etc., can be read or
> written. Interrupts can then be handled as blocking reads, as could
> other types of events we implement.
>
> Would something like this work well?
>
> William Breathitt Gray
>
> > > 2. Should device driver callbacks return int or long? I sometimes see
> > > error values returned as long (e.g. PTR_ERR(), the file_operations
> > > structure's ioctl callbacks, etc.); when is it necessary to return
> > > long as opposed to int?
> > >
> >
> > You should use a long if you ever have to return a point as it is
> > guaranteed to have the correct size. Else, just stick to an int if you
> > are not going to overflow it.
> >
> > > 3. I only implemented the unlocked_ioctl callback. Should I implement a
> > > compat_ioctl callback as well?
> > >
> >
> > The compat_ioctl is to handle 32bit userspace running on a 64bit kernel.
> > If your structures have the same size in both cases, then you don't have
> > to implement compat_ioctl.
> >
> > Have a look at Documentation/driver-api/ioctl.rst
> >
> >
> > --
> > Alexandre Belloni, Bootlin
> > Embedded Linux and Kernel engineering
> > https://bootlin.com
On Sat, May 02, 2020 at 05:55:36PM +0100, Jonathan Cameron wrote:
> On Fri, 1 May 2020 11:46:10 -0400
> William Breathitt Gray <[email protected]> wrote:
>
> > On Thu, Apr 30, 2020 at 10:13:45PM +0200, Alexandre Belloni wrote:
> > > Hi,
> > >
> > > On 29/04/2020 14:11:34-0400, William Breathitt Gray wrote:
> > > > Over the past couple years we have noticed some shortcomings with the
> > > > Counter sysfs interface. Although useful in the majority of situations,
> > > > there are certain use-cases where interacting through sysfs attributes
> > > > can become cumbersome and inefficient. A desire to support more advanced
> > > > functionality such as timestamps, multi-axis positioning tables, and
> > > > other such latency-sensitive applications, has motivated a reevaluation
> > > > of the Counter subsystem. I believe a character device interface will be
> > > > helpful for this more niche area of counter device use.
> > > >
> > > > To quell any concerns from the offset: this patchset makes no changes to
> > > > the existing Counter sysfs userspace interface -- existing userspace
> > > > applications will continue to work with no modifications necessary. I
> > > > request that driver maintainers please test their applications to verify
> > > > that this is true, and report any discrepancies if they arise.
> > > >
> > >
> > > On that topic, I'm wondering why the counter subsystem uses /sys/bus
> > > instead of /sys/class that would be more natural for a class of devices.
> > > I can't see how counters would be considered busses. I think you should
> > > consider moving it over to /sys/class (even if deprecating
> > > /sys/bus/counter will be long).
> >
> > At the time I wasn't quite familiar with sysfs development so I was
> > following the iio sysfs code rather closely. However, I see now that
> > you're probably right: this isn't really a bus but rather a collection
> > of various types of counters -- i.e. a class of devices.
> >
> > Perhaps I should migrate this then to /sys/class/counter. Of course, the
> > /sys/bus/counter location will have to remain for compatibility with
> > existing applications, but I think a simple symlink to the new
> > /sys/class/counter location should suffice for that.
> >
> > If anyone sees an issue with this give me a heads up.
> To just address this point as I've not read the rest of the thread yet...
>
> I would resist moving it. This one is an old argument.
>
> Some info in https://lwn.net/Articles/645810/
> As that puts it a "bus" is better known as a "subsystem".
>
> When we originally considered class vs bus for IIO, the view expressed
> at the times was that the whole separation of the two didn't mean anything
> and for non trivial cases bus was always preferred. It's nothing to do
> with with whether the thing is a bus or not. Now I suppose it's possible
> opinion has moved on this topic... However, I'd say there
> is really 0 advantage in moving an existing subsystem even if opinion
> has changed.
>
> +CC Greg in case he wants to add anything.
Traditionally classes are a unified way of representing data to
userspace, independant of the physical transport that the data came to
userspace on (i.e. input devices are a class, it doesn't matter if they
came on serial, USB, PS/2, or virtual busses.)
A bus is traditionally a collection of drivers that all talk on a same
physical transport, that then expose data from that transport to a
specific userspace class. Again, think USB mice drivers, serial mice
drivers, PS/2 mice drivers.
Busses bind a driver to a device it creates based on that "bus".
Classes create virtual devices that export data to userspace for a
specific common protocol.
Does that help?
One can argue (and have properly in the past), that classes and busses
really are not all that different, and there used to be code floating
around that made them the same exact thing in the kernel, with loads of
userspace sysfs symlinks to preserve things, but those are well out of
date and I don't think anyone feels like reviving them. However I think
systemd might still have code in it to work properly if that ever
happens, haven't looked in a few years...
thanks,
greg k-h
On Sun, 3 May 2020 11:23:16 +0200
Greg Kroah-Hartman <[email protected]> wrote:
> On Sat, May 02, 2020 at 05:55:36PM +0100, Jonathan Cameron wrote:
> > On Fri, 1 May 2020 11:46:10 -0400
> > William Breathitt Gray <[email protected]> wrote:
> >
> > > On Thu, Apr 30, 2020 at 10:13:45PM +0200, Alexandre Belloni wrote:
> > > > Hi,
> > > >
> > > > On 29/04/2020 14:11:34-0400, William Breathitt Gray wrote:
> > > > > Over the past couple years we have noticed some shortcomings with the
> > > > > Counter sysfs interface. Although useful in the majority of situations,
> > > > > there are certain use-cases where interacting through sysfs attributes
> > > > > can become cumbersome and inefficient. A desire to support more advanced
> > > > > functionality such as timestamps, multi-axis positioning tables, and
> > > > > other such latency-sensitive applications, has motivated a reevaluation
> > > > > of the Counter subsystem. I believe a character device interface will be
> > > > > helpful for this more niche area of counter device use.
> > > > >
> > > > > To quell any concerns from the offset: this patchset makes no changes to
> > > > > the existing Counter sysfs userspace interface -- existing userspace
> > > > > applications will continue to work with no modifications necessary. I
> > > > > request that driver maintainers please test their applications to verify
> > > > > that this is true, and report any discrepancies if they arise.
> > > > >
> > > >
> > > > On that topic, I'm wondering why the counter subsystem uses /sys/bus
> > > > instead of /sys/class that would be more natural for a class of devices.
> > > > I can't see how counters would be considered busses. I think you should
> > > > consider moving it over to /sys/class (even if deprecating
> > > > /sys/bus/counter will be long).
> > >
> > > At the time I wasn't quite familiar with sysfs development so I was
> > > following the iio sysfs code rather closely. However, I see now that
> > > you're probably right: this isn't really a bus but rather a collection
> > > of various types of counters -- i.e. a class of devices.
> > >
> > > Perhaps I should migrate this then to /sys/class/counter. Of course, the
> > > /sys/bus/counter location will have to remain for compatibility with
> > > existing applications, but I think a simple symlink to the new
> > > /sys/class/counter location should suffice for that.
> > >
> > > If anyone sees an issue with this give me a heads up.
> > To just address this point as I've not read the rest of the thread yet...
> >
> > I would resist moving it. This one is an old argument.
> >
> > Some info in https://lwn.net/Articles/645810/
> > As that puts it a "bus" is better known as a "subsystem".
> >
> > When we originally considered class vs bus for IIO, the view expressed
> > at the times was that the whole separation of the two didn't mean anything
> > and for non trivial cases bus was always preferred. It's nothing to do
> > with with whether the thing is a bus or not. Now I suppose it's possible
> > opinion has moved on this topic... However, I'd say there
> > is really 0 advantage in moving an existing subsystem even if opinion
> > has changed.
> >
> > +CC Greg in case he wants to add anything.
>
> Traditionally classes are a unified way of representing data to
> userspace, independant of the physical transport that the data came to
> userspace on (i.e. input devices are a class, it doesn't matter if they
> came on serial, USB, PS/2, or virtual busses.)
>
> A bus is traditionally a collection of drivers that all talk on a same
> physical transport, that then expose data from that transport to a
> specific userspace class. Again, think USB mice drivers, serial mice
> drivers, PS/2 mice drivers.
>
> Busses bind a driver to a device it creates based on that "bus".
> Classes create virtual devices that export data to userspace for a
> specific common protocol.
>
> Does that help?
>
> One can argue (and have properly in the past), that classes and busses
> really are not all that different, and there used to be code floating
> around that made them the same exact thing in the kernel, with loads of
> userspace sysfs symlinks to preserve things, but those are well out of
> date and I don't think anyone feels like reviving them. However I think
> systemd might still have code in it to work properly if that ever
> happens, haven't looked in a few years...
>
> thanks,
>
> greg k-h
Thanks for the explanation. Here key thing to my mind is counters went
in as a bus and should stay so because there is limited benefit in a move
and it would be ABI breaking. Maybe it 'should' have been a class, but
too late now.
Jonathan
On Sun, May 03, 2020 at 01:54:58PM +0100, Jonathan Cameron wrote:
> On Sun, 3 May 2020 11:23:16 +0200
> Greg Kroah-Hartman <[email protected]> wrote:
>
> > On Sat, May 02, 2020 at 05:55:36PM +0100, Jonathan Cameron wrote:
> > > On Fri, 1 May 2020 11:46:10 -0400
> > > William Breathitt Gray <[email protected]> wrote:
> > >
> > > > On Thu, Apr 30, 2020 at 10:13:45PM +0200, Alexandre Belloni wrote:
> > > > > Hi,
> > > > >
> > > > > On 29/04/2020 14:11:34-0400, William Breathitt Gray wrote:
> > > > > > Over the past couple years we have noticed some shortcomings with the
> > > > > > Counter sysfs interface. Although useful in the majority of situations,
> > > > > > there are certain use-cases where interacting through sysfs attributes
> > > > > > can become cumbersome and inefficient. A desire to support more advanced
> > > > > > functionality such as timestamps, multi-axis positioning tables, and
> > > > > > other such latency-sensitive applications, has motivated a reevaluation
> > > > > > of the Counter subsystem. I believe a character device interface will be
> > > > > > helpful for this more niche area of counter device use.
> > > > > >
> > > > > > To quell any concerns from the offset: this patchset makes no changes to
> > > > > > the existing Counter sysfs userspace interface -- existing userspace
> > > > > > applications will continue to work with no modifications necessary. I
> > > > > > request that driver maintainers please test their applications to verify
> > > > > > that this is true, and report any discrepancies if they arise.
> > > > > >
> > > > >
> > > > > On that topic, I'm wondering why the counter subsystem uses /sys/bus
> > > > > instead of /sys/class that would be more natural for a class of devices.
> > > > > I can't see how counters would be considered busses. I think you should
> > > > > consider moving it over to /sys/class (even if deprecating
> > > > > /sys/bus/counter will be long).
> > > >
> > > > At the time I wasn't quite familiar with sysfs development so I was
> > > > following the iio sysfs code rather closely. However, I see now that
> > > > you're probably right: this isn't really a bus but rather a collection
> > > > of various types of counters -- i.e. a class of devices.
> > > >
> > > > Perhaps I should migrate this then to /sys/class/counter. Of course, the
> > > > /sys/bus/counter location will have to remain for compatibility with
> > > > existing applications, but I think a simple symlink to the new
> > > > /sys/class/counter location should suffice for that.
> > > >
> > > > If anyone sees an issue with this give me a heads up.
> > > To just address this point as I've not read the rest of the thread yet...
> > >
> > > I would resist moving it. This one is an old argument.
> > >
> > > Some info in https://lwn.net/Articles/645810/
> > > As that puts it a "bus" is better known as a "subsystem".
> > >
> > > When we originally considered class vs bus for IIO, the view expressed
> > > at the times was that the whole separation of the two didn't mean anything
> > > and for non trivial cases bus was always preferred. It's nothing to do
> > > with with whether the thing is a bus or not. Now I suppose it's possible
> > > opinion has moved on this topic... However, I'd say there
> > > is really 0 advantage in moving an existing subsystem even if opinion
> > > has changed.
> > >
> > > +CC Greg in case he wants to add anything.
> >
> > Traditionally classes are a unified way of representing data to
> > userspace, independant of the physical transport that the data came to
> > userspace on (i.e. input devices are a class, it doesn't matter if they
> > came on serial, USB, PS/2, or virtual busses.)
> >
> > A bus is traditionally a collection of drivers that all talk on a same
> > physical transport, that then expose data from that transport to a
> > specific userspace class. Again, think USB mice drivers, serial mice
> > drivers, PS/2 mice drivers.
> >
> > Busses bind a driver to a device it creates based on that "bus".
> > Classes create virtual devices that export data to userspace for a
> > specific common protocol.
> >
> > Does that help?
> >
> > One can argue (and have properly in the past), that classes and busses
> > really are not all that different, and there used to be code floating
> > around that made them the same exact thing in the kernel, with loads of
> > userspace sysfs symlinks to preserve things, but those are well out of
> > date and I don't think anyone feels like reviving them. However I think
> > systemd might still have code in it to work properly if that ever
> > happens, haven't looked in a few years...
> >
> > thanks,
> >
> > greg k-h
>
> Thanks for the explanation. Here key thing to my mind is counters went
> in as a bus and should stay so because there is limited benefit in a move
> and it would be ABI breaking. Maybe it 'should' have been a class, but
> too late now.
>
> Jonathan
Very well, that's an understandable reason to avoid incompatibility
issues down the road, and userspace applications apparently care little
about the difference between /sys/bus and /sys/class anyway, so I'll
keep things as they are now and avoid those unnecessary changes.
William Breathitt Gray
On Wed, 29 Apr 2020 14:11:34 -0400
William Breathitt Gray <[email protected]> wrote:
> Over the past couple years we have noticed some shortcomings with the
> Counter sysfs interface. Although useful in the majority of situations,
> there are certain use-cases where interacting through sysfs attributes
> can become cumbersome and inefficient. A desire to support more advanced
> functionality such as timestamps, multi-axis positioning tables, and
> other such latency-sensitive applications, has motivated a reevaluation
> of the Counter subsystem. I believe a character device interface will be
> helpful for this more niche area of counter device use.
>
> To quell any concerns from the offset: this patchset makes no changes to
> the existing Counter sysfs userspace interface -- existing userspace
> applications will continue to work with no modifications necessary. I
> request that driver maintainers please test their applications to verify
> that this is true, and report any discrepancies if they arise.
>
> However, this patchset does contain a major reimplementation of the
> Counter subsystem core and driver API. A reimplementation was necessary
> in order to separate the sysfs code from the counter device drivers and
> internalize it as a dedicated component of the core Counter subsystem
> module. A minor benefit from all of this is that the sysfs interface is
> now ensured a certain amount of consistency because the translation is
> performed outside of individual counter device drivers.
>
> Essentially, the reimplementation has enabled counter device drivers to
> pass and handle data as native C datatypes now rather than the sysfs
> strings from before. A high-level view of how a count value is passed
> down from a counter device driver can be exemplified by the following:
>
> ----------------------
> / Counter device \
> +----------------------+
> | Count register: 0x28 |
> +----------------------+
> |
> -----------------
> / raw count data /
> -----------------
> |
> V
> +----------------------------+
> | Counter device driver |----------+
> +----------------------------+ |
> | Processes data from device | -------------------
> |----------------------------| / driver callbacks /
> | Type: unsigned long | -------------------
> | Value: 42 | |
> +----------------------------+ |
> | |
> ---------------- |
> / unsigned long / |
> ---------------- |
> | |
> | V
> | +----------------------+
> | | Counter core |
> | +----------------------+
> | | Routes device driver |
> | | callbacks to the |
> | | userspace interfaces |
> | +----------------------+
> | |
> | -------------------
> | / driver callbacks /
> | -------------------
> | |
> +-------+---------------+ |
> | | |
> | +-------|-------+
> | | |
> V | V
> +--------------------+ | +---------------------+
> | Counter sysfs |<-+->| Counter chrdev |
> +--------------------+ +---------------------+
> | Translates to the | | Translates to the |
> | standard Counter | | standard Counter |
> | sysfs output | | character device |
> |--------------------| |---------------------+
> | Type: const char * | | Type: unsigned long |
> | Value: "42" | | Value: 42 |
> +--------------------+ +---------------------+
> | |
> --------------- ----------------
> / const char * / / unsigned long /
> --------------- ----------------
> | |
> | V
> | +-----------+
> | | ioctl |
> | +-----------+
> | \ Count: 42 /
> | -----------
> |
> V
> +--------------------------------------------------+
> | `/sys/bus/counter/devices/counterX/countY/count` |
> +--------------------------------------------------+
> \ Count: "42" /
> --------------------------------------------------
>
> I am aware that an in-kernel API can simplify the data transfer between
> counter device drivers and the userspace interfaces, but I want to
> postpone that development until after the new Counter character device
> ioctl commands are solidified. A userspace ABI is effectively immutable
> so I want to make sure we get that right before working on an in-kernel
> API that is more flexible to change. However, when we do develop an
> in-kernel API, it will likely be housed as part of the Counter core
> component, through which the userspace interfaces will then communicate.
>
> Interaction with Counter character devices occurs via ioctl commands.
> This allows userspace applications to access and set counter data using
> native C datatypes rather than working through string translations.
>
> Regarding the organization of this patchset, I have combined the counter
> device driver changes with the first patch because the changes must all
> be taken together in order to avoid compilation errors. I can see how
> this can end up making it difficult to review so many changes at once,
> so alternatively I can separate out the counter device driver changes
> into their own dedicated patches -- with the understanding that the
> patches must all be taken together.
>
> In addition, I anticipate the Microchip TCB capture counter driver to
> break with this patchset. I'm not sure how that driver will be picked
> up yet so I have avoided adding it to this patchset right now. But the
> changes to support that driver are simple to make so I can add them in a
> later revision of this patchset.
>
> The following are some questions I have about this patchset:
>
> 1. Should enums be used to represent standard counter component states
> (e.g. COUNTER_SIGNAL_LOW), or would these be better defined as int?
>
> These standard counter component states are defined in the
> counter-types.h file and serve as constants used by counter device
> drivers and Counter subsystem components in order to ensure a
> consistent interface.
>
> My concern is whether enum constants will cause problems when passed
> to userspace via the Counter character device ioctl calls. Along the
> same lines is whether the C bool datatype is safe to pass as well,
> given that it is a more modern C datatype.
For enums, I'd pass them as integers.
Bool is probably fine either way.
>
> 2. Should device driver callbacks return int or long? I sometimes see
> error values returned as long (e.g. PTR_ERR(), the file_operations
> structure's ioctl callbacks, etc.); when is it necessary to return
> long as opposed to int?
In my view it doesn't really matter that much. For PTR_ERR it has to be
a long because a long is always the same length as a pointer, but an int
'might' not be. However PTR_ERR returns a value that always fits in an
integer anyway.
https://www.oreilly.com/library/view/linux-device-drivers/0596005903/ch11.html
Coding style in linux mostly use int for return values that might indicate
an error.
>
> 3. I only implemented the unlocked_ioctl callback. Should I implement a
> compat_ioctl callback as well?
Depends if you need to deal with the 32bit userspace on 64 bit kernel corner
cases. Looks like you only pass a pointer, in which case I think you
can just use the ioctl_compat_ptr callback to handle it for you.
>
> 4. How much space should allot for name strings? Name strings hold the
> names of components (ideally as they appear on datasheets), so I've
> arbitrarily chosen a size of 32 for the character device interface.
>
> 5. Should the owning component of an extension be determined by the
> device driver or Counter subsystem?
>
> A lot of the complexity in the counters-function-types.h file and the
> sysfs-callbacks.c file is due to the function pointer casts required
> in order to support three different ownership scenarios: the owning
> component is the device, the owning component is a Count, the owning
> component is a Signal.
>
> Because the Counter subsystem doesn't not know which scenario is
> valid, it must manually check and provide for all three ownership
> cases. On the other hand, device drivers do know exactly which case
> applies because they are the ones providing the callbacks.
>
> The complexity in the Counter subsystem code can be eliminated if the
> owning component is simply passed down to the callbacks as a void
> pointer. The device drivers will then be responsible for casting to
> the appropriate component type, but this should in theory not be a
> problem since the device driver assigned the callback to the owning
> component in the first place.
>
> William Breathitt Gray (4):
> counter: Internalize sysfs interface code
> docs: counter: Update to reflect sysfs internalization
> counter: Add character device interface
> docs: counter: Document character device interface
>
> Documentation/driver-api/generic-counter.rst | 259 ++-
> .../userspace-api/ioctl/ioctl-number.rst | 1 +
> MAINTAINERS | 3 +-
> drivers/counter/104-quad-8.c | 437 +++--
> drivers/counter/Makefile | 2 +
> drivers/counter/counter-chrdev.c | 1134 +++++++++++++
> drivers/counter/counter-chrdev.h | 16 +
> drivers/counter/counter-core.c | 220 +++
> drivers/counter/counter-function-types.h | 81 +
> drivers/counter/counter-strings.h | 46 +
> drivers/counter/counter-sysfs-callbacks.c | 566 +++++++
> drivers/counter/counter-sysfs-callbacks.h | 28 +
> drivers/counter/counter-sysfs.c | 524 ++++++
> drivers/counter/counter-sysfs.h | 14 +
> drivers/counter/counter.c | 1496 -----------------
> drivers/counter/ftm-quaddec.c | 46 +-
> drivers/counter/stm32-lptimer-cnt.c | 159 +-
> drivers/counter/stm32-timer-cnt.c | 132 +-
> drivers/counter/ti-eqep.c | 170 +-
> include/linux/counter.h | 547 +++---
> include/linux/counter_enum.h | 45 -
> include/uapi/linux/counter-types.h | 67 +
> include/uapi/linux/counter.h | 313 ++++
> 23 files changed, 3816 insertions(+), 2490 deletions(-)
> create mode 100644 drivers/counter/counter-chrdev.c
> create mode 100644 drivers/counter/counter-chrdev.h
> create mode 100644 drivers/counter/counter-core.c
> create mode 100644 drivers/counter/counter-function-types.h
> create mode 100644 drivers/counter/counter-strings.h
> create mode 100644 drivers/counter/counter-sysfs-callbacks.c
> create mode 100644 drivers/counter/counter-sysfs-callbacks.h
> create mode 100644 drivers/counter/counter-sysfs.c
> create mode 100644 drivers/counter/counter-sysfs.h
> delete mode 100644 drivers/counter/counter.c
> delete mode 100644 include/linux/counter_enum.h
> create mode 100644 include/uapi/linux/counter-types.h
> create mode 100644 include/uapi/linux/counter.h
>
>
> base-commit: 00edef1ac058b3c754d29bcfd35ea998d9e7a339
From: Jonathan Cameron
> Sent: 03 May 2020 15:13
...
> > The following are some questions I have about this patchset:
> >
> > 1. Should enums be used to represent standard counter component states
> > (e.g. COUNTER_SIGNAL_LOW), or would these be better defined as int?
> >
> > These standard counter component states are defined in the
> > counter-types.h file and serve as constants used by counter device
> > drivers and Counter subsystem components in order to ensure a
> > consistent interface.
> >
> > My concern is whether enum constants will cause problems when passed
> > to userspace via the Counter character device ioctl calls. Along the
> > same lines is whether the C bool datatype is safe to pass as well,
> > given that it is a more modern C datatype.
>
> For enums, I'd pass them as integers.
>
> Bool is probably fine either way.
Always use fixed size types in any API structures.
Ensure that fields are always on their natural boundaries.
So no enums and no bools.
It may even be worth using uint64_t for any userspace pointers.
At some point you'll live to regret anything else.
David
-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK
Registration No: 1397386 (Wales)
On Wed, 29 Apr 2020 14:11:35 -0400
William Breathitt Gray <[email protected]> wrote:
> This is a reimplementation of the Generic Counter driver interface.
> There are no modifications to the Counter subsystem userspace interface,
> so existing userspace applications should continue to run seamlessly.
>
> Overview
> ========
>
> The purpose of this patch is to internalize the sysfs interface code
> among the various counter drivers into a shared module. Counter drivers
> pass and take data natively (i.e. unsigned long, bool, size_t, etc.) and
> the shared counter module handles the translation between the sysfs
> interface. This gurantees a standard userspace interface for all counter
> drivers, and helps generalize the Generic Counter driver ABI in order to
> support the Generic Counter chardev interface (introduced in a
> subsequent patch) without changes to the existing counter drivers.
>
> A high-level view of how a count value is passed down from a counter
> driver can be exemplified by the following:
>
> ----------------------
> / Counter device \
> +----------------------+
> | Count register: 0x28 |
> +----------------------+
> |
> -----------------
> / raw count data /
> -----------------
> |
> V
> +----------------------------+
> | Counter device driver |----------+
> +----------------------------+ |
> | Processes data from device | -------------------
> |----------------------------| / driver callbacks /
> | Type: unsigned long | -------------------
> | Value: 42 | |
> +----------------------------+ |
> | |
> ---------------- |
> / unsigned long / |
> ---------------- |
> | |
> | V
> | +----------------------+
> | | Counter core |
> | +----------------------+
> | | Routes device driver |
> | | callbacks to the |
> | | userspace interfaces |
> | +----------------------+
> | |
> | -------------------
> | / driver callbacks /
> | -------------------
> | |
> +-------+ |
> | |
> | +---------------+
> | |
> V |
> +--------------------+ |
> | Counter sysfs |<-+
> +--------------------+
> | Translates to the |
> | standard Counter |
> | sysfs output |
> |--------------------|
> | Type: const char * |
> | Value: "42" |
> +--------------------+
> |
> ---------------
> / const char * /
> ---------------
> |
> V
> +--------------------------------------------------+
> | `/sys/bus/counter/devices/counterX/countY/count` |
> +--------------------------------------------------+
> \ Count: "42" /
> --------------------------------------------------
>
> There are three primary components involved:
>
> Counter device driver
> ---------------------
> Communicates with the hardware device to read/write data; e.g.
> counter drivers for 104-quad-8, stm32-timer, etc.
>
> Counter core
> ------------
> Registers the counter device driver to the system so that the
> respective callbacks are called during userspace interaction
>
> Counter sysfs
> -------------
> Translates counter data to the standard Counter sysfs interface
> format and vice versa
>
> Driver ABI
> ==========
>
> This reimplementation entails several changes to the driver ABI. In
> particular, the device driver callbacks are now expected to handle
> standard C datatypes rather than translating the sysfs I/O directly.
>
> To that end, the struct counter_data structure is introduced to
> establish counter extensions for Signals, Synapses, and Counts:
>
> struct counter_data {
> enum counter_data_type type;
> const char *name;
> void *read;
Untyped read and write functions seem very likely to be prone to problems.
Perhaps use a union to make sure each of the function patterns is named
and can be explicitly set?
> void *write;
> void *priv;
> };
>
> The "type" member specifies the type of data (e.g. unsigned long,
> boolean, etc.) handled by this extension. The "read" and "write" members
> can then be set by the counter device driver with callbacks to handle
> that data.
>
> Convenience macros such as COUNTER_DATA_UNSIGNED_LONG are provided for
> use by driver authors. In particular, driver authors are expected to use
> the provided macros for standard Counter subsystem attributes in order
> to maintain a consistent interface for userspace. For example, a counter
> device driver may define several standard attributes like so:
>
> struct counter_data count_ext[] = {
> COUNTER_DATA_DIRECTION(count_direction_read),
> COUNTER_DATA_ENABLE(count_enable_read, count_enable_write),
> COUNTER_DATA_CEILING(count_ceiling_read, count_ceiling_write),
> };
>
> This makes it intuitive to see, add, and modify the attributes that are
> supported by this driver ("direction", "enable", and "ceiling") and to
> maintain this code without getting lost in a web of struct braces.
>
> Callbacks must match the function type expected for the respective
> component or extension. These types are defined in the
> drivers/counter/counter-function-types.h file.
>
> The corresponding prototypes for the callbacks would be:
>
> int count_direction_read(struct counter_device *counter,
> struct counter_count *count,
> enum counter_count_direction *direction);
> int count_enable_read(struct counter_device *counter,
> struct counter_count *count, bool *enable);
> int count_enable_write(struct counter_device *counter,
> struct counter_count *count, bool enable);
> int count_ceiling_read(struct counter_device *counter,
> struct counter_count *count,
> unsigned long *ceiling);
> int count_ceiling_write(struct counter_device *counter,
> struct counter_count *count,
> unsigned long ceiling);
Perhaps used explicit sizes rather than long which can vary
across different platforms. Starting out with 64 bits
seems like a good idea for counters.
>
> In this way, driver authors no longer need to mess with sysfs strings
> and are instead able to focus on what they actually care about doing --
> getting data to/from the devices -- while the Generic Counter interface
> handles the translation of that data for them between the various
> userspace interfaces (e.g. sysfs and chardev).
>
> Architecture
> ============
>
> Counter device registration is the same as before: drivers populate a
> struct counter_device with components and callbacks, then pass the
> structure to the devm_counter_register function. However, what's
> different now is how the Counter subsystem code handles this
> registration internally.
>
> Whereas before callbacks would interact directly with sysfs data, this
> interaction is now abstracted and instead callbacks interact with native
> C data types. The counter_data structure forms the basis for Counter
> extentions.
>
> The counter-sysfs.c file contains the code to parse through the
> counter_device structure and register the requested components and
> extensions. Attributes are created and populated based on type, with
> respective translation functions to handle the mapping between sysfs and
> the counter driver callbacks.
>
> The counter-sysfs-callbacks.c file contains the code to map between the
> abstract read and write callbacks of the counter driver and the more
> specific show and store callbacks expected for sysfs. This mapping is
> represented by the counter_data_sysfs_show and counter_data_sysfs_store
> arrays, which point to the show and store translation functions for each
> attribute.
>
> The translation performed for each attribute is straightforward: the
> attribute type and data is parsed from the counter_attribute structure,
> the respective counter driver read/write callback is cast, and sysfs
> I/O is handled before or after the driver read/write function is called.
>
> The counter-function-types.h file contains the typedefs to simplify this
> casting code. The counter-strings.h file contains the standard Counter
> sysfs I/O string constants to maintain a consistent interface for
> userspace.
>
> Cc: Syed Nayyar Waris <[email protected]>
> Cc: Patrick Havelange <[email protected]>
> Cc: Fabrice Gasnier <[email protected]>
> Cc: Maxime Coquelin <[email protected]>
> Cc: Alexandre Torgue <[email protected]>
> Cc: David Lechner <[email protected]>
> Signed-off-by: William Breathitt Gray <[email protected]>
Various specific comments inline.
In general, moving to a non string based interface seems to eventually happen
to all subsystems ;) Strings just don't lend themselves to flexible interfaces.
Basic approach looks reasonable to me.
Jonathan
> ---
> MAINTAINERS | 2 +-
> drivers/counter/104-quad-8.c | 437 +++---
> drivers/counter/Makefile | 1 +
> drivers/counter/counter-core.c | 190 +++
> drivers/counter/counter-function-types.h | 81 ++
> drivers/counter/counter-strings.h | 46 +
> drivers/counter/counter-sysfs-callbacks.c | 566 ++++++++
> drivers/counter/counter-sysfs-callbacks.h | 28 +
> drivers/counter/counter-sysfs.c | 524 ++++++++
> drivers/counter/counter-sysfs.h | 14 +
> drivers/counter/counter.c | 1496 ---------------------
> drivers/counter/ftm-quaddec.c | 46 +-
> drivers/counter/stm32-lptimer-cnt.c | 159 +--
> drivers/counter/stm32-timer-cnt.c | 132 +-
> drivers/counter/ti-eqep.c | 170 +--
> include/linux/counter.h | 545 +++-----
> include/linux/counter_enum.h | 45 -
> include/uapi/linux/counter-types.h | 67 +
> 18 files changed, 2130 insertions(+), 2419 deletions(-)
> create mode 100644 drivers/counter/counter-core.c
> create mode 100644 drivers/counter/counter-function-types.h
> create mode 100644 drivers/counter/counter-strings.h
> create mode 100644 drivers/counter/counter-sysfs-callbacks.c
> create mode 100644 drivers/counter/counter-sysfs-callbacks.h
> create mode 100644 drivers/counter/counter-sysfs.c
> create mode 100644 drivers/counter/counter-sysfs.h
> delete mode 100644 drivers/counter/counter.c
> delete mode 100644 include/linux/counter_enum.h
> create mode 100644 include/uapi/linux/counter-types.h
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 10eb348c801c..89def3fe1c76 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -4367,7 +4367,7 @@ F: Documentation/ABI/testing/sysfs-bus-counter*
> F: Documentation/driver-api/generic-counter.rst
> F: drivers/counter/
> F: include/linux/counter.h
> -F: include/linux/counter_enum.h
> +F: include/uapi/linux/counter-types.h
>
> CPMAC ETHERNET DRIVER
> M: Florian Fainelli <[email protected]>
> diff --git a/drivers/counter/104-quad-8.c b/drivers/counter/104-quad-8.c
> index 9dab190c49b0..bc1801e1bce9 100644
> --- a/drivers/counter/104-quad-8.c
> +++ b/drivers/counter/104-quad-8.c
> @@ -651,21 +651,22 @@ static int quad8_count_write(struct counter_device *counter,
> }
>
> enum quad8_count_function {
> - QUAD8_COUNT_FUNCTION_PULSE_DIRECTION = 0,
> - QUAD8_COUNT_FUNCTION_QUADRATURE_X1,
> - QUAD8_COUNT_FUNCTION_QUADRATURE_X2,
> - QUAD8_COUNT_FUNCTION_QUADRATURE_X4
> + QUAD8_COUNT_FUNCTION_PULSE_DIRECTION = COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
> + QUAD8_COUNT_FUNCTION_QUADRATURE_X1 = COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A,
> + QUAD8_COUNT_FUNCTION_QUADRATURE_X2 = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
> + QUAD8_COUNT_FUNCTION_QUADRATURE_X4 = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
Feels like you'd be better off just dropping the local enum entirely.
I guess it gives you a small amount of protection against undefined values,
but at cost of some otherwise pointless indirection.
> };
>
> -static enum counter_count_function quad8_count_functions_list[] = {
> - [QUAD8_COUNT_FUNCTION_PULSE_DIRECTION] = COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
> - [QUAD8_COUNT_FUNCTION_QUADRATURE_X1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A,
> - [QUAD8_COUNT_FUNCTION_QUADRATURE_X2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
> - [QUAD8_COUNT_FUNCTION_QUADRATURE_X4] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4
> +static const enum counter_count_function quad8_count_functions_list[] = {
> + QUAD8_COUNT_FUNCTION_PULSE_DIRECTION,
> + QUAD8_COUNT_FUNCTION_QUADRATURE_X1,
> + QUAD8_COUNT_FUNCTION_QUADRATURE_X2,
> + QUAD8_COUNT_FUNCTION_QUADRATURE_X4,
> };
>
> -static int quad8_function_get(struct counter_device *counter,
> - struct counter_count *count, size_t *function)
> +static int quad8_function_read(struct counter_device *counter,
> + struct counter_count *count,
> + enum counter_count_function *function)
> {
> const struct quad8_iio *const priv = counter->priv;
> const int id = count->id;
> @@ -690,11 +691,13 @@ static int quad8_function_get(struct counter_device *counter,
> return 0;
> }
>
> -static int quad8_function_set(struct counter_device *counter,
> - struct counter_count *count, size_t function)
> +static int quad8_function_write(struct counter_device *counter,
> + struct counter_count *count,
> + enum counter_count_function function)
> {
> struct quad8_iio *const priv = counter->priv;
> const int id = count->id;
> + const enum quad8_count_function cnt_function = function;
> unsigned int *const quadrature_mode = priv->quadrature_mode + id;
> unsigned int *const scale = priv->quadrature_scale + id;
> unsigned int mode_cfg = priv->count_mode[id] << 1;
> @@ -702,7 +705,7 @@ static int quad8_function_set(struct counter_device *counter,
> const unsigned int idr_cfg = priv->index_polarity[id] << 1;
> const int base_offset = priv->base + 2 * id + 1;
>
> - if (function == QUAD8_COUNT_FUNCTION_PULSE_DIRECTION) {
> + if (cnt_function == QUAD8_COUNT_FUNCTION_PULSE_DIRECTION) {
> *quadrature_mode = 0;
>
> /* Quadrature scaling only available in quadrature mode */
> @@ -717,7 +720,7 @@ static int quad8_function_set(struct counter_device *counter,
> } else {
> *quadrature_mode = 1;
>
> - switch (function) {
> + switch (cnt_function) {
> case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
> *scale = 0;
> mode_cfg |= QUAD8_CMR_QUADRATURE_X1;
> @@ -730,6 +733,7 @@ static int quad8_function_set(struct counter_device *counter,
> *scale = 2;
> mode_cfg |= QUAD8_CMR_QUADRATURE_X4;
> break;
> + default: return -EINVAL;
> }
> }
>
> @@ -739,8 +743,9 @@ static int quad8_function_set(struct counter_device *counter,
> return 0;
> }
>
> -static void quad8_direction_get(struct counter_device *counter,
> - struct counter_count *count, enum counter_count_direction *direction)
> +static int quad8_direction_read(struct counter_device *counter,
> + struct counter_count *count,
> + enum counter_count_direction *direction)
> {
> const struct quad8_iio *const priv = counter->priv;
> unsigned int ud_flag;
> @@ -751,91 +756,81 @@ static void quad8_direction_get(struct counter_device *counter,
>
> *direction = (ud_flag) ? COUNTER_COUNT_DIRECTION_FORWARD :
> COUNTER_COUNT_DIRECTION_BACKWARD;
> -}
>
> -enum quad8_synapse_action {
> - QUAD8_SYNAPSE_ACTION_NONE = 0,
> - QUAD8_SYNAPSE_ACTION_RISING_EDGE,
> - QUAD8_SYNAPSE_ACTION_FALLING_EDGE,
> - QUAD8_SYNAPSE_ACTION_BOTH_EDGES
> -};
> + return 0;
> +}
>
> -static enum counter_synapse_action quad8_index_actions_list[] = {
> - [QUAD8_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
> - [QUAD8_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE
> +static const enum counter_synapse_action quad8_index_actions_list[] = {
> + COUNTER_SYNAPSE_ACTION_NONE,
> + COUNTER_SYNAPSE_ACTION_RISING_EDGE,
> };
>
> -static enum counter_synapse_action quad8_synapse_actions_list[] = {
> - [QUAD8_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
> - [QUAD8_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
> - [QUAD8_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
> - [QUAD8_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES
> +static const enum counter_synapse_action quad8_synapse_actions_list[] = {
> + COUNTER_SYNAPSE_ACTION_NONE,
> + COUNTER_SYNAPSE_ACTION_RISING_EDGE,
> + COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
> + COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
> };
>
> -static int quad8_action_get(struct counter_device *counter,
> - struct counter_count *count, struct counter_synapse *synapse,
> - size_t *action)
> +static int quad8_action_read(struct counter_device *counter,
> + struct counter_count *count,
> + struct counter_synapse *synapse,
> + enum counter_synapse_action *action)
> {
> struct quad8_iio *const priv = counter->priv;
> int err;
> - size_t function = 0;
> + enum counter_count_function function = 0;
> const size_t signal_a_id = count->synapses[0].signal->id;
> enum counter_count_direction direction;
>
> /* Handle Index signals */
> if (synapse->signal->id >= 16) {
> if (priv->preset_enable[count->id])
> - *action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
> + *action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
> else
> - *action = QUAD8_SYNAPSE_ACTION_NONE;
> + *action = COUNTER_SYNAPSE_ACTION_NONE;
>
> return 0;
> }
>
> - err = quad8_function_get(counter, count, &function);
> + err = quad8_function_read(counter, count, &function);
> if (err)
> return err;
>
> /* Default action mode */
> - *action = QUAD8_SYNAPSE_ACTION_NONE;
> + *action = COUNTER_SYNAPSE_ACTION_NONE;
>
> /* Determine action mode based on current count function mode */
> switch (function) {
> case QUAD8_COUNT_FUNCTION_PULSE_DIRECTION:
> if (synapse->signal->id == signal_a_id)
> - *action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
> + *action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
> break;
> case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
> if (synapse->signal->id == signal_a_id) {
> - quad8_direction_get(counter, count, &direction);
> + err = quad8_direction_read(counter, count, &direction);
> + if (err)
> + return err;
>
> if (direction == COUNTER_COUNT_DIRECTION_FORWARD)
> - *action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
> + *action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
> else
> - *action = QUAD8_SYNAPSE_ACTION_FALLING_EDGE;
> + *action = COUNTER_SYNAPSE_ACTION_FALLING_EDGE;
> }
> break;
> case QUAD8_COUNT_FUNCTION_QUADRATURE_X2:
> if (synapse->signal->id == signal_a_id)
> - *action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
> + *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
> break;
> case QUAD8_COUNT_FUNCTION_QUADRATURE_X4:
> - *action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
> + *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
> break;
> + default: return -EINVAL;
> }
>
> return 0;
> }
>
> -static const struct counter_ops quad8_ops = {
> - .signal_read = quad8_signal_read,
> - .count_read = quad8_count_read,
> - .count_write = quad8_count_write,
> - .function_get = quad8_function_get,
> - .function_set = quad8_function_set,
> - .action_get = quad8_action_get
> -};
> -
> static int quad8_index_polarity_get(struct counter_device *counter,
> struct counter_signal *signal, size_t *index_polarity)
> {
> @@ -864,12 +859,7 @@ static int quad8_index_polarity_set(struct counter_device *counter,
> return 0;
> }
>
> -static struct counter_signal_enum_ext quad8_index_pol_enum = {
> - .items = quad8_index_polarity_modes,
> - .num_items = ARRAY_SIZE(quad8_index_polarity_modes),
> - .get = quad8_index_polarity_get,
> - .set = quad8_index_polarity_set
> -};
> +static DEFINE_COUNTER_ENUM(quad8_index_pol_enum, quad8_index_polarity_modes);
>
> static int quad8_synchronous_mode_get(struct counter_device *counter,
> struct counter_signal *signal, size_t *synchronous_mode)
> @@ -903,22 +893,21 @@ static int quad8_synchronous_mode_set(struct counter_device *counter,
> return 0;
> }
>
> -static struct counter_signal_enum_ext quad8_syn_mode_enum = {
> - .items = quad8_synchronous_modes,
> - .num_items = ARRAY_SIZE(quad8_synchronous_modes),
> - .get = quad8_synchronous_mode_get,
> - .set = quad8_synchronous_mode_set
> -};
> +static DEFINE_COUNTER_ENUM(quad8_syn_mode_enum, quad8_synchronous_modes);
>
> -static ssize_t quad8_count_floor_read(struct counter_device *counter,
> - struct counter_count *count, void *private, char *buf)
> +static int quad8_count_floor_read(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long *floor)
> {
> /* Only a floor of 0 is supported */
> - return sprintf(buf, "0\n");
> + *floor = 0;
> +
> + return 0;
> }
>
> -static int quad8_count_mode_get(struct counter_device *counter,
> - struct counter_count *count, size_t *cnt_mode)
> +static int quad8_count_mode_read(struct counter_device *counter,
> + struct counter_count *count,
> + enum counter_count_mode *cnt_mode)
> {
> const struct quad8_iio *const priv = counter->priv;
>
> @@ -941,33 +930,35 @@ static int quad8_count_mode_get(struct counter_device *counter,
> return 0;
> }
>
> -static int quad8_count_mode_set(struct counter_device *counter,
> - struct counter_count *count, size_t cnt_mode)
> +static int quad8_count_mode_write(struct counter_device *counter,
> + struct counter_count *count,
> + enum counter_count_mode cnt_mode)
> {
> struct quad8_iio *const priv = counter->priv;
> + unsigned int count_mode = 0;
> unsigned int mode_cfg;
> const int base_offset = priv->base + 2 * count->id + 1;
>
> /* Map Generic Counter count mode to 104-QUAD-8 count mode */
> switch (cnt_mode) {
> case COUNTER_COUNT_MODE_NORMAL:
> - cnt_mode = 0;
> + count_mode = 0;
> break;
> case COUNTER_COUNT_MODE_RANGE_LIMIT:
> - cnt_mode = 1;
> + count_mode = 1;
> break;
> case COUNTER_COUNT_MODE_NON_RECYCLE:
> - cnt_mode = 2;
> + count_mode = 2;
> break;
> case COUNTER_COUNT_MODE_MODULO_N:
> - cnt_mode = 3;
> + count_mode = 3;
> break;
> }
>
> - priv->count_mode[count->id] = cnt_mode;
> + priv->count_mode[count->id] = count_mode;
>
> /* Set count mode configuration value */
> - mode_cfg = cnt_mode << 1;
> + mode_cfg = count_mode << 1;
>
> /* Add quadrature mode configuration */
> if (priv->quadrature_mode[count->id])
> @@ -979,92 +970,89 @@ static int quad8_count_mode_set(struct counter_device *counter,
> return 0;
> }
>
> -static struct counter_count_enum_ext quad8_cnt_mode_enum = {
> - .items = counter_count_mode_str,
> - .num_items = ARRAY_SIZE(counter_count_mode_str),
> - .get = quad8_count_mode_get,
> - .set = quad8_count_mode_set
> +static enum counter_count_mode quad8_cnt_modes[] = {
> + COUNTER_COUNT_MODE_NORMAL,
> + COUNTER_COUNT_MODE_RANGE_LIMIT,
> + COUNTER_COUNT_MODE_NON_RECYCLE,
> + COUNTER_COUNT_MODE_MODULO_N,
> };
>
> -static ssize_t quad8_count_direction_read(struct counter_device *counter,
> - struct counter_count *count, void *priv, char *buf)
> -{
> - enum counter_count_direction dir;
> -
> - quad8_direction_get(counter, count, &dir);
> -
> - return sprintf(buf, "%s\n", counter_count_direction_str[dir]);
> -}
> +static DEFINE_COUNTER_AVAILABLE(quad8_count_mode_available, quad8_cnt_modes);
>
> -static ssize_t quad8_count_enable_read(struct counter_device *counter,
> - struct counter_count *count, void *private, char *buf)
> +static int quad8_count_enable_read(struct counter_device *counter,
> + struct counter_count *count, bool *enable)
> {
> const struct quad8_iio *const priv = counter->priv;
>
> - return sprintf(buf, "%u\n", priv->ab_enable[count->id]);
> + *enable = priv->ab_enable[count->id];
> +
> + return 0;
> }
>
> -static ssize_t quad8_count_enable_write(struct counter_device *counter,
> - struct counter_count *count, void *private, const char *buf, size_t len)
> +static int quad8_count_enable_write(struct counter_device *counter,
> + struct counter_count *count, bool enable)
> {
> struct quad8_iio *const priv = counter->priv;
> const int base_offset = priv->base + 2 * count->id;
> - int err;
> - bool ab_enable;
> unsigned int ior_cfg;
>
> - err = kstrtobool(buf, &ab_enable);
> - if (err)
> - return err;
> + priv->ab_enable[count->id] = enable;
>
> - priv->ab_enable[count->id] = ab_enable;
> -
> - ior_cfg = ab_enable | priv->preset_enable[count->id] << 1;
> + ior_cfg = enable | priv->preset_enable[count->id] << 1;
>
> /* Load I/O control configuration */
> outb(QUAD8_CTR_IOR | ior_cfg, base_offset + 1);
>
> - return len;
> + return 0;
> }
>
> -static int quad8_error_noise_get(struct counter_device *counter,
> - struct counter_count *count, size_t *noise_error)
> +static ssize_t quad8_error_noise_read(struct counter_device *counter,
> + struct counter_count *count, char *buf,
> + size_t size)
> {
> const struct quad8_iio *const priv = counter->priv;
> const int base_offset = priv->base + 2 * count->id + 1;
> + size_t noise_error;
>
> - *noise_error = !!(inb(base_offset) & QUAD8_FLAG_E);
> + noise_error = !!(inb(base_offset) & QUAD8_FLAG_E);
>
> - return 0;
> + return snprintf(buf, size, "%s\n",
> + quad8_noise_error_states[noise_error]);
> }
>
> -static struct counter_count_enum_ext quad8_error_noise_enum = {
> - .items = quad8_noise_error_states,
> - .num_items = ARRAY_SIZE(quad8_noise_error_states),
> - .get = quad8_error_noise_get
> -};
> +static ssize_t quad8_error_noise_available_read(struct counter_device *counter,
> + struct counter_count *count,
> + char *buf, size_t size)
> +{
> + size_t i;
> + size_t len = 0;
>
> -static ssize_t quad8_count_preset_read(struct counter_device *counter,
> - struct counter_count *count, void *private, char *buf)
> + for (i = 0; i < ARRAY_SIZE(quad8_noise_error_states) && size > 1; i++)
> + len += scnprintf(buf + len, size - len, "%s\n",
> + quad8_noise_error_states[i]);
> +
> + return len;
> +}
> +
> +static int quad8_count_preset_read(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long *preset)
> {
> const struct quad8_iio *const priv = counter->priv;
>
> - return sprintf(buf, "%u\n", priv->preset[count->id]);
> + *preset = priv->preset[count->id];
> +
> + return 0;
> }
>
> -static ssize_t quad8_count_preset_write(struct counter_device *counter,
> - struct counter_count *count, void *private, const char *buf, size_t len)
> +static int quad8_count_preset_write(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long preset)
> {
> struct quad8_iio *const priv = counter->priv;
> const int base_offset = priv->base + 2 * count->id;
> - unsigned int preset;
> - int ret;
> int i;
>
> - ret = kstrtouint(buf, 0, &preset);
> - if (ret)
> - return ret;
> -
> /* Only 24-bit values are supported */
> if (preset > 0xFFFFFF)
> return -EINVAL;
> @@ -1078,11 +1066,12 @@ static ssize_t quad8_count_preset_write(struct counter_device *counter,
> for (i = 0; i < 3; i++)
> outb(preset >> (8 * i), base_offset);
>
> - return len;
> + return 0;
> }
>
> -static ssize_t quad8_count_ceiling_read(struct counter_device *counter,
> - struct counter_count *count, void *private, char *buf)
> +static int quad8_count_ceiling_read(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long *ceiling)
> {
> const struct quad8_iio *const priv = counter->priv;
>
> @@ -1090,15 +1079,18 @@ static ssize_t quad8_count_ceiling_read(struct counter_device *counter,
> switch (priv->count_mode[count->id]) {
> case 1:
> case 3:
> - return quad8_count_preset_read(counter, count, private, buf);
> + return quad8_count_preset_read(counter, count, ceiling);
> }
>
> /* By default 0x1FFFFFF (25 bits unsigned) is maximum count */
> - return sprintf(buf, "33554431\n");
> + *ceiling = 0x1FFFFFF;
> +
> + return 0;
> }
>
> -static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
> - struct counter_count *count, void *private, const char *buf, size_t len)
> +static int quad8_count_ceiling_write(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long ceiling)
> {
> struct quad8_iio *const priv = counter->priv;
>
> @@ -1106,34 +1098,31 @@ static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
> switch (priv->count_mode[count->id]) {
> case 1:
> case 3:
> - return quad8_count_preset_write(counter, count, private, buf,
> - len);
> + return quad8_count_preset_write(counter, count, ceiling);
> }
>
> - return len;
> + return -EINVAL;
> }
>
> -static ssize_t quad8_count_preset_enable_read(struct counter_device *counter,
> - struct counter_count *count, void *private, char *buf)
> +static int quad8_count_preset_enable_read(struct counter_device *counter,
> + struct counter_count *count,
> + bool *preset_enable)
> {
> const struct quad8_iio *const priv = counter->priv;
>
> - return sprintf(buf, "%u\n", !priv->preset_enable[count->id]);
> + *preset_enable = !priv->preset_enable[count->id];
> +
> + return 0;
> }
>
> -static ssize_t quad8_count_preset_enable_write(struct counter_device *counter,
> - struct counter_count *count, void *private, const char *buf, size_t len)
> +static int quad8_count_preset_enable_write(struct counter_device *counter,
> + struct counter_count *count,
> + bool preset_enable)
> {
> struct quad8_iio *const priv = counter->priv;
> const int base_offset = priv->base + 2 * count->id + 1;
> - bool preset_enable;
> - int ret;
> unsigned int ior_cfg;
>
> - ret = kstrtobool(buf, &preset_enable);
> - if (ret)
> - return ret;
> -
> /* Preset enable is active low in Input/Output Control register */
> preset_enable = !preset_enable;
>
> @@ -1144,18 +1133,16 @@ static ssize_t quad8_count_preset_enable_write(struct counter_device *counter,
> /* Load I/O control configuration to Input / Output Control Register */
> outb(QUAD8_CTR_IOR | ior_cfg, base_offset);
>
> - return len;
> + return 0;
> }
>
> -static ssize_t quad8_signal_cable_fault_read(struct counter_device *counter,
> - struct counter_signal *signal,
> - void *private, char *buf)
> +static int quad8_signal_cable_fault_read(struct counter_device *counter,
> + struct counter_signal *signal, bool *cable_fault)
> {
> const struct quad8_iio *const priv = counter->priv;
> const size_t channel_id = signal->id / 2;
> const bool disabled = !(priv->cable_fault_enable & BIT(channel_id));
> unsigned int status;
> - unsigned int fault;
>
> if (disabled)
> return -EINVAL;
> @@ -1164,36 +1151,29 @@ static ssize_t quad8_signal_cable_fault_read(struct counter_device *counter,
> status = inb(priv->base + QUAD8_DIFF_ENCODER_CABLE_STATUS);
>
> /* Mask respective channel and invert logic */
> - fault = !(status & BIT(channel_id));
> + *cable_fault = !(status & BIT(channel_id));
>
> - return sprintf(buf, "%u\n", fault);
> + return 0;
> }
>
> -static ssize_t quad8_signal_cable_fault_enable_read(
> - struct counter_device *counter, struct counter_signal *signal,
> - void *private, char *buf)
> +static int quad8_signal_cable_fault_enable_read(struct counter_device *counter,
> + struct counter_signal *signal, bool *enable)
> {
> const struct quad8_iio *const priv = counter->priv;
> const size_t channel_id = signal->id / 2;
> - const unsigned int enb = !!(priv->cable_fault_enable & BIT(channel_id));
>
> - return sprintf(buf, "%u\n", enb);
> + *enable = !!(priv->cable_fault_enable & BIT(channel_id));
> +
> + return 0;
> }
>
> -static ssize_t quad8_signal_cable_fault_enable_write(
> - struct counter_device *counter, struct counter_signal *signal,
> - void *private, const char *buf, size_t len)
> +static int quad8_signal_cable_fault_enable_write(struct counter_device *counter,
> + struct counter_signal *signal, bool enable)
> {
> struct quad8_iio *const priv = counter->priv;
> const size_t channel_id = signal->id / 2;
> - bool enable;
> - int ret;
> unsigned int cable_fault_enable;
>
> - ret = kstrtobool(buf, &enable);
> - if (ret)
> - return ret;
> -
> if (enable)
> priv->cable_fault_enable |= BIT(channel_id);
> else
> @@ -1204,31 +1184,29 @@ static ssize_t quad8_signal_cable_fault_enable_write(
>
> outb(cable_fault_enable, priv->base + QUAD8_DIFF_ENCODER_CABLE_STATUS);
>
> - return len;
> + return 0;
> }
>
> -static ssize_t quad8_signal_fck_prescaler_read(struct counter_device *counter,
> - struct counter_signal *signal, void *private, char *buf)
> +static int quad8_signal_fck_prescaler_read(struct counter_device *counter,
> + struct counter_signal *signal, unsigned long *prescaler)
> {
> const struct quad8_iio *const priv = counter->priv;
> - const size_t channel_id = signal->id / 2;
>
> - return sprintf(buf, "%u\n", priv->fck_prescaler[channel_id]);
> + *prescaler = priv->fck_prescaler[signal->id / 2];
> +
> + return 0;
> }
>
> -static ssize_t quad8_signal_fck_prescaler_write(struct counter_device *counter,
> - struct counter_signal *signal, void *private, const char *buf,
> - size_t len)
> +static int quad8_signal_fck_prescaler_write(struct counter_device *counter,
> + struct counter_signal *signal, unsigned long prescaler)
> {
> struct quad8_iio *const priv = counter->priv;
> const size_t channel_id = signal->id / 2;
> const int base_offset = priv->base + 2 * channel_id;
> - u8 prescaler;
> - int ret;
>
> - ret = kstrtou8(buf, 0, &prescaler);
> - if (ret)
> - return ret;
> + /* prescaler is an 8-bit value */
> + if (prescaler > 255)
> + return -ERANGE;
>
> priv->fck_prescaler[channel_id] = prescaler;
>
> @@ -1240,31 +1218,28 @@ static ssize_t quad8_signal_fck_prescaler_write(struct counter_device *counter,
> outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_BP | QUAD8_RLD_PRESET_PSC,
> base_offset + 1);
>
> - return len;
> + return 0;
> }
>
> -static const struct counter_signal_ext quad8_signal_ext[] = {
> - {
> - .name = "cable_fault",
> - .read = quad8_signal_cable_fault_read
> - },
> - {
> - .name = "cable_fault_enable",
> - .read = quad8_signal_cable_fault_enable_read,
> - .write = quad8_signal_cable_fault_enable_write
> - },
> - {
> - .name = "filter_clock_prescaler",
> - .read = quad8_signal_fck_prescaler_read,
> - .write = quad8_signal_fck_prescaler_write
> - }
> +static struct counter_data quad8_signal_ext[] = {
> + COUNTER_DATA_BOOL("cable_fault", quad8_signal_cable_fault_read, NULL),
> + COUNTER_DATA_BOOL("cable_fault_enable",
> + quad8_signal_cable_fault_enable_read,
> + quad8_signal_cable_fault_enable_write),
> + COUNTER_DATA_UNSIGNED_LONG("filter_clock_prescaler",
> + quad8_signal_fck_prescaler_read,
> + quad8_signal_fck_prescaler_write)
> };
>
> -static const struct counter_signal_ext quad8_index_ext[] = {
> - COUNTER_SIGNAL_ENUM("index_polarity", &quad8_index_pol_enum),
> - COUNTER_SIGNAL_ENUM_AVAILABLE("index_polarity", &quad8_index_pol_enum),
> - COUNTER_SIGNAL_ENUM("synchronous_mode", &quad8_syn_mode_enum),
> - COUNTER_SIGNAL_ENUM_AVAILABLE("synchronous_mode", &quad8_syn_mode_enum)
> +static struct counter_data quad8_index_ext[] = {
> + COUNTER_DATA_ENUM_AND_AVAILABLE("index_polarity",
> + quad8_index_polarity_get,
> + quad8_index_polarity_set,
> + quad8_index_pol_enum),
> + COUNTER_DATA_ENUM_AND_AVAILABLE("synchronous_mode",
> + quad8_synchronous_mode_get,
> + quad8_synchronous_mode_set,
> + quad8_syn_mode_enum),
> };
>
> #define QUAD8_QUAD_SIGNAL(_id, _name) { \
> @@ -1333,39 +1308,20 @@ static struct counter_synapse quad8_count_synapses[][3] = {
> QUAD8_COUNT_SYNAPSES(6), QUAD8_COUNT_SYNAPSES(7)
> };
>
> -static const struct counter_count_ext quad8_count_ext[] = {
> - {
> - .name = "ceiling",
> - .read = quad8_count_ceiling_read,
> - .write = quad8_count_ceiling_write
> - },
> - {
> - .name = "floor",
> - .read = quad8_count_floor_read
> - },
> - COUNTER_COUNT_ENUM("count_mode", &quad8_cnt_mode_enum),
> - COUNTER_COUNT_ENUM_AVAILABLE("count_mode", &quad8_cnt_mode_enum),
> - {
> - .name = "direction",
> - .read = quad8_count_direction_read
> - },
> - {
> - .name = "enable",
> - .read = quad8_count_enable_read,
> - .write = quad8_count_enable_write
> - },
> - COUNTER_COUNT_ENUM("error_noise", &quad8_error_noise_enum),
> - COUNTER_COUNT_ENUM_AVAILABLE("error_noise", &quad8_error_noise_enum),
> - {
> - .name = "preset",
> - .read = quad8_count_preset_read,
> - .write = quad8_count_preset_write
> - },
> - {
> - .name = "preset_enable",
> - .read = quad8_count_preset_enable_read,
> - .write = quad8_count_preset_enable_write
> - }
> +static struct counter_data quad8_count_ext[] = {
> + COUNTER_DATA_CEILING(quad8_count_ceiling_read,
> + quad8_count_ceiling_write),
> + COUNTER_DATA_FLOOR(quad8_count_floor_read, NULL),
> + COUNTER_DATA_COUNT_MODE_AND_AVAILABLE(quad8_count_mode_read,
> + quad8_count_mode_write,
> + quad8_count_mode_available),
> + COUNTER_DATA_DIRECTION(quad8_direction_read),
> + COUNTER_DATA_ENABLE(quad8_count_enable_read, quad8_count_enable_write),
> + COUNTER_DATA_ERROR_NOISE_AND_AVAILABLE(quad8_error_noise_read,
> + quad8_error_noise_available_read),
> + COUNTER_DATA_PRESET(quad8_count_preset_read, quad8_count_preset_write),
> + COUNTER_DATA_PRESET_ENABLE(quad8_count_preset_enable_read,
> + quad8_count_preset_enable_write),
> };
>
> #define QUAD8_COUNT(_id, _cntname) { \
> @@ -1421,7 +1377,12 @@ static int quad8_probe(struct device *dev, unsigned int id)
> quad8iio = iio_priv(indio_dev);
> quad8iio->counter.name = dev_name(dev);
> quad8iio->counter.parent = dev;
> - quad8iio->counter.ops = &quad8_ops;
> + quad8iio->counter.signal_read = quad8_signal_read;
> + quad8iio->counter.count_read = quad8_count_read;
> + quad8iio->counter.count_write = quad8_count_write;
> + quad8iio->counter.function_read = quad8_function_read;
> + quad8iio->counter.function_write = quad8_function_write;
> + quad8iio->counter.action_read = quad8_action_read;
> quad8iio->counter.counts = quad8_counts;
> quad8iio->counter.num_counts = ARRAY_SIZE(quad8_counts);
> quad8iio->counter.signals = quad8_signals;
> diff --git a/drivers/counter/Makefile b/drivers/counter/Makefile
> index 55142d1f4c43..2d2644bd7777 100644
> --- a/drivers/counter/Makefile
> +++ b/drivers/counter/Makefile
> @@ -4,6 +4,7 @@
> #
>
> obj-$(CONFIG_COUNTER) += counter.o
> +counter-y := counter-core.o counter-sysfs.o counter-sysfs-callbacks.o
>
> obj-$(CONFIG_104_QUAD_8) += 104-quad-8.o
> obj-$(CONFIG_STM32_TIMER_CNT) += stm32-timer-cnt.o
> diff --git a/drivers/counter/counter-core.c b/drivers/counter/counter-core.c
> new file mode 100644
> index 000000000000..008d51284a2c
> --- /dev/null
> +++ b/drivers/counter/counter-core.c
> @@ -0,0 +1,190 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Generic Counter interface
> + * Copyright (C) 2020 William Breathitt Gray
> + */
> +#include <linux/counter.h>
> +#include <linux/device.h>
> +#include <linux/err.h>
> +#include <linux/export.h>
> +#include <linux/gfp.h>
> +#include <linux/idr.h>
> +#include <linux/init.h>
> +#include <linux/module.h>
> +#include <linux/slab.h>
> +
> +#include "counter-sysfs.h"
> +
> +/* Provides a unique ID for each counter device */
> +static DEFINE_IDA(counter_ida);
> +
> +static void counter_device_release(struct device *dev)
> +{
> + struct counter_device *const counter = dev_get_drvdata(dev);
> +
> + counter_sysfs_free(counter);
> + kfree(&counter->dev);
> + ida_simple_remove(&counter_ida, counter->id);
> +}
> +
> +static struct device_type counter_device_type = {
> + .name = "counter_device",
> + .release = counter_device_release
> +};
> +
> +static struct bus_type counter_bus_type = {
> + .name = "counter"
> +};
> +
> +/**
> + * counter_register - register Counter to the system
> + * @counter: pointer to Counter to register
> + *
> + * This function registers a Counter to the system. A sysfs "counter" directory
> + * will be created and populated with sysfs attributes correlating with the
> + * Counter Signals, Synapses, and Counts respectively.
> + */
> +int counter_register(struct counter_device *const counter)
> +{
> + struct device *const dev = &counter->dev;
> + int err;
> +
> + /* Acquire unique ID */
> + counter->id = ida_simple_get(&counter_ida, 0, 0, GFP_KERNEL);
> + if (counter->id < 0)
> + return counter->id;
> +
> + /* Configure device structure for Counter */
> + dev->type = &counter_device_type;
> + dev->bus = &counter_bus_type;
> + if (counter->parent) {
> + dev->parent = counter->parent;
> + dev->of_node = counter->parent->of_node;
> + }
> + dev_set_name(dev, "counter%d", counter->id);
> + device_initialize(dev);
> + dev_set_drvdata(dev, counter);
> +
> + /* Add Counter sysfs attributes */
> + err = counter_sysfs_add(counter);
> + if (err)
> + goto err_free_id;
> +
> + /* Add device to system */
> + err = device_add(dev);
> + if (err)
> + goto err_free_sysfs;
> +
> + return 0;
> +
> +err_free_sysfs:
> + counter_sysfs_free(counter);
> +err_free_id:
> + ida_simple_remove(&counter_ida, counter->id);
> + return err;
> +}
> +EXPORT_SYMBOL_GPL(counter_register);
> +
> +/**
> + * counter_unregister - unregister Counter from the system
> + * @counter: pointer to Counter to unregister
> + *
> + * The Counter is unregistered from the system; all allocated memory is freed.
> + */
> +void counter_unregister(struct counter_device *const counter)
> +{
> + if (counter) {
> + device_del(&counter->dev);
> + counter_sysfs_free(counter);
> + }
> +}
> +EXPORT_SYMBOL_GPL(counter_unregister);
> +
> +static void devm_counter_unreg(struct device *dev, void *res)
> +{
> + counter_unregister(*(struct counter_device **)res);
> +}
> +
> +/**
> + * devm_counter_register - Resource-managed counter_register
> + * @dev: device to allocate counter_device for
> + * @counter: pointer to Counter to register
> + *
> + * Managed counter_register. The Counter registered with this function is
> + * automatically unregistered on driver detach. This function calls
> + * counter_register internally. Refer to that function for more information.
> + *
> + * If an Counter registered with this function needs to be unregistered
> + * separately, devm_counter_unregister must be used.
> + *
> + * RETURNS:
> + * 0 on success, negative error number on failure.
> + */
> +int devm_counter_register(struct device *dev,
> + struct counter_device *const counter)
> +{
> + struct counter_device **ptr;
> + int ret;
> +
> + ptr = devres_alloc(devm_counter_unreg, sizeof(*ptr), GFP_KERNEL);
> + if (!ptr)
> + return -ENOMEM;
> +
> + ret = counter_register(counter);
> + if (!ret) {
> + *ptr = counter;
> + devres_add(dev, ptr);
> + } else {
> + devres_free(ptr);
> + }
> +
> + return ret;
> +}
> +EXPORT_SYMBOL_GPL(devm_counter_register);
> +
> +static int devm_counter_match(struct device *dev, void *res, void *data)
> +{
> + struct counter_device **r = res;
> +
> + if (!r || !*r) {
> + WARN_ON(!r || !*r);
> + return 0;
> + }
> +
> + return *r == data;
> +}
> +
> +/**
> + * devm_counter_unregister - Resource-managed counter_unregister
Having just gone through the process of ripping all these out of IIO, is
there actually a valid reason why devm_counter_unregister would ever
be called?
> + * @dev: device this counter_device belongs to
> + * @counter: pointer to Counter associated with the device
> + *
> + * Unregister Counter registered with devm_counter_register.
> + */
> +void devm_counter_unregister(struct device *dev,
> + struct counter_device *const counter)
> +{
> + int rc;
> +
> + rc = devres_release(dev, devm_counter_unreg, devm_counter_match,
> + counter);
> + WARN_ON(rc);
> +}
> +EXPORT_SYMBOL_GPL(devm_counter_unregister);
> +
> +static int __init counter_init(void)
> +{
> + return bus_register(&counter_bus_type);
> +}
> +
> +static void __exit counter_exit(void)
> +{
> + bus_unregister(&counter_bus_type);
> +}
> +
> +subsys_initcall(counter_init);
> +module_exit(counter_exit);
> +
> +MODULE_AUTHOR("William Breathitt Gray <[email protected]>");
> +MODULE_DESCRIPTION("Generic Counter interface");
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/counter/counter-function-types.h b/drivers/counter/counter-function-types.h
> new file mode 100644
> index 000000000000..1a67b3904193
> --- /dev/null
> +++ b/drivers/counter/counter-function-types.h
> @@ -0,0 +1,81 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * Counter callback function types
> + * Copyright (C) 2020 William Breathitt Gray
> + */
> +#ifndef _COUNTER_FUNCTION_TYPES_H_
> +#define _COUNTER_FUNCTION_TYPES_H_
> +
> +#include <linux/counter.h>
> +#include <linux/types.h>
> +
> +#define COUNTER_DATA_CALLBACKS(_name, _type) \
> + typedef int (*counter_count_##_name##_read)(struct counter_device *, \
> + struct counter_count *, \
> + _type *); \
> + typedef int (*counter_count_##_name##_write)(struct counter_device *, \
> + struct counter_count *, \
> + _type); \
> + typedef int (*counter_device_##_name##_read)(struct counter_device *, \
> + _type *); \
> + typedef int (*counter_device_##_name##_write)(struct counter_device *, \
> + _type); \
> + typedef int (*counter_signal_##_name##_read)(struct counter_device *, \
> + struct counter_signal *, \
> + _type *); \
> + typedef int (*counter_signal_##_name##_write)(struct counter_device *, \
> + struct counter_signal *, \
> + _type)
> +
> +COUNTER_DATA_CALLBACKS(bool, bool);
> +COUNTER_DATA_CALLBACKS(lu, unsigned long);
> +COUNTER_DATA_CALLBACKS(zu, size_t);
> +
> +typedef ssize_t (*counter_count_s_read)(struct counter_device *,
> + struct counter_count *, char *, size_t);
> +typedef ssize_t (*counter_count_s_write)(struct counter_device *,
> + struct counter_count *, const char *,
> + size_t);
> +typedef ssize_t (*counter_device_s_read)(struct counter_device *, char *,
> + size_t);
> +typedef ssize_t (*counter_device_s_write)(struct counter_device *, const char *,
> + size_t);
> +typedef ssize_t (*counter_signal_s_read)(struct counter_device *,
> + struct counter_signal *, char *,
> + size_t);
> +typedef ssize_t (*counter_signal_s_write)(struct counter_device *,
> + struct counter_signal *, const char *,
> + size_t);
> +
> +typedef int (*counter_count_function_read)(struct counter_device *,
> + struct counter_count *,
> + enum counter_count_function *);
> +typedef int (*counter_count_function_write)(struct counter_device *,
> + struct counter_count *,
> + enum counter_count_function);
> +
> +typedef int (*counter_signal_signal_read)(struct counter_device *,
> + struct counter_signal *,
> + enum counter_signal_value *);
> +
> +typedef int (*counter_synapse_action_read)(struct counter_device *,
> + struct counter_count *,
> + struct counter_synapse *,
> + enum counter_synapse_action *);
> +typedef int (*counter_synapse_action_write)(struct counter_device *,
> + struct counter_count *,
> + struct counter_synapse *,
> + enum counter_synapse_action);
> +
> +typedef int (*counter_count_direction_read)(struct counter_device *,
> + struct counter_count *,
> + enum counter_count_direction *);
> +
> +typedef int (*counter_count_mode_read)(struct counter_device *,
> + struct counter_count *,
> + enum counter_count_mode *);
> +typedef int (*counter_count_mode_write)(struct counter_device *,
> + struct counter_count *,
> + enum counter_count_mode);
> +
> +#endif /* _COUNTER_FUNCTION_TYPES_H_ */
> diff --git a/drivers/counter/counter-strings.h b/drivers/counter/counter-strings.h
> new file mode 100644
> index 000000000000..d67788e01bb9
> --- /dev/null
> +++ b/drivers/counter/counter-strings.h
Give you are centralising the handling of these, I'd be a bit surprised to ever
see this included from more than one file. As such, I'd just put it in the
c files that uses it.
> @@ -0,0 +1,46 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * Generic Counter strings
> + * Copyright (C) 2020 William Breathitt Gray
> + */
> +#ifndef _COUNTER_STRINGS_H_
> +#define _COUNTER_STRINGS_H_
> +
> +#include <linux/counter.h>
> +
> +const char *const counter_count_direction_str[] = {
> + [COUNTER_COUNT_DIRECTION_FORWARD] = "forward",
> + [COUNTER_COUNT_DIRECTION_BACKWARD] = "backward"
> +};
> +
> +const char *const counter_count_function_str[] = {
> + [COUNTER_COUNT_FUNCTION_INCREASE] = "increase",
> + [COUNTER_COUNT_FUNCTION_DECREASE] = "decrease",
> + [COUNTER_COUNT_FUNCTION_PULSE_DIRECTION] = "pulse-direction",
> + [COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A] = "quadrature x1 a",
> + [COUNTER_COUNT_FUNCTION_QUADRATURE_X1_B] = "quadrature x1 b",
> + [COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A] = "quadrature x2 a",
> + [COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B] = "quadrature x2 b",
> + [COUNTER_COUNT_FUNCTION_QUADRATURE_X4] = "quadrature x4"
> +};
> +
> +const char *const counter_count_mode_str[] = {
> + [COUNTER_COUNT_MODE_NORMAL] = "normal",
> + [COUNTER_COUNT_MODE_RANGE_LIMIT] = "range limit",
> + [COUNTER_COUNT_MODE_NON_RECYCLE] = "non-recycle",
> + [COUNTER_COUNT_MODE_MODULO_N] = "modulo-n"
> +};
> +
> +const char *const counter_signal_value_str[] = {
> + [COUNTER_SIGNAL_LOW] = "low",
> + [COUNTER_SIGNAL_HIGH] = "high"
> +};
> +
> +const char *const counter_synapse_action_str[] = {
> + [COUNTER_SYNAPSE_ACTION_NONE] = "none",
> + [COUNTER_SYNAPSE_ACTION_RISING_EDGE] = "rising edge",
> + [COUNTER_SYNAPSE_ACTION_FALLING_EDGE] = "falling edge",
> + [COUNTER_SYNAPSE_ACTION_BOTH_EDGES] = "both edges"
> +};
> +
> +#endif /* _COUNTER_STRINGS_H_ */
> diff --git a/drivers/counter/counter-sysfs-callbacks.c b/drivers/counter/counter-sysfs-callbacks.c
> new file mode 100644
> index 000000000000..5740d61e999b
> --- /dev/null
> +++ b/drivers/counter/counter-sysfs-callbacks.c
> @@ -0,0 +1,566 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Generic Counter sysfs callbacks
> + * Copyright (C) 2020 William Breathitt Gray
> + */
> +#include <linux/counter.h>
> +#include <linux/device.h>
> +#include <linux/err.h>
> +#include <linux/kernel.h>
> +#include <linux/types.h>
> +#include <linux/string.h>
> +#include <linux/types.h>
> +
> +#include "counter-function-types.h"
> +#include "counter-strings.h"
> +#include "counter-sysfs-callbacks.h"
> +
> +#define to_counter_attribute(_dev_attr) \
> + container_of(_dev_attr, struct counter_attribute, dev_attr)
> +
> +static ssize_t counter_data_bool_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_count_bool_read count_bool_read = a->data.read;
> + const counter_device_bool_read device_bool_read = a->data.read;
> + const counter_signal_bool_read signal_bool_read = a->data.read;
That's not pretty. Try my union suggestion, then all of the functions
will be typed in the first place.
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + void *const owner = a->owner;
Skip having a local copy of a->owner as code will shorter and easier
to follow without.
> + int err = 0;
> + bool data;
> +
> + switch (a->type) {
> + case COUNTER_OWNER_TYPE_COUNT:
> + err = count_bool_read(counter, owner, &data);
> + break;
> + case COUNTER_OWNER_TYPE_DEVICE:
> + err = device_bool_read(counter, &data);
> + break;
> + case COUNTER_OWNER_TYPE_SIGNAL:
> + err = signal_bool_read(counter, owner, &data);
> + break;
As this stands any value of a->type not listed returns no error.
> + }
> + if (err)
> + return err;
> +
> + return sprintf(buf, "%u\n", (unsigned int)data);
> +}
> +
> +static ssize_t counter_data_bool_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t len)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_count_bool_write count_bool_write = a->data.write;
> + const counter_device_bool_write device_bool_write = a->data.write;
> + const counter_signal_bool_write signal_bool_write = a->data.write;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + void *const owner = a->owner;
> + int err;
> + bool data;
> +
> + err = kstrtobool(buf, &data);
> + if (err)
> + return err;
> +
> + switch (a->type) {
> + case COUNTER_OWNER_TYPE_COUNT:
> + err = count_bool_write(counter, owner, data);
> + break;
> + case COUNTER_OWNER_TYPE_DEVICE:
> + err = device_bool_write(counter, data);
> + break;
> + case COUNTER_OWNER_TYPE_SIGNAL:
> + err = signal_bool_write(counter, owner, data);
> + break;
default:
return -EINVAL;
> + }
> + if (err)
> + return err;
> +
> + return len;
> +}
> +
> +static ssize_t counter_data_lu_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_count_lu_read count_lu_read = a->data.read;
> + const counter_device_lu_read device_lu_read = a->data.read;
> + const counter_signal_lu_read signal_lu_read = a->data.read;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + void *const owner = a->owner;
> + int err = 0;
> + unsigned long data;
> +
> + switch (a->type) {
> + case COUNTER_OWNER_TYPE_COUNT:
> + err = count_lu_read(counter, owner, &data);
> + break;
> + case COUNTER_OWNER_TYPE_DEVICE:
> + err = device_lu_read(counter, &data);
> + break;
> + case COUNTER_OWNER_TYPE_SIGNAL:
> + err = signal_lu_read(counter, owner, &data);
> + break;
> + }
> + if (err)
> + return err;
> +
> + return sprintf(buf, "%lu\n", data);
> +}
> +
> +static ssize_t counter_data_lu_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t len)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_count_lu_write count_lu_write = a->data.write;
> + const counter_device_lu_write device_lu_write = a->data.write;
> + const counter_signal_lu_write signal_lu_write = a->data.write;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + void *const owner = a->owner;
> + int err;
> + unsigned long data;
> +
> + err = kstrtoul(buf, 0, &data);
> + if (err)
> + return err;
> +
> + switch (a->type) {
> + case COUNTER_OWNER_TYPE_COUNT:
> + err = count_lu_write(counter, owner, data);
> + break;
> + case COUNTER_OWNER_TYPE_DEVICE:
> + err = device_lu_write(counter, data);
> + break;
> + case COUNTER_OWNER_TYPE_SIGNAL:
> + err = signal_lu_write(counter, owner, data);
> + break;
> + }
> + if (err)
> + return err;
> +
> + return len;
> +}
> +
> +static ssize_t counter_data_zu_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_device_zu_read zu_read = a->data.read;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + int err;
> + size_t data;
> +
> + err = zu_read(counter, &data);
> + if (err)
> + return err;
> +
> + return sprintf(buf, "%zu\n", data);
> +}
> +
> +static ssize_t counter_data_s_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_count_s_read count_s_read = a->data.read;
> + const counter_device_s_read device_s_read = a->data.read;
> + const counter_signal_s_read signal_s_read = a->data.read;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + void *const owner = a->owner;
> +
> + switch (a->type) {
> + case COUNTER_OWNER_TYPE_COUNT:
> + return count_s_read(counter, owner, buf, PAGE_SIZE);
> + case COUNTER_OWNER_TYPE_DEVICE:
> + return device_s_read(counter, buf, PAGE_SIZE);
> + case COUNTER_OWNER_TYPE_SIGNAL:
> + return signal_s_read(counter, owner, buf, PAGE_SIZE);
> + }
> +
> + return -EINVAL;
> +}
> +
> +static ssize_t counter_data_s_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t len)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_count_s_write count_s_write = a->data.write;
> + const counter_device_s_write device_s_write = a->data.write;
> + const counter_signal_s_write signal_s_write = a->data.write;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + void *const owner = a->owner;
> +
> + switch (a->type) {
> + case COUNTER_OWNER_TYPE_COUNT:
> + return count_s_write(counter, owner, buf, len);
> + case COUNTER_OWNER_TYPE_DEVICE:
> + return device_s_write(counter, buf, len);
> + case COUNTER_OWNER_TYPE_SIGNAL:
> + return signal_s_write(counter, owner, buf, len);
> + }
> +
> + return -EINVAL;
> +}
> +
> +static ssize_t counter_data_count_function_show(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_count_function_read function_read = a->data.read;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + struct counter_count *const count = a->owner;
> + int err;
> + enum counter_count_function function;
> +
> + err = function_read(counter, count, &function);
> + if (err)
> + return err;
> +
> + return sprintf(buf, "%s\n", counter_count_function_str[function]);
> +}
> +
> +static ssize_t counter_data_count_function_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t len)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_count_function_write function_write = a->data.write;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + struct counter_count *const count = a->owner;
> + const size_t num_functions = count->num_functions;
> + int err;
> + size_t index;
> + enum counter_count_function function;
> +
> + /* Find requested function mode */
> + for (index = 0; index < num_functions; index++) {
> + function = count->functions_list[index];
> + if (sysfs_streq(buf, counter_count_function_str[function]))
> + break;
> + }
> + /* If requested function mode not found */
> + if (index >= num_functions)
> + return -EINVAL;
> +
> + err = function_write(counter, count, function);
> + if (err)
> + return err;
> +
> + return len;
> +}
> +
> +static ssize_t counter_data_count_function_available_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const struct counter_count *const count = a->owner;
> + size_t i;
> + enum counter_count_function function;
> + ssize_t len = 0;
> +
> + for (i = 0; i < count->num_functions; i++) {
> + function = count->functions_list[i];
> + len += sprintf(buf + len, "%s\n",
> + counter_count_function_str[function]);
> + }
> +
> + return len;
> +}
> +
> +static ssize_t counter_data_signal_show(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_signal_signal_read signal_read = a->data.read;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + struct counter_signal *const signal = a->owner;
> + int err;
> + enum counter_signal_value value;
> +
> + err = signal_read(counter, signal, &value);
> + if (err)
> + return err;
> +
> + return sprintf(buf, "%s\n", counter_signal_value_str[value]);
> +}
> +
> +static ssize_t counter_data_synapse_action_show(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_synapse_action_read action_read = a->data.read;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + struct counter_count *const count = a->owner;
> + struct counter_synapse *const synapse = a->data.priv;
> + int err;
> + enum counter_synapse_action action;
> +
> + err = action_read(counter, count, synapse, &action);
> + if (err)
> + return err;
> +
> + return sprintf(buf, "%s\n", counter_synapse_action_str[action]);
> +}
> +
> +static ssize_t counter_data_synapse_action_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t len)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_synapse_action_write action_write = a->data.write;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + struct counter_count *const count = a->owner;
> + struct counter_synapse *const synapse = a->data.priv;
> + const size_t num_actions = synapse->num_actions;
> + int err;
> + size_t index;
> + enum counter_synapse_action action;
> +
> + /* Find requested action mode */
> + for (index = 0; index < num_actions; index++) {
> + action = synapse->actions_list[index];
> + if (sysfs_streq(buf, counter_synapse_action_str[action]))
> + break;
> + }
> + /* If requested action mode not found */
> + if (index >= num_actions)
> + return -EINVAL;
> +
> + err = action_write(counter, count, synapse, action);
> + if (err)
> + return err;
> +
> + return len;
> +}
> +
> +static ssize_t counter_data_synapse_action_available_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const struct counter_synapse *const synapse = a->data.priv;
> + size_t i;
> + enum counter_synapse_action action;
> + ssize_t len = 0;
> +
> + for (i = 0; i < synapse->num_actions; i++) {
> + action = synapse->actions_list[i];
> + len += sprintf(buf + len, "%s\n",
> + counter_synapse_action_str[action]);
> + }
> +
> + return len;
> +}
> +
> +static ssize_t counter_data_enum_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_count_zu_read count_enum_read = a->data.read;
> + const counter_device_zu_read device_enum_read = a->data.read;
> + const counter_signal_zu_read signal_enum_read = a->data.read;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + void *const owner = a->owner;
> + struct counter_enum *const cntr_enum = a->data.priv;
> + int err = 0;
> + size_t index;
> +
> + switch (a->type) {
> + case COUNTER_OWNER_TYPE_COUNT:
> + err = count_enum_read(counter, owner, &index);
> + break;
> + case COUNTER_OWNER_TYPE_DEVICE:
> + err = device_enum_read(counter, &index);
> + break;
> + case COUNTER_OWNER_TYPE_SIGNAL:
> + err = signal_enum_read(counter, owner, &index);
> + break;
> + }
> + if (err)
> + return err;
> +
> + if (index >= cntr_enum->num_items)
> + return -EINVAL;
> +
> + return sprintf(buf, "%s\n", cntr_enum->items[index]);
> +}
> +
> +static ssize_t counter_data_enum_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t len)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + struct counter_enum *const cntr_enum = a->data.priv;
> + const size_t num_items = cntr_enum->num_items;
> + const counter_count_zu_write count_enum_write = a->data.write;
> + const counter_device_zu_write device_enum_write = a->data.write;
> + const counter_signal_zu_write signal_enum_write = a->data.write;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + void *const owner = a->owner;
> + ssize_t index;
> + int err = 0;
> +
> + index = __sysfs_match_string(cntr_enum->items, num_items, buf);
> + if (index < 0)
> + return index;
> +
> + switch (a->type) {
> + case COUNTER_OWNER_TYPE_COUNT:
> + err = count_enum_write(counter, owner, index);
> + break;
> + case COUNTER_OWNER_TYPE_DEVICE:
> + err = device_enum_write(counter, index);
> + break;
> + case COUNTER_OWNER_TYPE_SIGNAL:
> + err = signal_enum_write(counter, owner, index);
> + break;
> + }
> + if (err)
> + return err;
> +
> + return len;
> +}
> +
> +static ssize_t counter_data_enum_available_show(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + struct counter_enum *const cntr_enum = a->data.priv;
> + size_t i;
> + size_t len = 0;
> +
> + for (i = 0; i < cntr_enum->num_items; i++)
> + len += sprintf(buf + len, "%s\n", cntr_enum->items[i]);
> +
> + return len;
> +}
> +
> +static ssize_t counter_data_count_direction_show(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_count_direction_read direction_read = a->data.read;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + struct counter_count *const count = a->owner;
> + int err;
> + enum counter_count_direction direction;
> +
> + err = direction_read(counter, count, &direction);
> + if (err)
> + return err;
> +
> + return sprintf(buf, "%s\n", counter_count_direction_str[direction]);
> +}
> +
> +static ssize_t counter_data_count_mode_show(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_count_mode_read count_mode_read = a->data.read;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + struct counter_count *const count = a->owner;
> + int err;
> + enum counter_count_mode count_mode;
> +
> + err = count_mode_read(counter, count, &count_mode);
> + if (err)
> + return err;
> +
> + return sprintf(buf, "%s\n", counter_count_mode_str[count_mode]);
> +}
> +
> +static ssize_t counter_data_count_mode_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t len)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const counter_count_mode_write count_mode_write = a->data.write;
> + struct counter_device *const counter = dev_get_drvdata(dev);
> + struct counter_count *const count = a->owner;
> + const struct counter_available *const available = a->data.priv;
> + const enum counter_count_mode *const items = available->items;
> + const size_t num_count_modes = available->num_items;
> + int err;
> + size_t index;
> + enum counter_count_mode count_mode;
> +
> + /* Find requested count mode */
> + for (index = 0; index < num_count_modes; index++) {
> + count_mode = items[index];
> + if (sysfs_streq(buf, counter_count_mode_str[count_mode]))
> + break;
> + }
> + /* If requested count mode not found */
> + if (index >= num_count_modes)
> + return -EINVAL;
> +
> + err = count_mode_write(counter, count, count_mode);
> + if (err)
> + return err;
> +
> + return len;
> +}
> +
> +static ssize_t counter_data_count_mode_available_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + const struct counter_attribute *const a = to_counter_attribute(attr);
> + const struct counter_available *const available = a->data.priv;
> + const enum counter_count_mode *const items = available->items;
> + size_t i;
> + enum counter_count_mode count_mode;
> + ssize_t len = 0;
> +
> + for (i = 0; i < available->num_items; i++) {
> + count_mode = items[i];
> + len += sprintf(buf + len, "%s\n",
> + counter_count_mode_str[count_mode]);
> + }
> +
> + return len;
> +}
> +
> +ssize_t (*counter_data_sysfs_show[])(struct device *, struct device_attribute *,
> + char *) = {
> + [COUNTER_DATA_TYPE_BOOL] = counter_data_bool_show,
> + [COUNTER_DATA_TYPE_UNSIGNED_LONG] = counter_data_lu_show,
> + [COUNTER_DATA_TYPE_SIZE] = counter_data_zu_show,
> + [COUNTER_DATA_TYPE_STRING] = counter_data_s_show,
> + [COUNTER_DATA_TYPE_COUNT_FUNCTION] = counter_data_count_function_show,
> + [COUNTER_DATA_TYPE_COUNT_FUNCTION_AVAILABLE] = counter_data_count_function_available_show,
> + [COUNTER_DATA_TYPE_SIGNAL] = counter_data_signal_show,
> + [COUNTER_DATA_TYPE_SYNAPSE_ACTION] = counter_data_synapse_action_show,
> + [COUNTER_DATA_TYPE_SYNAPSE_ACTION_AVAILABLE] = counter_data_synapse_action_available_show,
> + [COUNTER_DATA_TYPE_ENUM] = counter_data_enum_show,
> + [COUNTER_DATA_TYPE_ENUM_AVAILABLE] = counter_data_enum_available_show,
> + [COUNTER_DATA_TYPE_COUNT_DIRECTION] = counter_data_count_direction_show,
> + [COUNTER_DATA_TYPE_COUNT_MODE] = counter_data_count_mode_show,
> + [COUNTER_DATA_TYPE_COUNT_MODE_AVAILABLE] = counter_data_count_mode_available_show,
> +};
> +
> +ssize_t (*counter_data_sysfs_store[])(struct device *,
> + struct device_attribute *, const char *,
> + size_t) = {
> + [COUNTER_DATA_TYPE_BOOL] = counter_data_bool_store,
> + [COUNTER_DATA_TYPE_UNSIGNED_LONG] = counter_data_lu_store,
> + [COUNTER_DATA_TYPE_SIZE] = NULL,
> + [COUNTER_DATA_TYPE_STRING] = counter_data_s_store,
> + [COUNTER_DATA_TYPE_COUNT_FUNCTION] = counter_data_count_function_store,
> + [COUNTER_DATA_TYPE_COUNT_FUNCTION_AVAILABLE] = NULL,
> + [COUNTER_DATA_TYPE_SIGNAL] = NULL,
> + [COUNTER_DATA_TYPE_SYNAPSE_ACTION] = counter_data_synapse_action_store,
> + [COUNTER_DATA_TYPE_SYNAPSE_ACTION_AVAILABLE] = NULL,
> + [COUNTER_DATA_TYPE_ENUM] = counter_data_enum_store,
> + [COUNTER_DATA_TYPE_ENUM_AVAILABLE] = NULL,
> + [COUNTER_DATA_TYPE_COUNT_DIRECTION] = NULL,
> + [COUNTER_DATA_TYPE_COUNT_MODE] = counter_data_count_mode_store,
> + [COUNTER_DATA_TYPE_COUNT_MODE_AVAILABLE] = NULL,
> +};
> diff --git a/drivers/counter/counter-sysfs-callbacks.h b/drivers/counter/counter-sysfs-callbacks.h
> new file mode 100644
> index 000000000000..cf44e7c6ed18
> --- /dev/null
> +++ b/drivers/counter/counter-sysfs-callbacks.h
> @@ -0,0 +1,28 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * Generic Counter sysfs callbacks
> + * Copyright (C) 2020 William Breathitt Gray
> + */
> +#ifndef _COUNTER_SYSFS_CALLBACKS_H_
> +#define _COUNTER_SYSFS_CALLBACKS_H_
> +
> +#include <linux/counter.h>
> +#include <linux/types.h>
> +
> +struct counter_attribute {
> + struct device_attribute dev_attr;
> + struct list_head l;
> +
> + struct counter_data data;
> + enum counter_owner_type type;
> + void *owner;
> +};
> +
> +extern ssize_t (*counter_data_sysfs_show[])(struct device *,
> + struct device_attribute *, char *);
> +
> +extern ssize_t (*counter_data_sysfs_store[])(struct device *,
> + struct device_attribute *,
> + const char *, size_t);
> +
> +#endif /* _COUNTER_SYSFS_CALLBACKS_H_ */
> diff --git a/drivers/counter/counter-sysfs.c b/drivers/counter/counter-sysfs.c
> new file mode 100644
> index 000000000000..ed56c6b52490
> --- /dev/null
> +++ b/drivers/counter/counter-sysfs.c
> @@ -0,0 +1,524 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Generic Counter sysfs interface
> + * Copyright (C) 2020 William Breathitt Gray
> + */
> +#include <linux/counter.h>
> +#include <linux/device.h>
> +#include <linux/err.h>
> +#include <linux/gfp.h>
> +#include <linux/kernel.h>
> +#include <linux/list.h>
> +#include <linux/slab.h>
> +#include <linux/sysfs.h>
> +#include <linux/types.h>
> +
> +#include "counter-sysfs-callbacks.h"
> +
> +static int counter_attribute_create(struct counter_attribute_group *const group,
> + const struct counter_data *const data,
> + const enum counter_owner_type type,
> + void *const owner)
> +{
> + struct counter_attribute *counter_attr;
> + struct device_attribute *dev_attr;
> +
> + /* Allocate and initialize Counter attribute */
> + counter_attr = kzalloc(sizeof(*counter_attr), GFP_KERNEL);
> + if (!counter_attr)
> + return -ENOMEM;
> + counter_attr->data = *data;
> + counter_attr->type = type;
> + counter_attr->owner = owner;
> +
> + /* Configure device attribute */
> + dev_attr = &counter_attr->dev_attr;
> + sysfs_attr_init(&dev_attr->attr);
> + dev_attr->attr.name = data->name;
> + if (data->read) {
> + dev_attr->attr.mode |= 0444;
> + dev_attr->show = counter_data_sysfs_show[data->type];
> + }
> + if (data->write) {
> + dev_attr->attr.mode |= 0200;
> + dev_attr->store = counter_data_sysfs_store[data->type];
> + }
> +
> + /* Keep track of the attribute for later cleanup */
> + list_add(&counter_attr->l, &group->attr_list);
> + group->num_attr++;
> +
> + return 0;
> +}
> +
> +static struct counter_data counter_signal_data = {
> + .type = COUNTER_DATA_TYPE_SIGNAL,
> + .name = "signal",
> +};
> +
> +static struct counter_data counter_name_data =
> + COUNTER_DATA_STRING("name", NULL, NULL);
> +
> +static ssize_t counter_signal_name_read(struct counter_device *counter,
> + struct counter_signal *signal,
> + char *buf, size_t size)
> +{
> + return snprintf(buf, size, "%s\n", signal->name);
> +}
> +
> +static int counter_signal_attributes_create(
> + struct counter_attribute_group *const group,
> + struct counter_signal *const signal, void *const signal_read)
> +{
> + const enum counter_owner_type type = COUNTER_OWNER_TYPE_SIGNAL;
> + int err;
> + struct counter_data data;
> + size_t i;
> + const struct counter_data *ext;
> +
> + /* Create main Signal attribute */
> + data = counter_signal_data;
> + data.read = signal_read;
> + err = counter_attribute_create(group, &data, type, signal);
> + if (err)
> + return err;
> +
> + /* Create Signal name attribute */
> + data = counter_name_data;
> + data.read = counter_signal_name_read;
> + err = counter_attribute_create(group, &data, type, signal);
> + if (err)
> + return err;
> +
> + /* Create an attribute for each extension */
> + for (i = 0; i < signal->num_ext; i++) {
> + ext = signal->ext + i;
> + err = counter_attribute_create(group, ext, type, signal);
> + if (err)
> + return err;
> + }
> +
> + return 0;
> +}
> +
> +static int counter_signals_register(
> + struct counter_attribute_group *const groups_list,
> + const struct counter_device *const counter)
> +{
> + void *const signal_read = counter->signal_read;
> + size_t i;
> + struct counter_signal *signal;
> + const char *name;
> + int err;
> +
> + /* Register each Signal */
> + for (i = 0; i < counter->num_signals; i++) {
> + signal = counter->signals + i;
> +
> + /* Generate Signal attribute directory name */
> + name = kasprintf(GFP_KERNEL, "signal%d", signal->id);
> + if (!name)
> + return -ENOMEM;
> + groups_list[i].attr_group.name = name;
> +
> + /* Create all attributes associated with Signal */
> + err = counter_signal_attributes_create(groups_list + i, signal,
> + signal_read);
> + if (err)
> + return err;
> + }
> +
> + return 0;
> +}
> +
> +struct counter_synapse_name {
> + struct list_head l;
> + const char *name;
> +};
> +
> +static int counter_synapses_register(
> + struct counter_attribute_group *const group,
> + struct counter_device *const counter, struct counter_count *const count)
> +{
> + const enum counter_owner_type type = COUNTER_OWNER_TYPE_COUNT;
> + size_t i;
> + struct counter_synapse *synapse;
> + int id;
> + struct counter_synapse_name *name;
> + struct counter_data data;
> + int err;
> +
> + /* Register each Synapse */
> + for (i = 0; i < count->num_synapses; i++) {
> + synapse = count->synapses + i;
> + id = synapse->signal->id;
> +
> + /* Generate Synapse name list item */
> + name = kmalloc(sizeof(*name), GFP_KERNEL);
> + if (!name)
> + return -ENOMEM;
> + list_add(&name->l, &counter->synapse_names_list);
> +
> + /* Generate Synapse action name */
> + name->name = kasprintf(GFP_KERNEL, "signal%d_action", id);
> + if (!name->name)
> + return -ENOMEM;
> +
> + /* Create action attribute */
> + data.type = COUNTER_DATA_TYPE_SYNAPSE_ACTION;
> + data.name = name->name;
> + data.read = counter->action_read;
> + data.write = counter->action_write;
> + data.priv = synapse;
> + err = counter_attribute_create(group, &data, type, count);
> + if (err)
> + return err;
> +
> + /* Generate Synapse action_available name */
> + name->name = kasprintf(GFP_KERNEL, "signal%d_action_available",
> + id);
> + if (!name->name)
> + return -ENOMEM;
> +
> + /* Create action_available attribute */
> + data.type = COUNTER_DATA_TYPE_SYNAPSE_ACTION_AVAILABLE;
> + data.name = name->name;
> + data.read = counter->action_read;
> + data.priv = synapse;
> + err = counter_attribute_create(group, &data, type, count);
> + if (err)
> + return err;
> + }
> +
> + return 0;
> +}
> +
> +static struct counter_data counter_count_data =
> + COUNTER_DATA_UNSIGNED_LONG("count", NULL, NULL);
> +
> +static ssize_t counter_count_name_read(struct counter_device *counter,
> + struct counter_count *count, char *buf,
> + size_t size)
> +{
> + return snprintf(buf, size, "%s\n", count->name);
> +}
> +
> +static struct counter_data counter_count_function_data = {
> + .type = COUNTER_DATA_TYPE_COUNT_FUNCTION,
> + .name = "function",
> +};
> +
> +static struct counter_data counter_count_function_available_data = {
> + .type = COUNTER_DATA_TYPE_COUNT_FUNCTION_AVAILABLE,
> + .name = "function_available",
> +};
> +
> +static int counter_count_attributes_create(
> + struct counter_attribute_group *const group,
> + const struct counter_device *const counter,
> + struct counter_count *const count)
> +{
> + const enum counter_owner_type type = COUNTER_OWNER_TYPE_COUNT;
> + int err;
> + struct counter_data data;
> + size_t i;
> + const struct counter_data *ext;
> +
> + /* Create main Count attribute */
> + data = counter_count_data;
> + data.read = counter->count_read;
> + data.write = counter->count_write;
> + err = counter_attribute_create(group, &data, type, count);
> + if (err)
> + return err;
> +
> + /* Create Count name attribute */
> + data = counter_name_data;
> + data.read = counter_count_name_read;
> + err = counter_attribute_create(group, &data, type, count);
> + if (err)
> + return err;
> +
> + /* Create Count function attribute */
> + data = counter_count_function_data;
> + data.read = counter->function_read;
> + data.write = counter->function_write;
> + err = counter_attribute_create(group, &data, type, count);
> + if (err)
> + return err;
> +
> + /* Create Count function_available attribute */
> + data = counter_count_function_available_data;
> + data.read = counter->function_read;
> + err = counter_attribute_create(group, &data, type, count);
> + if (err)
> + return err;
> +
> + /* Create an attribute for each extension */
> + for (i = 0; i < count->num_ext; i++) {
> + ext = count->ext + i;
> + err = counter_attribute_create(group, ext, type, count);
> + if (err)
> + return err;
> + }
> +
> + return 0;
> +}
> +
> +static int counter_counts_register(
> + struct counter_attribute_group *const groups_list,
> + struct counter_device *const counter)
> +{
> + size_t i;
> + struct counter_count *count;
> + const char *name;
> + int err;
> +
> + /* Register each Count */
> + for (i = 0; i < counter->num_counts; i++) {
> + count = counter->counts + i;
> +
> + /* Generate Count attribute directory name */
> + name = kasprintf(GFP_KERNEL, "count%d", count->id);
> + if (!name)
> + return -ENOMEM;
> + groups_list[i].attr_group.name = name;
> +
> + /* Register the Synapses associated with each Count */
> + err = counter_synapses_register(groups_list + i, counter,
> + count);
> + if (err)
> + return err;
> +
> + /* Create all attributes associated with Count */
> + err = counter_count_attributes_create(groups_list + i, counter,
> + count);
> + if (err)
> + return err;
> + }
> +
> + return 0;
> +}
> +
> +static ssize_t counter_name_read(struct counter_device *counter, char *buf,
> + size_t size)
> +{
> + return snprintf(buf, size, "%s\n", counter->name);
> +}
> +
> +static int counter_num_signals_read(struct counter_device *counter, size_t *val)
> +{
> + *val = counter->num_signals;
> + return 0;
> +}
> +
> +static int counter_num_counts_read(struct counter_device *counter, size_t *val)
> +{
> + *val = counter->num_counts;
> + return 0;
> +}
> +
> +#define COUNTER_DATA_SIZE(_name, _read) \
> +{ \
> + .type = COUNTER_DATA_TYPE_SIZE, \
> + .name = (_name), \
> + .read = (_read), \
> +}
> +
> +static struct counter_data counter_num_signals_data =
> + COUNTER_DATA_SIZE("num_signals", counter_num_signals_read);
> +
> +static struct counter_data counter_num_counts_data =
> + COUNTER_DATA_SIZE("num_counts", counter_num_counts_read);
> +
> +static void counter_groups_list_free(struct counter_device *const counter)
> +{
> + struct counter_attribute_group *group;
> + struct counter_attribute *p, *n;
> +
> + /* Loop through all attribute groups (signals, counts, device, etc.) */
> + while (counter->num_groups--) {
> + group = counter->groups_list + counter->num_groups;
> +
> + /* Free all attribute group and associated attributes memory */
> + kfree(group->attr_group.name);
> + kfree(group->attr_group.attrs);
> +
> + /* Free attribute list */
> + list_for_each_entry_safe(p, n, &group->attr_list, l)
> + kfree(p);
> + }
> +
> + kfree(counter->groups_list);
> +}
> +
> +static int counter_device_register(struct counter_attribute_group *group,
> + struct counter_device *const counter)
> +{
> + const enum counter_owner_type type = COUNTER_OWNER_TYPE_DEVICE;
> + struct counter_data data;
> + int err;
> + size_t i;
> + const struct counter_data *ext;
> +
> + /* Register Signals */
> + err = counter_signals_register(group, counter);
> + if (err)
> + goto err_free_groups_list;
> + group += counter->num_signals;
> +
> + /* Register Counts and respective Synapses */
> + err = counter_counts_register(group, counter);
> + if (err)
> + goto err_free_groups_list;
> + group += counter->num_counts;
> +
> + /* Create name attribute */
> + data = counter_name_data;
> + data.read = counter_name_read;
> + err = counter_attribute_create(group, &data, type, NULL);
> + if (err)
> + goto err_free_groups_list;
> +
> + /* Create num_signals attribute */
> + data = counter_num_signals_data;
> + err = counter_attribute_create(group, &data, type, NULL);
> + if (err)
> + goto err_free_groups_list;
> +
> + /* Create num_counts attribute */
> + data = counter_num_counts_data;
> + err = counter_attribute_create(group, &data, type, NULL);
> + if (err)
> + goto err_free_groups_list;
> +
> + /* Create an attribute for each extension */
> + for (i = 0; i < counter->num_ext; i++) {
> + ext = counter->ext + i;
> + err = counter_attribute_create(group, ext, type, NULL);
> + if (err)
> + goto err_free_groups_list;
> + }
> +
> + return 0;
> +
> +err_free_groups_list:
> + counter_groups_list_free(counter);
> + return err;
> +}
> +
> +static int counter_groups_list_prepare(struct counter_device *const counter)
> +{
> + const size_t num_grps = counter->num_signals + counter->num_counts + 1;
> + struct counter_attribute_group *groups_list;
> + size_t i;
> + int err;
> +
> + /* Allocate space for attribute groups (signals, counts, and ext) */
> + groups_list = kcalloc(num_grps, sizeof(*groups_list), GFP_KERNEL);
> + if (!groups_list)
> + return -ENOMEM;
> +
> + /* Store groups_list in counter structure */
> + counter->groups_list = groups_list;
> + counter->num_groups = num_grps;
> +
> + /* Initialize attribute lists */
> + for (i = 0; i < num_grps; i++)
> + INIT_LIST_HEAD(&groups_list[i].attr_list);
> +
> + /* Register Counter device attributes */
> + err = counter_device_register(groups_list, counter);
> + if (err)
> + return err;
return counter_device_register...
> +
> + return 0;
> +}
> +
> +static int counter_groups_prepare(struct counter_device *const counter)
> +{
> + size_t i, j;
> + struct counter_attribute_group *group;
> + struct attribute **attrs;
> + int err;
> + struct counter_attribute *p;
> +
> + /* Allocate attribute groups for association with device */
> + counter->groups = kcalloc(counter->num_groups + 1,
> + sizeof(*counter->groups), GFP_KERNEL);
> + if (!counter->groups)
> + return -ENOMEM;
> +
> + /* Prepare each group of attributes for association */
> + for (i = 0; i < counter->num_groups; i++) {
> + group = counter->groups_list + i;
> +
> + /* Allocate space for attribute pointers */
> + attrs = kcalloc(group->num_attr + 1, sizeof(*attrs),
> + GFP_KERNEL);
> + if (!attrs) {
> + err = -ENOMEM;
> + goto err_free_groups;
> + }
> + group->attr_group.attrs = attrs;
> +
> + /* Add attribute pointers to attribute group */
> + j = 0;
> + list_for_each_entry(p, &group->attr_list, l)
> + attrs[j++] = &p->dev_attr.attr;
> +
> + /* Group attributes in attribute group */
> + counter->groups[i] = &group->attr_group;
> + }
> + /* Associate attributes with device */
> + counter->dev.groups = counter->groups;
> +
> + return 0;
> +
> +err_free_groups:
> + kfree(counter->groups);
> + return err;
> +}
> +
> +static void counter_synapse_names_free(struct list_head *const names_list)
> +{
> + struct counter_synapse_name *p, *n;
> +
> + list_for_each_entry_safe(p, n, names_list, l) {
> + kfree(p->name);
> + kfree(p);
> + }
> +}
> +
> +int counter_sysfs_add(struct counter_device *const counter)
> +{
> + int err;
> +
> + /* Initialize Synapse names list */
> + INIT_LIST_HEAD(&counter->synapse_names_list);
> +
> + /* Prepare device attributes */
> + err = counter_groups_list_prepare(counter);
> + if (err)
> + goto err_free_synapse_names;
> +
> + /* Organize device attributes to groups and match to device */
> + err = counter_groups_prepare(counter);
> + if (err)
> + goto err_free_groups_list;
> +
> + return 0;
> +
> +err_free_groups_list:
> + counter_groups_list_free(counter);
> +err_free_synapse_names:
> + counter_synapse_names_free(&counter->synapse_names_list);
> + return err;
> +}
> +
> +void counter_sysfs_free(struct counter_device *const counter)
> +{
> + kfree(counter->groups);
> + counter_groups_list_free(counter);
> + counter_synapse_names_free(&counter->synapse_names_list);
> +}
> diff --git a/drivers/counter/counter-sysfs.h b/drivers/counter/counter-sysfs.h
> new file mode 100644
> index 000000000000..00e7cd6ea083
> --- /dev/null
> +++ b/drivers/counter/counter-sysfs.h
> @@ -0,0 +1,14 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * Counter sysfs interface
> + * Copyright (C) 2020 William Breathitt Gray
> + */
> +#ifndef _COUNTER_SYSFS_H_
> +#define _COUNTER_SYSFS_H_
> +
> +#include <linux/counter.h>
> +
> +int counter_sysfs_add(struct counter_device *const counter);
> +void counter_sysfs_free(struct counter_device *const counter);
> +
> +#endif /* _COUNTER_SYSFS_H_ */
> diff --git a/drivers/counter/counter.c b/drivers/counter/counter.c
> deleted file mode 100644
> index 6a683d086008..000000000000
> --- a/drivers/counter/counter.c
> +++ /dev/null
> @@ -1,1496 +0,0 @@
> -// SPDX-License-Identifier: GPL-2.0
> -/*
> - * Generic Counter interface
> - * Copyright (C) 2018 William Breathitt Gray
> - */
> -#include <linux/counter.h>
> -#include <linux/device.h>
> -#include <linux/err.h>
> -#include <linux/export.h>
> -#include <linux/fs.h>
> -#include <linux/gfp.h>
> -#include <linux/idr.h>
> -#include <linux/init.h>
> -#include <linux/kernel.h>
> -#include <linux/list.h>
> -#include <linux/module.h>
> -#include <linux/printk.h>
> -#include <linux/slab.h>
> -#include <linux/string.h>
> -#include <linux/sysfs.h>
> -#include <linux/types.h>
> -
> -const char *const counter_count_direction_str[2] = {
> - [COUNTER_COUNT_DIRECTION_FORWARD] = "forward",
> - [COUNTER_COUNT_DIRECTION_BACKWARD] = "backward"
> -};
> -EXPORT_SYMBOL_GPL(counter_count_direction_str);
> -
> -const char *const counter_count_mode_str[4] = {
> - [COUNTER_COUNT_MODE_NORMAL] = "normal",
> - [COUNTER_COUNT_MODE_RANGE_LIMIT] = "range limit",
> - [COUNTER_COUNT_MODE_NON_RECYCLE] = "non-recycle",
> - [COUNTER_COUNT_MODE_MODULO_N] = "modulo-n"
> -};
> -EXPORT_SYMBOL_GPL(counter_count_mode_str);
> -
> -ssize_t counter_signal_enum_read(struct counter_device *counter,
> - struct counter_signal *signal, void *priv,
> - char *buf)
> -{
> - const struct counter_signal_enum_ext *const e = priv;
> - int err;
> - size_t index;
> -
> - if (!e->get)
> - return -EINVAL;
> -
> - err = e->get(counter, signal, &index);
> - if (err)
> - return err;
> -
> - if (index >= e->num_items)
> - return -EINVAL;
> -
> - return sprintf(buf, "%s\n", e->items[index]);
> -}
> -EXPORT_SYMBOL_GPL(counter_signal_enum_read);
> -
> -ssize_t counter_signal_enum_write(struct counter_device *counter,
> - struct counter_signal *signal, void *priv,
> - const char *buf, size_t len)
> -{
> - const struct counter_signal_enum_ext *const e = priv;
> - ssize_t index;
> - int err;
> -
> - if (!e->set)
> - return -EINVAL;
> -
> - index = __sysfs_match_string(e->items, e->num_items, buf);
> - if (index < 0)
> - return index;
> -
> - err = e->set(counter, signal, index);
> - if (err)
> - return err;
> -
> - return len;
> -}
> -EXPORT_SYMBOL_GPL(counter_signal_enum_write);
> -
> -ssize_t counter_signal_enum_available_read(struct counter_device *counter,
> - struct counter_signal *signal,
> - void *priv, char *buf)
> -{
> - const struct counter_signal_enum_ext *const e = priv;
> - size_t i;
> - size_t len = 0;
> -
> - if (!e->num_items)
> - return 0;
> -
> - for (i = 0; i < e->num_items; i++)
> - len += sprintf(buf + len, "%s\n", e->items[i]);
> -
> - return len;
> -}
> -EXPORT_SYMBOL_GPL(counter_signal_enum_available_read);
> -
> -ssize_t counter_count_enum_read(struct counter_device *counter,
> - struct counter_count *count, void *priv,
> - char *buf)
> -{
> - const struct counter_count_enum_ext *const e = priv;
> - int err;
> - size_t index;
> -
> - if (!e->get)
> - return -EINVAL;
> -
> - err = e->get(counter, count, &index);
> - if (err)
> - return err;
> -
> - if (index >= e->num_items)
> - return -EINVAL;
> -
> - return sprintf(buf, "%s\n", e->items[index]);
> -}
> -EXPORT_SYMBOL_GPL(counter_count_enum_read);
> -
> -ssize_t counter_count_enum_write(struct counter_device *counter,
> - struct counter_count *count, void *priv,
> - const char *buf, size_t len)
> -{
> - const struct counter_count_enum_ext *const e = priv;
> - ssize_t index;
> - int err;
> -
> - if (!e->set)
> - return -EINVAL;
> -
> - index = __sysfs_match_string(e->items, e->num_items, buf);
> - if (index < 0)
> - return index;
> -
> - err = e->set(counter, count, index);
> - if (err)
> - return err;
> -
> - return len;
> -}
> -EXPORT_SYMBOL_GPL(counter_count_enum_write);
> -
> -ssize_t counter_count_enum_available_read(struct counter_device *counter,
> - struct counter_count *count,
> - void *priv, char *buf)
> -{
> - const struct counter_count_enum_ext *const e = priv;
> - size_t i;
> - size_t len = 0;
> -
> - if (!e->num_items)
> - return 0;
> -
> - for (i = 0; i < e->num_items; i++)
> - len += sprintf(buf + len, "%s\n", e->items[i]);
> -
> - return len;
> -}
> -EXPORT_SYMBOL_GPL(counter_count_enum_available_read);
> -
> -ssize_t counter_device_enum_read(struct counter_device *counter, void *priv,
> - char *buf)
> -{
> - const struct counter_device_enum_ext *const e = priv;
> - int err;
> - size_t index;
> -
> - if (!e->get)
> - return -EINVAL;
> -
> - err = e->get(counter, &index);
> - if (err)
> - return err;
> -
> - if (index >= e->num_items)
> - return -EINVAL;
> -
> - return sprintf(buf, "%s\n", e->items[index]);
> -}
> -EXPORT_SYMBOL_GPL(counter_device_enum_read);
> -
> -ssize_t counter_device_enum_write(struct counter_device *counter, void *priv,
> - const char *buf, size_t len)
> -{
> - const struct counter_device_enum_ext *const e = priv;
> - ssize_t index;
> - int err;
> -
> - if (!e->set)
> - return -EINVAL;
> -
> - index = __sysfs_match_string(e->items, e->num_items, buf);
> - if (index < 0)
> - return index;
> -
> - err = e->set(counter, index);
> - if (err)
> - return err;
> -
> - return len;
> -}
> -EXPORT_SYMBOL_GPL(counter_device_enum_write);
> -
> -ssize_t counter_device_enum_available_read(struct counter_device *counter,
> - void *priv, char *buf)
> -{
> - const struct counter_device_enum_ext *const e = priv;
> - size_t i;
> - size_t len = 0;
> -
> - if (!e->num_items)
> - return 0;
> -
> - for (i = 0; i < e->num_items; i++)
> - len += sprintf(buf + len, "%s\n", e->items[i]);
> -
> - return len;
> -}
> -EXPORT_SYMBOL_GPL(counter_device_enum_available_read);
> -
> -struct counter_attr_parm {
> - struct counter_device_attr_group *group;
> - const char *prefix;
> - const char *name;
> - ssize_t (*show)(struct device *dev, struct device_attribute *attr,
> - char *buf);
> - ssize_t (*store)(struct device *dev, struct device_attribute *attr,
> - const char *buf, size_t len);
> - void *component;
> -};
> -
> -struct counter_device_attr {
> - struct device_attribute dev_attr;
> - struct list_head l;
> - void *component;
> -};
> -
> -static int counter_attribute_create(const struct counter_attr_parm *const parm)
> -{
> - struct counter_device_attr *counter_attr;
> - struct device_attribute *dev_attr;
> - int err;
> - struct list_head *const attr_list = &parm->group->attr_list;
> -
> - /* Allocate a Counter device attribute */
> - counter_attr = kzalloc(sizeof(*counter_attr), GFP_KERNEL);
> - if (!counter_attr)
> - return -ENOMEM;
> - dev_attr = &counter_attr->dev_attr;
> -
> - sysfs_attr_init(&dev_attr->attr);
> -
> - /* Configure device attribute */
> - dev_attr->attr.name = kasprintf(GFP_KERNEL, "%s%s", parm->prefix,
> - parm->name);
> - if (!dev_attr->attr.name) {
> - err = -ENOMEM;
> - goto err_free_counter_attr;
> - }
> - if (parm->show) {
> - dev_attr->attr.mode |= 0444;
> - dev_attr->show = parm->show;
> - }
> - if (parm->store) {
> - dev_attr->attr.mode |= 0200;
> - dev_attr->store = parm->store;
> - }
> -
> - /* Store associated Counter component with attribute */
> - counter_attr->component = parm->component;
> -
> - /* Keep track of the attribute for later cleanup */
> - list_add(&counter_attr->l, attr_list);
> - parm->group->num_attr++;
> -
> - return 0;
> -
> -err_free_counter_attr:
> - kfree(counter_attr);
> - return err;
> -}
> -
> -#define to_counter_attr(_dev_attr) \
> - container_of(_dev_attr, struct counter_device_attr, dev_attr)
> -
> -struct counter_signal_unit {
> - struct counter_signal *signal;
> -};
> -
> -static const char *const counter_signal_value_str[] = {
> - [COUNTER_SIGNAL_LOW] = "low",
> - [COUNTER_SIGNAL_HIGH] = "high"
> -};
> -
> -static ssize_t counter_signal_show(struct device *dev,
> - struct device_attribute *attr, char *buf)
> -{
> - struct counter_device *const counter = dev_get_drvdata(dev);
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_signal_unit *const component = devattr->component;
> - struct counter_signal *const signal = component->signal;
> - int err;
> - enum counter_signal_value val;
> -
> - err = counter->ops->signal_read(counter, signal, &val);
> - if (err)
> - return err;
> -
> - return sprintf(buf, "%s\n", counter_signal_value_str[val]);
> -}
> -
> -struct counter_name_unit {
> - const char *name;
> -};
> -
> -static ssize_t counter_device_attr_name_show(struct device *dev,
> - struct device_attribute *attr,
> - char *buf)
> -{
> - const struct counter_name_unit *const comp = to_counter_attr(attr)->component;
> -
> - return sprintf(buf, "%s\n", comp->name);
> -}
> -
> -static int counter_name_attribute_create(
> - struct counter_device_attr_group *const group,
> - const char *const name)
> -{
> - struct counter_name_unit *name_comp;
> - struct counter_attr_parm parm;
> - int err;
> -
> - /* Skip if no name */
> - if (!name)
> - return 0;
> -
> - /* Allocate name attribute component */
> - name_comp = kmalloc(sizeof(*name_comp), GFP_KERNEL);
> - if (!name_comp)
> - return -ENOMEM;
> - name_comp->name = name;
> -
> - /* Allocate Signal name attribute */
> - parm.group = group;
> - parm.prefix = "";
> - parm.name = "name";
> - parm.show = counter_device_attr_name_show;
> - parm.store = NULL;
> - parm.component = name_comp;
> - err = counter_attribute_create(&parm);
> - if (err)
> - goto err_free_name_comp;
> -
> - return 0;
> -
> -err_free_name_comp:
> - kfree(name_comp);
> - return err;
> -}
> -
> -struct counter_signal_ext_unit {
> - struct counter_signal *signal;
> - const struct counter_signal_ext *ext;
> -};
> -
> -static ssize_t counter_signal_ext_show(struct device *dev,
> - struct device_attribute *attr, char *buf)
> -{
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_signal_ext_unit *const comp = devattr->component;
> - const struct counter_signal_ext *const ext = comp->ext;
> -
> - return ext->read(dev_get_drvdata(dev), comp->signal, ext->priv, buf);
> -}
> -
> -static ssize_t counter_signal_ext_store(struct device *dev,
> - struct device_attribute *attr,
> - const char *buf, size_t len)
> -{
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_signal_ext_unit *const comp = devattr->component;
> - const struct counter_signal_ext *const ext = comp->ext;
> -
> - return ext->write(dev_get_drvdata(dev), comp->signal, ext->priv, buf,
> - len);
> -}
> -
> -static void counter_device_attr_list_free(struct list_head *attr_list)
> -{
> - struct counter_device_attr *p, *n;
> -
> - list_for_each_entry_safe(p, n, attr_list, l) {
> - /* free attribute name and associated component memory */
> - kfree(p->dev_attr.attr.name);
> - kfree(p->component);
> - list_del(&p->l);
> - kfree(p);
> - }
> -}
> -
> -static int counter_signal_ext_register(
> - struct counter_device_attr_group *const group,
> - struct counter_signal *const signal)
> -{
> - const size_t num_ext = signal->num_ext;
> - size_t i;
> - const struct counter_signal_ext *ext;
> - struct counter_signal_ext_unit *signal_ext_comp;
> - struct counter_attr_parm parm;
> - int err;
> -
> - /* Create an attribute for each extension */
> - for (i = 0 ; i < num_ext; i++) {
> - ext = signal->ext + i;
> -
> - /* Allocate signal_ext attribute component */
> - signal_ext_comp = kmalloc(sizeof(*signal_ext_comp), GFP_KERNEL);
> - if (!signal_ext_comp) {
> - err = -ENOMEM;
> - goto err_free_attr_list;
> - }
> - signal_ext_comp->signal = signal;
> - signal_ext_comp->ext = ext;
> -
> - /* Allocate a Counter device attribute */
> - parm.group = group;
> - parm.prefix = "";
> - parm.name = ext->name;
> - parm.show = (ext->read) ? counter_signal_ext_show : NULL;
> - parm.store = (ext->write) ? counter_signal_ext_store : NULL;
> - parm.component = signal_ext_comp;
> - err = counter_attribute_create(&parm);
> - if (err) {
> - kfree(signal_ext_comp);
> - goto err_free_attr_list;
> - }
> - }
> -
> - return 0;
> -
> -err_free_attr_list:
> - counter_device_attr_list_free(&group->attr_list);
> - return err;
> -}
> -
> -static int counter_signal_attributes_create(
> - struct counter_device_attr_group *const group,
> - const struct counter_device *const counter,
> - struct counter_signal *const signal)
> -{
> - struct counter_signal_unit *signal_comp;
> - struct counter_attr_parm parm;
> - int err;
> -
> - /* Allocate Signal attribute component */
> - signal_comp = kmalloc(sizeof(*signal_comp), GFP_KERNEL);
> - if (!signal_comp)
> - return -ENOMEM;
> - signal_comp->signal = signal;
> -
> - /* Create main Signal attribute */
> - parm.group = group;
> - parm.prefix = "";
> - parm.name = "signal";
> - parm.show = (counter->ops->signal_read) ? counter_signal_show : NULL;
> - parm.store = NULL;
> - parm.component = signal_comp;
> - err = counter_attribute_create(&parm);
> - if (err) {
> - kfree(signal_comp);
> - return err;
> - }
> -
> - /* Create Signal name attribute */
> - err = counter_name_attribute_create(group, signal->name);
> - if (err)
> - goto err_free_attr_list;
> -
> - /* Register Signal extension attributes */
> - err = counter_signal_ext_register(group, signal);
> - if (err)
> - goto err_free_attr_list;
> -
> - return 0;
> -
> -err_free_attr_list:
> - counter_device_attr_list_free(&group->attr_list);
> - return err;
> -}
> -
> -static int counter_signals_register(
> - struct counter_device_attr_group *const groups_list,
> - const struct counter_device *const counter)
> -{
> - const size_t num_signals = counter->num_signals;
> - size_t i;
> - struct counter_signal *signal;
> - const char *name;
> - int err;
> -
> - /* Register each Signal */
> - for (i = 0; i < num_signals; i++) {
> - signal = counter->signals + i;
> -
> - /* Generate Signal attribute directory name */
> - name = kasprintf(GFP_KERNEL, "signal%d", signal->id);
> - if (!name) {
> - err = -ENOMEM;
> - goto err_free_attr_groups;
> - }
> - groups_list[i].attr_group.name = name;
> -
> - /* Create all attributes associated with Signal */
> - err = counter_signal_attributes_create(groups_list + i, counter,
> - signal);
> - if (err)
> - goto err_free_attr_groups;
> - }
> -
> - return 0;
> -
> -err_free_attr_groups:
> - do {
> - kfree(groups_list[i].attr_group.name);
> - counter_device_attr_list_free(&groups_list[i].attr_list);
> - } while (i--);
> - return err;
> -}
> -
> -static const char *const counter_synapse_action_str[] = {
> - [COUNTER_SYNAPSE_ACTION_NONE] = "none",
> - [COUNTER_SYNAPSE_ACTION_RISING_EDGE] = "rising edge",
> - [COUNTER_SYNAPSE_ACTION_FALLING_EDGE] = "falling edge",
> - [COUNTER_SYNAPSE_ACTION_BOTH_EDGES] = "both edges"
> -};
> -
> -struct counter_action_unit {
> - struct counter_synapse *synapse;
> - struct counter_count *count;
> -};
> -
> -static ssize_t counter_action_show(struct device *dev,
> - struct device_attribute *attr, char *buf)
> -{
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - int err;
> - struct counter_device *const counter = dev_get_drvdata(dev);
> - const struct counter_action_unit *const component = devattr->component;
> - struct counter_count *const count = component->count;
> - struct counter_synapse *const synapse = component->synapse;
> - size_t action_index;
> - enum counter_synapse_action action;
> -
> - err = counter->ops->action_get(counter, count, synapse, &action_index);
> - if (err)
> - return err;
> -
> - synapse->action = action_index;
> -
> - action = synapse->actions_list[action_index];
> - return sprintf(buf, "%s\n", counter_synapse_action_str[action]);
> -}
> -
> -static ssize_t counter_action_store(struct device *dev,
> - struct device_attribute *attr,
> - const char *buf, size_t len)
> -{
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_action_unit *const component = devattr->component;
> - struct counter_synapse *const synapse = component->synapse;
> - size_t action_index;
> - const size_t num_actions = synapse->num_actions;
> - enum counter_synapse_action action;
> - int err;
> - struct counter_device *const counter = dev_get_drvdata(dev);
> - struct counter_count *const count = component->count;
> -
> - /* Find requested action mode */
> - for (action_index = 0; action_index < num_actions; action_index++) {
> - action = synapse->actions_list[action_index];
> - if (sysfs_streq(buf, counter_synapse_action_str[action]))
> - break;
> - }
> - /* If requested action mode not found */
> - if (action_index >= num_actions)
> - return -EINVAL;
> -
> - err = counter->ops->action_set(counter, count, synapse, action_index);
> - if (err)
> - return err;
> -
> - synapse->action = action_index;
> -
> - return len;
> -}
> -
> -struct counter_action_avail_unit {
> - const enum counter_synapse_action *actions_list;
> - size_t num_actions;
> -};
> -
> -static ssize_t counter_synapse_action_available_show(struct device *dev,
> - struct device_attribute *attr, char *buf)
> -{
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_action_avail_unit *const component = devattr->component;
> - size_t i;
> - enum counter_synapse_action action;
> - ssize_t len = 0;
> -
> - for (i = 0; i < component->num_actions; i++) {
> - action = component->actions_list[i];
> - len += sprintf(buf + len, "%s\n",
> - counter_synapse_action_str[action]);
> - }
> -
> - return len;
> -}
> -
> -static int counter_synapses_register(
> - struct counter_device_attr_group *const group,
> - const struct counter_device *const counter,
> - struct counter_count *const count, const char *const count_attr_name)
> -{
> - size_t i;
> - struct counter_synapse *synapse;
> - const char *prefix;
> - struct counter_action_unit *action_comp;
> - struct counter_attr_parm parm;
> - int err;
> - struct counter_action_avail_unit *avail_comp;
> -
> - /* Register each Synapse */
> - for (i = 0; i < count->num_synapses; i++) {
> - synapse = count->synapses + i;
> -
> - /* Generate attribute prefix */
> - prefix = kasprintf(GFP_KERNEL, "signal%d_",
> - synapse->signal->id);
> - if (!prefix) {
> - err = -ENOMEM;
> - goto err_free_attr_list;
> - }
> -
> - /* Allocate action attribute component */
> - action_comp = kmalloc(sizeof(*action_comp), GFP_KERNEL);
> - if (!action_comp) {
> - err = -ENOMEM;
> - goto err_free_prefix;
> - }
> - action_comp->synapse = synapse;
> - action_comp->count = count;
> -
> - /* Create action attribute */
> - parm.group = group;
> - parm.prefix = prefix;
> - parm.name = "action";
> - parm.show = (counter->ops->action_get) ? counter_action_show : NULL;
> - parm.store = (counter->ops->action_set) ? counter_action_store : NULL;
> - parm.component = action_comp;
> - err = counter_attribute_create(&parm);
> - if (err) {
> - kfree(action_comp);
> - goto err_free_prefix;
> - }
> -
> - /* Allocate action available attribute component */
> - avail_comp = kmalloc(sizeof(*avail_comp), GFP_KERNEL);
> - if (!avail_comp) {
> - err = -ENOMEM;
> - goto err_free_prefix;
> - }
> - avail_comp->actions_list = synapse->actions_list;
> - avail_comp->num_actions = synapse->num_actions;
> -
> - /* Create action_available attribute */
> - parm.group = group;
> - parm.prefix = prefix;
> - parm.name = "action_available";
> - parm.show = counter_synapse_action_available_show;
> - parm.store = NULL;
> - parm.component = avail_comp;
> - err = counter_attribute_create(&parm);
> - if (err) {
> - kfree(avail_comp);
> - goto err_free_prefix;
> - }
> -
> - kfree(prefix);
> - }
> -
> - return 0;
> -
> -err_free_prefix:
> - kfree(prefix);
> -err_free_attr_list:
> - counter_device_attr_list_free(&group->attr_list);
> - return err;
> -}
> -
> -struct counter_count_unit {
> - struct counter_count *count;
> -};
> -
> -static ssize_t counter_count_show(struct device *dev,
> - struct device_attribute *attr,
> - char *buf)
> -{
> - struct counter_device *const counter = dev_get_drvdata(dev);
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_count_unit *const component = devattr->component;
> - struct counter_count *const count = component->count;
> - int err;
> - unsigned long val;
> -
> - err = counter->ops->count_read(counter, count, &val);
> - if (err)
> - return err;
> -
> - return sprintf(buf, "%lu\n", val);
> -}
> -
> -static ssize_t counter_count_store(struct device *dev,
> - struct device_attribute *attr,
> - const char *buf, size_t len)
> -{
> - struct counter_device *const counter = dev_get_drvdata(dev);
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_count_unit *const component = devattr->component;
> - struct counter_count *const count = component->count;
> - int err;
> - unsigned long val;
> -
> - err = kstrtoul(buf, 0, &val);
> - if (err)
> - return err;
> -
> - err = counter->ops->count_write(counter, count, val);
> - if (err)
> - return err;
> -
> - return len;
> -}
> -
> -static const char *const counter_count_function_str[] = {
> - [COUNTER_COUNT_FUNCTION_INCREASE] = "increase",
> - [COUNTER_COUNT_FUNCTION_DECREASE] = "decrease",
> - [COUNTER_COUNT_FUNCTION_PULSE_DIRECTION] = "pulse-direction",
> - [COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A] = "quadrature x1 a",
> - [COUNTER_COUNT_FUNCTION_QUADRATURE_X1_B] = "quadrature x1 b",
> - [COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A] = "quadrature x2 a",
> - [COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B] = "quadrature x2 b",
> - [COUNTER_COUNT_FUNCTION_QUADRATURE_X4] = "quadrature x4"
> -};
> -
> -static ssize_t counter_function_show(struct device *dev,
> - struct device_attribute *attr, char *buf)
> -{
> - int err;
> - struct counter_device *const counter = dev_get_drvdata(dev);
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_count_unit *const component = devattr->component;
> - struct counter_count *const count = component->count;
> - size_t func_index;
> - enum counter_count_function function;
> -
> - err = counter->ops->function_get(counter, count, &func_index);
> - if (err)
> - return err;
> -
> - count->function = func_index;
> -
> - function = count->functions_list[func_index];
> - return sprintf(buf, "%s\n", counter_count_function_str[function]);
> -}
> -
> -static ssize_t counter_function_store(struct device *dev,
> - struct device_attribute *attr,
> - const char *buf, size_t len)
> -{
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_count_unit *const component = devattr->component;
> - struct counter_count *const count = component->count;
> - const size_t num_functions = count->num_functions;
> - size_t func_index;
> - enum counter_count_function function;
> - int err;
> - struct counter_device *const counter = dev_get_drvdata(dev);
> -
> - /* Find requested Count function mode */
> - for (func_index = 0; func_index < num_functions; func_index++) {
> - function = count->functions_list[func_index];
> - if (sysfs_streq(buf, counter_count_function_str[function]))
> - break;
> - }
> - /* Return error if requested Count function mode not found */
> - if (func_index >= num_functions)
> - return -EINVAL;
> -
> - err = counter->ops->function_set(counter, count, func_index);
> - if (err)
> - return err;
> -
> - count->function = func_index;
> -
> - return len;
> -}
> -
> -struct counter_count_ext_unit {
> - struct counter_count *count;
> - const struct counter_count_ext *ext;
> -};
> -
> -static ssize_t counter_count_ext_show(struct device *dev,
> - struct device_attribute *attr, char *buf)
> -{
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_count_ext_unit *const comp = devattr->component;
> - const struct counter_count_ext *const ext = comp->ext;
> -
> - return ext->read(dev_get_drvdata(dev), comp->count, ext->priv, buf);
> -}
> -
> -static ssize_t counter_count_ext_store(struct device *dev,
> - struct device_attribute *attr,
> - const char *buf, size_t len)
> -{
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_count_ext_unit *const comp = devattr->component;
> - const struct counter_count_ext *const ext = comp->ext;
> -
> - return ext->write(dev_get_drvdata(dev), comp->count, ext->priv, buf,
> - len);
> -}
> -
> -static int counter_count_ext_register(
> - struct counter_device_attr_group *const group,
> - struct counter_count *const count)
> -{
> - size_t i;
> - const struct counter_count_ext *ext;
> - struct counter_count_ext_unit *count_ext_comp;
> - struct counter_attr_parm parm;
> - int err;
> -
> - /* Create an attribute for each extension */
> - for (i = 0 ; i < count->num_ext; i++) {
> - ext = count->ext + i;
> -
> - /* Allocate count_ext attribute component */
> - count_ext_comp = kmalloc(sizeof(*count_ext_comp), GFP_KERNEL);
> - if (!count_ext_comp) {
> - err = -ENOMEM;
> - goto err_free_attr_list;
> - }
> - count_ext_comp->count = count;
> - count_ext_comp->ext = ext;
> -
> - /* Allocate count_ext attribute */
> - parm.group = group;
> - parm.prefix = "";
> - parm.name = ext->name;
> - parm.show = (ext->read) ? counter_count_ext_show : NULL;
> - parm.store = (ext->write) ? counter_count_ext_store : NULL;
> - parm.component = count_ext_comp;
> - err = counter_attribute_create(&parm);
> - if (err) {
> - kfree(count_ext_comp);
> - goto err_free_attr_list;
> - }
> - }
> -
> - return 0;
> -
> -err_free_attr_list:
> - counter_device_attr_list_free(&group->attr_list);
> - return err;
> -}
> -
> -struct counter_func_avail_unit {
> - const enum counter_count_function *functions_list;
> - size_t num_functions;
> -};
> -
> -static ssize_t counter_count_function_available_show(struct device *dev,
> - struct device_attribute *attr, char *buf)
> -{
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_func_avail_unit *const component = devattr->component;
> - const enum counter_count_function *const func_list = component->functions_list;
> - const size_t num_functions = component->num_functions;
> - size_t i;
> - enum counter_count_function function;
> - ssize_t len = 0;
> -
> - for (i = 0; i < num_functions; i++) {
> - function = func_list[i];
> - len += sprintf(buf + len, "%s\n",
> - counter_count_function_str[function]);
> - }
> -
> - return len;
> -}
> -
> -static int counter_count_attributes_create(
> - struct counter_device_attr_group *const group,
> - const struct counter_device *const counter,
> - struct counter_count *const count)
> -{
> - struct counter_count_unit *count_comp;
> - struct counter_attr_parm parm;
> - int err;
> - struct counter_count_unit *func_comp;
> - struct counter_func_avail_unit *avail_comp;
> -
> - /* Allocate count attribute component */
> - count_comp = kmalloc(sizeof(*count_comp), GFP_KERNEL);
> - if (!count_comp)
> - return -ENOMEM;
> - count_comp->count = count;
> -
> - /* Create main Count attribute */
> - parm.group = group;
> - parm.prefix = "";
> - parm.name = "count";
> - parm.show = (counter->ops->count_read) ? counter_count_show : NULL;
> - parm.store = (counter->ops->count_write) ? counter_count_store : NULL;
> - parm.component = count_comp;
> - err = counter_attribute_create(&parm);
> - if (err) {
> - kfree(count_comp);
> - return err;
> - }
> -
> - /* Allocate function attribute component */
> - func_comp = kmalloc(sizeof(*func_comp), GFP_KERNEL);
> - if (!func_comp) {
> - err = -ENOMEM;
> - goto err_free_attr_list;
> - }
> - func_comp->count = count;
> -
> - /* Create Count function attribute */
> - parm.group = group;
> - parm.prefix = "";
> - parm.name = "function";
> - parm.show = (counter->ops->function_get) ? counter_function_show : NULL;
> - parm.store = (counter->ops->function_set) ? counter_function_store : NULL;
> - parm.component = func_comp;
> - err = counter_attribute_create(&parm);
> - if (err) {
> - kfree(func_comp);
> - goto err_free_attr_list;
> - }
> -
> - /* Allocate function available attribute component */
> - avail_comp = kmalloc(sizeof(*avail_comp), GFP_KERNEL);
> - if (!avail_comp) {
> - err = -ENOMEM;
> - goto err_free_attr_list;
> - }
> - avail_comp->functions_list = count->functions_list;
> - avail_comp->num_functions = count->num_functions;
> -
> - /* Create Count function_available attribute */
> - parm.group = group;
> - parm.prefix = "";
> - parm.name = "function_available";
> - parm.show = counter_count_function_available_show;
> - parm.store = NULL;
> - parm.component = avail_comp;
> - err = counter_attribute_create(&parm);
> - if (err) {
> - kfree(avail_comp);
> - goto err_free_attr_list;
> - }
> -
> - /* Create Count name attribute */
> - err = counter_name_attribute_create(group, count->name);
> - if (err)
> - goto err_free_attr_list;
> -
> - /* Register Count extension attributes */
> - err = counter_count_ext_register(group, count);
> - if (err)
> - goto err_free_attr_list;
> -
> - return 0;
> -
> -err_free_attr_list:
> - counter_device_attr_list_free(&group->attr_list);
> - return err;
> -}
> -
> -static int counter_counts_register(
> - struct counter_device_attr_group *const groups_list,
> - const struct counter_device *const counter)
> -{
> - size_t i;
> - struct counter_count *count;
> - const char *name;
> - int err;
> -
> - /* Register each Count */
> - for (i = 0; i < counter->num_counts; i++) {
> - count = counter->counts + i;
> -
> - /* Generate Count attribute directory name */
> - name = kasprintf(GFP_KERNEL, "count%d", count->id);
> - if (!name) {
> - err = -ENOMEM;
> - goto err_free_attr_groups;
> - }
> - groups_list[i].attr_group.name = name;
> -
> - /* Register the Synapses associated with each Count */
> - err = counter_synapses_register(groups_list + i, counter, count,
> - name);
> - if (err)
> - goto err_free_attr_groups;
> -
> - /* Create all attributes associated with Count */
> - err = counter_count_attributes_create(groups_list + i, counter,
> - count);
> - if (err)
> - goto err_free_attr_groups;
> - }
> -
> - return 0;
> -
> -err_free_attr_groups:
> - do {
> - kfree(groups_list[i].attr_group.name);
> - counter_device_attr_list_free(&groups_list[i].attr_list);
> - } while (i--);
> - return err;
> -}
> -
> -struct counter_size_unit {
> - size_t size;
> -};
> -
> -static ssize_t counter_device_attr_size_show(struct device *dev,
> - struct device_attribute *attr,
> - char *buf)
> -{
> - const struct counter_size_unit *const comp = to_counter_attr(attr)->component;
> -
> - return sprintf(buf, "%zu\n", comp->size);
> -}
> -
> -static int counter_size_attribute_create(
> - struct counter_device_attr_group *const group,
> - const size_t size, const char *const name)
> -{
> - struct counter_size_unit *size_comp;
> - struct counter_attr_parm parm;
> - int err;
> -
> - /* Allocate size attribute component */
> - size_comp = kmalloc(sizeof(*size_comp), GFP_KERNEL);
> - if (!size_comp)
> - return -ENOMEM;
> - size_comp->size = size;
> -
> - parm.group = group;
> - parm.prefix = "";
> - parm.name = name;
> - parm.show = counter_device_attr_size_show;
> - parm.store = NULL;
> - parm.component = size_comp;
> - err = counter_attribute_create(&parm);
> - if (err)
> - goto err_free_size_comp;
> -
> - return 0;
> -
> -err_free_size_comp:
> - kfree(size_comp);
> - return err;
> -}
> -
> -struct counter_ext_unit {
> - const struct counter_device_ext *ext;
> -};
> -
> -static ssize_t counter_device_ext_show(struct device *dev,
> - struct device_attribute *attr, char *buf)
> -{
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_ext_unit *const component = devattr->component;
> - const struct counter_device_ext *const ext = component->ext;
> -
> - return ext->read(dev_get_drvdata(dev), ext->priv, buf);
> -}
> -
> -static ssize_t counter_device_ext_store(struct device *dev,
> - struct device_attribute *attr,
> - const char *buf, size_t len)
> -{
> - const struct counter_device_attr *const devattr = to_counter_attr(attr);
> - const struct counter_ext_unit *const component = devattr->component;
> - const struct counter_device_ext *const ext = component->ext;
> -
> - return ext->write(dev_get_drvdata(dev), ext->priv, buf, len);
> -}
> -
> -static int counter_device_ext_register(
> - struct counter_device_attr_group *const group,
> - struct counter_device *const counter)
> -{
> - size_t i;
> - struct counter_ext_unit *ext_comp;
> - struct counter_attr_parm parm;
> - int err;
> -
> - /* Create an attribute for each extension */
> - for (i = 0 ; i < counter->num_ext; i++) {
> - /* Allocate extension attribute component */
> - ext_comp = kmalloc(sizeof(*ext_comp), GFP_KERNEL);
> - if (!ext_comp) {
> - err = -ENOMEM;
> - goto err_free_attr_list;
> - }
> -
> - ext_comp->ext = counter->ext + i;
> -
> - /* Allocate extension attribute */
> - parm.group = group;
> - parm.prefix = "";
> - parm.name = counter->ext[i].name;
> - parm.show = (counter->ext[i].read) ? counter_device_ext_show : NULL;
> - parm.store = (counter->ext[i].write) ? counter_device_ext_store : NULL;
> - parm.component = ext_comp;
> - err = counter_attribute_create(&parm);
> - if (err) {
> - kfree(ext_comp);
> - goto err_free_attr_list;
> - }
> - }
> -
> - return 0;
> -
> -err_free_attr_list:
> - counter_device_attr_list_free(&group->attr_list);
> - return err;
> -}
> -
> -static int counter_global_attr_register(
> - struct counter_device_attr_group *const group,
> - struct counter_device *const counter)
> -{
> - int err;
> -
> - /* Create name attribute */
> - err = counter_name_attribute_create(group, counter->name);
> - if (err)
> - return err;
> -
> - /* Create num_counts attribute */
> - err = counter_size_attribute_create(group, counter->num_counts,
> - "num_counts");
> - if (err)
> - goto err_free_attr_list;
> -
> - /* Create num_signals attribute */
> - err = counter_size_attribute_create(group, counter->num_signals,
> - "num_signals");
> - if (err)
> - goto err_free_attr_list;
> -
> - /* Register Counter device extension attributes */
> - err = counter_device_ext_register(group, counter);
> - if (err)
> - goto err_free_attr_list;
> -
> - return 0;
> -
> -err_free_attr_list:
> - counter_device_attr_list_free(&group->attr_list);
> - return err;
> -}
> -
> -static void counter_device_groups_list_free(
> - struct counter_device_attr_group *const groups_list,
> - const size_t num_groups)
> -{
> - struct counter_device_attr_group *group;
> - size_t i;
> -
> - /* loop through all attribute groups (signals, counts, global, etc.) */
> - for (i = 0; i < num_groups; i++) {
> - group = groups_list + i;
> -
> - /* free all attribute group and associated attributes memory */
> - kfree(group->attr_group.name);
> - kfree(group->attr_group.attrs);
> - counter_device_attr_list_free(&group->attr_list);
> - }
> -
> - kfree(groups_list);
> -}
> -
> -static int counter_device_groups_list_prepare(
> - struct counter_device *const counter)
> -{
> - const size_t total_num_groups =
> - counter->num_signals + counter->num_counts + 1;
> - struct counter_device_attr_group *groups_list;
> - size_t i;
> - int err;
> - size_t num_groups = 0;
> -
> - /* Allocate space for attribute groups (signals, counts, and ext) */
> - groups_list = kcalloc(total_num_groups, sizeof(*groups_list),
> - GFP_KERNEL);
> - if (!groups_list)
> - return -ENOMEM;
> -
> - /* Initialize attribute lists */
> - for (i = 0; i < total_num_groups; i++)
> - INIT_LIST_HEAD(&groups_list[i].attr_list);
> -
> - /* Register Signals */
> - err = counter_signals_register(groups_list, counter);
> - if (err)
> - goto err_free_groups_list;
> - num_groups += counter->num_signals;
> -
> - /* Register Counts and respective Synapses */
> - err = counter_counts_register(groups_list + num_groups, counter);
> - if (err)
> - goto err_free_groups_list;
> - num_groups += counter->num_counts;
> -
> - /* Register Counter global attributes */
> - err = counter_global_attr_register(groups_list + num_groups, counter);
> - if (err)
> - goto err_free_groups_list;
> - num_groups++;
> -
> - /* Store groups_list in device_state */
> - counter->device_state->groups_list = groups_list;
> - counter->device_state->num_groups = num_groups;
> -
> - return 0;
> -
> -err_free_groups_list:
> - counter_device_groups_list_free(groups_list, num_groups);
> - return err;
> -}
> -
> -static int counter_device_groups_prepare(
> - struct counter_device_state *const device_state)
> -{
> - size_t i, j;
> - struct counter_device_attr_group *group;
> - int err;
> - struct counter_device_attr *p;
> -
> - /* Allocate attribute groups for association with device */
> - device_state->groups = kcalloc(device_state->num_groups + 1,
> - sizeof(*device_state->groups),
> - GFP_KERNEL);
> - if (!device_state->groups)
> - return -ENOMEM;
> -
> - /* Prepare each group of attributes for association */
> - for (i = 0; i < device_state->num_groups; i++) {
> - group = device_state->groups_list + i;
> -
> - /* Allocate space for attribute pointers in attribute group */
> - group->attr_group.attrs = kcalloc(group->num_attr + 1,
> - sizeof(*group->attr_group.attrs), GFP_KERNEL);
> - if (!group->attr_group.attrs) {
> - err = -ENOMEM;
> - goto err_free_groups;
> - }
> -
> - /* Add attribute pointers to attribute group */
> - j = 0;
> - list_for_each_entry(p, &group->attr_list, l)
> - group->attr_group.attrs[j++] = &p->dev_attr.attr;
> -
> - /* Group attributes in attribute group */
> - device_state->groups[i] = &group->attr_group;
> - }
> - /* Associate attributes with device */
> - device_state->dev.groups = device_state->groups;
> -
> - return 0;
> -
> -err_free_groups:
> - do {
> - group = device_state->groups_list + i;
> - kfree(group->attr_group.attrs);
> - group->attr_group.attrs = NULL;
> - } while (i--);
> - kfree(device_state->groups);
> - return err;
> -}
> -
> -/* Provides a unique ID for each counter device */
> -static DEFINE_IDA(counter_ida);
> -
> -static void counter_device_release(struct device *dev)
> -{
> - struct counter_device *const counter = dev_get_drvdata(dev);
> - struct counter_device_state *const device_state = counter->device_state;
> -
> - kfree(device_state->groups);
> - counter_device_groups_list_free(device_state->groups_list,
> - device_state->num_groups);
> - ida_simple_remove(&counter_ida, device_state->id);
> - kfree(device_state);
> -}
> -
> -static struct device_type counter_device_type = {
> - .name = "counter_device",
> - .release = counter_device_release
> -};
> -
> -static struct bus_type counter_bus_type = {
> - .name = "counter"
> -};
> -
> -/**
> - * counter_register - register Counter to the system
> - * @counter: pointer to Counter to register
> - *
> - * This function registers a Counter to the system. A sysfs "counter" directory
> - * will be created and populated with sysfs attributes correlating with the
> - * Counter Signals, Synapses, and Counts respectively.
> - */
> -int counter_register(struct counter_device *const counter)
> -{
> - struct counter_device_state *device_state;
> - int err;
> -
> - /* Allocate internal state container for Counter device */
> - device_state = kzalloc(sizeof(*device_state), GFP_KERNEL);
> - if (!device_state)
> - return -ENOMEM;
> - counter->device_state = device_state;
> -
> - /* Acquire unique ID */
> - device_state->id = ida_simple_get(&counter_ida, 0, 0, GFP_KERNEL);
> - if (device_state->id < 0) {
> - err = device_state->id;
> - goto err_free_device_state;
> - }
> -
> - /* Configure device structure for Counter */
> - device_state->dev.type = &counter_device_type;
> - device_state->dev.bus = &counter_bus_type;
> - if (counter->parent) {
> - device_state->dev.parent = counter->parent;
> - device_state->dev.of_node = counter->parent->of_node;
> - }
> - dev_set_name(&device_state->dev, "counter%d", device_state->id);
> - device_initialize(&device_state->dev);
> - dev_set_drvdata(&device_state->dev, counter);
> -
> - /* Prepare device attributes */
> - err = counter_device_groups_list_prepare(counter);
> - if (err)
> - goto err_free_id;
> -
> - /* Organize device attributes to groups and match to device */
> - err = counter_device_groups_prepare(device_state);
> - if (err)
> - goto err_free_groups_list;
> -
> - /* Add device to system */
> - err = device_add(&device_state->dev);
> - if (err)
> - goto err_free_groups;
> -
> - return 0;
> -
> -err_free_groups:
> - kfree(device_state->groups);
> -err_free_groups_list:
> - counter_device_groups_list_free(device_state->groups_list,
> - device_state->num_groups);
> -err_free_id:
> - ida_simple_remove(&counter_ida, device_state->id);
> -err_free_device_state:
> - kfree(device_state);
> - return err;
> -}
> -EXPORT_SYMBOL_GPL(counter_register);
> -
> -/**
> - * counter_unregister - unregister Counter from the system
> - * @counter: pointer to Counter to unregister
> - *
> - * The Counter is unregistered from the system; all allocated memory is freed.
> - */
> -void counter_unregister(struct counter_device *const counter)
> -{
> - if (counter)
> - device_del(&counter->device_state->dev);
> -}
> -EXPORT_SYMBOL_GPL(counter_unregister);
> -
> -static void devm_counter_unreg(struct device *dev, void *res)
> -{
> - counter_unregister(*(struct counter_device **)res);
> -}
> -
> -/**
> - * devm_counter_register - Resource-managed counter_register
> - * @dev: device to allocate counter_device for
> - * @counter: pointer to Counter to register
> - *
> - * Managed counter_register. The Counter registered with this function is
> - * automatically unregistered on driver detach. This function calls
> - * counter_register internally. Refer to that function for more information.
> - *
> - * If an Counter registered with this function needs to be unregistered
> - * separately, devm_counter_unregister must be used.
> - *
> - * RETURNS:
> - * 0 on success, negative error number on failure.
> - */
> -int devm_counter_register(struct device *dev,
> - struct counter_device *const counter)
> -{
> - struct counter_device **ptr;
> - int ret;
> -
> - ptr = devres_alloc(devm_counter_unreg, sizeof(*ptr), GFP_KERNEL);
> - if (!ptr)
> - return -ENOMEM;
> -
> - ret = counter_register(counter);
> - if (!ret) {
> - *ptr = counter;
> - devres_add(dev, ptr);
> - } else {
> - devres_free(ptr);
> - }
> -
> - return ret;
> -}
> -EXPORT_SYMBOL_GPL(devm_counter_register);
> -
> -static int devm_counter_match(struct device *dev, void *res, void *data)
> -{
> - struct counter_device **r = res;
> -
> - if (!r || !*r) {
> - WARN_ON(!r || !*r);
> - return 0;
> - }
> -
> - return *r == data;
> -}
> -
> -/**
> - * devm_counter_unregister - Resource-managed counter_unregister
> - * @dev: device this counter_device belongs to
> - * @counter: pointer to Counter associated with the device
> - *
> - * Unregister Counter registered with devm_counter_register.
> - */
> -void devm_counter_unregister(struct device *dev,
> - struct counter_device *const counter)
> -{
> - int rc;
> -
> - rc = devres_release(dev, devm_counter_unreg, devm_counter_match,
> - counter);
> - WARN_ON(rc);
> -}
> -EXPORT_SYMBOL_GPL(devm_counter_unregister);
> -
> -static int __init counter_init(void)
> -{
> - return bus_register(&counter_bus_type);
> -}
> -
> -static void __exit counter_exit(void)
> -{
> - bus_unregister(&counter_bus_type);
> -}
> -
> -subsys_initcall(counter_init);
> -module_exit(counter_exit);
> -
> -MODULE_AUTHOR("William Breathitt Gray <[email protected]>");
> -MODULE_DESCRIPTION("Generic Counter interface");
> -MODULE_LICENSE("GPL v2");
> diff --git a/drivers/counter/ftm-quaddec.c b/drivers/counter/ftm-quaddec.c
> index c2b3fdfd8b77..450353f495a2 100644
> --- a/drivers/counter/ftm-quaddec.c
> +++ b/drivers/counter/ftm-quaddec.c
> @@ -151,29 +151,19 @@ static const char * const ftm_quaddec_prescaler[] = {
> "1", "2", "4", "8", "16", "32", "64", "128"
> };
>
> -static struct counter_count_enum_ext ftm_quaddec_prescaler_enum = {
> - .items = ftm_quaddec_prescaler,
> - .num_items = ARRAY_SIZE(ftm_quaddec_prescaler),
> - .get = ftm_quaddec_get_prescaler,
> - .set = ftm_quaddec_set_prescaler
> -};
> -
> -enum ftm_quaddec_synapse_action {
> - FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES,
> -};
> +static DEFINE_COUNTER_ENUM(ftm_quaddec_prescaler_enum, ftm_quaddec_prescaler);
>
> -static enum counter_synapse_action ftm_quaddec_synapse_actions[] = {
> - [FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES] =
> +static const enum counter_synapse_action ftm_quaddec_synapse_actions[] = {
> COUNTER_SYNAPSE_ACTION_BOTH_EDGES
> };
>
> enum ftm_quaddec_count_function {
> - FTM_QUADDEC_COUNT_ENCODER_MODE_1,
> + FTM_QUADDEC_COUNT_ENCODER_MODE_1 =
> + COUNTER_COUNT_FUNCTION_QUADRATURE_X4
> };
>
> static const enum counter_count_function ftm_quaddec_count_functions[] = {
> - [FTM_QUADDEC_COUNT_ENCODER_MODE_1] =
> - COUNTER_COUNT_FUNCTION_QUADRATURE_X4
> + FTM_QUADDEC_COUNT_ENCODER_MODE_1
> };
>
> static int ftm_quaddec_count_read(struct counter_device *counter,
> @@ -208,7 +198,7 @@ static int ftm_quaddec_count_write(struct counter_device *counter,
>
> static int ftm_quaddec_count_function_get(struct counter_device *counter,
> struct counter_count *count,
> - size_t *function)
> + enum counter_count_function *function)
> {
> *function = FTM_QUADDEC_COUNT_ENCODER_MODE_1;
>
> @@ -218,20 +208,13 @@ static int ftm_quaddec_count_function_get(struct counter_device *counter,
> static int ftm_quaddec_action_get(struct counter_device *counter,
> struct counter_count *count,
> struct counter_synapse *synapse,
> - size_t *action)
> + enum counter_synapse_action *action)
> {
> - *action = FTM_QUADDEC_SYNAPSE_ACTION_BOTH_EDGES;
> + *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
>
> return 0;
> }
>
> -static const struct counter_ops ftm_quaddec_cnt_ops = {
> - .count_read = ftm_quaddec_count_read,
> - .count_write = ftm_quaddec_count_write,
> - .function_get = ftm_quaddec_count_function_get,
> - .action_get = ftm_quaddec_action_get,
> -};
> -
> static struct counter_signal ftm_quaddec_signals[] = {
> {
> .id = 0,
> @@ -256,9 +239,11 @@ static struct counter_synapse ftm_quaddec_count_synapses[] = {
> }
> };
>
> -static const struct counter_count_ext ftm_quaddec_count_ext[] = {
> - COUNTER_COUNT_ENUM("prescaler", &ftm_quaddec_prescaler_enum),
> - COUNTER_COUNT_ENUM_AVAILABLE("prescaler", &ftm_quaddec_prescaler_enum),
> +static struct counter_data ftm_quaddec_count_ext[] = {
> + COUNTER_DATA_ENUM_AND_AVAILABLE("prescaler",
> + ftm_quaddec_get_prescaler,
> + ftm_quaddec_set_prescaler,
> + ftm_quaddec_prescaler_enum),
> };
>
> static struct counter_count ftm_quaddec_counts = {
> @@ -302,7 +287,10 @@ static int ftm_quaddec_probe(struct platform_device *pdev)
> }
> ftm->counter.name = dev_name(&pdev->dev);
> ftm->counter.parent = &pdev->dev;
> - ftm->counter.ops = &ftm_quaddec_cnt_ops;
> + ftm->counter.count_read = ftm_quaddec_count_read;
> + ftm->counter.count_write = ftm_quaddec_count_write;
> + ftm->counter.function_read = ftm_quaddec_count_function_get;
> + ftm->counter.action_read = ftm_quaddec_action_get;
> ftm->counter.counts = &ftm_quaddec_counts;
> ftm->counter.num_counts = 1;
> ftm->counter.signals = ftm_quaddec_signals;
> diff --git a/drivers/counter/stm32-lptimer-cnt.c b/drivers/counter/stm32-lptimer-cnt.c
> index 8e276eb655f5..53ca88533831 100644
> --- a/drivers/counter/stm32-lptimer-cnt.c
> +++ b/drivers/counter/stm32-lptimer-cnt.c
> @@ -352,30 +352,44 @@ static const struct iio_chan_spec stm32_lptim_cnt_channels = {
> * @STM32_LPTIM_ENCODER_BOTH_EDGE: count on both edges (IN1 & IN2 quadrature)
> */
> enum stm32_lptim_cnt_function {
> - STM32_LPTIM_COUNTER_INCREASE,
> - STM32_LPTIM_ENCODER_BOTH_EDGE,
> + STM32_LPTIM_COUNTER_INCREASE = COUNTER_COUNT_FUNCTION_INCREASE,
> + STM32_LPTIM_ENCODER_BOTH_EDGE = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
> };
>
> static enum counter_count_function stm32_lptim_cnt_functions[] = {
> - [STM32_LPTIM_COUNTER_INCREASE] = COUNTER_COUNT_FUNCTION_INCREASE,
> - [STM32_LPTIM_ENCODER_BOTH_EDGE] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
> + STM32_LPTIM_COUNTER_INCREASE,
> + STM32_LPTIM_ENCODER_BOTH_EDGE,
> };
>
> enum stm32_lptim_synapse_action {
> + /* Index must match with stm32_lptim_cnt_polarity[] (priv->polarity) */
> STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE,
> STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE,
> STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES,
> STM32_LPTIM_SYNAPSE_ACTION_NONE,
> };
>
> -static enum counter_synapse_action stm32_lptim_cnt_synapse_actions[] = {
> - /* Index must match with stm32_lptim_cnt_polarity[] (priv->polarity) */
> +static const enum stm32_lptim_synapse_action stm32_lptim_c2l_actions_map[] = {
> + [COUNTER_SYNAPSE_ACTION_RISING_EDGE] = STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE,
> + [COUNTER_SYNAPSE_ACTION_FALLING_EDGE] = STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE,
> + [COUNTER_SYNAPSE_ACTION_BOTH_EDGES] = STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES,
> + [COUNTER_SYNAPSE_ACTION_NONE] = STM32_LPTIM_SYNAPSE_ACTION_NONE,
> +};
> +
> +static const enum counter_synapse_action stm32_lptim_l2c_actions_map[] = {
> [STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
> [STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
> [STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
> [STM32_LPTIM_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
> };
>
> +static const enum counter_synapse_action stm32_lptim_cnt_synapse_actions[] = {
> + stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE],
> + stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE],
> + stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES],
> + stm32_lptim_l2c_actions_map[STM32_LPTIM_SYNAPSE_ACTION_NONE],
> +};
> +
> static int stm32_lptim_cnt_read(struct counter_device *counter,
> struct counter_count *count, unsigned long *val)
> {
> @@ -394,7 +408,7 @@ static int stm32_lptim_cnt_read(struct counter_device *counter,
>
> static int stm32_lptim_cnt_function_get(struct counter_device *counter,
> struct counter_count *count,
> - size_t *function)
> + enum counter_count_function *function)
> {
> struct stm32_lptim_cnt *const priv = counter->priv;
>
> @@ -413,7 +427,7 @@ static int stm32_lptim_cnt_function_get(struct counter_device *counter,
>
> static int stm32_lptim_cnt_function_set(struct counter_device *counter,
> struct counter_count *count,
> - size_t function)
> + enum counter_count_function function)
> {
> struct stm32_lptim_cnt *const priv = counter->priv;
>
> @@ -423,19 +437,20 @@ static int stm32_lptim_cnt_function_set(struct counter_device *counter,
> switch (function) {
> case STM32_LPTIM_COUNTER_INCREASE:
> priv->quadrature_mode = 0;
> - return 0;
> + break;
> case STM32_LPTIM_ENCODER_BOTH_EDGE:
> priv->quadrature_mode = 1;
> priv->polarity = STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES;
> - return 0;
> + break;
> + default: return -EINVAL;
> }
>
> - return -EINVAL;
> + return 0;
> }
>
> -static ssize_t stm32_lptim_cnt_enable_read(struct counter_device *counter,
> - struct counter_count *count,
> - void *private, char *buf)
> +static int stm32_lptim_cnt_enable_read(struct counter_device *counter,
> + struct counter_count *count,
> + bool *enable)
> {
> struct stm32_lptim_cnt *const priv = counter->priv;
> int ret;
> @@ -444,22 +459,18 @@ static ssize_t stm32_lptim_cnt_enable_read(struct counter_device *counter,
> if (ret < 0)
> return ret;
>
> - return scnprintf(buf, PAGE_SIZE, "%u\n", ret);
> + *enable = ret;
> +
> + return 0;
> }
>
> -static ssize_t stm32_lptim_cnt_enable_write(struct counter_device *counter,
> - struct counter_count *count,
> - void *private,
> - const char *buf, size_t len)
> +static int stm32_lptim_cnt_enable_write(struct counter_device *counter,
> + struct counter_count *count,
> + bool enable)
> {
> struct stm32_lptim_cnt *const priv = counter->priv;
> - bool enable;
> int ret;
>
> - ret = kstrtobool(buf, &enable);
> - if (ret)
> - return ret;
> -
> /* Check nobody uses the timer, or already disabled/enabled */
> ret = stm32_lptim_is_enabled(priv);
> if ((ret < 0) || (!ret && !enable))
> @@ -475,48 +486,51 @@ static ssize_t stm32_lptim_cnt_enable_write(struct counter_device *counter,
> if (ret)
> return ret;
>
> - return len;
> + return 0;
> }
>
> -static ssize_t stm32_lptim_cnt_ceiling_read(struct counter_device *counter,
> - struct counter_count *count,
> - void *private, char *buf)
> +static int stm32_lptim_cnt_ceiling_read(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long *ceiling)
> {
> struct stm32_lptim_cnt *const priv = counter->priv;
>
> - return stm32_lptim_cnt_get_ceiling(priv, buf);
> + *ceiling = priv->ceiling;
> +
> + return 0;
> }
>
> -static ssize_t stm32_lptim_cnt_ceiling_write(struct counter_device *counter,
> - struct counter_count *count,
> - void *private,
> - const char *buf, size_t len)
> +static int stm32_lptim_cnt_ceiling_write(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long ceiling)
> {
> struct stm32_lptim_cnt *const priv = counter->priv;
>
> - return stm32_lptim_cnt_set_ceiling(priv, buf, len);
> + if (stm32_lptim_is_enabled(priv))
> + return -EBUSY;
> +
> + priv->ceiling = ceiling;
> +
> + if (ceiling > STM32_LPTIM_MAX_ARR)
> + return -EINVAL;
> +
> + return 0;
> }
>
> -static const struct counter_count_ext stm32_lptim_cnt_ext[] = {
> - {
> - .name = "enable",
> - .read = stm32_lptim_cnt_enable_read,
> - .write = stm32_lptim_cnt_enable_write
> - },
> - {
> - .name = "ceiling",
> - .read = stm32_lptim_cnt_ceiling_read,
> - .write = stm32_lptim_cnt_ceiling_write
> - },
> +static struct counter_data stm32_lptim_cnt_ext[] = {
> + COUNTER_DATA_ENABLE(stm32_lptim_cnt_enable_read,
> + stm32_lptim_cnt_enable_write),
> + COUNTER_DATA_CEILING(stm32_lptim_cnt_ceiling_read,
> + stm32_lptim_cnt_ceiling_write),
> };
>
> static int stm32_lptim_cnt_action_get(struct counter_device *counter,
> struct counter_count *count,
> struct counter_synapse *synapse,
> - size_t *action)
> + enum counter_synapse_action *action)
> {
> struct stm32_lptim_cnt *const priv = counter->priv;
> - size_t function;
> + enum counter_count_function function;
> int err;
>
> err = stm32_lptim_cnt_function_get(counter, count, &function);
> @@ -527,25 +541,27 @@ static int stm32_lptim_cnt_action_get(struct counter_device *counter,
> case STM32_LPTIM_COUNTER_INCREASE:
> /* LP Timer acts as up-counter on input 1 */
> if (synapse->signal->id == count->synapses[0].signal->id)
> - *action = priv->polarity;
> + *action = stm32_lptim_l2c_actions_map[priv->polarity];
> else
> - *action = STM32_LPTIM_SYNAPSE_ACTION_NONE;
> - return 0;
> + *action = COUNTER_SYNAPSE_ACTION_NONE;
> + break;
> case STM32_LPTIM_ENCODER_BOTH_EDGE:
> - *action = priv->polarity;
> - return 0;
> + *action = stm32_lptim_l2c_actions_map[priv->polarity];
> + break;
> + default: return -EINVAL;
> }
>
> - return -EINVAL;
> + return 0;
> }
>
> static int stm32_lptim_cnt_action_set(struct counter_device *counter,
> struct counter_count *count,
> struct counter_synapse *synapse,
> - size_t action)
> + enum counter_synapse_action action)
> {
> struct stm32_lptim_cnt *const priv = counter->priv;
> - size_t function;
> + enum counter_count_function function;
> + enum stm32_lptim_cnt_function cnt_function;
> int err;
>
> if (stm32_lptim_is_enabled(priv))
> @@ -554,29 +570,18 @@ static int stm32_lptim_cnt_action_set(struct counter_device *counter,
> err = stm32_lptim_cnt_function_get(counter, count, &function);
> if (err)
> return err;
> + cnt_function = function;
>
> /* only set polarity when in counter mode (on input 1) */
> - if (function == STM32_LPTIM_COUNTER_INCREASE
> - && synapse->signal->id == count->synapses[0].signal->id) {
> - switch (action) {
> - case STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE:
> - case STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE:
> - case STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES:
> - priv->polarity = action;
> - return 0;
> - }
> - }
> + if (cnt_function != STM32_LPTIM_COUNTER_INCREASE
> + || synapse->signal->id != count->synapses[0].signal->id
> + || action == COUNTER_SYNAPSE_ACTION_NONE)
> + return -EINVAL;
>
> - return -EINVAL;
> -}
> + priv->polarity = stm32_lptim_c2l_actions_map[action];
>
> -static const struct counter_ops stm32_lptim_cnt_ops = {
> - .count_read = stm32_lptim_cnt_read,
> - .function_get = stm32_lptim_cnt_function_get,
> - .function_set = stm32_lptim_cnt_function_set,
> - .action_get = stm32_lptim_cnt_action_get,
> - .action_set = stm32_lptim_cnt_action_set,
> -};
> + return 0;
> +}
>
> static struct counter_signal stm32_lptim_cnt_signals[] = {
> {
> @@ -660,7 +665,11 @@ static int stm32_lptim_cnt_probe(struct platform_device *pdev)
> /* Initialize Counter device */
> priv->counter.name = dev_name(&pdev->dev);
> priv->counter.parent = &pdev->dev;
> - priv->counter.ops = &stm32_lptim_cnt_ops;
> + priv->counter.count_read = stm32_lptim_cnt_read;
> + priv->counter.function_read = stm32_lptim_cnt_function_get;
> + priv->counter.function_write = stm32_lptim_cnt_function_set;
> + priv->counter.action_read = stm32_lptim_cnt_action_get;
> + priv->counter.action_write = stm32_lptim_cnt_action_set;
> if (ddata->has_encoder) {
> priv->counter.counts = &stm32_lptim_enc_counts;
> priv->counter.num_signals = ARRAY_SIZE(stm32_lptim_cnt_signals);
> diff --git a/drivers/counter/stm32-timer-cnt.c b/drivers/counter/stm32-timer-cnt.c
> index ef2a974a2f10..09e87cf79ce9 100644
> --- a/drivers/counter/stm32-timer-cnt.c
> +++ b/drivers/counter/stm32-timer-cnt.c
> @@ -45,17 +45,17 @@ struct stm32_timer_cnt {
> */
> enum stm32_count_function {
> STM32_COUNT_SLAVE_MODE_DISABLED = -1,
> + STM32_COUNT_ENCODER_MODE_1 = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
> + STM32_COUNT_ENCODER_MODE_2 = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,
> + STM32_COUNT_ENCODER_MODE_3 = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
> +};
> +
> +static const enum counter_count_function stm32_count_functions[] = {
> STM32_COUNT_ENCODER_MODE_1,
> STM32_COUNT_ENCODER_MODE_2,
> STM32_COUNT_ENCODER_MODE_3,
> };
>
> -static enum counter_count_function stm32_count_functions[] = {
> - [STM32_COUNT_ENCODER_MODE_1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
> - [STM32_COUNT_ENCODER_MODE_2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,
> - [STM32_COUNT_ENCODER_MODE_3] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
> -};
> -
> static int stm32_count_read(struct counter_device *counter,
> struct counter_count *count, unsigned long *val)
> {
> @@ -82,7 +82,7 @@ static int stm32_count_write(struct counter_device *counter,
>
> static int stm32_count_function_get(struct counter_device *counter,
> struct counter_count *count,
> - size_t *function)
> + enum counter_count_function *function)
> {
> struct stm32_timer_cnt *const priv = counter->priv;
> u32 smcr;
> @@ -106,7 +106,7 @@ static int stm32_count_function_get(struct counter_device *counter,
>
> static int stm32_count_function_set(struct counter_device *counter,
> struct counter_count *count,
> - size_t function)
> + enum counter_count_function function)
> {
> struct stm32_timer_cnt *const priv = counter->priv;
> u32 cr1, sms;
> @@ -146,78 +146,66 @@ static int stm32_count_function_set(struct counter_device *counter,
> return 0;
> }
>
> -static ssize_t stm32_count_direction_read(struct counter_device *counter,
> +static int stm32_count_direction_read(struct counter_device *counter,
> struct counter_count *count,
> - void *private, char *buf)
> + enum counter_count_direction *direction)
> {
> struct stm32_timer_cnt *const priv = counter->priv;
> - const char *direction;
> u32 cr1;
>
> regmap_read(priv->regmap, TIM_CR1, &cr1);
> - direction = (cr1 & TIM_CR1_DIR) ? "backward" : "forward";
> + *direction = (cr1 & TIM_CR1_DIR) ? COUNTER_COUNT_DIRECTION_BACKWARD :
> + COUNTER_COUNT_DIRECTION_FORWARD;
>
> - return scnprintf(buf, PAGE_SIZE, "%s\n", direction);
> + return 0;
> }
>
> -static ssize_t stm32_count_ceiling_read(struct counter_device *counter,
> - struct counter_count *count,
> - void *private, char *buf)
> +static int stm32_count_ceiling_read(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long *ceiling)
> {
> struct stm32_timer_cnt *const priv = counter->priv;
> u32 arr;
>
> regmap_read(priv->regmap, TIM_ARR, &arr);
>
> - return snprintf(buf, PAGE_SIZE, "%u\n", arr);
> + *ceiling = arr;
> +
> + return 0;
> }
>
> -static ssize_t stm32_count_ceiling_write(struct counter_device *counter,
> - struct counter_count *count,
> - void *private,
> - const char *buf, size_t len)
> +static int stm32_count_ceiling_write(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long ceiling)
> {
> struct stm32_timer_cnt *const priv = counter->priv;
> - unsigned int ceiling;
> - int ret;
> -
> - ret = kstrtouint(buf, 0, &ceiling);
> - if (ret)
> - return ret;
>
> /* TIMx_ARR register shouldn't be buffered (ARPE=0) */
> regmap_update_bits(priv->regmap, TIM_CR1, TIM_CR1_ARPE, 0);
> regmap_write(priv->regmap, TIM_ARR, ceiling);
>
> priv->ceiling = ceiling;
> - return len;
> + return 0;
> }
>
> -static ssize_t stm32_count_enable_read(struct counter_device *counter,
> - struct counter_count *count,
> - void *private, char *buf)
> +static int stm32_count_enable_read(struct counter_device *counter,
> + struct counter_count *count, bool *enable)
> {
> struct stm32_timer_cnt *const priv = counter->priv;
> u32 cr1;
>
> regmap_read(priv->regmap, TIM_CR1, &cr1);
>
> - return scnprintf(buf, PAGE_SIZE, "%d\n", (bool)(cr1 & TIM_CR1_CEN));
> + *enable = cr1 & TIM_CR1_CEN;
> +
> + return 0;
> }
>
> -static ssize_t stm32_count_enable_write(struct counter_device *counter,
> - struct counter_count *count,
> - void *private,
> - const char *buf, size_t len)
> +static int stm32_count_enable_write(struct counter_device *counter,
> + struct counter_count *count, bool enable)
> {
> struct stm32_timer_cnt *const priv = counter->priv;
> - int err;
> u32 cr1;
> - bool enable;
> -
> - err = kstrtobool(buf, &enable);
> - if (err)
> - return err;
>
> if (enable) {
> regmap_read(priv->regmap, TIM_CR1, &cr1);
> @@ -236,46 +224,31 @@ static ssize_t stm32_count_enable_write(struct counter_device *counter,
> /* Keep enabled state to properly handle low power states */
> priv->enabled = enable;
>
> - return len;
> + return 0;
> }
>
> -static const struct counter_count_ext stm32_count_ext[] = {
> - {
> - .name = "direction",
> - .read = stm32_count_direction_read,
> - },
> - {
> - .name = "enable",
> - .read = stm32_count_enable_read,
> - .write = stm32_count_enable_write
> - },
> - {
> - .name = "ceiling",
> - .read = stm32_count_ceiling_read,
> - .write = stm32_count_ceiling_write
> - },
> -};
> -
> -enum stm32_synapse_action {
> - STM32_SYNAPSE_ACTION_NONE,
> - STM32_SYNAPSE_ACTION_BOTH_EDGES
> +static struct counter_data stm32_count_ext[] = {
> + COUNTER_DATA_DIRECTION(stm32_count_direction_read),
> + COUNTER_DATA_ENABLE(stm32_count_enable_read, stm32_count_enable_write),
> + COUNTER_DATA_CEILING(stm32_count_ceiling_read,
> + stm32_count_ceiling_write),
> };
>
> -static enum counter_synapse_action stm32_synapse_actions[] = {
> - [STM32_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
> - [STM32_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES
> +static const enum counter_synapse_action stm32_synapse_actions[] = {
> + COUNTER_SYNAPSE_ACTION_NONE,
> + COUNTER_SYNAPSE_ACTION_BOTH_EDGES
> };
>
> static int stm32_action_get(struct counter_device *counter,
> struct counter_count *count,
> struct counter_synapse *synapse,
> - size_t *action)
> + enum counter_synapse_action *action)
> {
> - size_t function;
> + enum counter_count_function function;
> int err;
>
> /* Default action mode (e.g. STM32_COUNT_SLAVE_MODE_DISABLED) */
> - *action = STM32_SYNAPSE_ACTION_NONE;
> + *action = COUNTER_SYNAPSE_ACTION_NONE;
>
> err = stm32_count_function_get(counter, count, &function);
> if (err)
> @@ -285,30 +258,23 @@ static int stm32_action_get(struct counter_device *counter,
> case STM32_COUNT_ENCODER_MODE_1:
> /* counts up/down on TI1FP1 edge depending on TI2FP2 level */
> if (synapse->signal->id == count->synapses[0].signal->id)
> - *action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
> + *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
> break;
> case STM32_COUNT_ENCODER_MODE_2:
> /* counts up/down on TI2FP2 edge depending on TI1FP1 level */
> if (synapse->signal->id == count->synapses[1].signal->id)
> - *action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
> + *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
> break;
> case STM32_COUNT_ENCODER_MODE_3:
> /* counts up/down on both TI1FP1 and TI2FP2 edges */
> - *action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
> + *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
> break;
> + default: return -EINVAL;
> }
>
> return 0;
> }
>
> -static const struct counter_ops stm32_timer_cnt_ops = {
> - .count_read = stm32_count_read,
> - .count_write = stm32_count_write,
> - .function_get = stm32_count_function_get,
> - .function_set = stm32_count_function_set,
> - .action_get = stm32_action_get,
> -};
> -
> static struct counter_signal stm32_signals[] = {
> {
> .id = 0,
> @@ -363,7 +329,11 @@ static int stm32_timer_cnt_probe(struct platform_device *pdev)
>
> priv->counter.name = dev_name(dev);
> priv->counter.parent = dev;
> - priv->counter.ops = &stm32_timer_cnt_ops;
> + priv->counter.count_read = stm32_count_read;
> + priv->counter.count_write = stm32_count_write;
> + priv->counter.function_read = stm32_count_function_get;
> + priv->counter.function_write = stm32_count_function_set;
> + priv->counter.action_read = stm32_action_get;
> priv->counter.counts = &stm32_counts;
> priv->counter.num_counts = 1;
> priv->counter.signals = stm32_signals;
> diff --git a/drivers/counter/ti-eqep.c b/drivers/counter/ti-eqep.c
> index 1ff07faef27f..b1fac22a0a4f 100644
> --- a/drivers/counter/ti-eqep.c
> +++ b/drivers/counter/ti-eqep.c
> @@ -74,16 +74,10 @@ enum {
>
> /* Position Counter Input Modes */
> enum {
> - TI_EQEP_COUNT_FUNC_QUAD_COUNT,
> - TI_EQEP_COUNT_FUNC_DIR_COUNT,
> - TI_EQEP_COUNT_FUNC_UP_COUNT,
> - TI_EQEP_COUNT_FUNC_DOWN_COUNT,
> -};
> -
> -enum {
> - TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES,
> - TI_EQEP_SYNAPSE_ACTION_RISING_EDGE,
> - TI_EQEP_SYNAPSE_ACTION_NONE,
> + TI_EQEP_COUNT_FUNC_QUAD_COUNT = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
> + TI_EQEP_COUNT_FUNC_DIR_COUNT = COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
> + TI_EQEP_COUNT_FUNC_UP_COUNT = COUNTER_COUNT_FUNCTION_INCREASE,
> + TI_EQEP_COUNT_FUNC_DOWN_COUNT = COUNTER_COUNT_FUNCTION_DECREASE,
> };
>
> struct ti_eqep_cnt {
> @@ -118,7 +112,8 @@ static int ti_eqep_count_write(struct counter_device *counter,
> }
>
> static int ti_eqep_function_get(struct counter_device *counter,
> - struct counter_count *count, size_t *function)
> + struct counter_count *count,
> + enum counter_count_function *function)
> {
> struct ti_eqep_cnt *priv = counter->priv;
> u32 qdecctl;
> @@ -130,7 +125,8 @@ static int ti_eqep_function_get(struct counter_device *counter,
> }
>
> static int ti_eqep_function_set(struct counter_device *counter,
> - struct counter_count *count, size_t function)
> + struct counter_count *count,
> + enum counter_count_function function)
> {
> struct ti_eqep_cnt *priv = counter->priv;
>
> @@ -140,10 +136,11 @@ static int ti_eqep_function_set(struct counter_device *counter,
>
> static int ti_eqep_action_get(struct counter_device *counter,
> struct counter_count *count,
> - struct counter_synapse *synapse, size_t *action)
> + struct counter_synapse *synapse,
> + enum counter_synapse_action *action)
> {
> struct ti_eqep_cnt *priv = counter->priv;
> - size_t function;
> + enum counter_count_function function;
> u32 qdecctl;
> int err;
>
> @@ -156,7 +153,7 @@ static int ti_eqep_action_get(struct counter_device *counter,
> /* In quadrature mode, the rising and falling edge of both
> * QEPA and QEPB trigger QCLK.
> */
> - *action = TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES;
> + *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
> break;
> case TI_EQEP_COUNT_FUNC_DIR_COUNT:
> /* In direction-count mode only rising edge of QEPA is counted
> @@ -164,10 +161,10 @@ static int ti_eqep_action_get(struct counter_device *counter,
> */
> switch (synapse->signal->id) {
> case TI_EQEP_SIGNAL_QEPA:
> - *action = TI_EQEP_SYNAPSE_ACTION_RISING_EDGE;
> + *action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
> break;
> default:
> - *action = TI_EQEP_SYNAPSE_ACTION_NONE;
> + *action = COUNTER_SYNAPSE_ACTION_NONE;
> break;
> }
> break;
> @@ -183,134 +180,103 @@ static int ti_eqep_action_get(struct counter_device *counter,
> return err;
>
> if (qdecctl & QDECCTL_XCR)
> - *action = TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES;
> + *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
> else
> - *action = TI_EQEP_SYNAPSE_ACTION_RISING_EDGE;
> + *action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
> break;
> default:
> - *action = TI_EQEP_SYNAPSE_ACTION_NONE;
> + *action = COUNTER_SYNAPSE_ACTION_NONE;
> break;
> }
> break;
> + default: return -EINVAL;
> }
>
> return 0;
> }
>
> -static const struct counter_ops ti_eqep_counter_ops = {
> - .count_read = ti_eqep_count_read,
> - .count_write = ti_eqep_count_write,
> - .function_get = ti_eqep_function_get,
> - .function_set = ti_eqep_function_set,
> - .action_get = ti_eqep_action_get,
> -};
> -
> -static ssize_t ti_eqep_position_ceiling_read(struct counter_device *counter,
> - struct counter_count *count,
> - void *ext_priv, char *buf)
> +static int ti_eqep_position_ceiling_read(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long *ceiling)
> {
> struct ti_eqep_cnt *priv = counter->priv;
> u32 qposmax;
>
> regmap_read(priv->regmap32, QPOSMAX, &qposmax);
>
> - return sprintf(buf, "%u\n", qposmax);
> + *ceiling = qposmax;
> +
> + return 0;
> }
>
> -static ssize_t ti_eqep_position_ceiling_write(struct counter_device *counter,
> - struct counter_count *count,
> - void *ext_priv, const char *buf,
> - size_t len)
> +static int ti_eqep_position_ceiling_write(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long ceiling)
> {
> struct ti_eqep_cnt *priv = counter->priv;
> - int err;
> - u32 res;
>
> - err = kstrtouint(buf, 0, &res);
> - if (err < 0)
> - return err;
> + regmap_write(priv->regmap32, QPOSMAX, ceiling);
>
> - regmap_write(priv->regmap32, QPOSMAX, res);
> -
> - return len;
> + return 0;
> }
>
> -static ssize_t ti_eqep_position_floor_read(struct counter_device *counter,
> - struct counter_count *count,
> - void *ext_priv, char *buf)
> +static int ti_eqep_position_floor_read(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long *floor)
> {
> struct ti_eqep_cnt *priv = counter->priv;
> u32 qposinit;
>
> regmap_read(priv->regmap32, QPOSINIT, &qposinit);
>
> - return sprintf(buf, "%u\n", qposinit);
> + *floor = qposinit;
> +
> + return 0;
> }
>
> -static ssize_t ti_eqep_position_floor_write(struct counter_device *counter,
> - struct counter_count *count,
> - void *ext_priv, const char *buf,
> - size_t len)
> +static int ti_eqep_position_floor_write(struct counter_device *counter,
> + struct counter_count *count,
> + unsigned long floor)
> {
> struct ti_eqep_cnt *priv = counter->priv;
> - int err;
> - u32 res;
>
> - err = kstrtouint(buf, 0, &res);
> - if (err < 0)
> - return err;
> + regmap_write(priv->regmap32, QPOSINIT, floor);
>
> - regmap_write(priv->regmap32, QPOSINIT, res);
> -
> - return len;
> + return 0;
> }
>
> -static ssize_t ti_eqep_position_enable_read(struct counter_device *counter,
> - struct counter_count *count,
> - void *ext_priv, char *buf)
> +static int ti_eqep_position_enable_read(struct counter_device *counter,
> + struct counter_count *count,
> + bool *enable)
> {
> struct ti_eqep_cnt *priv = counter->priv;
> u32 qepctl;
>
> regmap_read(priv->regmap16, QEPCTL, &qepctl);
>
> - return sprintf(buf, "%u\n", !!(qepctl & QEPCTL_PHEN));
> + *enable = !!(qepctl & QEPCTL_PHEN);
> +
> + return 0;
> }
>
> -static ssize_t ti_eqep_position_enable_write(struct counter_device *counter,
> - struct counter_count *count,
> - void *ext_priv, const char *buf,
> - size_t len)
> +static int ti_eqep_position_enable_write(struct counter_device *counter,
> + struct counter_count *count,
> + bool enable)
> {
> struct ti_eqep_cnt *priv = counter->priv;
> - int err;
> - bool res;
>
> - err = kstrtobool(buf, &res);
> - if (err < 0)
> - return err;
> -
> - regmap_write_bits(priv->regmap16, QEPCTL, QEPCTL_PHEN, res ? -1 : 0);
> + regmap_write_bits(priv->regmap16, QEPCTL, QEPCTL_PHEN, enable ? -1 : 0);
>
> - return len;
> + return 0;
> }
>
> -static struct counter_count_ext ti_eqep_position_ext[] = {
> - {
> - .name = "ceiling",
> - .read = ti_eqep_position_ceiling_read,
> - .write = ti_eqep_position_ceiling_write,
> - },
> - {
> - .name = "floor",
> - .read = ti_eqep_position_floor_read,
> - .write = ti_eqep_position_floor_write,
> - },
> - {
> - .name = "enable",
> - .read = ti_eqep_position_enable_read,
> - .write = ti_eqep_position_enable_write,
> - },
> +static struct counter_data ti_eqep_position_ext[] = {
> + COUNTER_DATA_CEILING(ti_eqep_position_ceiling_read,
> + ti_eqep_position_ceiling_write),
> + COUNTER_DATA_FLOOR(ti_eqep_position_floor_read,
> + ti_eqep_position_floor_write),
> + COUNTER_DATA_ENABLE(ti_eqep_position_enable_read,
> + ti_eqep_position_enable_write),
> };
>
> static struct counter_signal ti_eqep_signals[] = {
> @@ -325,16 +291,16 @@ static struct counter_signal ti_eqep_signals[] = {
> };
>
> static const enum counter_count_function ti_eqep_position_functions[] = {
> - [TI_EQEP_COUNT_FUNC_QUAD_COUNT] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
> - [TI_EQEP_COUNT_FUNC_DIR_COUNT] = COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
> - [TI_EQEP_COUNT_FUNC_UP_COUNT] = COUNTER_COUNT_FUNCTION_INCREASE,
> - [TI_EQEP_COUNT_FUNC_DOWN_COUNT] = COUNTER_COUNT_FUNCTION_DECREASE,
> + TI_EQEP_COUNT_FUNC_QUAD_COUNT,
> + TI_EQEP_COUNT_FUNC_DIR_COUNT,
> + TI_EQEP_COUNT_FUNC_UP_COUNT,
> + TI_EQEP_COUNT_FUNC_DOWN_COUNT,
> };
>
> static const enum counter_synapse_action ti_eqep_position_synapse_actions[] = {
> - [TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
> - [TI_EQEP_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
> - [TI_EQEP_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
> + COUNTER_SYNAPSE_ACTION_BOTH_EDGES,
> + COUNTER_SYNAPSE_ACTION_RISING_EDGE,
> + COUNTER_SYNAPSE_ACTION_NONE,
> };
>
> static struct counter_synapse ti_eqep_position_synapses[] = {
> @@ -406,7 +372,11 @@ static int ti_eqep_probe(struct platform_device *pdev)
>
> priv->counter.name = dev_name(dev);
> priv->counter.parent = dev;
> - priv->counter.ops = &ti_eqep_counter_ops;
> + priv->counter.count_read = ti_eqep_count_read;
> + priv->counter.count_write = ti_eqep_count_write;
> + priv->counter.function_read = ti_eqep_function_get;
> + priv->counter.function_write = ti_eqep_function_set;
> + priv->counter.action_read = ti_eqep_action_get;
> priv->counter.counts = ti_eqep_counts;
> priv->counter.num_counts = ARRAY_SIZE(ti_eqep_counts);
> priv->counter.signals = ti_eqep_signals;
> diff --git a/include/linux/counter.h b/include/linux/counter.h
> index 9dbd5df4cd34..d628c7eaf754 100644
> --- a/include/linux/counter.h
> +++ b/include/linux/counter.h
> @@ -6,449 +6,286 @@
> #ifndef _COUNTER_H_
> #define _COUNTER_H_
>
> -#include <linux/counter_enum.h>
> #include <linux/device.h>
> +#include <linux/kernel.h>
> +#include <linux/list.h>
> #include <linux/types.h>
> +#include <uapi/linux/counter-types.h>
>
> -enum counter_count_direction {
> - COUNTER_COUNT_DIRECTION_FORWARD = 0,
> - COUNTER_COUNT_DIRECTION_BACKWARD
> -};
> -extern const char *const counter_count_direction_str[2];
> -
> -enum counter_count_mode {
> - COUNTER_COUNT_MODE_NORMAL = 0,
> - COUNTER_COUNT_MODE_RANGE_LIMIT,
> - COUNTER_COUNT_MODE_NON_RECYCLE,
> - COUNTER_COUNT_MODE_MODULO_N
> -};
> -extern const char *const counter_count_mode_str[4];
> -
> -struct counter_device;
> -struct counter_signal;
> -
> -/**
> - * struct counter_signal_ext - Counter Signal extensions
> - * @name: attribute name
> - * @read: read callback for this attribute; may be NULL
> - * @write: write callback for this attribute; may be NULL
> - * @priv: data private to the driver
> - */
> -struct counter_signal_ext {
> +struct counter_data {
> + enum counter_data_type type;
> const char *name;
> - ssize_t (*read)(struct counter_device *counter,
> - struct counter_signal *signal, void *priv, char *buf);
> - ssize_t (*write)(struct counter_device *counter,
> - struct counter_signal *signal, void *priv,
> - const char *buf, size_t len);
> + void *read;
> + void *write;
> void *priv;
> };
>
> /**
> * struct counter_signal - Counter Signal node
> - * @id: unique ID used to identify signal
> - * @name: device-specific Signal name; ideally, this should match the name
> - * as it appears in the datasheet documentation
> - * @ext: optional array of Counter Signal extensions
> - * @num_ext: number of Counter Signal extensions specified in @ext
> - * @priv: optional private data supplied by driver
> + * @id: unique ID used to identify the Signal
> + * @name: device-specific Signal name
> + * @ext: optional array of Signal extensions
> + * @num_ext: number of Signal extensions specified in @ext
> */
> struct counter_signal {
> int id;
> const char *name;
>
> - const struct counter_signal_ext *ext;
> + struct counter_data *ext;
> size_t num_ext;
> -
> - void *priv;
> -};
> -
> -/**
> - * struct counter_signal_enum_ext - Signal enum extension attribute
> - * @items: Array of strings
> - * @num_items: Number of items specified in @items
> - * @set: Set callback function; may be NULL
> - * @get: Get callback function; may be NULL
> - *
> - * The counter_signal_enum_ext structure can be used to implement enum style
> - * Signal extension attributes. Enum style attributes are those which have a set
> - * of strings that map to unsigned integer values. The Generic Counter Signal
> - * enum extension helper code takes care of mapping between value and string, as
> - * well as generating a "_available" file which contains a list of all available
> - * items. The get callback is used to query the currently active item; the index
> - * of the item within the respective items array is returned via the 'item'
> - * parameter. The set callback is called when the attribute is updated; the
> - * 'item' parameter contains the index of the newly activated item within the
> - * respective items array.
> - */
> -struct counter_signal_enum_ext {
> - const char * const *items;
> - size_t num_items;
> - int (*get)(struct counter_device *counter,
> - struct counter_signal *signal, size_t *item);
> - int (*set)(struct counter_device *counter,
> - struct counter_signal *signal, size_t item);
> -};
> -
> -/**
> - * COUNTER_SIGNAL_ENUM() - Initialize Signal enum extension
> - * @_name: Attribute name
> - * @_e: Pointer to a counter_signal_enum_ext structure
> - *
> - * This should usually be used together with COUNTER_SIGNAL_ENUM_AVAILABLE()
> - */
> -#define COUNTER_SIGNAL_ENUM(_name, _e) \
> -{ \
> - .name = (_name), \
> - .read = counter_signal_enum_read, \
> - .write = counter_signal_enum_write, \
> - .priv = (_e) \
> -}
> -
> -/**
> - * COUNTER_SIGNAL_ENUM_AVAILABLE() - Initialize Signal enum available extension
> - * @_name: Attribute name ("_available" will be appended to the name)
> - * @_e: Pointer to a counter_signal_enum_ext structure
> - *
> - * Creates a read only attribute that lists all the available enum items in a
> - * newline separated list. This should usually be used together with
> - * COUNTER_SIGNAL_ENUM()
> - */
> -#define COUNTER_SIGNAL_ENUM_AVAILABLE(_name, _e) \
> -{ \
> - .name = (_name "_available"), \
> - .read = counter_signal_enum_available_read, \
> - .priv = (_e) \
> -}
> -
> -enum counter_synapse_action {
> - COUNTER_SYNAPSE_ACTION_NONE = 0,
> - COUNTER_SYNAPSE_ACTION_RISING_EDGE,
> - COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
> - COUNTER_SYNAPSE_ACTION_BOTH_EDGES
> };
>
> /**
> * struct counter_synapse - Counter Synapse node
> - * @action: index of current action mode
> * @actions_list: array of available action modes
> * @num_actions: number of action modes specified in @actions_list
> - * @signal: pointer to associated signal
> + * @signal: pointer to the associated Signal
> */
> struct counter_synapse {
> - size_t action;
> const enum counter_synapse_action *actions_list;
> size_t num_actions;
>
> struct counter_signal *signal;
> };
>
> -struct counter_count;
> -
> -/**
> - * struct counter_count_ext - Counter Count extension
> - * @name: attribute name
> - * @read: read callback for this attribute; may be NULL
> - * @write: write callback for this attribute; may be NULL
> - * @priv: data private to the driver
> - */
> -struct counter_count_ext {
> - const char *name;
> - ssize_t (*read)(struct counter_device *counter,
> - struct counter_count *count, void *priv, char *buf);
> - ssize_t (*write)(struct counter_device *counter,
> - struct counter_count *count, void *priv,
> - const char *buf, size_t len);
> - void *priv;
> -};
> -
> -enum counter_count_function {
> - COUNTER_COUNT_FUNCTION_INCREASE = 0,
> - COUNTER_COUNT_FUNCTION_DECREASE,
> - COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
> - COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A,
> - COUNTER_COUNT_FUNCTION_QUADRATURE_X1_B,
> - COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
> - COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,
> - COUNTER_COUNT_FUNCTION_QUADRATURE_X4
> -};
> -
> /**
> * struct counter_count - Counter Count node
> - * @id: unique ID used to identify Count
> - * @name: device-specific Count name; ideally, this should match
> - * the name as it appears in the datasheet documentation
> - * @function: index of current function mode
> - * @functions_list: array available function modes
> + * @id: unique ID used to identify the Count
> + * @name: device-specific Count name
> + * @functions_list: array of available function modes
> * @num_functions: number of function modes specified in @functions_list
> - * @synapses: array of synapses for initialization
> - * @num_synapses: number of synapses specified in @synapses
> - * @ext: optional array of Counter Count extensions
> - * @num_ext: number of Counter Count extensions specified in @ext
> - * @priv: optional private data supplied by driver
> + * @synapses: array of Synapses for initialization
> + * @num_synapses: number of Synapses specified in @synapses
> + * @ext: optional array of Count extensions
> + * @num_ext: number of Count extensions specified in @ext
> */
> struct counter_count {
> int id;
> const char *name;
>
> - size_t function;
> const enum counter_count_function *functions_list;
> size_t num_functions;
>
> struct counter_synapse *synapses;
> size_t num_synapses;
>
> - const struct counter_count_ext *ext;
> + struct counter_data *ext;
> size_t num_ext;
> -
> - void *priv;
> -};
> -
> -/**
> - * struct counter_count_enum_ext - Count enum extension attribute
> - * @items: Array of strings
> - * @num_items: Number of items specified in @items
> - * @set: Set callback function; may be NULL
> - * @get: Get callback function; may be NULL
> - *
> - * The counter_count_enum_ext structure can be used to implement enum style
> - * Count extension attributes. Enum style attributes are those which have a set
> - * of strings that map to unsigned integer values. The Generic Counter Count
> - * enum extension helper code takes care of mapping between value and string, as
> - * well as generating a "_available" file which contains a list of all available
> - * items. The get callback is used to query the currently active item; the index
> - * of the item within the respective items array is returned via the 'item'
> - * parameter. The set callback is called when the attribute is updated; the
> - * 'item' parameter contains the index of the newly activated item within the
> - * respective items array.
> - */
> -struct counter_count_enum_ext {
> - const char * const *items;
> - size_t num_items;
> - int (*get)(struct counter_device *counter, struct counter_count *count,
> - size_t *item);
> - int (*set)(struct counter_device *counter, struct counter_count *count,
> - size_t item);
> };
>
> /**
> - * COUNTER_COUNT_ENUM() - Initialize Count enum extension
> - * @_name: Attribute name
> - * @_e: Pointer to a counter_count_enum_ext structure
> - *
> - * This should usually be used together with COUNTER_COUNT_ENUM_AVAILABLE()
> - */
> -#define COUNTER_COUNT_ENUM(_name, _e) \
> -{ \
> - .name = (_name), \
> - .read = counter_count_enum_read, \
> - .write = counter_count_enum_write, \
> - .priv = (_e) \
> -}
> -
> -/**
> - * COUNTER_COUNT_ENUM_AVAILABLE() - Initialize Count enum available extension
> - * @_name: Attribute name ("_available" will be appended to the name)
> - * @_e: Pointer to a counter_count_enum_ext structure
> - *
> - * Creates a read only attribute that lists all the available enum items in a
> - * newline separated list. This should usually be used together with
> - * COUNTER_COUNT_ENUM()
> - */
> -#define COUNTER_COUNT_ENUM_AVAILABLE(_name, _e) \
> -{ \
> - .name = (_name "_available"), \
> - .read = counter_count_enum_available_read, \
> - .priv = (_e) \
> -}
> -
> -/**
> - * struct counter_device_attr_group - internal container for attribute group
> + * struct counter_attribute_group - internal container for attribute group
> * @attr_group: Counter sysfs attributes group
> * @attr_list: list to keep track of created Counter sysfs attributes
> * @num_attr: number of Counter sysfs attributes
> */
> -struct counter_device_attr_group {
> +struct counter_attribute_group {
> struct attribute_group attr_group;
> struct list_head attr_list;
> size_t num_attr;
> };
>
> /**
> - * struct counter_device_state - internal state container for a Counter device
> + * struct counter_device - Counter data structure
> + * @name: name of the device
> + * @parent: optional parent device providing the counters
> + * @signal_read: optional read callback for Signals. The read value of
> + * the respective Signal should be passed back via the
> + * value parameter.
> + * @count_read: optional read callback for Counts. The read value of the
> + * respective Count should be passed back via the value
> + * parameter.
> + * @count_write: optional write callback for Counts. The write value for
> + * the respective Count is passed in via the value
> + * parameter.
> + * @function_read: optional read callback the Count function modes. The
> + * read function mode of the respective Count should be
> + * passed back via the function parameter.
> + * @function_write: option write callback for Count function modes. The
> + * function mode to write for the respective Count is
> + * passed in via the function parameter.
> + * @action_read: optional read callback the Synapse action modes. The
> + * read action mode of the respective Synapse should be
> + * passed back via the action parameter.
> + * @action_write: option write callback for Synapse action modes. The
> + * action mode to write for the respective Synapse is
> + * passed in via the action parameter.
> + * @signals: array of Signals
> + * @num_signals: number of Signals specified in @signals
> + * @counts: array of Counts
> + * @num_counts: number of Counts specified in @counts
> + * @ext: optional array of Counter device extensions
> + * @num_ext: number of Counter device extensions specified in @ext
> + * @priv: optional private data supplied by driver
> * @id: unique ID used to identify the Counter
> * @dev: internal device structure
> + * @synapse_names_list: Synapse names list
> * @groups_list: attribute groups list (for Signals, Counts, and ext)
> * @num_groups: number of attribute groups containers
> * @groups: Counter sysfs attribute groups (to populate @dev.groups)
> */
> -struct counter_device_state {
> +struct counter_device {
> + const char *name;
> + struct device *parent;
> +
> + int (*signal_read)(struct counter_device *counter,
> + struct counter_signal *signal,
> + enum counter_signal_value *value);
> + int (*count_read)(struct counter_device *counter,
> + struct counter_count *count, unsigned long *value);
> + int (*count_write)(struct counter_device *counter,
> + struct counter_count *count, unsigned long value);
> + int (*function_read)(struct counter_device *counter,
> + struct counter_count *count,
> + enum counter_count_function *function);
> + int (*function_write)(struct counter_device *counter,
> + struct counter_count *count,
> + enum counter_count_function function);
> + int (*action_read)(struct counter_device *counter,
> + struct counter_count *count,
> + struct counter_synapse *synapse,
> + enum counter_synapse_action *action);
> + int (*action_write)(struct counter_device *counter,
> + struct counter_count *count,
> + struct counter_synapse *synapse,
> + enum counter_synapse_action action);
> +
> + struct counter_signal *signals;
> + size_t num_signals;
> + struct counter_count *counts;
> + size_t num_counts;
> +
> + struct counter_data *ext;
> + size_t num_ext;
> +
> + void *priv;
> +
> int id;
> struct device dev;
> - struct counter_device_attr_group *groups_list;
> + struct list_head synapse_names_list;
> + struct counter_attribute_group *groups_list;
> size_t num_groups;
> const struct attribute_group **groups;
> };
>
> -enum counter_signal_value {
> - COUNTER_SIGNAL_LOW = 0,
> - COUNTER_SIGNAL_HIGH
> -};
> +int counter_register(struct counter_device *const counter);
> +void counter_unregister(struct counter_device *const counter);
> +int devm_counter_register(struct device *dev,
> + struct counter_device *const counter);
> +void devm_counter_unregister(struct device *dev,
> + struct counter_device *const counter);
>
> -/**
> - * struct counter_ops - Callbacks from driver
> - * @signal_read: optional read callback for Signal attribute. The read
> - * value of the respective Signal should be passed back via
> - * the val parameter.
> - * @count_read: optional read callback for Count attribute. The read
> - * value of the respective Count should be passed back via
> - * the val parameter.
> - * @count_write: optional write callback for Count attribute. The write
> - * value for the respective Count is passed in via the val
> - * parameter.
> - * @function_get: function to get the current count function mode. Returns
> - * 0 on success and negative error code on error. The index
> - * of the respective Count's returned function mode should
> - * be passed back via the function parameter.
> - * @function_set: function to set the count function mode. function is the
> - * index of the requested function mode from the respective
> - * Count's functions_list array.
> - * @action_get: function to get the current action mode. Returns 0 on
> - * success and negative error code on error. The index of
> - * the respective Synapse's returned action mode should be
> - * passed back via the action parameter.
> - * @action_set: function to set the action mode. action is the index of
> - * the requested action mode from the respective Synapse's
> - * actions_list array.
> - */
> -struct counter_ops {
> - int (*signal_read)(struct counter_device *counter,
> - struct counter_signal *signal,
> - enum counter_signal_value *val);
> - int (*count_read)(struct counter_device *counter,
> - struct counter_count *count, unsigned long *val);
> - int (*count_write)(struct counter_device *counter,
> - struct counter_count *count, unsigned long val);
> - int (*function_get)(struct counter_device *counter,
> - struct counter_count *count, size_t *function);
> - int (*function_set)(struct counter_device *counter,
> - struct counter_count *count, size_t function);
> - int (*action_get)(struct counter_device *counter,
> - struct counter_count *count,
> - struct counter_synapse *synapse, size_t *action);
> - int (*action_set)(struct counter_device *counter,
> - struct counter_count *count,
> - struct counter_synapse *synapse, size_t action);
> -};
> +#define COUNTER_DATA_BOOL(_name, _read, _write) \
> +{ \
> + .type = COUNTER_DATA_TYPE_BOOL, \
> + .name = (_name), \
> + .read = (_read), \
> + .write = (_write), \
> +}
>
> -/**
> - * struct counter_device_ext - Counter device extension
> - * @name: attribute name
> - * @read: read callback for this attribute; may be NULL
> - * @write: write callback for this attribute; may be NULL
> - * @priv: data private to the driver
> - */
> -struct counter_device_ext {
> - const char *name;
> - ssize_t (*read)(struct counter_device *counter, void *priv, char *buf);
> - ssize_t (*write)(struct counter_device *counter, void *priv,
> - const char *buf, size_t len);
> - void *priv;
> +#define COUNTER_DATA_UNSIGNED_LONG(_name, _read, _write) \
> +{ \
> + .type = COUNTER_DATA_TYPE_UNSIGNED_LONG, \
> + .name = (_name), \
> + .read = (_read), \
> + .write = (_write), \
> +}
> +
> +#define COUNTER_DATA_STRING(_name, _read, _write) \
> +{ \
> + .type = COUNTER_DATA_TYPE_STRING, \
> + .name = (_name), \
> + .read = (_read), \
> + .write = (_write), \
> +}
> +
> +struct counter_available {
> + void *items;
> + size_t num_items;
> };
>
> -/**
> - * struct counter_device_enum_ext - Counter enum extension attribute
> - * @items: Array of strings
> - * @num_items: Number of items specified in @items
> - * @set: Set callback function; may be NULL
> - * @get: Get callback function; may be NULL
> - *
> - * The counter_device_enum_ext structure can be used to implement enum style
> - * Counter extension attributes. Enum style attributes are those which have a
> - * set of strings that map to unsigned integer values. The Generic Counter enum
> - * extension helper code takes care of mapping between value and string, as well
> - * as generating a "_available" file which contains a list of all available
> - * items. The get callback is used to query the currently active item; the index
> - * of the item within the respective items array is returned via the 'item'
> - * parameter. The set callback is called when the attribute is updated; the
> - * 'item' parameter contains the index of the newly activated item within the
> - * respective items array.
> - */
> -struct counter_device_enum_ext {
> +#define DEFINE_COUNTER_AVAILABLE(_name, _items) \
> + struct counter_available _name = { \
> + .items = (_items), \
> + .num_items = ARRAY_SIZE(_items), \
> + }
> +
> +struct counter_enum {
> const char * const *items;
> size_t num_items;
> - int (*get)(struct counter_device *counter, size_t *item);
> - int (*set)(struct counter_device *counter, size_t item);
> };
>
> -/**
> - * COUNTER_DEVICE_ENUM() - Initialize Counter enum extension
> - * @_name: Attribute name
> - * @_e: Pointer to a counter_device_enum_ext structure
> - *
> - * This should usually be used together with COUNTER_DEVICE_ENUM_AVAILABLE()
> - */
> -#define COUNTER_DEVICE_ENUM(_name, _e) \
> +#define DEFINE_COUNTER_ENUM(_name, _items) \
> + struct counter_enum _name = { \
> + .items = (_items), \
> + .num_items = ARRAY_SIZE(_items), \
> + }
> +
> +#define COUNTER_DATA_ENUM(_name, _get, _set, _enum) \
> { \
> + .type = COUNTER_DATA_TYPE_ENUM, \
> .name = (_name), \
> - .read = counter_device_enum_read, \
> - .write = counter_device_enum_write, \
> - .priv = (_e) \
> + .read = (_get), \
> + .write = (_set), \
> + .priv = &(_enum), \
> }
>
> -/**
> - * COUNTER_DEVICE_ENUM_AVAILABLE() - Initialize Counter enum available extension
> - * @_name: Attribute name ("_available" will be appended to the name)
> - * @_e: Pointer to a counter_device_enum_ext structure
> - *
> - * Creates a read only attribute that lists all the available enum items in a
> - * newline separated list. This should usually be used together with
> - * COUNTER_DEVICE_ENUM()
> - */
> -#define COUNTER_DEVICE_ENUM_AVAILABLE(_name, _e) \
> +#define COUNTER_DATA_ENUM_AVAILABLE(_name, _read, _enum) \
> { \
> + .type = COUNTER_DATA_TYPE_ENUM_AVAILABLE, \
> .name = (_name "_available"), \
> - .read = counter_device_enum_available_read, \
> - .priv = (_e) \
> + .read = (_read), \
> + .priv = &(_enum), \
> }
>
> -/**
> - * struct counter_device - Counter data structure
> - * @name: name of the device as it appears in the datasheet
> - * @parent: optional parent device providing the counters
> - * @device_state: internal device state container
> - * @ops: callbacks from driver
> - * @signals: array of Signals
> - * @num_signals: number of Signals specified in @signals
> - * @counts: array of Counts
> - * @num_counts: number of Counts specified in @counts
> - * @ext: optional array of Counter device extensions
> - * @num_ext: number of Counter device extensions specified in @ext
> - * @priv: optional private data supplied by driver
> - */
> -struct counter_device {
> - const char *name;
> - struct device *parent;
> - struct counter_device_state *device_state;
> +#define COUNTER_DATA_ENUM_AND_AVAILABLE(_name, _get, _set, _enum) \
> + COUNTER_DATA_ENUM(_name, _get, _set, _enum), \
> + COUNTER_DATA_ENUM_AVAILABLE(_name, _get, _enum)
>
> - const struct counter_ops *ops;
> +#define COUNTER_DATA_CEILING(_read, _write) \
> + COUNTER_DATA_UNSIGNED_LONG("ceiling", _read, _write)
>
> - struct counter_signal *signals;
> - size_t num_signals;
> - struct counter_count *counts;
> - size_t num_counts;
> +#define COUNTER_DATA_COUNT_MODE(_read, _write) \
> +{ \
> + .type = COUNTER_DATA_TYPE_COUNT_MODE, \
> + .name = "count_mode", \
> + .read = (_read), \
> + .write = (_write), \
> +}
>
> - const struct counter_device_ext *ext;
> - size_t num_ext;
> +#define COUNTER_DATA_COUNT_MODE_AVAILABLE(_read, _available) \
> +{ \
> + .type = COUNTER_DATA_TYPE_COUNT_MODE_AVAILABLE, \
> + .name = "count_mode_available", \
> + .read = (_read), \
> + .priv = &(_available), \
> +}
>
> - void *priv;
> -};
> +#define COUNTER_DATA_COUNT_MODE_AND_AVAILABLE(_read, _write, _available) \
> + COUNTER_DATA_COUNT_MODE(_read, _write), \
> + COUNTER_DATA_COUNT_MODE_AVAILABLE(_read, _available)
>
> -int counter_register(struct counter_device *const counter);
> -void counter_unregister(struct counter_device *const counter);
> -int devm_counter_register(struct device *dev,
> - struct counter_device *const counter);
> -void devm_counter_unregister(struct device *dev,
> - struct counter_device *const counter);
> +#define COUNTER_DATA_DIRECTION(_read) \
> +{ \
> + .type = COUNTER_DATA_TYPE_COUNT_DIRECTION, \
> + .name = "direction", \
> + .read = (_read), \
> +}
> +
> +#define COUNTER_DATA_ENABLE(_read, _write) \
> + COUNTER_DATA_BOOL("enable", _read, _write)
> +
> +#define COUNTER_DATA_ERROR_NOISE_AND_AVAILABLE(_read, _available) \
> + COUNTER_DATA_STRING("error_noise", _read, NULL), \
> + COUNTER_DATA_STRING("error_noise_available", _available, NULL)
> +
> +#define COUNTER_DATA_FLOOR(_read, _write) \
> + COUNTER_DATA_UNSIGNED_LONG("floor", _read, _write)
> +
> +#define COUNTER_DATA_PRESET(_read, _write) \
> + COUNTER_DATA_UNSIGNED_LONG("preset", _read, _write)
> +
> +#define COUNTER_DATA_PRESET_ENABLE(_read, _write) \
> + COUNTER_DATA_BOOL("preset_enable", _read, _write)
>
> #endif /* _COUNTER_H_ */
> diff --git a/include/linux/counter_enum.h b/include/linux/counter_enum.h
> deleted file mode 100644
> index 9f917298a88f..000000000000
> --- a/include/linux/counter_enum.h
> +++ /dev/null
> @@ -1,45 +0,0 @@
> -/* SPDX-License-Identifier: GPL-2.0 */
> -/*
> - * Counter interface enum functions
> - * Copyright (C) 2018 William Breathitt Gray
> - */
> -#ifndef _COUNTER_ENUM_H_
> -#define _COUNTER_ENUM_H_
> -
> -#include <linux/types.h>
> -
> -struct counter_device;
> -struct counter_signal;
> -struct counter_count;
> -
> -ssize_t counter_signal_enum_read(struct counter_device *counter,
> - struct counter_signal *signal, void *priv,
> - char *buf);
> -ssize_t counter_signal_enum_write(struct counter_device *counter,
> - struct counter_signal *signal, void *priv,
> - const char *buf, size_t len);
> -
> -ssize_t counter_signal_enum_available_read(struct counter_device *counter,
> - struct counter_signal *signal,
> - void *priv, char *buf);
> -
> -ssize_t counter_count_enum_read(struct counter_device *counter,
> - struct counter_count *count, void *priv,
> - char *buf);
> -ssize_t counter_count_enum_write(struct counter_device *counter,
> - struct counter_count *count, void *priv,
> - const char *buf, size_t len);
> -
> -ssize_t counter_count_enum_available_read(struct counter_device *counter,
> - struct counter_count *count,
> - void *priv, char *buf);
> -
> -ssize_t counter_device_enum_read(struct counter_device *counter, void *priv,
> - char *buf);
> -ssize_t counter_device_enum_write(struct counter_device *counter, void *priv,
> - const char *buf, size_t len);
> -
> -ssize_t counter_device_enum_available_read(struct counter_device *counter,
> - void *priv, char *buf);
> -
> -#endif /* _COUNTER_ENUM_H_ */
> diff --git a/include/uapi/linux/counter-types.h b/include/uapi/linux/counter-types.h
> new file mode 100644
> index 000000000000..757256775949
> --- /dev/null
> +++ b/include/uapi/linux/counter-types.h
> @@ -0,0 +1,67 @@
> +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
> +/*
> + * Counter interface data types
> + * Copyright (C) 2020 William Breathitt Gray
> + */
> +#ifndef _UAPI_COUNTER_TYPES_H_
> +#define _UAPI_COUNTER_TYPES_H_
> +
> +enum counter_count_direction {
> + COUNTER_COUNT_DIRECTION_FORWARD = 0,
> + COUNTER_COUNT_DIRECTION_BACKWARD
> +};
> +
> +enum counter_count_mode {
> + COUNTER_COUNT_MODE_NORMAL = 0,
> + COUNTER_COUNT_MODE_RANGE_LIMIT,
> + COUNTER_COUNT_MODE_NON_RECYCLE,
> + COUNTER_COUNT_MODE_MODULO_N
> +};
> +
> +enum counter_count_function {
> + COUNTER_COUNT_FUNCTION_INCREASE = 0,
> + COUNTER_COUNT_FUNCTION_DECREASE,
> + COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
> + COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A,
> + COUNTER_COUNT_FUNCTION_QUADRATURE_X1_B,
> + COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
> + COUNTER_COUNT_FUNCTION_QUADRATURE_X2_B,
> + COUNTER_COUNT_FUNCTION_QUADRATURE_X4
> +};
> +
> +enum counter_signal_value {
> + COUNTER_SIGNAL_LOW = 0,
> + COUNTER_SIGNAL_HIGH
> +};
> +
> +enum counter_synapse_action {
> + COUNTER_SYNAPSE_ACTION_NONE = 0,
> + COUNTER_SYNAPSE_ACTION_RISING_EDGE,
> + COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
> + COUNTER_SYNAPSE_ACTION_BOTH_EDGES
> +};
> +
> +enum counter_data_type {
> + COUNTER_DATA_TYPE_BOOL = 0,
> + COUNTER_DATA_TYPE_UNSIGNED_LONG,
> + COUNTER_DATA_TYPE_SIZE,
> + COUNTER_DATA_TYPE_STRING,
> + COUNTER_DATA_TYPE_COUNT_FUNCTION,
> + COUNTER_DATA_TYPE_COUNT_FUNCTION_AVAILABLE,
> + COUNTER_DATA_TYPE_SIGNAL,
> + COUNTER_DATA_TYPE_SYNAPSE_ACTION,
> + COUNTER_DATA_TYPE_SYNAPSE_ACTION_AVAILABLE,
> + COUNTER_DATA_TYPE_ENUM,
> + COUNTER_DATA_TYPE_ENUM_AVAILABLE,
> + COUNTER_DATA_TYPE_COUNT_DIRECTION,
> + COUNTER_DATA_TYPE_COUNT_MODE,
> + COUNTER_DATA_TYPE_COUNT_MODE_AVAILABLE,
> +};
> +
> +enum counter_owner_type {
> + COUNTER_OWNER_TYPE_DEVICE,
> + COUNTER_OWNER_TYPE_SIGNAL,
> + COUNTER_OWNER_TYPE_COUNT,
> +};
> +
> +#endif /* _UAPI_COUNTER_TYPES_H_ */
On Wed, 29 Apr 2020 15:21:05 -0500
David Lechner <[email protected]> wrote:
> On 4/29/20 1:11 PM, William Breathitt Gray wrote:
> > Over the past couple years we have noticed some shortcomings with the
> > Counter sysfs interface. Although useful in the majority of situations,
> > there are certain use-cases where interacting through sysfs attributes
> > can become cumbersome and inefficient. A desire to support more advanced
> > functionality such as timestamps, multi-axis positioning tables, and
> > other such latency-sensitive applications, has motivated a reevaluation
> > of the Counter subsystem. I believe a character device interface will be
> > helpful for this more niche area of counter device use.
>
> Nice to see some progress being made. :-)
>
> >
> > Interaction with Counter character devices occurs via ioctl commands.
> > This allows userspace applications to access and set counter data using
> > native C datatypes rather than working through string translations.
>
> For most aspects of the counter subsystem, this is not an issue since
> configuring a counter is not a time-sensitive operation. Instead of
> ioctls, I was expecting to just be able to read the character device
> and receive counter events or poll to wait for events similar to how
> the input subsystem works or how buffers work in the iio subsystem.
>
> I'm afraid I don't really see much use in having ioctls that do
> exactly what sysfs already does. And my intuition tells me that the
> extra work needed to maintain it will probably cost more than any
> benefit gained. (Maybe other have a different experience that leads
> to a different conclusion?)
I agree with David here. The ioctls are currently doing what could have
been done nicely with a userspace library. Moving away from the string
based internal interface is a good move to my mind, because it ensures
consistency in they sysfs interface and provides for in kernel users
when they make sense. The step of then using that to simplify providing
an IOCTL interface to do the same things doesn't seem particularly useful.
So what do we gain?
Jonathan
On Fri, 1 May 2020 11:46:10 -0400
William Breathitt Gray <[email protected]> wrote:
> On Thu, Apr 30, 2020 at 10:13:45PM +0200, Alexandre Belloni wrote:
> > Hi,
> >
> > On 29/04/2020 14:11:34-0400, William Breathitt Gray wrote:
> > > Over the past couple years we have noticed some shortcomings with the
> > > Counter sysfs interface. Although useful in the majority of situations,
> > > there are certain use-cases where interacting through sysfs attributes
> > > can become cumbersome and inefficient. A desire to support more advanced
> > > functionality such as timestamps, multi-axis positioning tables, and
> > > other such latency-sensitive applications, has motivated a reevaluation
> > > of the Counter subsystem. I believe a character device interface will be
> > > helpful for this more niche area of counter device use.
> > >
> > > To quell any concerns from the offset: this patchset makes no changes to
> > > the existing Counter sysfs userspace interface -- existing userspace
> > > applications will continue to work with no modifications necessary. I
> > > request that driver maintainers please test their applications to verify
> > > that this is true, and report any discrepancies if they arise.
> > >
> >
> > On that topic, I'm wondering why the counter subsystem uses /sys/bus
> > instead of /sys/class that would be more natural for a class of devices.
> > I can't see how counters would be considered busses. I think you should
> > consider moving it over to /sys/class (even if deprecating
> > /sys/bus/counter will be long).
>
> At the time I wasn't quite familiar with sysfs development so I was
> following the iio sysfs code rather closely. However, I see now that
> you're probably right: this isn't really a bus but rather a collection
> of various types of counters -- i.e. a class of devices.
>
> Perhaps I should migrate this then to /sys/class/counter. Of course, the
> /sys/bus/counter location will have to remain for compatibility with
> existing applications, but I think a simple symlink to the new
> /sys/class/counter location should suffice for that.
>
> If anyone sees an issue with this give me a heads up.
>
> > > Interaction with Counter character devices occurs via ioctl commands.
> > > This allows userspace applications to access and set counter data using
> > > native C datatypes rather than working through string translations.
> > >
> >
> > I agree with David that you should consider using read to retrieve the
> > counter data as this will simplify interrupt handling/polling and
> > blocking/non-blocking reads can be used by an application. ABI wise,
> > this can also be a good move as you could always consider having an
> > ioctl requesting a specific format when reading the device so you are
> > not stuck with the initial format you are going to choose.
>
> My hesitation to implement support for read/write calls is due to a
> concern that we will end up with various incompatible formats between
> counter drivers (thus requiring users to have intimate knowledge of the
> drivers and therefore defeating the purpose of a subsystem). However, if
> we can standardize on a format that is flexible enough to work for all
> counter drivers, then read/write calls should not be a problem.
Absolutely. So the different approaches that have been taken to this
approach...
1) IIO, describe the format in sysfs. Highest performance option but
heavily constrained in what the data flow can be. Was it a good idea?
I think the jury is still out on that after 11 or more years :)
2) Input (evdev) - fixed length self describing records. High overhead,
inflexible format, but just fine for the fairly sensible sorts of things
that make up human input.
https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/input.h#L28
>
> I think a general format could be possible. For example, the counter
> character device can return a standard header data at the start which
> provides general information about the counter device: number of
> counters, number or signals, number of extensions, etc. From this
> information, offsets can be computed (or perhaps provided by the device)
> to where the binary data for the count, extension, etc., can be read or
> written. Interrupts can then be handled as blocking reads, as could
> other types of events we implement.
>
> Would something like this work well?
It's kind of somewhere between IIO and Input. Firstly think about what
you might want to actually have out. Mostly I'm thinking timestamp + count
value from devices that self clock. Perhaps additional flag to indicate
a preset has been hit.
Variable length records are a pain. Reality is neither IIO* nor input
actually uses them (*once running :) ). Fixed length lets you push it
through a kfifo to deal with userspace being slow to read it.
So I'd think about doing it the input way and using multiple records
for multiple counters. Timestamp can be used to work out they were at the
same instant (or various other options such as an 'end' flag).
More fun occurs if you want to start controlling 'triggers' etc as that
leads to an explosion of the control interface that we still haven't gotten
fully sorted in IIO.
Good luck :)
Jonathan
>
> William Breathitt Gray
>
> > > 2. Should device driver callbacks return int or long? I sometimes see
> > > error values returned as long (e.g. PTR_ERR(), the file_operations
> > > structure's ioctl callbacks, etc.); when is it necessary to return
> > > long as opposed to int?
> > >
> >
> > You should use a long if you ever have to return a point as it is
> > guaranteed to have the correct size. Else, just stick to an int if you
> > are not going to overflow it.
> >
> > > 3. I only implemented the unlocked_ioctl callback. Should I implement a
> > > compat_ioctl callback as well?
> > >
> >
> > The compat_ioctl is to handle 32bit userspace running on a 64bit kernel.
> > If your structures have the same size in both cases, then you don't have
> > to implement compat_ioctl.
> >
> > Have a look at Documentation/driver-api/ioctl.rst
> >
> >
> > --
> > Alexandre Belloni, Bootlin
> > Embedded Linux and Kernel engineering
> > https://bootlin.com