counter: add GPIO-based counter driver

Add a binding for a generic GPIO-based counter. Two GPIOs (signal-a, signal-b) drive two Counts; optional index GPIOs load a preset. The counter function (quadrature, pulse-direction, increase/decrease) is selected at runtime via the counter sysfs interface.

Signed-off-by Wadim Mueller <[email protected]>

---
v7:
- index-gpios split into seperate index1-gpios/index2-gpios, so Count 2 can have an index line without a dummy entry for Count 1
- dropped Conors Ack since the binding changed

---
 .../bindings/counter/gpio-counter.yaml        | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/counter/gpio-counter.yaml

Documentation/devicetree/bindings/counter/gpio-counter.yaml new file +6 -0

new file mode 100644
index 000000000000..782cb177ed0b
@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/counter/gpio-counter.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+

Add a platform driver that turns plain GPIOs into a counter device. Edge interrupts on signal-a, signal-b (and optional index) are decoded in software. Quadrature steps are validated with a 2-bit Gray-code parity check; direction comes from the same identity.

The driver exposes two Counts on the same wires:

"Count 1" - Synapses on A, B and optional Index 1. Supports
QUADRATURE_X1_{A,B} / X2_{A,B} / X4, PULSE_DIRECTION, INCREASE and DECREASE.
"Count 2" - Synapse on B and optional Index 2. Supports INCREASE
and DECREASE only.

Per-Count state (value, ceiling, preset, enable, function, direction) lives in struct gpio_counter_count_priv so new per-Count features (e.g. floor) can be added without touching parallel arrays.

Sleepable GPIO providers (I2C/SPI expanders) are rejected at probe since the ISRs run in hardirq context.

Signed-off-by Wadim Mueller <[email protected]>

drivers/counter/gpio-counter.c new file +16 -0

+static void gpio_counter_index_pulse(struct counter_device *counter,
+				     enum gpio_counter_count_id count_id)
+{
+	struct gpio_counter_priv *priv = counter_priv(counter);
+	struct gpio_counter_count_priv *cp = &priv->count_priv[count_id];
+	unsigned long flags;
+
+	spin_lock_irqsave(&priv->lock, flags);
+	if (cp->preset_enabled)
+		cp->value = (cp->preset > cp->ceiling) ? cp->ceiling : cp->preset;
+	spin_unlock_irqrestore(&priv->lock, flags);
+
+	counter_push_event(counter, COUNTER_EVENT_INDEX, count_id);
+}
+
+static irqreturn_t gpio_counter_index1_isr(int irq, void *dev_id)

drivers/counter/gpio-counter.c new file +10 -0

