Introduce the Counter character device interface

Duplicate ABIs are not valid, so let's consolidate these sysfs attributes into the main sysfs-bus-counter documentation file.

Cc Patrick Havelange <[email protected]>

Signed-off-by William Breathitt Gray <[email protected]>

---
 Documentation/ABI/testing/sysfs-bus-counter   | 76 ++++++++++++++++++-
 .../ABI/testing/sysfs-bus-counter-104-quad-8  | 61 ---------------
 .../ABI/testing/sysfs-bus-counter-ftm-quaddec | 16 ----
 MAINTAINERS                                   |  4 +-
 4 files changed, 75 insertions(+), 82 deletions(-)
 delete mode 100644 Documentation/ABI/testing/sysfs-bus-counter-104-quad-8
 delete mode 100644 Documentation/ABI/testing/sysfs-bus-counter-ftm-quaddec

Documentation/ABI/testing/sysfs-bus-counter +74 -2

index 566bd99fe0a5..29f54484183f 100644
@@ -57,6 +57,7 @@ Description:
 What:		/sys/bus/counter/devices/counterX/countY/count_mode_available
 What:		/sys/bus/counter/devices/counterX/countY/error_noise_available
 What:		/sys/bus/counter/devices/counterX/countY/function_available
+What:		/sys/bus/counter/devices/counterX/countY/prescaler_available
 What:		/sys/bus/counter/devices/counterX/countY/signalZ_action_available
 KernelVersion:	5.2
 Contact:	[email protected]

@@ -154,6 +155,15 @@ Description:
 		Count Y. If possible, this should match the name of the
 		respective channel as it appears in the device datasheet.
 
+What:		/sys/bus/counter/devices/counterX/countY/prescaler
+KernelVersion:	5.2
+Contact:	[email protected]
+Description:
+		Configure the prescaler value associated with Count Y.
+		On the FlexTimer, the counter clock source passes through a
+		prescaler (i.e. a counter). This acts like a clock
+		divider.
+
 What:		/sys/bus/counter/devices/counterX/countY/preset
 KernelVersion:	5.2
 Contact:	[email protected]

@@ -215,11 +225,45 @@ Description:
 		Read-only attribute that indicates the total number of Signals
 		belonging to the Counter.
 
-What:		/sys/bus/counter/devices/counterX/signalY/signal
+What:		/sys/bus/counter/devices/counterX/signalY/cable_fault
+KernelVersion:	5.7
+Contact:	[email protected]
+Description:
+		Read-only attribute that indicates whether a differential
+		encoder cable fault (not connected or loose wires) is detected
+		for the respective channel of Signal Y. Valid attribute values
+		are boolean. Detection must first be enabled via the
+		corresponding cable_fault_enable attribute.
+
+What:		/sys/bus/counter/devices/counterX/signalY/cable_fault_enable
+KernelVersion:	5.7
+Contact:	[email protected]
+Description:
+		Whether detection of differential encoder cable faults for the
+		respective channel of Signal Y is enabled. Valid attribute
+		values are boolean.
+
+What:		/sys/bus/counter/devices/counterX/signalY/filter_clock_prescaler
+KernelVersion:	5.7
+Contact:	[email protected]
+Description:
+		Filter clock factor for input Signal Y. This prescaler value
+		affects the inputs of both quadrature pair signals.
+
+What:		/sys/bus/counter/devices/counterX/signalY/index_polarity
 KernelVersion:	5.2
 Contact:	[email protected]
 Description:
-		Signal data of Signal Y represented as a string.
+		Active level of index input Signal Y; irrelevant in
+		non-synchronous load mode.
+
+What:		/sys/bus/counter/devices/counterX/signalY/index_polarity_available
+What:		/sys/bus/counter/devices/counterX/signalY/synchronous_mode_available
+KernelVersion:	5.2
+Contact:	[email protected]
+Description:
+		Discrete set of available values for the respective Signal Y
+		configuration are listed in this file.
 
 What:		/sys/bus/counter/devices/counterX/signalY/name
 KernelVersion:	5.2

@@ -228,3 +272,31 @@ Description:
 		Read-only attribute that indicates the device-specific name of
 		Signal Y. If possible, this should match the name of the
 		respective signal as it appears in the device datasheet.
+
+What:		/sys/bus/counter/devices/counterX/signalY/signal
+KernelVersion:	5.2
+Contact:	[email protected]
+Description:
+		Signal data of Signal Y represented as a string.
+
+What:		/sys/bus/counter/devices/counterX/signalY/synchronous_mode
+KernelVersion:	5.2
+Contact:	[email protected]
+Description:
+		Configure the counter associated with Signal Y for
+		non-synchronous or synchronous load mode. Synchronous load mode
+		cannot be selected in non-quadrature (Pulse-Direction) clock
+		mode.
+
+		non-synchronous:
+			A logic low level is the active level at this index
+			input. The index function (as enabled via preset_enable)
+			is performed directly on the active level of the index
+			input.
+
+		synchronous:
+			Intended for interfacing with encoder Index output in
+			quadrature clock mode. The active level is configured
+			via index_polarity. The index function (as enabled via
+			preset_enable) is performed synchronously with the
+			quadrature clock on the active level of the index input.

Documentation/ABI/testing/sysfs-bus-counter-104-quad-8 deleted +0 -61

deleted file mode 100644
index eac32180c40d..000000000000
@@ -1,61 +0,0 @@
-What:		/sys/bus/counter/devices/counterX/signalY/cable_fault
-KernelVersion:	5.7
-Contact:	[email protected]
-Description:
-		Read-only attribute that indicates whether a differential
-		encoder cable fault (not connected or loose wires) is detected
-		for the respective channel of Signal Y. Valid attribute values
-		are boolean. Detection must first be enabled via the
-		corresponding cable_fault_enable attribute.
-
-What:		/sys/bus/counter/devices/counterX/signalY/cable_fault_enable
-KernelVersion:	5.7
-Contact:	[email protected]
-Description:
-		Whether detection of differential encoder cable faults for the
-		respective channel of Signal Y is enabled. Valid attribute
-		values are boolean.
-
-What:		/sys/bus/counter/devices/counterX/signalY/filter_clock_prescaler
-KernelVersion:	5.7
-Contact:	[email protected]
-Description:
-		Filter clock factor for input Signal Y. This prescaler value
-		affects the inputs of both quadrature pair signals.
-
-What:		/sys/bus/counter/devices/counterX/signalY/index_polarity
-KernelVersion:	5.2
-Contact:	[email protected]
-Description:
-		Active level of index input Signal Y; irrelevant in
-		non-synchronous load mode.
-
-What:		/sys/bus/counter/devices/counterX/signalY/index_polarity_available
-What:		/sys/bus/counter/devices/counterX/signalY/synchronous_mode_available
-KernelVersion:	5.2
-Contact:	[email protected]
-Description:
-		Discrete set of available values for the respective Signal Y
-		configuration are listed in this file.
-
-What:		/sys/bus/counter/devices/counterX/signalY/synchronous_mode
-KernelVersion:	5.2
-Contact:	[email protected]
-Description:
-		Configure the counter associated with Signal Y for
-		non-synchronous or synchronous load mode. Synchronous load mode
-		cannot be selected in non-quadrature (Pulse-Direction) clock
-		mode.
-
-		non-synchronous:
-			A logic low level is the active level at this index
-			input. The index function (as enabled via preset_enable)
-			is performed directly on the active level of the index
-			input.
-
-		synchronous:
-			Intended for interfacing with encoder Index output in
-			quadrature clock mode. The active level is configured
-			via index_polarity. The index function (as enabled via
-			preset_enable) is performed synchronously with the
-			quadrature clock on the active level of the index input.

Documentation/ABI/testing/sysfs-bus-counter-ftm-quaddec deleted +0 -16

deleted file mode 100644
index 7d2e7b363467..000000000000
@@ -1,16 +0,0 @@
-What:		/sys/bus/counter/devices/counterX/countY/prescaler_available
-KernelVersion:	5.2
-Contact:	[email protected]
-Description:
-		Discrete set of available values for the respective Count Y
-		configuration are listed in this file. Values are delimited by
-		newline characters.
-
-What:		/sys/bus/counter/devices/counterX/countY/prescaler
-KernelVersion:	5.2
-Contact:	[email protected]
-Description:
-		Configure the prescaler value associated with Count Y.
-		On the FlexTimer, the counter clock source passes through a
-		prescaler (i.e. a counter). This acts like a clock
-		divider.

MAINTAINERS +1 -3

index e697044d34d6..d858582c917b 100644
@@ -297,7 +297,6 @@ M:	William Breathitt Gray <[email protected]>
 M:	Syed Nayyar Waris <[email protected]>
 L:	[email protected]
 S:	Maintained
-F:	Documentation/ABI/testing/sysfs-bus-counter-104-quad-8
 F:	drivers/counter/104-quad-8.c
 
 ACCES PCI-IDIO-16 GPIO DRIVER

