Introduce the Counter character device interface

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

Cc Maxime Coquelin <[email protected]>

Cc Alexandre Torgue <[email protected]>

Cc David Lechner <[email protected]>

Acked-by Syed Nayyar Waris <[email protected]>

Reviewed-by Fabrice Gasnier <[email protected]>

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

---

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 Jarkko Nikula <[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 Dan Carpenter <[email protected]>

Reviewed-by David Lechner <[email protected]>

Tested-by David Lechner <[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          |  145 +++
 drivers/counter/counter-sysfs.c         |  846 +++++++++++++
 drivers/counter/counter-sysfs.h         |   13 +
 drivers/counter/counter.c               | 1496 -----------------------
 drivers/counter/ftm-quaddec.c           |   56 +-
 drivers/counter/intel-qep.c             |  144 +--
 drivers/counter/interrupt-cnt.c         |   62 +-
 drivers/counter/microchip-tcb-capture.c |   93 +-
 drivers/counter/stm32-lptimer-cnt.c     |  162 ++-
 drivers/counter/stm32-timer-cnt.c       |  147 +--
 drivers/counter/ti-eqep.c               |  180 +--
 include/linux/counter.h                 |  658 +++++-----
 include/linux/counter_enum.h            |   45 -
 16 files changed, 1920 insertions(+), 2578 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 9bf553e53f0f..2cac15216ba9 100644
@@ -4687,7 +4687,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
 
 CP2615 I2C DRIVER
 M:     Bence Csókás <[email protected]>

drivers/counter/104-quad-8.c +191 -258

index 5283ff128c17..d1161c27c488 100644
@@ -116,7 +116,7 @@ static int quad8_signal_read(struct counter_device *counter,
 }
 
 static int quad8_count_read(struct counter_device *counter,
-       struct counter_count *count, unsigned long *val)
+                           struct counter_count *count, u64 *val)
 {
        struct quad8 *const priv = counter->priv;
        const int base_offset = priv->base + 2 * count->id;

@@ -147,7 +147,7 @@ static int quad8_count_read(struct counter_device *counter,
 }
 
 static int quad8_count_write(struct counter_device *counter,
-       struct counter_count *count, unsigned long val)
+                            struct counter_count *count, u64 val)
 {
        struct quad8 *const priv = counter->priv;
        const int base_offset = priv->base + 2 * count->id;

@@ -187,22 +187,16 @@ 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
-};
-
 static const enum counter_function quad8_count_functions_list[] = {
-       [QUAD8_COUNT_FUNCTION_PULSE_DIRECTION] = COUNTER_FUNCTION_PULSE_DIRECTION,
-       [QUAD8_COUNT_FUNCTION_QUADRATURE_X1] = COUNTER_FUNCTION_QUADRATURE_X1_A,
-       [QUAD8_COUNT_FUNCTION_QUADRATURE_X2] = COUNTER_FUNCTION_QUADRATURE_X2_A,
-       [QUAD8_COUNT_FUNCTION_QUADRATURE_X4] = COUNTER_FUNCTION_QUADRATURE_X4
+       COUNTER_FUNCTION_PULSE_DIRECTION,
+       COUNTER_FUNCTION_QUADRATURE_X1_A,
+       COUNTER_FUNCTION_QUADRATURE_X2_A,
+       COUNTER_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_function *function)
 {
        struct quad8 *const priv = counter->priv;
        const int id = count->id;

@@ -212,25 +206,26 @@ 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 = COUNTER_FUNCTION_QUADRATURE_X1_A;
                        break;
                case 1:
-                       *function = QUAD8_COUNT_FUNCTION_QUADRATURE_X2;
+                       *function = COUNTER_FUNCTION_QUADRATURE_X2_A;
                        break;
                case 2:
-                       *function = QUAD8_COUNT_FUNCTION_QUADRATURE_X4;
+                       *function = COUNTER_FUNCTION_QUADRATURE_X4;
                        break;
                }
        else
-               *function = QUAD8_COUNT_FUNCTION_PULSE_DIRECTION;
+               *function = COUNTER_FUNCTION_PULSE_DIRECTION;
 
        mutex_unlock(&priv->lock);
 
        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_function function)
 {
        struct quad8 *const priv = counter->priv;
        const int id = count->id;

@@ -246,7 +241,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 == COUNTER_FUNCTION_PULSE_DIRECTION) {
                *quadrature_mode = 0;
 
                /* Quadrature scaling only available in quadrature mode */

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

@@ -289,8 +284,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 *const priv = counter->priv;
        unsigned int ud_flag;

@@ -301,76 +297,74 @@ 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 const 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
+       COUNTER_SYNAPSE_ACTION_NONE,
+       COUNTER_SYNAPSE_ACTION_RISING_EDGE,
 };
 
 static const 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
+       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 *const priv = counter->priv;
        int err;
-       size_t function = 0;
+       enum counter_function function;
        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:
+       case COUNTER_FUNCTION_PULSE_DIRECTION:
                if (synapse->signal->id == signal_a_id)
-                       *action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
+                       *action = COUNTER_SYNAPSE_ACTION_RISING_EDGE;
                return 0;
-       case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
+       case COUNTER_FUNCTION_QUADRATURE_X1_A:
                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;
                }
                return 0;
-       case QUAD8_COUNT_FUNCTION_QUADRATURE_X2:
+       case COUNTER_FUNCTION_QUADRATURE_X2_A:
                if (synapse->signal->id == signal_a_id)
-                       *action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
+                       *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
                return 0;
-       case QUAD8_COUNT_FUNCTION_QUADRATURE_X4:
-               *action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
+       case COUNTER_FUNCTION_QUADRATURE_X4:
+               *action = COUNTER_SYNAPSE_ACTION_BOTH_EDGES;
                return 0;
        default:
                /* should never reach this path */