+static int gpio_counter_setup_signals(struct gpio_counter_priv *priv)
+{
+	priv->signals[GPIO_COUNTER_SIGNAL_A].id   = GPIO_COUNTER_SIGNAL_A;
+	priv->signals[GPIO_COUNTER_SIGNAL_A].name = "Signal A";
+	priv->signals[GPIO_COUNTER_SIGNAL_B].id   = GPIO_COUNTER_SIGNAL_B;
+	priv->signals[GPIO_COUNTER_SIGNAL_B].name = "Signal B";
+
+	if (priv->count_priv[GPIO_COUNTER_COUNT_1].has_index) {
+		priv->signals[GPIO_COUNTER_SIGNAL_INDEX1].id =
+			GPIO_COUNTER_SIGNAL_INDEX1;

drivers/counter/gpio-counter.c new file +13 -0

+}
+
+static int gpio_counter_setup_synapses(struct gpio_counter_priv *priv)
+{
+	int n_c1 = 2, n_c2 = 1;
+
+	priv->synapses_count1[0].actions_list = gpio_counter_synapse_actions;
+	priv->synapses_count1[0].num_actions =
+		ARRAY_SIZE(gpio_counter_synapse_actions);
+	priv->synapses_count1[0].signal = &priv->signals[GPIO_COUNTER_SIGNAL_A];
+
+	priv->synapses_count1[1].actions_list = gpio_counter_synapse_actions;
+	priv->synapses_count1[1].num_actions =

drivers/counter/gpio-counter.c new file +5 -0

+		n_c1 = 3;
+	}
+
+	priv->synapses_count2[0].actions_list = gpio_counter_synapse_actions;
+	priv->synapses_count2[0].num_actions =

Quoted 10 lines · Wadim Mueller

drivers/counter/gpio-counter.c new file +10 -0

+static int gpio_counter_setup_signals(struct gpio_counter_priv *priv)
+{
+	priv->signals[GPIO_COUNTER_SIGNAL_A].id   = GPIO_COUNTER_SIGNAL_A;
+	priv->signals[GPIO_COUNTER_SIGNAL_A].name = "Signal A";
+	priv->signals[GPIO_COUNTER_SIGNAL_B].id   = GPIO_COUNTER_SIGNAL_B;
+	priv->signals[GPIO_COUNTER_SIGNAL_B].name = "Signal B";
+
+	if (priv->count_priv[GPIO_COUNTER_COUNT_1].has_index) {
+		priv->signals[GPIO_COUNTER_SIGNAL_INDEX1].id =
+			GPIO_COUNTER_SIGNAL_INDEX1;

drivers/counter/gpio-counter.c line 767

Quoted 10 lines

drivers/counter/gpio-counter.c new file +10 -0

+		priv->signals[GPIO_COUNTER_SIGNAL_INDEX1].name = "Index 1";
+	}
+	if (priv->count_priv[GPIO_COUNTER_COUNT_2].has_index) {
+		priv->signals[GPIO_COUNTER_SIGNAL_INDEX2].id =
+			GPIO_COUNTER_SIGNAL_INDEX2;
+		priv->signals[GPIO_COUNTER_SIGNAL_INDEX2].name = "Index 2";
+	}
+
+	return 2 + priv->count_priv[GPIO_COUNTER_COUNT_1].has_index +
+	       priv->count_priv[GPIO_COUNTER_COUNT_2].has_index;

As sashiko-bot pointed out, the Counter subsystem doesn't handle gaps in the signals array. What you can try instead is use a local variable num_signals to hold the current signals array offset:

	num_signals = 2;
	if (priv->count_priv[GPIO_COUNTER_COUNT_1].has_index) {
		priv->signals[i].id = GPIO_COUNTER_SIGNAL_INDEX1;
		priv->signals[i].name = "Index 1";
		i++;
	}
	if (priv->count_priv[GPIO_COUNTER_COUNT_2].has_index) {
		priv->signals[i].id = GPIO_COUNTER_SIGNAL_INDEX2;
		priv->signals[i].name = "Index 2";
		i++;
	}

	return i;

Now, to refer back to the correct signals element later you have three
options: loop through the signals array and check each id, or save the signals offset to a member of count_priv so you can refer to it later.

I think the first option is the simplest because there are only two Index Signals and a single if statement suffices: if priv->signals[2].id is not GPIO_COUNTER_SIGNAL_INDEX1, then it is GPIO_COUNTER_SIGNAL_INDEX2 (and vice versa).

Quoted 13 lines

drivers/counter/gpio-counter.c new file +13 -0

+}
+
+static int gpio_counter_setup_synapses(struct gpio_counter_priv *priv)
+{
+	int n_c1 = 2, n_c2 = 1;
+
+	priv->synapses_count1[0].actions_list = gpio_counter_synapse_actions;
+	priv->synapses_count1[0].num_actions =
+		ARRAY_SIZE(gpio_counter_synapse_actions);
+	priv->synapses_count1[0].signal = &priv->signals[GPIO_COUNTER_SIGNAL_A];
+
+	priv->synapses_count1[1].actions_list = gpio_counter_synapse_actions;
+	priv->synapses_count1[1].num_actions =

drivers/counter/gpio-counter.c line 790

Quoted 10 lines

drivers/counter/gpio-counter.c new file +10 -0

+		ARRAY_SIZE(gpio_counter_synapse_actions);
+	priv->synapses_count1[1].signal = &priv->signals[GPIO_COUNTER_SIGNAL_B];
+
+	if (priv->count_priv[GPIO_COUNTER_COUNT_1].has_index) {
+		priv->synapses_count1[2].actions_list =
+			gpio_counter_index_synapse_actions;
+		priv->synapses_count1[2].num_actions =
+			ARRAY_SIZE(gpio_counter_index_synapse_actions);
+		priv->synapses_count1[2].signal =
+			&priv->signals[GPIO_COUNTER_SIGNAL_INDEX1];

You can use a ternary directly like this:

	priv->synapses_count1[2].signal = (priv->signals[2].id == GPIO_COUNTER_SIGNAL_INDEX1)
		? &priv->signals[2] : &priv->signals[3];