@@ -4540,7 +4539,7 @@ COUNTER SUBSYSTEM
 M:	William Breathitt Gray <[email protected]>
 L:	[email protected]
 S:	Maintained
-F:	Documentation/ABI/testing/sysfs-bus-counter*
+F:	Documentation/ABI/testing/sysfs-bus-counter
 F:	Documentation/driver-api/generic-counter.rst
 F:	drivers/counter/
 F:	include/linux/counter.h

@@ -6925,7 +6924,6 @@ FLEXTIMER FTM-QUADDEC DRIVER
 M:	Patrick Havelange <[email protected]>
 L:	[email protected]
 S:	Maintained
-F:	Documentation/ABI/testing/sysfs-bus-counter-ftm-quaddec
 F:	Documentation/devicetree/bindings/counter/ftm-quaddec.txt
 F:	drivers/counter/ftm-quaddec.c
 

Quoted 2 lines · On Fri, 12 Feb 2021 21:13:25 +0900 William Breathitt Gray…

Duplicate ABIs are not valid, so let's consolidate these sysfs attributes into the main sysfs-bus-counter documentation file.

This is sensible to do, but is there any duplicate ABI? I went looking for any resulting build problems and couldn't see what was actually duplicated.

Jonathan

Duplicate ABIs are not valid, so let's consolidate these sysfs attributes into the main sysfs-bus-counter documentation file.

Cc Patrick Havelange <[email protected]>

Signed-off-by William Breathitt Gray <[email protected]>

---

"Miscellaneous" is the correct spelling.

Signed-off-by William Breathitt Gray <[email protected]>

---

The 104-QUAD-8 only has two count modes where a ceiling value makes
sense: Range Limit and Modulo-N. Outside of these two modes, setting a ceiling value is an invalid operation -- so let's report it as such by returning -EINVAL.

Fixes fc069262261c ("counter: 104-quad-8: Add lock guards - generic interface")

Cc Syed Nayyar Waris <[email protected]>

Signed-off-by William Breathitt Gray <[email protected]>

---
  drivers/counter/104-quad-8.c | 5 +++--
  1 file changed, 3 insertions(+), 2 deletions(-)

drivers/counter/104-quad-8.c +1 -1

index 9691f8612be8..f0608b21196a 100644
@@ -714,13 +714,14 @@ static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
  	switch (priv->count_mode[count->id]) {
  	case 1:
  	case 3:
+		mutex_unlock(&priv->lock);
  		quad8_preset_register_set(priv, count->id, ceiling);
-		break;

Quoted 32 lines · William Breathitt Gray

The 104-QUAD-8 only has two count modes where a ceiling value makes
sense: Range Limit and Modulo-N. Outside of these two modes, setting a ceiling value is an invalid operation -- so let's report it as such by returning -EINVAL.

Fixes fc069262261c ("counter: 104-quad-8: Add lock guards - generic interface")

Cc Syed Nayyar Waris <[email protected]>

Signed-off-by William Breathitt Gray <[email protected]>

---
  drivers/counter/104-quad-8.c | 5 +++--
  1 file changed, 3 insertions(+), 2 deletions(-)

drivers/counter/104-quad-8.c +3 -2

index 9691f8612be8..f0608b21196a 100644
@@ -714,13 +714,14 @@ static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
  	switch (priv->count_mode[count->id]) {
  	case 1:
  	case 3:
+		mutex_unlock(&priv->lock);
  		quad8_preset_register_set(priv, count->id, ceiling);
-		break;
+		return len;
  	}
 
  	mutex_unlock(&priv->lock);
 
-	return len;
+	return -EINVAL;
  }
 