@@ -382,9 +376,9 @@ 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
+       .function_read = quad8_function_read,
+       .function_write = quad8_function_write,
+       .action_read = quad8_action_read
 };
 
 static const char *const quad8_index_polarity_modes[] = {

@@ -393,7 +387,8 @@ static const char *const quad8_index_polarity_modes[] = {
 };
 
 static int quad8_index_polarity_get(struct counter_device *counter,
-       struct counter_signal *signal, size_t *index_polarity)
+                                   struct counter_signal *signal,
+                                   u32 *index_polarity)
 {
        const struct quad8 *const priv = counter->priv;
        const size_t channel_id = signal->id - 16;

@@ -404,7 +399,8 @@ static int quad8_index_polarity_get(struct counter_device *counter,
 }
 
 static int quad8_index_polarity_set(struct counter_device *counter,
-       struct counter_signal *signal, size_t index_polarity)
+                                   struct counter_signal *signal,
+                                   u32 index_polarity)
 {
        struct quad8 *const priv = counter->priv;
        const size_t channel_id = signal->id - 16;

@@ -425,20 +421,14 @@ 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 const char *const quad8_synchronous_modes[] = {
        "non-synchronous",
        "synchronous"
 };
 
 static int quad8_synchronous_mode_get(struct counter_device *counter,
-       struct counter_signal *signal, size_t *synchronous_mode)
+                                     struct counter_signal *signal,
+                                     u32 *synchronous_mode)
 {
        const struct quad8 *const priv = counter->priv;
        const size_t channel_id = signal->id - 16;

@@ -449,7 +439,8 @@ static int quad8_synchronous_mode_get(struct counter_device *counter,
 }
 
 static int quad8_synchronous_mode_set(struct counter_device *counter,
-       struct counter_signal *signal, size_t synchronous_mode)
+                                     struct counter_signal *signal,
+                                     u32 synchronous_mode)
 {
        struct quad8 *const priv = counter->priv;
        const size_t channel_id = signal->id - 16;

@@ -476,22 +467,18 @@ 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 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, u64 *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 *const priv = counter->priv;
 

@@ -514,26 +501,28 @@ 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 *const priv = counter->priv;
+       unsigned int count_mode;
        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;
        default:
                /* should never reach this path */

@@ -542,10 +531,10 @@ static int quad8_count_mode_set(struct counter_device *counter,
 
        mutex_lock(&priv->lock);
 
-       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])

@@ -559,56 +548,35 @@ 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 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 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, u8 *enable)
 {
        const struct quad8 *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, u8 enable)
 {
        struct quad8 *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;
-
        mutex_lock(&priv->lock);
 
-       priv->ab_enable[count->id] = ab_enable;
+       priv->ab_enable[count->id] = 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);
 
        mutex_unlock(&priv->lock);
 
-       return len;
+       return 0;
 }
 
 static const char *const quad8_noise_error_states[] = {

@@ -617,7 +585,7 @@ static const char *const quad8_noise_error_states[] = {
 };
 
 static int quad8_error_noise_get(struct counter_device *counter,
-       struct counter_count *count, size_t *noise_error)
+                                struct counter_count *count, u32 *noise_error)
 {
        const struct quad8 *const priv = counter->priv;
        const int base_offset = priv->base + 2 * count->id + 1;

@@ -627,18 +595,14 @@ static int quad8_error_noise_get(struct counter_device *counter,
        return 0;
 }
 
-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_count_preset_read(struct counter_device *counter,
-       struct counter_count *count, void *private, char *buf)
+static int quad8_count_preset_read(struct counter_device *counter,
+                                  struct counter_count *count, u64 *preset)
 {
        const struct quad8 *const priv = counter->priv;
 
-       return sprintf(buf, "%u\n", priv->preset[count->id]);
+       *preset = priv->preset[count->id];
+
+       return 0;
 }
 
 static void quad8_preset_register_set(struct quad8 *const priv, const int id,

@@ -657,16 +621,10 @@ static void quad8_preset_register_set(struct quad8 *const priv, const int id,
                outb(preset >> (8 * i), base_offset);
 }
 
-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, u64 preset)
 {
        struct quad8 *const priv = counter->priv;
-       unsigned int preset;
-       int ret;
-
-       ret = kstrtouint(buf, 0, &preset);
-       if (ret)
-               return ret;
 
        /* Only 24-bit values are supported */
        if (preset > 0xFFFFFF)

@@ -678,11 +636,11 @@ static ssize_t quad8_count_preset_write(struct counter_device *counter,
 
        mutex_unlock(&priv->lock);
 
-       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, u64 *ceiling)
 {
        struct quad8 *const priv = counter->priv;
 

@@ -692,26 +650,23 @@ static ssize_t quad8_count_ceiling_read(struct counter_device *counter,
        switch (priv->count_mode[count->id]) {
        case 1:
        case 3:
-               mutex_unlock(&priv->lock);
-               return sprintf(buf, "%u\n", priv->preset[count->id]);
+               *ceiling = priv->preset[count->id];
+               break;
+       default:
+               /* By default 0x1FFFFFF (25 bits unsigned) is maximum count */
+               *ceiling = 0x1FFFFFF;
+               break;
        }
 
        mutex_unlock(&priv->lock);
 
-       /* By default 0x1FFFFFF (25 bits unsigned) is maximum count */
-       return sprintf(buf, "33554431\n");
+       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, u64 ceiling)
 {
        struct quad8 *const priv = counter->priv;
-       unsigned int ceiling;
-       int ret;
-
-       ret = kstrtouint(buf, 0, &ceiling);
-       if (ret)
-               return ret;
 
        /* Only 24-bit values are supported */
        if (ceiling > 0xFFFFFF)

@@ -725,7 +680,7 @@ static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
        case 3:
                quad8_preset_register_set(priv, count->id, ceiling);
                mutex_unlock(&priv->lock);
-               return len;
+               return 0;
        }
 
        mutex_unlock(&priv->lock);

@@ -733,27 +688,25 @@ static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
        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,
+                                         u8 *preset_enable)
 {
        const struct quad8 *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,
+                                          u8 preset_enable)
 {
        struct quad8 *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;
 

@@ -761,25 +714,24 @@ static ssize_t quad8_count_preset_enable_write(struct counter_device *counter,
 
        priv->preset_enable[count->id] = preset_enable;
 
-       ior_cfg = priv->ab_enable[count->id] | (unsigned int)preset_enable << 1;
+       ior_cfg = priv->ab_enable[count->id] | preset_enable << 1;
 
        /* Load I/O control configuration to Input / Output Control Register */
        outb(QUAD8_CTR_IOR | ior_cfg, base_offset);
 
        mutex_unlock(&priv->lock);
 
-       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,
+                                        u8 *cable_fault)
 {
        struct quad8 *const priv = counter->priv;
        const size_t channel_id = signal->id / 2;
        bool disabled;
        unsigned int status;
-       unsigned int fault;
 
        mutex_lock(&priv->lock);
 

@@ -796,36 +748,31 @@ static ssize_t quad8_signal_cable_fault_read(struct counter_device *counter,
        mutex_unlock(&priv->lock);
 
        /* 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,
+                                               u8 *enable)
 {
        const struct quad8 *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,
+                                                u8 enable)
 {
        struct quad8 *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;
-
        mutex_lock(&priv->lock);
 
        if (enable)

@@ -840,31 +787,27 @@ static ssize_t quad8_signal_cable_fault_enable_write(
 
        mutex_unlock(&priv->lock);
 
-       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,
+                                          u8 *prescaler)
 {
        const struct quad8 *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,
+                                           u8 prescaler)
 {
        struct quad8 *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;
 
        mutex_lock(&priv->lock);
 

@@ -880,31 +823,30 @@ static ssize_t quad8_signal_fck_prescaler_write(struct counter_device *counter,
 
        mutex_unlock(&priv->lock);
 
-       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_comp quad8_signal_ext[] = {
+       COUNTER_COMP_SIGNAL_BOOL("cable_fault", quad8_signal_cable_fault_read,
+                                NULL),
+       COUNTER_COMP_SIGNAL_BOOL("cable_fault_enable",
+                                quad8_signal_cable_fault_enable_read,
+                                quad8_signal_cable_fault_enable_write),
+       COUNTER_COMP_SIGNAL_U8("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 DEFINE_COUNTER_ENUM(quad8_index_pol_enum, quad8_index_polarity_modes);
+static DEFINE_COUNTER_ENUM(quad8_synch_mode_enum, quad8_synchronous_modes);
+
+static struct counter_comp quad8_index_ext[] = {
+       COUNTER_COMP_SIGNAL_ENUM("index_polarity", quad8_index_polarity_get,
+                                quad8_index_polarity_set,
+                                quad8_index_pol_enum),
+       COUNTER_COMP_SIGNAL_ENUM("synchronous_mode", quad8_synchronous_mode_get,
+                                quad8_synchronous_mode_set,
+                                quad8_synch_mode_enum),
 };
 
 #define QUAD8_QUAD_SIGNAL(_id, _name) {                \

@@ -973,39 +915,30 @@ 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 const 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 DEFINE_COUNTER_AVAILABLE(quad8_count_mode_available, quad8_cnt_modes);
+
+static DEFINE_COUNTER_ENUM(quad8_error_noise_enum, quad8_noise_error_states);
+
+static struct counter_comp quad8_count_ext[] = {
+       COUNTER_COMP_CEILING(quad8_count_ceiling_read,
+                            quad8_count_ceiling_write),
+       COUNTER_COMP_FLOOR(quad8_count_floor_read, NULL),
+       COUNTER_COMP_COUNT_MODE(quad8_count_mode_read, quad8_count_mode_write,
+                               quad8_count_mode_available),
+       COUNTER_COMP_DIRECTION(quad8_direction_read),
+       COUNTER_COMP_ENABLE(quad8_count_enable_read, quad8_count_enable_write),
+       COUNTER_COMP_COUNT_ENUM("error_noise", quad8_error_noise_get, NULL,
+                               quad8_error_noise_enum),
+       COUNTER_COMP_PRESET(quad8_count_preset_read, quad8_count_preset_write),
+       COUNTER_COMP_PRESET_ENABLE(quad8_count_preset_enable_read,
+                                  quad8_count_preset_enable_write),
 };
 
 #define QUAD8_COUNT(_id, _cntname) {                                   \

drivers/counter/Makefile +1 -0

index 19742e6f5e3e..1ab7e087fdc2 100644
@@ -4,6 +4,7 @@
 #
 
 obj-$(CONFIG_COUNTER) += counter.o
+counter-y := counter-core.o counter-sysfs.o
 
 obj-$(CONFIG_104_QUAD_8)       += 104-quad-8.o
 obj-$(CONFIG_INTERRUPT_CNT)            += interrupt-cnt.o

drivers/counter/counter-core.c new file +145 -0

new file mode 100644
index 000000000000..15f735ef296e
@@ -0,0 +1,145 @@
+// 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/export.h>
+#include <linux/gfp.h>
+#include <linux/idr.h>
+#include <linux/init.h>
+#include <linux/module.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_chrdev_remove(counter);
+       ida_free(&counter_ida, dev->id);
+}
+
+static struct device_type counter_device_type = {
+       .name = "counter_device",
+       .release = counter_device_release,
+};
+
+static struct bus_type counter_bus_type = {
+       .name = "counter",
+       .dev_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 id;
+       int err;
+
+       /* Acquire unique ID */
+       id = ida_alloc(&counter_ida, GFP_KERNEL);
+       if (id < 0)
+               return id;
+
+       /* Configure device structure for Counter */
+       dev->id = id;
+       dev->type = &counter_device_type;
+       dev->bus = &counter_bus_type;
+       if (counter->parent) {
+               dev->parent = counter->parent;
+               dev->of_node = counter->parent->of_node;
+       }
+       device_initialize(dev);
+       dev_set_drvdata(dev, counter);
+
+       /* Add Counter sysfs attributes */
+       err = counter_sysfs_add(counter);
+       if (err < 0)
+               goto err_free_id;
+
+       /* Add device to system */
+       err = device_add(dev);
+       if (err < 0)
+               goto err_free_id;
+
+       return 0;
+
+err_free_id:
+       put_device(dev);
+       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.
+ */
+void counter_unregister(struct counter_device *const counter)
+{
+       if (!counter)
+               return;
+
+       device_unregister(&counter->dev);
+}
+EXPORT_SYMBOL_GPL(counter_unregister);
+
+static void devm_counter_release(void *counter)
+{
+       counter_unregister(counter);
+}
+
+/**
+ * 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.
+ *
+ * RETURNS:
+ * 0 on success, negative error number on failure.
+ */
+int devm_counter_register(struct device *dev,
+                         struct counter_device *const counter)
+{
+       int err;
+
+       err = counter_register(counter);
+       if (err < 0)
+               return err;
+
+       return devm_add_action_or_reset(dev, devm_counter_release, counter);
+}
+EXPORT_SYMBOL_GPL(devm_counter_register);
+
+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");

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

new file mode 100644
index 000000000000..07588130600a
@@ -0,0 +1,846 @@
+// 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/string.h>
+#include <linux/sysfs.h>
+#include <linux/types.h>
+
+#include "counter-sysfs.h"
+
+/**
+ * struct counter_attribute - Counter sysfs attribute
+ * @dev_attr:  device attribute for sysfs
+ * @l:         node to add Counter attribute to attribute group list
+ * @comp:      Counter component callbacks and data
+ * @scope:     Counter scope of the attribute
+ * @parent:    pointer to the parent component
+ */
+struct counter_attribute {
+       struct device_attribute dev_attr;
+       struct list_head l;
+
+       struct counter_comp comp;
+       enum counter_scope scope;
+       void *parent;
+};
+
+#define to_counter_attribute(_dev_attr) \
+       container_of(_dev_attr, struct counter_attribute, dev_attr)
+
+/**
+ * struct counter_attribute_group - container for attribute group
+ * @name:      name of the attribute group
+ * @attr_list: list to keep track of created attributes
+ * @num_attr:  number of attributes
+ */
+struct counter_attribute_group {
+       const char *name;
+       struct list_head attr_list;
+       size_t num_attr;
+};
+
+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 const char *const counter_signal_value_str[] = {
+       [COUNTER_SIGNAL_LEVEL_LOW] = "low",
+       [COUNTER_SIGNAL_LEVEL_HIGH] = "high"
+};
+
+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"
+};
+
+static const char *const counter_count_direction_str[] = {
+       [COUNTER_COUNT_DIRECTION_FORWARD] = "forward",
+       [COUNTER_COUNT_DIRECTION_BACKWARD] = "backward"
+};
+
+static 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"
+};
+
+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;
+
+       switch (a->scope) {
+       case COUNTER_SCOPE_DEVICE:
+               err = a->comp.device_u8_read(counter, &data);
+               break;
+       case COUNTER_SCOPE_SIGNAL:
+               err = a->comp.signal_u8_read(counter, a->parent, &data);
+               break;
+       case COUNTER_SCOPE_COUNT:
+               err = a->comp.count_u8_read(counter, a->parent, &data);
+               break;
+       default:
+               return -EINVAL;
+       }
+       if (err < 0)
+               return err;
+
+       if (a->comp.type == COUNTER_COMP_BOOL)
+               data = !!data;
+
+       return sprintf(buf, "%u\n", (unsigned int)data);
+}
+
+static ssize_t counter_comp_u8_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_device *const counter = dev_get_drvdata(dev);
+       int err;
+       bool bool_data = 0;
+       u8 data = 0;
+
+       if (a->comp.type == COUNTER_COMP_BOOL) {
+               err = kstrtobool(buf, &bool_data);
+               data = bool_data;
+       } else
+               err = kstrtou8(buf, 0, &data);
+       if (err < 0)
+               return err;
+
+       switch (a->scope) {
+       case COUNTER_SCOPE_DEVICE:
+               err = a->comp.device_u8_write(counter, data);
+               break;
+       case COUNTER_SCOPE_SIGNAL:
+               err = a->comp.signal_u8_write(counter, a->parent, data);
+               break;
+       case COUNTER_SCOPE_COUNT:
+               err = a->comp.count_u8_write(counter, a->parent, data);
+               break;
+       default:
+               return -EINVAL;
+       }
+       if (err < 0)
+               return err;
+
+       return len;
+}
+
+static ssize_t counter_comp_u32_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);
+       const struct counter_available *const avail = a->comp.priv;
+       int err;
+       u32 data = 0;
+
+       switch (a->scope) {
+       case COUNTER_SCOPE_DEVICE:
+               err = a->comp.device_u32_read(counter, &data);
+               break;
+       case COUNTER_SCOPE_SIGNAL:
+               err = a->comp.signal_u32_read(counter, a->parent, &data);
+               break;
+       case COUNTER_SCOPE_COUNT:
+               if (a->comp.type == COUNTER_COMP_SYNAPSE_ACTION)
+                       err = a->comp.action_read(counter, a->parent,
+                                                 a->comp.priv, &data);
+               else
+                       err = a->comp.count_u32_read(counter, a->parent, &data);
+               break;
+       default:
+               return -EINVAL;
+       }
+       if (err < 0)
+               return err;
+
+       switch (a->comp.type) {
+       case COUNTER_COMP_FUNCTION:
+               return sysfs_emit(buf, "%s\n", counter_function_str[data]);
+       case COUNTER_COMP_SIGNAL_LEVEL:
+               return sysfs_emit(buf, "%s\n", counter_signal_value_str[data]);
+       case COUNTER_COMP_SYNAPSE_ACTION:
+               return sysfs_emit(buf, "%s\n", counter_synapse_action_str[data]);
+       case COUNTER_COMP_ENUM:
+               return sysfs_emit(buf, "%s\n", avail->strs[data]);
+       case COUNTER_COMP_COUNT_DIRECTION:
+               return sysfs_emit(buf, "%s\n", counter_count_direction_str[data]);
+       case COUNTER_COMP_COUNT_MODE:
+               return sysfs_emit(buf, "%s\n", counter_count_mode_str[data]);
+       default:
+               return sprintf(buf, "%u\n", (unsigned int)data);
+       }
+}
+
+static int counter_find_enum(u32 *const enum_item, const u32 *const enums,
+                            const size_t num_enums, const char *const buf,
+                            const char *const string_array[])
+{
+       size_t index;
+
+       for (index = 0; index < num_enums; index++) {
+               *enum_item = enums[index];
+               if (sysfs_streq(buf, string_array[*enum_item]))
+                       return 0;
+       }
+
+       return -EINVAL;
+}
+
+static ssize_t counter_comp_u32_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_device *const counter = dev_get_drvdata(dev);
+       struct counter_count *const count = a->parent;
+       struct counter_synapse *const synapse = a->comp.priv;
+       const struct counter_available *const avail = a->comp.priv;
+       int err;
+       u32 data = 0;
+
+       switch (a->comp.type) {
+       case COUNTER_COMP_FUNCTION:
+               err = counter_find_enum(&data, count->functions_list,
+                                       count->num_functions, buf,
+                                       counter_function_str);
+               break;
+       case COUNTER_COMP_SYNAPSE_ACTION:
+               err = counter_find_enum(&data, synapse->actions_list,
+                                       synapse->num_actions, buf,
+                                       counter_synapse_action_str);
+               break;
+       case COUNTER_COMP_ENUM:
+               err = __sysfs_match_string(avail->strs, avail->num_items, buf);
+               data = err;
+               break;
+       case COUNTER_COMP_COUNT_MODE:
+               err = counter_find_enum(&data, avail->enums, avail->num_items,
+                                       buf, counter_count_mode_str);
+               break;
+       default:
+               err = kstrtou32(buf, 0, &data);
+               break;
+       }
+       if (err < 0)
+               return err;
+
+       switch (a->scope) {
+       case COUNTER_SCOPE_DEVICE:
+               err = a->comp.device_u32_write(counter, data);
+               break;
+       case COUNTER_SCOPE_SIGNAL:
+               err = a->comp.signal_u32_write(counter, a->parent, data);
+               break;
+       case COUNTER_SCOPE_COUNT:
+               if (a->comp.type == COUNTER_COMP_SYNAPSE_ACTION)
+                       err = a->comp.action_write(counter, count, synapse,
+                                                  data);
+               else
+                       err = a->comp.count_u32_write(counter, count, data);
+               break;
+       default:
+               return -EINVAL;
+       }
+       if (err < 0)
+               return err;
+
+       return len;
+}
+
+static ssize_t counter_comp_u64_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;
+       u64 data = 0;
+
+       switch (a->scope) {
+       case COUNTER_SCOPE_DEVICE:
+               err = a->comp.device_u64_read(counter, &data);
+               break;
+       case COUNTER_SCOPE_SIGNAL:
+               err = a->comp.signal_u64_read(counter, a->parent, &data);
+               break;
+       case COUNTER_SCOPE_COUNT:
+               err = a->comp.count_u64_read(counter, a->parent, &data);
+               break;
+       default:
+               return -EINVAL;
+       }
+       if (err < 0)
+               return err;
+
+       return sprintf(buf, "%llu\n", (unsigned long long)data);
+}
+
+static ssize_t counter_comp_u64_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_device *const counter = dev_get_drvdata(dev);
+       int err;
+       u64 data = 0;
+
+       err = kstrtou64(buf, 0, &data);
+       if (err < 0)
+               return err;
+
+       switch (a->scope) {
+       case COUNTER_SCOPE_DEVICE:
+               err = a->comp.device_u64_write(counter, data);
+               break;
+       case COUNTER_SCOPE_SIGNAL:
+               err = a->comp.signal_u64_write(counter, a->parent, data);
+               break;
+       case COUNTER_SCOPE_COUNT:
+               err = a->comp.count_u64_write(counter, a->parent, data);
+               break;
+       default:
+               return -EINVAL;
+       }
+       if (err < 0)
+               return err;
+
+       return len;
+}
+
+static ssize_t enums_available_show(const u32 *const enums,
+                                   const size_t num_enums,
+                                   const char *const strs[], char *buf)
+{
+       size_t len = 0;
+       size_t index;
+
+       for (index = 0; index < num_enums; index++)
+               len += sysfs_emit_at(buf, len, "%s\n", strs[enums[index]]);
+
+       return len;
+}
+
+static ssize_t strs_available_show(const struct counter_available *const avail,
+                                  char *buf)
+{
+       size_t len = 0;
+       size_t index;
+
+       for (index = 0; index < avail->num_items; index++)
+               len += sysfs_emit_at(buf, len, "%s\n", avail->strs[index]);
+
+       return len;
+}
+
+static ssize_t counter_comp_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->parent;
+       const struct counter_synapse *const synapse = a->comp.priv;
+       const struct counter_available *const avail = a->comp.priv;
+
+       switch (a->comp.type) {
+       case COUNTER_COMP_FUNCTION:
+               return enums_available_show(count->functions_list,
+                                           count->num_functions,
+                                           counter_function_str, buf);
+       case COUNTER_COMP_SYNAPSE_ACTION:
+               return enums_available_show(synapse->actions_list,
+                                           synapse->num_actions,
+                                           counter_synapse_action_str, buf);
+       case COUNTER_COMP_ENUM:
+               return strs_available_show(avail, buf);
+       case COUNTER_COMP_COUNT_MODE:
+               return enums_available_show(avail->enums, avail->num_items,
+                                           counter_count_mode_str, buf);
+       default:
+               return -EINVAL;
+       }
+}
+
+static int counter_avail_attr_create(struct device *const dev,
+       struct counter_attribute_group *const group,
+       const struct counter_comp *const comp, void *const parent)
+{
+       struct counter_attribute *counter_attr;
+       struct device_attribute *dev_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.type = comp->type;
+       counter_attr->comp.priv = comp->priv;
+       counter_attr->parent = parent;
+
+       /* Initialize sysfs attribute */
+       dev_attr = &counter_attr->dev_attr;
+       sysfs_attr_init(&dev_attr->attr);
+
+       /* Configure device attribute */
+       dev_attr->attr.name = devm_kasprintf(dev, GFP_KERNEL, "%s_available",
+                                            comp->name);
+       if (!dev_attr->attr.name)
+               return -ENOMEM;
+       dev_attr->attr.mode = 0444;
+       dev_attr->show = counter_comp_available_show;
+
+       /* Store list node */
+       list_add(&counter_attr->l, &group->attr_list);
+       group->num_attr++;
+
+       return 0;
+}
+
+static int counter_attr_create(struct device *const dev,
+                              struct counter_attribute_group *const group,
+                              const struct counter_comp *const comp,
+                              const enum counter_scope scope,
+                              void *const parent)
+{
+       struct counter_attribute *counter_attr;
+       struct device_attribute *dev_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 = *comp;
+       counter_attr->scope = scope;
+       counter_attr->parent = parent;
+
+       /* Configure device attribute */
+       dev_attr = &counter_attr->dev_attr;
+       sysfs_attr_init(&dev_attr->attr);
+       dev_attr->attr.name = comp->name;
+       switch (comp->type) {
+       case COUNTER_COMP_U8:
+       case COUNTER_COMP_BOOL:
+               if (comp->device_u8_read) {
+                       dev_attr->attr.mode |= 0444;
+                       dev_attr->show = counter_comp_u8_show;
+               }
+               if (comp->device_u8_write) {
+                       dev_attr->attr.mode |= 0200;
+                       dev_attr->store = counter_comp_u8_store;
+               }
+               break;
+       case COUNTER_COMP_SIGNAL_LEVEL:
+       case COUNTER_COMP_FUNCTION:
+       case COUNTER_COMP_SYNAPSE_ACTION:
+       case COUNTER_COMP_ENUM:
+       case COUNTER_COMP_COUNT_DIRECTION:
+       case COUNTER_COMP_COUNT_MODE:
+               if (comp->device_u32_read) {
+                       dev_attr->attr.mode |= 0444;
+                       dev_attr->show = counter_comp_u32_show;
+               }
+               if (comp->device_u32_write) {
+                       dev_attr->attr.mode |= 0200;
+                       dev_attr->store = counter_comp_u32_store;
+               }
+               break;
+       case COUNTER_COMP_U64:
+               if (comp->device_u64_read) {
+                       dev_attr->attr.mode |= 0444;
+                       dev_attr->show = counter_comp_u64_show;
+               }
+               if (comp->device_u64_write) {
+                       dev_attr->attr.mode |= 0200;
+                       dev_attr->store = counter_comp_u64_store;
+               }
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       /* Store list node */
+       list_add(&counter_attr->l, &group->attr_list);
+       group->num_attr++;
+
+       /* Create "*_available" attribute if needed */
+       switch (comp->type) {
+       case COUNTER_COMP_FUNCTION:
+       case COUNTER_COMP_SYNAPSE_ACTION:
+       case COUNTER_COMP_ENUM:
+       case COUNTER_COMP_COUNT_MODE:
+               return counter_avail_attr_create(dev, group, comp, parent);
+       default:
+               return 0;
+       }
+}
+
+static ssize_t counter_comp_name_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+       return sysfs_emit(buf, "%s\n", to_counter_attribute(attr)->comp.name);
+}
+
+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);
+       counter_attr->dev_attr.attr.name = "name";
+       counter_attr->dev_attr.attr.mode = 0444;
+       counter_attr->dev_attr.show = counter_comp_name_show;
+
+       /* Store list node */
+       list_add(&counter_attr->l, &group->attr_list);
+       group->num_attr++;
+
+       return 0;
+}
+
+static struct counter_comp counter_signal_comp = {
+       .type = COUNTER_COMP_SIGNAL_LEVEL,
+       .name = "signal",
+};
+
+static int counter_signal_attrs_create(struct counter_device *const counter,
+       struct counter_attribute_group *const group,
+       struct counter_signal *const signal)
+{
+       const enum counter_scope scope = COUNTER_SCOPE_SIGNAL;
+       struct device *const dev = &counter->dev;
+       int err;
+       struct counter_comp comp;
+       size_t i;
+
+       /* Create main Signal attribute */
+       comp = counter_signal_comp;
+       comp.signal_u32_read = counter->ops->signal_read;
+       err = counter_attr_create(dev, group, &comp, scope, signal);
+       if (err < 0)
+               return err;
+
+       /* Create Signal name attribute */
+       err = counter_name_attr_create(dev, group, signal->name);
+       if (err < 0)
+               return err;
+
+       /* Create an attribute for each extension */
+       for (i = 0; i < signal->num_ext; i++) {
+               err = counter_attr_create(dev, group, signal->ext + i, scope,
+                                         signal);
+               if (err < 0)
+                       return err;
+       }
+
+       return 0;
+}
+
+static int counter_sysfs_signals_add(struct counter_device *const counter,
+       struct counter_attribute_group *const groups)
+{
+       size_t i;
+       int err;
+
+       /* Add each Signal */
+       for (i = 0; i < counter->num_signals; i++) {
+               /* Generate Signal attribute directory name */
+               groups[i].name = devm_kasprintf(&counter->dev, GFP_KERNEL,
+                                               "signal%zu", i);
+               if (!groups[i].name)
+                       return -ENOMEM;
+
+               /* Create all attributes associated with Signal */
+               err = counter_signal_attrs_create(counter, groups + i,
+                                                 counter->signals + i);
+               if (err < 0)
+                       return err;
+       }
+
+       return 0;
+}
+
+static int counter_sysfs_synapses_add(struct counter_device *const counter,
+       struct counter_attribute_group *const group,
+       struct counter_count *const count)
+{
+       size_t i;
+
+       /* Add each Synapse */
+       for (i = 0; i < count->num_synapses; i++) {
+               struct device *const dev = &counter->dev;
+               struct counter_synapse *synapse;
+               size_t id;
+               struct counter_comp comp;
+               int err;
+
+               synapse = count->synapses + i;
+
+               /* Generate Synapse action name */
+               id = synapse->signal - counter->signals;
+               comp.name = devm_kasprintf(dev, GFP_KERNEL, "signal%zu_action",
+                                          id);
+               if (!comp.name)
+                       return -ENOMEM;
+
+               /* Create action attribute */
+               comp.type = COUNTER_COMP_SYNAPSE_ACTION;
+               comp.action_read = counter->ops->action_read;
+               comp.action_write = counter->ops->action_write;
+               comp.priv = synapse;
+               err = counter_attr_create(dev, group, &comp,
+                                         COUNTER_SCOPE_COUNT, count);
+               if (err < 0)
+                       return err;
+       }
+
+       return 0;
+}
+
+static struct counter_comp counter_count_comp =
+       COUNTER_COMP_COUNT_U64("count", NULL, NULL);
+
+static struct counter_comp counter_function_comp = {
+       .type = COUNTER_COMP_FUNCTION,
+       .name = "function",
+};
+
+static int counter_count_attrs_create(struct counter_device *const counter,
+       struct counter_attribute_group *const group,
+       struct counter_count *const count)
+{
+       const enum counter_scope scope = COUNTER_SCOPE_COUNT;
+       struct device *const dev = &counter->dev;
+       int err;
+       struct counter_comp comp;
+       size_t i;
+
+       /* Create main Count attribute */
+       comp = counter_count_comp;
+       comp.count_u64_read = counter->ops->count_read;
+       comp.count_u64_write = counter->ops->count_write;
+       err = counter_attr_create(dev, group, &comp, scope, count);
+       if (err < 0)
+               return err;
+
+       /* Create Count name attribute */
+       err = counter_name_attr_create(dev, group, count->name);
+       if (err < 0)
+               return err;
+
+       /* Create Count function attribute */
+       comp = counter_function_comp;
+       comp.count_u32_read = counter->ops->function_read;
+       comp.count_u32_write = counter->ops->function_write;
+       err = counter_attr_create(dev, group, &comp, scope, count);
+       if (err < 0)
+               return err;
+
+       /* Create an attribute for each extension */
+       for (i = 0; i < count->num_ext; i++) {
+               err = counter_attr_create(dev, group, count->ext + i, scope,
+                                         count);
+               if (err < 0)
+                       return err;
+       }
+
+       return 0;
+}
+
+static int counter_sysfs_counts_add(struct counter_device *const counter,
+       struct counter_attribute_group *const groups)
+{
+       size_t i;
+       struct counter_count *count;
+       int err;
+
+       /* Add each Count */
+       for (i = 0; i < counter->num_counts; i++) {
+               count = counter->counts + i;
+
+               /* Generate Count attribute directory name */
+               groups[i].name = devm_kasprintf(&counter->dev, GFP_KERNEL,
+                                               "count%zu", i);
+               if (!groups[i].name)
+                       return -ENOMEM;
+
+               /* Add sysfs attributes of the Synapses */
+               err = counter_sysfs_synapses_add(counter, groups + i, count);
+               if (err < 0)
+                       return err;
+
+               /* Create all attributes associated with Count */
+               err = counter_count_attrs_create(counter, groups + i, count);
+               if (err < 0)
+                       return err;
+       }
+
+       return 0;
+}
+
+static int counter_num_signals_read(struct counter_device *counter, u8 *val)
+{
+       *val = counter->num_signals;
+       return 0;
+}
+
+static int counter_num_counts_read(struct counter_device *counter, u8 *val)
+{
+       *val = counter->num_counts;
+       return 0;
+}
+
+static struct counter_comp counter_num_signals_comp =
+       COUNTER_COMP_DEVICE_U8("num_signals", counter_num_signals_read, NULL);
+
+static struct counter_comp counter_num_counts_comp =
+       COUNTER_COMP_DEVICE_U8("num_counts", counter_num_counts_read, NULL);
+
+static int counter_sysfs_attr_add(struct counter_device *const counter,
+                                 struct counter_attribute_group *group)
+{
+       const enum counter_scope scope = COUNTER_SCOPE_DEVICE;
+       struct device *const dev = &counter->dev;
+       int err;
+       size_t i;
+
+       /* Add Signals sysfs attributes */
+       err = counter_sysfs_signals_add(counter, group);
+       if (err < 0)
+               return err;
+       group += counter->num_signals;
+
+       /* Add Counts sysfs attributes */
+       err = counter_sysfs_counts_add(counter, group);
+       if (err < 0)
+               return err;
+       group += counter->num_counts;
+
+       /* Create name attribute */
+       err = counter_name_attr_create(dev, group, counter->name);
+       if (err < 0)
+               return err;
+
+       /* Create num_signals attribute */
+       err = counter_attr_create(dev, group, &counter_num_signals_comp, scope,
+                                 NULL);
+       if (err < 0)
+               return err;
+
+       /* Create num_counts attribute */
+       err = counter_attr_create(dev, group, &counter_num_counts_comp, scope,
+                                 NULL);
+       if (err < 0)
+               return err;
+
+       /* Create an attribute for each extension */
+       for (i = 0; i < counter->num_ext; i++) {
+               err = counter_attr_create(dev, group, counter->ext + i, scope,
+                                         NULL);
+               if (err < 0)
+                       return err;
+       }
+
+       return 0;
+}
+
+/**
+ * counter_sysfs_add - Adds Counter sysfs attributes to the device structure
+ * @counter:   Pointer to the Counter device structure
+ *
+ * Counter sysfs attributes are created and added to the respective device
+ * structure for later registration to the system. Resource-managed memory
+ * allocation is performed by this function, and this memory should be freed
+ * when no longer needed (automatically by a device_unregister call, or
+ * manually by a devres_release_all call).
+ */
+int counter_sysfs_add(struct counter_device *const counter)
+{
+       struct device *const dev = &counter->dev;
+       const size_t num_groups = counter->num_signals + counter->num_counts + 1;
+       struct counter_attribute_group *groups;
+       size_t i, j;
+       int err;
+       struct attribute_group *group;
+       struct counter_attribute *p;
+
+       /* Allocate space for attribute groups (signals, counts, and ext) */
+       groups = devm_kcalloc(dev, num_groups, sizeof(*groups), GFP_KERNEL);
+       if (!groups)
+               return -ENOMEM;
+
+       /* Initialize attribute lists */
+       for (i = 0; i < num_groups; i++)
+               INIT_LIST_HEAD(&groups[i].attr_list);
+
+       /* Add Counter device sysfs attributes */
+       err = counter_sysfs_attr_add(counter, groups);
+       if (err < 0)
+               return err;
+
+       /* Allocate attribute groups for association with device */
+       dev->groups = devm_kcalloc(dev, num_groups + 1, sizeof(*dev->groups),
+                                  GFP_KERNEL);
+       if (!dev->groups)
+               return -ENOMEM;
+
+       /* Prepare each group of attributes for association */
+       for (i = 0; i < num_groups; i++) {
+               /* Allocate space for attribute group */
+               group = devm_kzalloc(dev, sizeof(*group), GFP_KERNEL);
+               if (!group)
+                       return -ENOMEM;
+               group->name = groups[i].name;
+
+               /* Allocate space for attribute pointers */
+               group->attrs = devm_kcalloc(dev, groups[i].num_attr + 1,
+                                           sizeof(*group->attrs), GFP_KERNEL);
+               if (!group->attrs)
+                       return -ENOMEM;
+
+               /* Add attribute pointers to attribute group */
+               j = 0;
+               list_for_each_entry(p, &groups[i].attr_list, l)
+                       group->attrs[j++] = &p->dev_attr.attr;
+
+               /* Associate attribute group */
+               dev->groups[i] = group;
+       }
+
+       return 0;
+}