drivers/counter/104-quad-8.c static ssize_t quad8_count_ceiling_write(struct counter_device *counter, · line 727

Quoted 2 lines

drivers/counter/104-quad-8.c +0 -0

  static ssize_t quad8_count_preset_enable_read(struct counter_device *counter,

What happens if the register is written to when in the wrong mode?

If it doesn't hurt anything, I would suggest always writing the register instead so that users don't have to know worry about the fact that the mode has to be set first.

Only a select set of modes (function, action, etc.) are valid for a given device configuration. This patch ensures that invalid modes result in a return -EINVAL. Such a situation should never occur in reality, but it's good to define a default switch cases for the sake of making the intent of the code clear.

Cc Syed Nayyar Waris <[email protected]>

Cc Kamel Bouhara <[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]>

---
 drivers/counter/104-quad-8.c            | 10 ++++++++++
 drivers/counter/microchip-tcb-capture.c |  6 ++++++
 drivers/counter/stm32-lptimer-cnt.c     | 10 ++++++----
 drivers/counter/stm32-timer-cnt.c       |  3 +++
 drivers/counter/ti-eqep.c               |  3 +++
 5 files changed, 28 insertions(+), 4 deletions(-)

drivers/counter/104-quad-8.c +10 -0

index 9a96296b0625..674263b4d2c4 100644
@@ -273,6 +273,10 @@ static int quad8_function_set(struct counter_device *counter,
 			*scale = 2;
 			mode_cfg |= QUAD8_CMR_QUADRATURE_X4;
 			break;
+		default:
+			/* should never reach this path */
+			mutex_unlock(&priv->lock);
+			return -EINVAL;
 		}
 	}
 

@@ -367,6 +371,9 @@ static int quad8_action_get(struct counter_device *counter,
 	case QUAD8_COUNT_FUNCTION_QUADRATURE_X4:
 		*action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
 		break;
+	default:
+		/* should never reach this path */
+		return -EINVAL;
 	}
 
 	return 0;

@@ -529,6 +536,9 @@ static int quad8_count_mode_set(struct counter_device *counter,
 	case COUNTER_COUNT_MODE_MODULO_N:
 		cnt_mode = 3;
 		break;
+	default:
+		/* should never reach this path */
+		return -EINVAL;
 	}
 
 	mutex_lock(&priv->lock);

drivers/counter/microchip-tcb-capture.c +6 -0

index 710acc0a3704..ee979b011012 100644
@@ -133,6 +133,9 @@ static int mchp_tc_count_function_set(struct counter_device *counter,
 		bmr |= ATMEL_TC_QDEN | ATMEL_TC_POSEN;
 		cmr |= ATMEL_TC_ETRGEDG_RISING | ATMEL_TC_ABETRG | ATMEL_TC_XC0;
 		break;
+	default:
+		/* should never reach this path */
+		return -EINVAL;
 	}
 
 	regmap_write(priv->regmap, ATMEL_TC_BMR, bmr);

@@ -226,6 +229,9 @@ static int mchp_tc_count_action_set(struct counter_device *counter,
 	case MCHP_TC_SYNAPSE_ACTION_BOTH_EDGE:
 		edge = ATMEL_TC_ETRGEDG_BOTH;
 		break;
+	default:
+		/* should never reach this path */
+		return -EINVAL;
 	}
 
 	return regmap_write_bits(priv->regmap,

drivers/counter/stm32-lptimer-cnt.c +6 -4

index 937439635d53..daf988e7b208 100644
@@ -206,9 +206,10 @@ static int stm32_lptim_cnt_function_set(struct counter_device *counter,
 		priv->quadrature_mode = 1;
 		priv->polarity = STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES;
 		return 0;
+	default:
+		/* should never reach this path */
+		return -EINVAL;
 	}
-
-	return -EINVAL;
 }
 
 static ssize_t stm32_lptim_cnt_enable_read(struct counter_device *counter,

@@ -326,9 +327,10 @@ static int stm32_lptim_cnt_action_get(struct counter_device *counter,
 	case STM32_LPTIM_ENCODER_BOTH_EDGE:
 		*action = priv->polarity;
 		return 0;
+	default:
+		/* should never reach this path */
+		return -EINVAL;
 	}
-
-	return -EINVAL;
 }
 
 static int stm32_lptim_cnt_action_set(struct counter_device *counter,

drivers/counter/stm32-timer-cnt.c +3 -0

index ef2a974a2f10..431a3d08ed6c 100644
@@ -296,6 +296,9 @@ static int stm32_action_get(struct counter_device *counter,
 		/* counts up/down on both TI1FP1 and TI2FP2 edges */
 		*action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
 		break;
+	default:
+		/* should never reach this path */
+		return -EINVAL;
 	}
 
 	return 0;

drivers/counter/ti-eqep.c +3 -0

index a60aee1a1a29..7844fdf78a97 100644
@@ -192,6 +192,9 @@ static int ti_eqep_action_get(struct counter_device *counter,
 			break;
 		}
 		break;
+	default:
+		/* should never reach this path */
+		return -EINVAL;
 	}
 
 	return 0;

Only a select set of modes (function, action, etc.) are valid for a given device configuration. This patch ensures that invalid modes result in a return -EINVAL. Such a situation should never occur in reality, but it's good to define a default switch cases for the sake of making the intent of the code clear.

Cc Syed Nayyar Waris <[email protected]>

Cc Kamel Bouhara <[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]>

---

Quoted 6 lines · William Breathitt Gray

Only a select set of modes (function, action, etc.) are valid for a given device configuration. This patch ensures that invalid modes result in a return -EINVAL. Such a situation should never occur in reality, but it's good to define a default switch cases for the sake of making the intent of the code clear.

Quoted 8 lines

Cc Syed Nayyar Waris <[email protected]>

Cc Kamel Bouhara <[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]>

---

Reviewed-by David Lechner <[email protected]>

(In response to Jonathan's comment, I think this is fine rather than adding more churn to change all of the breaks to returns - but will keep that in mind for future changes.)

ERANGE is a semantically better error code to return when an argument value falls outside the supported limit range of a device.

Cc Syed Nayyar Waris <[email protected]>

Cc Fabrice Gasnier <[email protected]>

Cc Maxime Coquelin <[email protected]>

Cc Alexandre Torgue <[email protected]>

Signed-off-by William Breathitt Gray <[email protected]>

---
 drivers/counter/104-quad-8.c        | 6 +++---
 drivers/counter/stm32-lptimer-cnt.c | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

drivers/counter/104-quad-8.c +3 -3

index 674263b4d2c4..a2cabb028db0 100644
@@ -154,7 +154,7 @@ static int quad8_count_write(struct counter_device *counter,
 
 	/* Only 24-bit values are supported */
 	if (val > 0xFFFFFF)
-		return -EINVAL;
+		return -ERANGE;
 
 	mutex_lock(&priv->lock);
 

@@ -671,7 +671,7 @@ static ssize_t quad8_count_preset_write(struct counter_device *counter,
 
 	/* Only 24-bit values are supported */
 	if (preset > 0xFFFFFF)
-		return -EINVAL;
+		return -ERANGE;
 
 	mutex_lock(&priv->lock);
 

@@ -716,7 +716,7 @@ static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
 
 	/* Only 24-bit values are supported */
 	if (ceiling > 0xFFFFFF)
-		return -EINVAL;
+		return -ERANGE;
 
 	mutex_lock(&priv->lock);
 

drivers/counter/stm32-lptimer-cnt.c +1 -1

index daf988e7b208..d5f9d580d06d 100644
@@ -283,7 +283,7 @@ static ssize_t stm32_lptim_cnt_ceiling_write(struct counter_device *counter,
 		return ret;
 
 	if (ceiling > STM32_LPTIM_MAX_ARR)
-		return -EINVAL;
+		return -ERANGE;
 
 	priv->ceiling = ceiling;
 

Quoted 2 lines · On Fri, 12 Feb 2021 21:13:34 +0900 William Breathitt Gray…

ERANGE is a semantically better error code to return when an argument value falls outside the supported limit range of a device.

#define ERANGE 34 /* Math result not representable */

Not generally applicable to a parameter being out of range despite the name.
#define EINVAL 22 /* Invalid argument */
Is probably closer to what we want to describe here.

Jonathan

Quoted 6 lines · Jonathan Cameron

Quoted 2 lines · On Fri, 12 Feb 2021 21:13:34 +0900 William Breathitt Gray…

ERANGE is a semantically better error code to return when an argument value falls outside the supported limit range of a device.

Quoted 8 lines

#define ERANGE 34 /* Math result not representable */

Not generally applicable to a parameter being out of range despite the name.
#define EINVAL 22 /* Invalid argument */
Is probably closer to what we want to describe here.

Jonathan

The comment for ERANGE in error-base.h may be terse to a fault. I believe there's a connotation here provided by ERANGE that is absent from EINVAL: primarily that the device buffer is incapable of supporting the desired value (i.e. there is a hardware limitation).

This is why strtoul() returns ERANGE if the correct value is outside the range of representable values: the result of the operation is valid in theory (it would be an unsigned integer), but it cannot be returned to the user due to a limitation of the hardware to support that value (e.g. 32-bit registers) [1].

The changes in this patch follow the same logic: these are arguments that are valid in theory (e.g. they are unsigned integers), but the underlying devices are incapable of processing such a value (e.g. the 104-QUAD-8 can only handle 24-bit values).

[1] https://stackoverflow.com/a/34981398/1806289

William Breathitt Gray

ERANGE is a semantically better error code to return when an argument value falls outside the supported limit range of a device.

Cc Syed Nayyar Waris <[email protected]>

Cc Fabrice Gasnier <[email protected]>

Cc Maxime Coquelin <[email protected]>

Cc Alexandre Torgue <[email protected]>

Signed-off-by William Breathitt Gray <[email protected]>

---

Signal values will always be levels so let's be explicit it about it to make the intent of the code clear.

Cc Syed Nayyar Waris <[email protected]>

Cc Kamel Bouhara <[email protected]>

Signed-off-by William Breathitt Gray <[email protected]>

---

The phrase "Counter Count function" is verbose and unintentionally implies that function is a Count extension. This patch adjusts the Counter subsystem code to use the more direct "Counter function" phrase to make the intent of this code clearer. The phrase "Count action" is adjusted herein as well for the same reason.

Cc Syed Nayyar Waris <[email protected]>

Cc Patrick Havelange <[email protected]>

Cc Kamel Bouhara <[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]>

---
 drivers/counter/104-quad-8.c            | 62 +++++++++++-----------
 drivers/counter/counter.c               | 38 +++++++-------
 drivers/counter/ftm-quaddec.c           | 23 ++++-----
 drivers/counter/microchip-tcb-capture.c | 44 ++++++++--------
 drivers/counter/stm32-lptimer-cnt.c     | 56 ++++++++++----------
 drivers/counter/stm32-timer-cnt.c       | 68 ++++++++++++-------------
 drivers/counter/ti-eqep.c               | 28 +++++-----
 include/linux/counter.h                 | 20 ++++----
 8 files changed, 166 insertions(+), 173 deletions(-)

drivers/counter/104-quad-8.c +31 -31

index ead0eeb6c846..eca3f6482719 100644
@@ -187,18 +187,18 @@ static int quad8_count_write(struct counter_device *counter,
 	return 0;
 }
 
-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
+enum quad8_function {
+	QUAD8_FUNCTION_PULSE_DIRECTION = 0,
+	QUAD8_FUNCTION_QUADRATURE_X1,
+	QUAD8_FUNCTION_QUADRATURE_X2,
+	QUAD8_FUNCTION_QUADRATURE_X4
 };
 
-static const enum counter_count_function quad8_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_function quad8_functions_list[] = {
+	[QUAD8_FUNCTION_PULSE_DIRECTION] = COUNTER_FUNCTION_PULSE_DIRECTION,
+	[QUAD8_FUNCTION_QUADRATURE_X1] = COUNTER_FUNCTION_QUADRATURE_X1_A,
+	[QUAD8_FUNCTION_QUADRATURE_X2] = COUNTER_FUNCTION_QUADRATURE_X2_A,
+	[QUAD8_FUNCTION_QUADRATURE_X4] = COUNTER_FUNCTION_QUADRATURE_X4
 };
 
 static int quad8_function_get(struct counter_device *counter,

@@ -212,17 +212,17 @@ static int quad8_function_get(struct counter_device *counter,
 	if (priv->quadrature_mode[id])
 		switch (priv->quadrature_scale[id]) {
 		case 0:
-			*function = QUAD8_COUNT_FUNCTION_QUADRATURE_X1;
+			*function = QUAD8_FUNCTION_QUADRATURE_X1;
 			break;
 		case 1:
-			*function = QUAD8_COUNT_FUNCTION_QUADRATURE_X2;
+			*function = QUAD8_FUNCTION_QUADRATURE_X2;
 			break;
 		case 2:
-			*function = QUAD8_COUNT_FUNCTION_QUADRATURE_X4;
+			*function = QUAD8_FUNCTION_QUADRATURE_X4;
 			break;
 		}
 	else
-		*function = QUAD8_COUNT_FUNCTION_PULSE_DIRECTION;
+		*function = QUAD8_FUNCTION_PULSE_DIRECTION;
 
 	mutex_unlock(&priv->lock);
 

@@ -246,7 +246,7 @@ static int quad8_function_set(struct counter_device *counter,
 	mode_cfg = priv->count_mode[id] << 1;
 	idr_cfg = priv->index_polarity[id] << 1;
 
-	if (function == QUAD8_COUNT_FUNCTION_PULSE_DIRECTION) {
+	if (function == QUAD8_FUNCTION_PULSE_DIRECTION) {
 		*quadrature_mode = 0;
 
 		/* Quadrature scaling only available in quadrature mode */

@@ -262,15 +262,15 @@ static int quad8_function_set(struct counter_device *counter,
 		*quadrature_mode = 1;
 
 		switch (function) {
-		case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
+		case QUAD8_FUNCTION_QUADRATURE_X1:
 			*scale = 0;
 			mode_cfg |= QUAD8_CMR_QUADRATURE_X1;
 			break;
-		case QUAD8_COUNT_FUNCTION_QUADRATURE_X2:
+		case QUAD8_FUNCTION_QUADRATURE_X2:
 			*scale = 1;
 			mode_cfg |= QUAD8_CMR_QUADRATURE_X2;
 			break;
-		case QUAD8_COUNT_FUNCTION_QUADRATURE_X4:
+		case QUAD8_FUNCTION_QUADRATURE_X4:
 			*scale = 2;
 			mode_cfg |= QUAD8_CMR_QUADRATURE_X4;
 			break;

@@ -351,11 +351,11 @@ static int quad8_action_get(struct counter_device *counter,
 
 	/* Determine action mode based on current count function mode */
 	switch (function) {
-	case QUAD8_COUNT_FUNCTION_PULSE_DIRECTION:
+	case QUAD8_FUNCTION_PULSE_DIRECTION:
 		if (synapse->signal->id == signal_a_id)
 			*action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
 		break;
-	case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
+	case QUAD8_FUNCTION_QUADRATURE_X1:
 		if (synapse->signal->id == signal_a_id) {
 			quad8_direction_get(counter, count, &direction);
 

@@ -365,11 +365,11 @@ static int quad8_action_get(struct counter_device *counter,
 				*action = QUAD8_SYNAPSE_ACTION_FALLING_EDGE;
 		}
 		break;
-	case QUAD8_COUNT_FUNCTION_QUADRATURE_X2:
+	case QUAD8_FUNCTION_QUADRATURE_X2:
 		if (synapse->signal->id == signal_a_id)
 			*action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
 		break;
-	case QUAD8_COUNT_FUNCTION_QUADRATURE_X4:
+	case QUAD8_FUNCTION_QUADRATURE_X4:
 		*action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
 		break;
 	default:

@@ -1010,15 +1010,15 @@ static const struct counter_count_ext quad8_count_ext[] = {
 	}
 };
 
-#define QUAD8_COUNT(_id, _cntname) {					\
-	.id = (_id),							\
-	.name = (_cntname),						\
-	.functions_list = quad8_count_functions_list,			\
-	.num_functions = ARRAY_SIZE(quad8_count_functions_list),	\
-	.synapses = quad8_count_synapses[(_id)],			\
-	.num_synapses =	2,						\
-	.ext = quad8_count_ext,						\
-	.num_ext = ARRAY_SIZE(quad8_count_ext)				\
+#define QUAD8_COUNT(_id, _cntname) {				\
+	.id = (_id),						\
+	.name = (_cntname),					\
+	.functions_list = quad8_functions_list,			\
+	.num_functions = ARRAY_SIZE(quad8_functions_list),	\
+	.synapses = quad8_count_synapses[(_id)],		\
+	.num_synapses =	2,					\
+	.ext = quad8_count_ext,					\
+	.num_ext = ARRAY_SIZE(quad8_count_ext)			\
 }
 
 static struct counter_count quad8_counts[] = {

drivers/counter/counter.c +19 -19

index cb92673552b5..de921e8a3f72 100644
@@ -744,15 +744,15 @@ static ssize_t counter_count_store(struct device *dev,
 	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 const char *const counter_function_str[] = {
+	[COUNTER_FUNCTION_INCREASE] = "increase",
+	[COUNTER_FUNCTION_DECREASE] = "decrease",
+	[COUNTER_FUNCTION_PULSE_DIRECTION] = "pulse-direction",
+	[COUNTER_FUNCTION_QUADRATURE_X1_A] = "quadrature x1 a",
+	[COUNTER_FUNCTION_QUADRATURE_X1_B] = "quadrature x1 b",
+	[COUNTER_FUNCTION_QUADRATURE_X2_A] = "quadrature x2 a",
+	[COUNTER_FUNCTION_QUADRATURE_X2_B] = "quadrature x2 b",
+	[COUNTER_FUNCTION_QUADRATURE_X4] = "quadrature x4"
 };
 
 static ssize_t counter_function_show(struct device *dev,

@@ -764,7 +764,7 @@ static ssize_t counter_function_show(struct device *dev,
 	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;
+	enum counter_function function;
 
 	err = counter->ops->function_get(counter, count, &func_index);
 	if (err)

@@ -773,7 +773,7 @@ static ssize_t counter_function_show(struct device *dev,
 	count->function = func_index;
 
 	function = count->functions_list[func_index];
-	return sprintf(buf, "%s\n", counter_count_function_str[function]);
+	return sprintf(buf, "%s\n", counter_function_str[function]);
 }
 
 static ssize_t counter_function_store(struct device *dev,

@@ -785,14 +785,14 @@ static ssize_t counter_function_store(struct device *dev,
 	struct counter_count *const count = component->count;
 	const size_t num_functions = count->num_functions;
 	size_t func_index;
-	enum counter_count_function function;
+	enum counter_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]))
+		if (sysfs_streq(buf, counter_function_str[function]))
 			break;
 	}
 	/* Return error if requested Count function mode not found */

@@ -880,25 +880,25 @@ static int counter_count_ext_register(
 }
 
 struct counter_func_avail_unit {
-	const enum counter_count_function *functions_list;
+	const enum counter_function *functions_list;
 	size_t num_functions;
 };
 
-static ssize_t counter_count_function_available_show(struct device *dev,
+static ssize_t counter_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 enum counter_function *const func_list = component->functions_list;
 	const size_t num_functions = component->num_functions;
 	size_t i;
-	enum counter_count_function function;
+	enum counter_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]);
+			       counter_function_str[function]);
 	}
 
 	return len;

@@ -968,7 +968,7 @@ static int counter_count_attributes_create(
 	parm.group = group;
 	parm.prefix = "";
 	parm.name = "function_available";
-	parm.show = counter_count_function_available_show;
+	parm.show = counter_function_available_show;
 	parm.store = NULL;
 	parm.component = avail_comp;
 	err = counter_attribute_create(&parm);

drivers/counter/ftm-quaddec.c +11 -12

index 9371532406ca..97599061ca31 100644
@@ -167,13 +167,12 @@ 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,
+enum ftm_quaddec_function {
+	FTM_QUADDEC_ENCODER_MODE_1,
 };
 
-static const enum counter_count_function ftm_quaddec_count_functions[] = {
-	[FTM_QUADDEC_COUNT_ENCODER_MODE_1] =
-	COUNTER_COUNT_FUNCTION_QUADRATURE_X4
+static const enum counter_function ftm_quaddec_functions[] = {
+	[FTM_QUADDEC_ENCODER_MODE_1] = COUNTER_FUNCTION_QUADRATURE_X4
 };
 
 static int ftm_quaddec_count_read(struct counter_device *counter,

@@ -206,11 +205,11 @@ static int ftm_quaddec_count_write(struct counter_device *counter,
 	return 0;
 }
 
-static int ftm_quaddec_count_function_get(struct counter_device *counter,
-					  struct counter_count *count,
-					  size_t *function)
+static int ftm_quaddec_function_get(struct counter_device *counter,
+				    struct counter_count *count,
+				    size_t *function)
 {
-	*function = FTM_QUADDEC_COUNT_ENCODER_MODE_1;
+	*function = FTM_QUADDEC_ENCODER_MODE_1;
 
 	return 0;
 }

@@ -228,7 +227,7 @@ static int ftm_quaddec_action_get(struct counter_device *counter,
 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,
+	.function_get = ftm_quaddec_function_get,
 	.action_get = ftm_quaddec_action_get,
 };
 

@@ -264,8 +263,8 @@ static const struct counter_count_ext ftm_quaddec_count_ext[] = {
 static struct counter_count ftm_quaddec_counts = {
 	.id = 0,
 	.name = "Channel 1 Count",
-	.functions_list = ftm_quaddec_count_functions,
-	.num_functions = ARRAY_SIZE(ftm_quaddec_count_functions),
+	.functions_list = ftm_quaddec_functions,
+	.num_functions = ARRAY_SIZE(ftm_quaddec_functions),
 	.synapses = ftm_quaddec_count_synapses,
 	.num_synapses = ARRAY_SIZE(ftm_quaddec_count_synapses),
 	.ext = ftm_quaddec_count_ext,

drivers/counter/microchip-tcb-capture.c +20 -24

index f56c4e328018..d4cfaffe9499 100644
@@ -32,14 +32,14 @@ struct mchp_tc_data {
 	bool trig_inverted;
 };
 
-enum mchp_tc_count_function {
+enum mchp_tc_function {
 	MCHP_TC_FUNCTION_INCREASE,
 	MCHP_TC_FUNCTION_QUADRATURE,
 };
 
-static enum counter_count_function mchp_tc_count_functions[] = {
-	[MCHP_TC_FUNCTION_INCREASE] = COUNTER_COUNT_FUNCTION_INCREASE,
-	[MCHP_TC_FUNCTION_QUADRATURE] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4,
+static enum counter_function mchp_tc_functions[] = {
+	[MCHP_TC_FUNCTION_INCREASE] = COUNTER_FUNCTION_INCREASE,
+	[MCHP_TC_FUNCTION_QUADRATURE] = COUNTER_FUNCTION_QUADRATURE_X4,
 };
 
 enum mchp_tc_synapse_action {

@@ -80,9 +80,8 @@ static struct counter_synapse mchp_tc_count_synapses[] = {
 	}
 };
 
-static int mchp_tc_count_function_get(struct counter_device *counter,
-				      struct counter_count *count,
-				      size_t *function)
+static int mchp_tc_function_get(struct counter_device *counter,
+				struct counter_count *count, size_t *function)
 {
 	struct mchp_tc_data *const priv = counter->priv;
 

@@ -94,9 +93,8 @@ static int mchp_tc_count_function_get(struct counter_device *counter,
 	return 0;
 }
 
-static int mchp_tc_count_function_set(struct counter_device *counter,
-				      struct counter_count *count,
-				      size_t function)
+static int mchp_tc_function_set(struct counter_device *counter,
+				struct counter_count *count, size_t function)
 {
 	struct mchp_tc_data *const priv = counter->priv;
 	u32 bmr, cmr;

@@ -176,10 +174,9 @@ static int mchp_tc_count_signal_read(struct counter_device *counter,
 	return 0;
 }
 
-static int mchp_tc_count_action_get(struct counter_device *counter,
-				    struct counter_count *count,
-				    struct counter_synapse *synapse,
-				    size_t *action)
+static int mchp_tc_action_get(struct counter_device *counter,
+			      struct counter_count *count,
+			      struct counter_synapse *synapse, size_t *action)
 {
 	struct mchp_tc_data *const priv = counter->priv;
 	u32 cmr;

@@ -204,10 +201,9 @@ static int mchp_tc_count_action_get(struct counter_device *counter,
 	return 0;
 }
 
-static int mchp_tc_count_action_set(struct counter_device *counter,
-				    struct counter_count *count,
-				    struct counter_synapse *synapse,
-				    size_t action)
+static int mchp_tc_action_set(struct counter_device *counter,
+			      struct counter_count *count,
+			      struct counter_synapse *synapse, size_t action)
 {
 	struct mchp_tc_data *const priv = counter->priv;
 	u32 edge = ATMEL_TC_ETRGEDG_NONE;

@@ -256,8 +252,8 @@ static struct counter_count mchp_tc_counts[] = {
 	{
 		.id = 0,
 		.name = "Timer Counter",
-		.functions_list = mchp_tc_count_functions,
-		.num_functions = ARRAY_SIZE(mchp_tc_count_functions),
+		.functions_list = mchp_tc_functions,
+		.num_functions = ARRAY_SIZE(mchp_tc_functions),
 		.synapses = mchp_tc_count_synapses,
 		.num_synapses = ARRAY_SIZE(mchp_tc_count_synapses),
 	},

@@ -266,10 +262,10 @@ static struct counter_count mchp_tc_counts[] = {
 static const struct counter_ops mchp_tc_ops = {
 	.signal_read  = mchp_tc_count_signal_read,
 	.count_read   = mchp_tc_count_read,
-	.function_get = mchp_tc_count_function_get,
-	.function_set = mchp_tc_count_function_set,
-	.action_get   = mchp_tc_count_action_get,
-	.action_set   = mchp_tc_count_action_set
+	.function_get = mchp_tc_function_get,
+	.function_set = mchp_tc_function_set,
+	.action_get   = mchp_tc_action_get,
+	.action_set   = mchp_tc_action_set
 };
 
 static const struct atmel_tcb_config tcb_rm9200_config = {

drivers/counter/stm32-lptimer-cnt.c +28 -28

index d5f9d580d06d..31477c6a0611 100644
@@ -108,7 +108,7 @@ static int stm32_lptim_setup(struct stm32_lptim_cnt *priv, int enable)
 }
 
 /**
- * enum stm32_lptim_cnt_function - enumerates LPTimer counter & encoder modes
+ * enum stm32_lptim_function - enumerates LPTimer counter & encoder modes
  * @STM32_LPTIM_COUNTER_INCREASE: up count on IN1 rising, falling or both edges
  * @STM32_LPTIM_ENCODER_BOTH_EDGE: count on both edges (IN1 & IN2 quadrature)
  *

@@ -129,14 +129,14 @@ static int stm32_lptim_setup(struct stm32_lptim_cnt *priv, int enable)
  * | edges   | Low  ->  |   Up     |   Down  |   Down   |   Up    |
  * +---------+----------+----------+---------+----------+---------+
  */
-enum stm32_lptim_cnt_function {
+enum stm32_lptim_function {
 	STM32_LPTIM_COUNTER_INCREASE,
 	STM32_LPTIM_ENCODER_BOTH_EDGE,
 };
 
-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,
+static enum counter_function stm32_lptim_functions[] = {
+	[STM32_LPTIM_COUNTER_INCREASE] = COUNTER_FUNCTION_INCREASE,
+	[STM32_LPTIM_ENCODER_BOTH_EDGE] = COUNTER_FUNCTION_QUADRATURE_X4,
 };
 
 enum stm32_lptim_synapse_action {

@@ -170,9 +170,9 @@ static int stm32_lptim_cnt_read(struct counter_device *counter,
 	return 0;
 }
 
-static int stm32_lptim_cnt_function_get(struct counter_device *counter,
-					struct counter_count *count,
-					size_t *function)
+static int stm32_lptim_function_get(struct counter_device *counter,
+				    struct counter_count *count,
+				    size_t *function)
 {
 	struct stm32_lptim_cnt *const priv = counter->priv;
 

@@ -189,9 +189,9 @@ static int stm32_lptim_cnt_function_get(struct counter_device *counter,
 	return -EINVAL;
 }
 
-static int stm32_lptim_cnt_function_set(struct counter_device *counter,
-					struct counter_count *count,
-					size_t function)
+static int stm32_lptim_function_set(struct counter_device *counter,
+				    struct counter_count *count,
+				    size_t function)
 {
 	struct stm32_lptim_cnt *const priv = counter->priv;
 

@@ -303,16 +303,16 @@ static const struct counter_count_ext stm32_lptim_cnt_ext[] = {
 	},
 };
 
-static int stm32_lptim_cnt_action_get(struct counter_device *counter,
-				      struct counter_count *count,
-				      struct counter_synapse *synapse,
-				      size_t *action)
+static int stm32_lptim_action_get(struct counter_device *counter,
+				  struct counter_count *count,
+				  struct counter_synapse *synapse,
+				  size_t *action)
 {
 	struct stm32_lptim_cnt *const priv = counter->priv;
 	size_t function;
 	int err;
 
-	err = stm32_lptim_cnt_function_get(counter, count, &function);
+	err = stm32_lptim_function_get(counter, count, &function);
 	if (err)
 		return err;
 

@@ -333,10 +333,10 @@ static int stm32_lptim_cnt_action_get(struct counter_device *counter,
 	}
 }
 
-static int stm32_lptim_cnt_action_set(struct counter_device *counter,
-				      struct counter_count *count,
-				      struct counter_synapse *synapse,
-				      size_t action)
+static int stm32_lptim_action_set(struct counter_device *counter,
+				  struct counter_count *count,
+				  struct counter_synapse *synapse,
+				  size_t action)
 {
 	struct stm32_lptim_cnt *const priv = counter->priv;
 	size_t function;

@@ -345,7 +345,7 @@ static int stm32_lptim_cnt_action_set(struct counter_device *counter,
 	if (stm32_lptim_is_enabled(priv))
 		return -EBUSY;
 
-	err = stm32_lptim_cnt_function_get(counter, count, &function);
+	err = stm32_lptim_function_get(counter, count, &function);
 	if (err)
 		return err;
 

@@ -366,10 +366,10 @@ static int stm32_lptim_cnt_action_set(struct counter_device *counter,
 
 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,
+	.function_get = stm32_lptim_function_get,
+	.function_set = stm32_lptim_function_set,
+	.action_get = stm32_lptim_action_get,
+	.action_set = stm32_lptim_action_set,
 };
 
 static struct counter_signal stm32_lptim_cnt_signals[] = {

@@ -400,8 +400,8 @@ static struct counter_synapse stm32_lptim_cnt_synapses[] = {
 static struct counter_count stm32_lptim_enc_counts = {
 	.id = 0,
 	.name = "LPTimer Count",
-	.functions_list = stm32_lptim_cnt_functions,
-	.num_functions = ARRAY_SIZE(stm32_lptim_cnt_functions),
+	.functions_list = stm32_lptim_functions,
+	.num_functions = ARRAY_SIZE(stm32_lptim_functions),
 	.synapses = stm32_lptim_cnt_synapses,
 	.num_synapses = ARRAY_SIZE(stm32_lptim_cnt_synapses),
 	.ext = stm32_lptim_cnt_ext,

@@ -412,7 +412,7 @@ static struct counter_count stm32_lptim_enc_counts = {
 static struct counter_count stm32_lptim_in1_counts = {
 	.id = 0,
 	.name = "LPTimer Count",
-	.functions_list = stm32_lptim_cnt_functions,
+	.functions_list = stm32_lptim_functions,
 	.num_functions = 1,
 	.synapses = stm32_lptim_cnt_synapses,
 	.num_synapses = 1,

drivers/counter/stm32-timer-cnt.c +33 -35

index 431a3d08ed6c..02a7c8bd77df 100644
@@ -37,23 +37,23 @@ struct stm32_timer_cnt {
 };
 
 /**
- * enum stm32_count_function - enumerates stm32 timer counter encoder modes
- * @STM32_COUNT_SLAVE_MODE_DISABLED: counts on internal clock when CEN=1
- * @STM32_COUNT_ENCODER_MODE_1: counts TI1FP1 edges, depending on TI2FP2 level
- * @STM32_COUNT_ENCODER_MODE_2: counts TI2FP2 edges, depending on TI1FP1 level
- * @STM32_COUNT_ENCODER_MODE_3: counts on both TI1FP1 and TI2FP2 edges
+ * enum stm32_function - enumerates stm32 timer counter encoder modes
+ * @STM32_SLAVE_MODE_DISABLED: counts on internal clock when CEN=1
+ * @STM32_ENCODER_MODE_1: counts TI1FP1 edges, depending on TI2FP2 level
+ * @STM32_ENCODER_MODE_2: counts TI2FP2 edges, depending on TI1FP1 level
+ * @STM32_ENCODER_MODE_3: counts on both TI1FP1 and TI2FP2 edges
  */
-enum stm32_count_function {
-	STM32_COUNT_SLAVE_MODE_DISABLED = -1,
-	STM32_COUNT_ENCODER_MODE_1,
-	STM32_COUNT_ENCODER_MODE_2,
-	STM32_COUNT_ENCODER_MODE_3,
+enum stm32_function {
+	STM32_SLAVE_MODE_DISABLED = -1,
+	STM32_ENCODER_MODE_1,
+	STM32_ENCODER_MODE_2,
+	STM32_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 enum counter_function stm32_functions[] = {
+	[STM32_ENCODER_MODE_1] = COUNTER_FUNCTION_QUADRATURE_X2_A,
+	[STM32_ENCODER_MODE_2] = COUNTER_FUNCTION_QUADRATURE_X2_B,
+	[STM32_ENCODER_MODE_3] = COUNTER_FUNCTION_QUADRATURE_X4,
 };
 
 static int stm32_count_read(struct counter_device *counter,

@@ -80,9 +80,8 @@ static int stm32_count_write(struct counter_device *counter,
 	return regmap_write(priv->regmap, TIM_CNT, val);
 }
 
-static int stm32_count_function_get(struct counter_device *counter,
-				    struct counter_count *count,
-				    size_t *function)
+static int stm32_function_get(struct counter_device *counter,
+			      struct counter_count *count, size_t *function)
 {
 	struct stm32_timer_cnt *const priv = counter->priv;
 	u32 smcr;

@@ -91,34 +90,33 @@ static int stm32_count_function_get(struct counter_device *counter,
 
 	switch (smcr & TIM_SMCR_SMS) {
 	case 1:
-		*function = STM32_COUNT_ENCODER_MODE_1;
+		*function = STM32_ENCODER_MODE_1;
 		return 0;
 	case 2:
-		*function = STM32_COUNT_ENCODER_MODE_2;
+		*function = STM32_ENCODER_MODE_2;
 		return 0;
 	case 3:
-		*function = STM32_COUNT_ENCODER_MODE_3;
+		*function = STM32_ENCODER_MODE_3;
 		return 0;
 	}
 
 	return -EINVAL;
 }
 
-static int stm32_count_function_set(struct counter_device *counter,
-				    struct counter_count *count,
-				    size_t function)
+static int stm32_function_set(struct counter_device *counter,
+			      struct counter_count *count, size_t function)
 {
 	struct stm32_timer_cnt *const priv = counter->priv;
 	u32 cr1, sms;
 
 	switch (function) {
-	case STM32_COUNT_ENCODER_MODE_1:
+	case STM32_ENCODER_MODE_1:
 		sms = 1;
 		break;
-	case STM32_COUNT_ENCODER_MODE_2:
+	case STM32_ENCODER_MODE_2:
 		sms = 2;
 		break;
-	case STM32_COUNT_ENCODER_MODE_3:
+	case STM32_ENCODER_MODE_3:
 		sms = 3;
 		break;
 	default:

@@ -274,25 +272,25 @@ static int stm32_action_get(struct counter_device *counter,
 	size_t function;
 	int err;
 
-	/* Default action mode (e.g. STM32_COUNT_SLAVE_MODE_DISABLED) */
+	/* Default action mode (e.g. STM32_SLAVE_MODE_DISABLED) */
 	*action = STM32_SYNAPSE_ACTION_NONE;
 
-	err = stm32_count_function_get(counter, count, &function);
+	err = stm32_function_get(counter, count, &function);
 	if (err)
 		return 0;
 
 	switch (function) {
-	case STM32_COUNT_ENCODER_MODE_1:
+	case STM32_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;
 		break;
-	case STM32_COUNT_ENCODER_MODE_2:
+	case STM32_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;
 		break;
-	case STM32_COUNT_ENCODER_MODE_3:
+	case STM32_ENCODER_MODE_3:
 		/* counts up/down on both TI1FP1 and TI2FP2 edges */
 		*action = STM32_SYNAPSE_ACTION_BOTH_EDGES;
 		break;

@@ -307,8 +305,8 @@ static int stm32_action_get(struct counter_device *counter,
 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,
+	.function_get = stm32_function_get,
+	.function_set = stm32_function_set,
 	.action_get = stm32_action_get,
 };
 

@@ -339,8 +337,8 @@ static struct counter_synapse stm32_count_synapses[] = {
 static struct counter_count stm32_counts = {
 	.id = 0,
 	.name = "Channel 1 Count",
-	.functions_list = stm32_count_functions,
-	.num_functions = ARRAY_SIZE(stm32_count_functions),
+	.functions_list = stm32_functions,
+	.num_functions = ARRAY_SIZE(stm32_functions),
 	.synapses = stm32_count_synapses,
 	.num_synapses = ARRAY_SIZE(stm32_count_synapses),
 	.ext = stm32_count_ext,

drivers/counter/ti-eqep.c +14 -14

index 7844fdf78a97..8d45b0443610 100644
@@ -73,11 +73,11 @@ 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_function {
+	TI_EQEP_FUNCTION_QUAD_COUNT,
+	TI_EQEP_FUNCTION_DIR_COUNT,
+	TI_EQEP_FUNCTION_UP_COUNT,
+	TI_EQEP_FUNCTION_DOWN_COUNT,
 };
 
 enum {

@@ -152,13 +152,13 @@ static int ti_eqep_action_get(struct counter_device *counter,
 		return err;
 
 	switch (function) {
-	case TI_EQEP_COUNT_FUNC_QUAD_COUNT:
+	case TI_EQEP_FUNCTION_QUAD_COUNT:
 		/* In quadrature mode, the rising and falling edge of both
 		 * QEPA and QEPB trigger QCLK.
 		 */
 		*action = TI_EQEP_SYNAPSE_ACTION_BOTH_EDGES;
 		break;
-	case TI_EQEP_COUNT_FUNC_DIR_COUNT:
+	case TI_EQEP_FUNCTION_DIR_COUNT:
 		/* In direction-count mode only rising edge of QEPA is counted
 		 * and QEPB gives direction.
 		 */

@@ -171,8 +171,8 @@ static int ti_eqep_action_get(struct counter_device *counter,
 			break;
 		}
 		break;
-	case TI_EQEP_COUNT_FUNC_UP_COUNT:
-	case TI_EQEP_COUNT_FUNC_DOWN_COUNT:
+	case TI_EQEP_FUNCTION_UP_COUNT:
+	case TI_EQEP_FUNCTION_DOWN_COUNT:
 		/* In up/down-count modes only QEPA is counted and QEPB is not
 		 * used.
 		 */

@@ -327,11 +327,11 @@ 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,
+static const enum counter_function ti_eqep_position_functions[] = {
+	[TI_EQEP_FUNCTION_QUAD_COUNT]	= COUNTER_FUNCTION_QUADRATURE_X4,
+	[TI_EQEP_FUNCTION_DIR_COUNT]	= COUNTER_FUNCTION_PULSE_DIRECTION,
+	[TI_EQEP_FUNCTION_UP_COUNT]	= COUNTER_FUNCTION_INCREASE,
+	[TI_EQEP_FUNCTION_DOWN_COUNT]	= COUNTER_FUNCTION_DECREASE,
 };
 
 static const enum counter_synapse_action ti_eqep_position_synapse_actions[] = {

include/linux/counter.h +10 -10

index 79f5dcaf6ba0..d16ce2819b48 100644
@@ -162,15 +162,15 @@ struct counter_count_ext {
 	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
+enum counter_function {
+	COUNTER_FUNCTION_INCREASE = 0,
+	COUNTER_FUNCTION_DECREASE,
+	COUNTER_FUNCTION_PULSE_DIRECTION,
+	COUNTER_FUNCTION_QUADRATURE_X1_A,
+	COUNTER_FUNCTION_QUADRATURE_X1_B,
+	COUNTER_FUNCTION_QUADRATURE_X2_A,
+	COUNTER_FUNCTION_QUADRATURE_X2_B,
+	COUNTER_FUNCTION_QUADRATURE_X4
 };
 
 /**

@@ -192,7 +192,7 @@ struct counter_count {
 	const char *name;
 
 	size_t function;
-	const enum counter_count_function *functions_list;
+	const enum counter_function *functions_list;
 	size_t num_functions;
 
 	struct counter_synapse *synapses;

Quoted 6 lines · On Fri, 12 Feb 2021 21:13:36 +0900 William Breathitt Gray…

The phrase "Counter Count function" is verbose and unintentionally implies that function is a Count extension. This patch adjusts the Counter subsystem code to use the more direct "Counter function" phrase to make the intent of this code clearer. The phrase "Count action" is adjusted herein as well for the same reason.

Quoted 8 lines

Cc Syed Nayyar Waris <[email protected]>

Cc Patrick Havelange <[email protected]>

Cc Kamel Bouhara <[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]>

I agree this makes sense in the counter core code, but in the drivers it may not be quite so obvious we are talking about a counter function given some of the bits of hardware do a number of other things.

I guess up to the various driver maintainers on whether they think the new meaning is clear enough!

Jonathan

Quoted 22 lines · Jonathan Cameron

Quoted 6 lines · On Fri, 12 Feb 2021 21:13:36 +0900 William Breathitt Gray…

The phrase "Counter Count function" is verbose and unintentionally implies that function is a Count extension. This patch adjusts the Counter subsystem code to use the more direct "Counter function" phrase to make the intent of this code clearer. The phrase "Count action" is adjusted herein as well for the same reason.

Quoted 8 lines

Cc Syed Nayyar Waris <[email protected]>

Cc Patrick Havelange <[email protected]>

Cc Kamel Bouhara <[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]>

I agree this makes sense in the counter core code, but in the drivers it may not be quite so obvious we are talking about a counter function given some of the bits of hardware do a number of other things.

Quoted 5 lines

I guess up to the various driver maintainers on whether they think the new meaning is clear enough!

Jonathan

TBH, I think "counter count function" makes more sense to me.

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.

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. u8, u64, etc.) and the shared counter module handles the translation between the sysfs interface and the device drivers. This guarantees a standard userspace interface for all counter drivers, and helps generalize the Generic Counter driver ABI in order to support the Generic Counter chrdev interface (introduced in a subsequent patch) without significant changes to the existing counter drivers.

Note, 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_comp structure forms the basis for Counter extensions.

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 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 called, and sysfs I/O is handled before or after the driver read/write function is called.

Cc Syed Nayyar Waris <[email protected]>

Cc Patrick Havelange <[email protected]>

Cc Kamel Bouhara <[email protected]>

Cc Fabrice Gasnier <[email protected]>

Cc Maxime Coquelin <[email protected]>

Cc Alexandre Torgue <[email protected]>

Cc David Lechner <[email protected]>

Cc Dan Carpenter <[email protected]>

Signed-off-by William Breathitt Gray <[email protected]>

---
 MAINTAINERS                             |    1 -
 drivers/counter/104-quad-8.c            |  449 +++----
 drivers/counter/Makefile                |    1 +
 drivers/counter/counter-core.c          |  153 +++
 drivers/counter/counter-sysfs.c         |  833 +++++++++++++
 drivers/counter/counter-sysfs.h         |   13 +
 drivers/counter/counter.c               | 1496 -----------------------
 drivers/counter/ftm-quaddec.c           |   56 +-
 drivers/counter/microchip-tcb-capture.c |   87 +-
 drivers/counter/stm32-lptimer-cnt.c     |  164 ++-
 drivers/counter/stm32-timer-cnt.c       |  142 +--
 drivers/counter/ti-eqep.c               |  211 ++--
 include/linux/counter.h                 |  631 +++++-----
 include/linux/counter_enum.h            |   45 -
 14 files changed, 1816 insertions(+), 2466 deletions(-)
 create mode 100644 drivers/counter/counter-core.c
 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

MAINTAINERS +0 -1

index d858582c917b..94a19606d947 100644
@@ -4543,7 +4543,6 @@ 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
 
 CPMAC ETHERNET DRIVER
 M:	Florian Fainelli <[email protected]>

drivers/counter/104-quad-8.c +0 -0

index eca3f6482719..41fdbd228be3 100644
@@ -116,7 +116,7 @@ static int quad8_signal_read(struct counter_device *counter,

drivers/counter/counter-sysfs.c new file +0 -0

new file mode 100644
index 000000000000..52513a213cc5
@@ -0,0 +1,833 @@

drivers/counter/counter-sysfs.c new file +9 -0

+
+static ssize_t counter_comp_u8_show(struct device *dev,
+				    struct device_attribute *attr, char *buf)
+{
+	const struct counter_attribute *const a = to_counter_attribute(attr);
+	struct counter_device *const counter = dev_get_drvdata(dev);
+	int err;
+	u8 data = 0;
+

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

+	}
+	if (err < 0)
+		return err;
+
+	if (a->comp.type == COUNTER_COMP_BOOL)
+		data = !!data;
+
+	return sprintf(buf, "%u\n", (unsigned int)data);
+}
+

drivers/counter/counter-sysfs.c new file +17 -0

+
+static int counter_name_attr_create(struct device *const dev,
+				    struct counter_attribute_group *const group,
+				    const char *const name)
+{
+	struct counter_attribute *counter_attr;
+
+	/* Allocate Counter attribute */
+	counter_attr = devm_kzalloc(dev, sizeof(*counter_attr), GFP_KERNEL);
+	if (!counter_attr)
+		return -ENOMEM;
+
+	/* Configure Counter attribute */
+	counter_attr->comp.name = name;
+
+	/* Configure device attribute */
+	sysfs_attr_init(&counter_attr->dev_attr.attr);

drivers/counter/counter-sysfs.c new file +6 -0

+
+
+static struct counter_comp counter_signal_comp = {
+	.type = COUNTER_COMP_SIGNAL_LEVEL,
+	.name = "signal",
+};

static struct counter_synapse ti_eqep_position_synapses[] = {

include/linux/counter.h +0 -0

index d16ce2819b48..76b0b06dd5db 100644
@@ -6,42 +6,184 @@
 #ifndef _COUNTER_H_
 #define _COUNTER_H_
 

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.

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. u8, u64, etc.) and the shared counter module handles the translation between the sysfs interface and the device drivers. This guarantees a standard userspace interface for all counter drivers, and helps generalize the Generic Counter driver ABI in order to support the Generic Counter chrdev interface (introduced in a subsequent patch) without significant changes to the existing counter drivers.

Note, 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_comp structure forms the basis for Counter extensions.

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 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 called, and sysfs I/O is handled before or after the driver read/write function is called.

Cc Syed Nayyar Waris <[email protected]>

Cc Patrick Havelange <[email protected]>

Cc Kamel Bouhara <[email protected]>

Cc Fabrice Gasnier <[email protected]>

Cc Maxime Coquelin <[email protected]>

Cc Alexandre Torgue <[email protected]>

Cc David Lechner <[email protected]>

Cc Dan Carpenter <[email protected]>

Signed-off-by William Breathitt Gray <[email protected]>

---

This is in preparation for a subsequent patch implementing a character device interface for the Counter subsystem.

Signed-off-by William Breathitt Gray <[email protected]>

---

This patch introduces a character device interface for the Counter subsystem. Device data is exposed through standard character device read operations. Device data is gathered when a Counter event is pushed by the respective Counter device driver. Configuration is handled via ioctl operations on the respective Counter character device node.

Cc David Lechner <[email protected]>

Cc Gwendal Grignou <[email protected]>

Cc Dan Carpenter <[email protected]>

Cc Oleksij Rempel <[email protected]>

Signed-off-by William Breathitt Gray <[email protected]>

---
 drivers/counter/Makefile         |   2 +-
 drivers/counter/counter-chrdev.c | 496 +++++++++++++++++++++++++++++++
 drivers/counter/counter-chrdev.h |  16 +
 drivers/counter/counter-core.c   |  37 ++-
 include/linux/counter.h          |  45 +++
 include/uapi/linux/counter.h     |  70 +++++
 6 files changed, 661 insertions(+), 5 deletions(-)
 create mode 100644 drivers/counter/counter-chrdev.c
 create mode 100644 drivers/counter/counter-chrdev.h

drivers/counter/counter-core.c +6 -0

index bcf672e1fc0d..c137fcb97d9c 100644
@@ -5,12 +5,16 @@
  */
 #include <linux/counter.h>
 #include <linux/device.h>
+#include <linux/device/bus.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/types.h>
 
+#include "counter-chrdev.h"
 #include "counter-sysfs.h"
 
 /* Provides a unique ID for each counter device */

@@ -33,6 +37,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

drivers/counter/counter-core.c +5 -0

 	dev->type = &counter_device_type;
 	dev->bus = &counter_bus_type;
 	if (counter->parent) {

@@ -65,18 +70,25 @@ 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 < 0)
+		goto err_free_id;
+
 	/* Add Counter sysfs attributes */

drivers/counter/counter-core.c +20 -1

 	return 0;
 
+err_remove_chrdev:
+	counter_chrdev_remove(counter);
 err_free_id:
 	put_device(dev);
 	return err;

@@ -138,13 +150,30 @@ int devm_counter_register(struct device *dev,
 }
 EXPORT_SYMBOL_GPL(devm_counter_register);
 
+#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);
 }
 

include/uapi/linux/counter.h +13 -0

index 6113938a6044..3d647a5383b8 100644
@@ -6,6 +6,19 @@
 #ifndef _UAPI_COUNTER_H_
 #define _UAPI_COUNTER_H_
 
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+/* Component type definitions */
+enum counter_component_type {
+	COUNTER_COMPONENT_NONE,
+	COUNTER_COMPONENT_SIGNAL,
+	COUNTER_COMPONENT_COUNT,
+	COUNTER_COMPONENT_FUNCTION,
+	COUNTER_COMPONENT_SYNAPSE_ACTION,
+	COUNTER_COMPONENT_EXTENSION,
+};
+
 /* Component scope definitions */
 enum counter_scope {
 	COUNTER_SCOPE_DEVICE,

include/uapi/linux/counter.h +51 -0

+ * @id: component ID (matching the Y/Z suffix of the respective sysfs path as
+ *	described in Documentation/ABI/testing/sysfs-bus-counter)
+ */
+struct counter_component {
+	__u8 type;
+	__u8 scope;
+	__u8 parent;
+	__u8 id;
+};
+
+/* Event type definitions */
+enum counter_event_type {
+	COUNTER_EVENT_OVERFLOW,
+	COUNTER_EVENT_UNDERFLOW,
+	COUNTER_EVENT_OVERFLOW_UNDERFLOW,
+	COUNTER_EVENT_THRESHOLD,
+	COUNTER_EVENT_INDEX,
+};
+
+/**
+ * struct counter_watch - Counter component watch configuration
+ * @component: component to watch when event triggers
+ * @event: event that triggers (one of enum counter_event_type)
+ * @channel: event channel (typically 0 unless the device supports concurrent
+ *	     events of the same type)
+ */
+struct counter_watch {
+	struct counter_component component;
+	__u8 event;
+	__u8 channel;
+};
+
+/* ioctl commands */
+#define COUNTER_ADD_WATCH_IOCTL _IOW(0x3E, 0x00, struct counter_watch)
+#define COUNTER_ENABLE_EVENTS_IOCTL _IO(0x3E, 0x01)
+#define COUNTER_DISABLE_EVENTS_IOCTL _IO(0x3E, 0x02)
+
+/**
+ * struct counter_event - Counter event data
+ * @timestamp: best estimate of time of event occurrence, in nanoseconds
+ * @value: component value
+ * @watch: component watch configuration
+ * @status: return status (system error number)
+ */
+struct counter_event {
+	__aligned_u64 timestamp;
+	__aligned_u64 value;
+	struct counter_watch watch;
+	__u8 status;
+};
+
 /* Count direction values */
 enum counter_count_direction {
 	COUNTER_COUNT_DIRECTION_FORWARD,

Quoted 11 lines · On Fri, 12 Feb 2021 21:13:41 +0900 William Breathitt Gray…

This patch introduces a character device interface for the Counter subsystem. Device data is exposed through standard character device read operations. Device data is gathered when a Counter event is pushed by the respective Counter device driver. Configuration is handled via ioctl operations on the respective Counter character device node.

Cc David Lechner <[email protected]>

Cc Gwendal Grignou <[email protected]>

Cc Dan Carpenter <[email protected]>

Cc Oleksij Rempel <[email protected]>

Signed-off-by William Breathitt Gray <[email protected]>

Hi William,

A few minor comments. Mostly seems to have come together well and makes sense to me.

Jonathan

Quoted 11 lines

---
 drivers/counter/Makefile         |   2 +-
 drivers/counter/counter-chrdev.c | 496 +++++++++++++++++++++++++++++++
 drivers/counter/counter-chrdev.h |  16 +
 drivers/counter/counter-core.c   |  37 ++-
 include/linux/counter.h          |  45 +++
 include/uapi/linux/counter.h     |  70 +++++
 6 files changed, 661 insertions(+), 5 deletions(-)
 create mode 100644 drivers/counter/counter-chrdev.c
 create mode 100644 drivers/counter/counter-chrdev.h

...

Quoted 34 lines

drivers/counter/counter-core.c +6 -0

index bcf672e1fc0d..c137fcb97d9c 100644
@@ -5,12 +5,16 @@
  */
 #include <linux/counter.h>
 #include <linux/device.h>
+#include <linux/device/bus.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/types.h>
 
+#include "counter-chrdev.h"
 #include "counter-sysfs.h"
 
 /* Provides a unique ID for each counter device */

@@ -33,6 +37,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

@@ -54,7 +60,6 @@ int counter_register(struct counter_device *const counter)
 	if (counter->id < 0)
 		return counter->id;
 

drivers/counter/counter-core.c int counter_register(struct counter_device *const counter) · line 57

Quoted 1 line

drivers/counter/counter-core.c +0 -1

-	/* Configure device structure for Counter */

Not sure why this comment gets removed here.

Quoted 18 lines

drivers/counter/counter-core.c +6 -1

 	dev->type = &counter_device_type;
 	dev->bus = &counter_bus_type;
 	if (counter->parent) {

@@ -65,18 +70,25 @@ 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 < 0)
+		goto err_free_id;
+
 	/* Add Counter sysfs attributes */
 	err = counter_sysfs_add(counter);
 	if (err < 0)
-		goto err_free_id;
+		goto err_remove_chrdev;
 

drivers/counter/counter-core.c int counter_register(struct counter_device *const counter) · line 86

Quoted 5 lines

drivers/counter/counter-core.c +1 -1

 	/* Add device to system */
 	err = device_add(dev);
 	if (err < 0)
-		goto err_free_id;
+		goto err_remove_chrdev;

It might be worth thinking about using cdev_device_add() though will require a slightly different order of adding.

Quoted 40 lines

drivers/counter/counter-core.c +20 -1

 	return 0;
 
+err_remove_chrdev:
+	counter_chrdev_remove(counter);
 err_free_id:
 	put_device(dev);
 	return err;

@@ -138,13 +150,30 @@ int devm_counter_register(struct device *dev,
 }
 EXPORT_SYMBOL_GPL(devm_counter_register);
 
+#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);
 }
 

...

Quoted 28 lines

include/uapi/linux/counter.h +13 -0

index 6113938a6044..3d647a5383b8 100644
@@ -6,6 +6,19 @@
 #ifndef _UAPI_COUNTER_H_
 #define _UAPI_COUNTER_H_
 
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+/* Component type definitions */
+enum counter_component_type {
+	COUNTER_COMPONENT_NONE,
+	COUNTER_COMPONENT_SIGNAL,
+	COUNTER_COMPONENT_COUNT,
+	COUNTER_COMPONENT_FUNCTION,
+	COUNTER_COMPONENT_SYNAPSE_ACTION,
+	COUNTER_COMPONENT_EXTENSION,
+};
+
 /* Component scope definitions */
 enum counter_scope {
 	COUNTER_SCOPE_DEVICE,

@@ -13,6 +26,63 @@ enum counter_scope {
 	COUNTER_SCOPE_COUNT,
 };
 

include/uapi/linux/counter.h enum counter_scope { · line 34

Quoted 6 lines

include/uapi/linux/counter.h +6 -0

+/**
+ * struct counter_component - Counter component identification
+ * @type: component type (one of enum counter_component_type)
+ * @scope: component scope (one of enum counter_scope)
+ * @parent: parent component ID (matching the Y/Z suffix of the respective sysfs
+ *	    path as described in Documentation/ABI/testing/sysfs-bus-counter)

Probably good to give an example here as well as the cross reference.

This patch introduces a character device interface for the Counter subsystem. Device data is exposed through standard character device read operations. Device data is gathered when a Counter event is pushed by the respective Counter device driver. Configuration is handled via ioctl operations on the respective Counter character device node.

drivers/counter/counter-chrdev.c new file +24 -0

+/**
+ * counter_push_event - queue event for userspace reading
+ * @counter:	pointer to Counter structure
+ * @event:	triggered event
+ * @channel:	event channel
+ *
+ * Note: If no one is watching for the respective event, it is silently
+ * discarded.
+ */
+void counter_push_event(struct counter_device *const counter, const u8 event,
+			const u8 channel)
+{
+	struct counter_event ev = {0};
+	unsigned int copied = 0;
+	unsigned long flags;
+	struct counter_event_node *event_node;
+	struct counter_comp_node *comp_node;
+
+	ev.timestamp = ktime_get_ns();
+	ev.watch.event = event;
+	ev.watch.channel = channel;
+
+	/* Could be in an interrupt context, so use a raw spin lock */
+	raw_spin_lock_irqsave(&counter->events_list_lock, flags);