drivers/counter/counter-sysfs.h new file +13 -0

new file mode 100644
index 000000000000..14fe566aca0e
@@ -0,0 +1,13 @@
+/* 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);
+
+#endif /* _COUNTER_SYSFS_H_ */

drivers/counter/counter.c deleted +0 -1496

deleted file mode 100644
index de921e8a3f72..000000000000
@@ -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_level_str[] = {
-       [COUNTER_SIGNAL_LEVEL_LOW] = "low",
-       [COUNTER_SIGNAL_LEVEL_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_level level;
-
-       err = counter->ops->signal_read(counter, signal, &level);
-       if (err)
-               return err;
-
-       return sprintf(buf, "%s\n", counter_signal_level_str[level]);
-}
-
-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_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,
-                                    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_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_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_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_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_function *functions_list;
-       size_t num_functions;
-};
-
-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_function *const func_list = component->functions_list;
-       const size_t num_functions = component->num_functions;
-       size_t i;
-       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_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_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(
[… more lines in the raw message]

Lines of this file are not shown. View the raw message.

drivers/counter/ftm-quaddec.c +23 -33

index 53c15f84909b..092a806a46d8 100644

Lines of this file are not shown. View the raw message.

drivers/counter/intel-qep.c +61 -83

index f4be9d78c84c..ec056f31fa55 100644

Lines of this file are not shown. View the raw message.

drivers/counter/interrupt-cnt.c +26 -36

index 1de4243db488..8514a87fcbee 100644

Lines of this file are not shown. View the raw message.

drivers/counter/microchip-tcb-capture.c +40 -53

index 4c57d43e7d66..79e0c84a3b81 100644

Lines of this file are not shown. View the raw message.

drivers/counter/stm32-lptimer-cnt.c +79 -83

index 13656957c45f..aef78a4217b5 100644

Lines of this file are not shown. View the raw message.

drivers/counter/stm32-timer-cnt.c +59 -88

index 3fb0debd7425..c690b76e5dab 100644

Lines of this file are not shown. View the raw message.

drivers/counter/ti-eqep.c +98 -82

index 94fe58bb3eab..09817c953f9a 100644

Lines of this file are not shown. View the raw message.

include/linux/counter.h +68 -14

index d16ce2819b48..b69277f5c4c5 100644

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.