Introduce the Counter subsystem

This patch introduces the Generic Counter interface for supporting counter devices. The Generic Counter interface serves as a catch-all to enable rudimentary support for devices that qualify as counters. More specific and apt counter interfaces may be developed on top of the Generic Counter interface, and those interfaces should be used by drivers where possible rather than the Generic Counter interface directly.

In the context of the Generic Counter interface, a counter is defined as a device that reports one or more "counter counts" based on the state changes of one or more "counter signals" as evaluated by a defined "counter function."

Driver callbacks should be provided to communicate with the device: to read and write various Signals and Counts, and to set and get the "action mode" and "function mode" for various Synapses and Counts respectively.

To support a counter device, a driver must first allocate the available Counter Signals via counter_signal structures. These Signals should be stored as an array and set to the signals array member of an allocated counter_device structure before the Counter is registered to the system.

Counter Counts may be allocated via counter_count structures, and respective Counter Signal associations (Synapses) made via counter_synapse structures. Associated counter_synapse structures are stored as an array and set to the the synapses array member of the respective counter_count structure. These counter_count structures are set to the counts array member of an allocated counter_device structure before the Counter is registered to the system.

A counter device is registered to the system by passing the respective initialized counter_device structure to the counter_register function; similarly, the counter_unregister function unregisters the respective Counter. The devm_counter_register and devm_counter_unregister functions serve as device memory-managed versions of the counter_register and counter_unregister functions respectively.

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

---
 MAINTAINERS                           |   7 +
 drivers/iio/Kconfig                   |   3 +-
 drivers/iio/counter/Kconfig           |  16 +-
 drivers/iio/counter/Makefile          |   3 +
 drivers/iio/counter/generic-counter.c | 992 ++++++++++++++++++++++++++++++++++
 include/linux/iio/counter.h           | 239 ++++++++
 6 files changed, 1255 insertions(+), 5 deletions(-)
 create mode 100644 drivers/iio/counter/generic-counter.c
 create mode 100644 include/linux/iio/counter.h

MAINTAINERS +7 -0

index 36f76be322a3..07dd7b933bfa 100644
@@ -3661,6 +3661,13 @@ W:	http://www.fi.muni.cz/~kas/cosa/
 S:	Maintained
 F:	drivers/net/wan/cosa*
 
+COUNTER INTERFACE
+M:	William Breathitt Gray <[email protected]>
+L:	[email protected]
+S:	Maintained
+F:	drivers/iio/counter/
+F:	include/linux/iio/counter.h
+
 CPMAC ETHERNET DRIVER
 M:	Florian Fainelli <[email protected]>
 L:	[email protected]

drivers/iio/Kconfig +2 -1

index b3c8c6ef0dff..62a923aeb462 100644
@@ -73,7 +73,6 @@ source "drivers/iio/adc/Kconfig"
 source "drivers/iio/amplifiers/Kconfig"
 source "drivers/iio/chemical/Kconfig"
 source "drivers/iio/common/Kconfig"
-source "drivers/iio/counter/Kconfig"
 source "drivers/iio/dac/Kconfig"
 source "drivers/iio/dummy/Kconfig"
 source "drivers/iio/frequency/Kconfig"

@@ -95,3 +94,5 @@ source "drivers/iio/proximity/Kconfig"
 source "drivers/iio/temperature/Kconfig"
 
 endif # IIO
+
+source "drivers/iio/counter/Kconfig"

drivers/iio/counter/Kconfig +12 -4

index 474e1ac4e7c0..4eaf4e53c5aa 100644
@@ -3,11 +3,18 @@
 #
 # When adding new entries keep the list in alphabetical order
 
-menu "Counters"
+menuconfig COUNTER
+	tristate "Counter support"
+	help
+	  Provides support for Counter devices. The Generic Counter API provides
+	  rudimentary support for counters and serves as building blocks to
+	  create more complex counter interfaces.
+
+if COUNTER
 
 config 104_QUAD_8
 	tristate "ACCES 104-QUAD-8 driver"
-	depends on PC104 && X86 && ISA_BUS_API
+	depends on PC104 && X86 && ISA_BUS_API && IIO
 	help
 	  Say yes here to build support for the ACCES 104-QUAD-8 quadrature
 	  encoder counter/interface device family (104-QUAD-8, 104-QUAD-4).

@@ -23,11 +30,12 @@ config 104_QUAD_8
 
 config STM32_LPTIMER_CNT
 	tristate "STM32 LP Timer encoder counter driver"
-	depends on MFD_STM32_LPTIMER || COMPILE_TEST
+	depends on (MFD_STM32_LPTIMER || COMPILE_TEST) && IIO
 	help
 	  Select this option to enable STM32 Low-Power Timer quadrature encoder
 	  and counter driver.
 
 	  To compile this driver as a module, choose M here: the
 	  module will be called stm32-lptimer-cnt.
-endmenu
+
+endif # COUNTER

drivers/iio/counter/Makefile +3 -0

index 1b9a896eb488..513c49d832d4 100644
@@ -4,5 +4,8 @@
 
 # When adding new entries keep the list in alphabetical order
 
+obj-$(CONFIG_COUNTER) += counter.o
+counter-$(CONFIG_COUNTER) += generic-counter.o
+
 obj-$(CONFIG_104_QUAD_8)	+= 104-quad-8.o
 obj-$(CONFIG_STM32_LPTIMER_CNT)	+= stm32-lptimer-cnt.o

drivers/iio/counter/generic-counter.c new file +77 -0

new file mode 100644
index 000000000000..0efd36ee2118
@@ -0,0 +1,992 @@
+/*
+ * Generic Counter interface
+ * Copyright (C) 2017 William Breathitt Gray
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+#include <linux/cdev.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/kdev_t.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>
+
+#include <linux/iio/counter.h>
+
+struct counter_device_attr {
+	struct device_attribute		dev_attr;
+	struct list_head		l;
+	void				*component;
+	void				*component_data;
+};
+
+static int counter_attribute_create(const char *const prefix,
+	const char *const 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 *const component, void *const component_data,
+	struct counter_device_state *const device_state)
+{
+	struct counter_device_attr *counter_attr;
+	struct device_attribute *dev_attr;
+	struct counter_device_attr *t;
+	int err;
+	struct list_head *const attr_list = &device_state->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", prefix, name);
+	if (!dev_attr->attr.name) {
+		err = -ENOMEM;
+		goto err_free_counter_attr;
+	}
+	if (show) {
+		dev_attr->attr.mode |= 0444;
+		dev_attr->show = show;
+	}
+	if (store) {
+		dev_attr->attr.mode |= 0200;
+		dev_attr->store = store;
+	}

drivers/iio/counter/generic-counter.c new file +568 -0

+
+	/* Store associated Counter component with attribute */
+	counter_attr->component = component;
+	counter_attr->component_data = component_data;
+
+	/* Keep track of the attribute for later cleanup */
+	list_add(&counter_attr->l, attr_list);
+	device_state->num_attr++;
+
+	return 0;
+
+err_free_attr_name:
+	kfree(dev_attr->attr.name);
+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)
+
+static ssize_t counter_signal_show(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	struct counter_device *const counter = dev_get_drvdata(dev);
+	struct counter_signal *const signal = to_counter_attr(attr)->component;
+
+	return counter->signal_read(counter, signal, buf);
+}
+
+static ssize_t counter_signal_store(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t len)
+{
+	struct counter_device *const counter = dev_get_drvdata(dev);
+	struct counter_signal *const signal = to_counter_attr(attr)->component;
+
+	return counter->signal_write(counter, signal, buf, len);
+}
+
+static ssize_t counter_device_attr_name_show(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	const char *const name = to_counter_attr(attr)->component;
+
+	return scnprintf(buf, PAGE_SIZE, "%s\n", name);
+}
+
+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 *const ext = devattr->component_data;
+	struct counter_device *const counter = dev_get_drvdata(dev);
+	struct counter_signal *const signal = devattr->component;
+
+	return ext->read(counter, 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 *const ext = devattr->component_data;
+	struct counter_device *const counter = dev_get_drvdata(dev);
+	struct counter_signal *const signal = devattr->component;
+
+	return ext->write(counter, signal, ext->priv, buf, len);
+}
+
+static int counter_signal_ext_register(const char *const prefix,
+	struct counter_signal *const signal,
+	struct counter_device_state *const device_state)
+{
+	const size_t num_ext = signal->num_ext;
+	size_t i;
+	const struct counter_signal_ext *ext;
+	int err;
+
+	/* Return early if no extensions */
+	if (!signal->ext || !num_ext)
+		return 0;
+
+	/* Create an attribute for each extension */
+	for (i = 0 ; i < num_ext; i++) {
+		ext = signal->ext + i;
+		err = counter_attribute_create(prefix, ext->name,
+			(ext->read) ? counter_signal_ext_show : NULL,
+			(ext->write) ? counter_signal_ext_store : NULL,
+			signal, ext, device_state);
+		if (err)
+			return err;
+	}
+
+	return 0;
+}
+
+static int counter_signal_attributes_create(const char *const signal_attr_name,
+	const struct counter_device *const counter,
+	struct counter_signal *const signal)
+{
+	struct counter_device_state *const device_state = counter->device_state;
+	int err;
+	const char *prefix;
+
+	/* Create main Signal attribute */
+	err = counter_attribute_create("", signal_attr_name,
+		(counter->signal_read) ? counter_signal_show : NULL,
+		(counter->signal_write) ? counter_signal_store : NULL,
+		signal, NULL, device_state);
+	if (err)
+		return err;
+
+	prefix = kasprintf(GFP_KERNEL, "%s_", signal_attr_name);
+	if (!prefix)
+		return -ENOMEM;
+
+	/* Create Signal name attribute */
+	if (signal->name) {
+		err = counter_attribute_create(prefix, "name",
+			counter_device_attr_name_show, NULL, signal->name, NULL,
+			device_state);
+		if (err)
+			goto err_free_prefix;
+	}
+
+	/* Register Signal extension attributes */
+	err = counter_signal_ext_register(prefix, signal, device_state);
+	if (err)
+		goto err_free_prefix;
+
+	kfree(prefix);
+
+	return 0;
+
+err_free_prefix:
+	kfree(prefix);
+	return err;
+}
+
+static int counter_signals_register(const struct counter_device *const counter)
+{
+	const size_t num_signals = counter->num_signals;
+	struct counter_device_state *const device_state = counter->device_state;
+	struct device *const dev = &device_state->dev;
+	size_t i;
+	struct counter_signal *signal;
+	const char *name;
+	int err;
+
+	/* At least one Signal must be defined */
+	if (!counter->signals || !num_signals) {
+		dev_err(dev, "Signals undefined\n");
+		return -EINVAL;
+	}
+
+	/* Register each Signal */
+	for (i = 0; i < num_signals; i++) {
+		signal = counter->signals + i;
+
+		/* Generate Signal attribute name */
+		name = kasprintf(GFP_KERNEL, "signal%d", signal->id);
+		if (!name)
+			return -ENOMEM;
+
+		/* Create all attributes associated with Signal */
+		err = counter_signal_attributes_create(name, counter, signal);
+		if (err)
+			goto err_free_name;
+
+		kfree(name);
+	}
+
+	return 0;
+
+err_free_name:
+	kfree(name);
+	return err;
+}
+
+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);
+	struct counter_count *const count = devattr->component_data;
+	struct counter_synapse *const synapse = devattr->component;
+	size_t action;
+
+	err = counter->action_get(counter, count, synapse, &action);
+	if (err)
+		return err;
+
+	synapse->action = action;
+
+	return scnprintf(buf, PAGE_SIZE, "%s\n", synapse->actions[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);
+	struct counter_synapse *const synapse = devattr->component;
+	size_t action;
+	const size_t num_actions = synapse->num_actions;
+	int err;
+	struct counter_device *const counter = dev_get_drvdata(dev);
+	struct counter_count *const count = devattr->component_data;
+
+	/* Find requested action mode */
+	for (action = 0; action < num_actions; action++)
+		if (sysfs_streq(buf, synapse->actions[action]))
+			break;
+	/* If requested action mode not found */
+	if (action >= num_actions)
+		return -EINVAL;
+
+	err = counter->action_set(counter, count, synapse, action);
+	if (err)
+		return err;
+
+	synapse->action = action;
+
+	return len;
+}
+
+static ssize_t counter_device_attr_available_show(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	const struct counter_device_attr *const devattr = to_counter_attr(attr);
+	const char *const *const modes = devattr->component;
+	const size_t num_modes = *(size_t *)devattr->component_data;
+	ssize_t len = 0;
+	size_t i;
+
+	for (i = 0; i < num_modes; i++)
+		len += scnprintf(buf + len, PAGE_SIZE - len, "%s\n", modes[i]);
+
+	return len;
+}
+
+static int counter_synapses_register(const struct counter_device *const counter,
+	struct counter_count *const count, const char *const count_attr_name)
+{
+	struct counter_device_state *const device_state = counter->device_state;
+	const size_t num_synapses = count->num_synapses;
+	struct device *const dev = &device_state->dev;
+	size_t i;
+	struct counter_synapse *synapse;
+	const char *prefix;
+	int err;
+
+	/* At least one Synapse must be defined */
+	if (!count->synapses || !num_synapses) {
+		dev_err(dev, "Count '%d' Synapses undefined\n",	count->id);
+		return -EINVAL;
+	}
+
+	/* Register each Synapse */
+	for (i = 0; i < num_synapses; i++) {
+		synapse = count->synapses + i;
+
+		/* Ensure all Synapses have a defined Signal */
+		if (!synapse->signal) {
+			dev_err(dev,
+				"Count '%d' Synapse '%zu' Signal undefined\n",
+				count->id, i);
+			return -EINVAL;
+		}
+
+		/* At least one action mode must be defined for each Synapse */
+		if (!synapse->actions || !synapse->num_actions) {
+			dev_err(dev,
+				"Count '%d' Signal '%d' action modes undefined\n",
+				count->id, synapse->signal->id);
+			return -EINVAL;
+		}
+
+		/* Generate attribute prefix */
+		prefix = kasprintf(GFP_KERNEL, "%s_signal%d_", count_attr_name,
+			synapse->signal->id);
+		if (!prefix)
+			return -ENOMEM;
+
+		/* Create action attribute */
+		err = counter_attribute_create(prefix, "action",
+			(counter->action_get) ? counter_action_show : NULL,
+			(counter->action_set) ? counter_action_store : NULL,
+			synapse, count, device_state);
+		if (err)
+			goto err_free_prefix;
+
+		/* Create action_available attribute */
+		err = counter_attribute_create(prefix, "action_available",
+			counter_device_attr_available_show, NULL,
+			synapse->actions, &synapse->num_actions, device_state);
+		if (err)
+			goto err_free_prefix;
+
+		kfree(prefix);
+	}
+
+	return 0;
+
+err_free_prefix:
+	kfree(prefix);
+	return err;
+}
+
+static ssize_t counter_count_show(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	struct counter_device *const counter = dev_get_drvdata(dev);
+	struct counter_count *const count = to_counter_attr(attr)->component;
+
+	return counter->count_read(counter, count, buf);
+}
+
+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);
+	struct counter_count *const count = to_counter_attr(attr)->component;
+
+	return counter->count_write(counter, count, buf, len);
+}
+
+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);
+	struct counter_count *const count = to_counter_attr(attr)->component;
+	size_t function;
+
+	err = counter->function_get(counter, count, &function);
+	if (err)
+		return err;
+
+	count->function = function;
+
+	return scnprintf(buf, PAGE_SIZE, "%s\n", count->functions[function]);
+}
+
+static ssize_t counter_function_store(struct device *dev,
+	struct device_attribute *attr, const char *buf, size_t len)
+{
+	struct counter_count *const count = to_counter_attr(attr)->component;
+	const size_t num_functions = count->num_functions;
+	size_t function;
+	int err;
+	struct counter_device *const counter = dev_get_drvdata(dev);
+
+	/* Find requested Count function mode */
+	for (function = 0; function < num_functions; function++)
+		if (sysfs_streq(buf, count->functions[function]))
+			break;
+	/* Return error if requested Count function mode not found */
+	if (function >= num_functions)
+		return -EINVAL;
+
+	err = counter->function_set(counter, count, function);
+	if (err)
+		return err;
+
+	count->function = function;
+
+	return len;
+}
+
+static ssize_t counter_count_synapses_show(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	size_t i;
+	struct counter_count *const count = to_counter_attr(attr)->component;
+	const struct counter_synapse *synapse;
+	ssize_t len = 0;
+
+	/* Print out a list of every Signal association to Count */
+	for (i = 0; i < count->num_synapses; i++) {
+		synapse = count->synapses + i;
+		len += snprintf(buf + len, PAGE_SIZE - len, "%d\t%s\t%s\n",
+			synapse->signal->id, synapse->signal->name,
+			synapse->actions[synapse->action]);
+		if (len >= PAGE_SIZE)
+			return -ENOMEM;
+	}
+
+	return len;
+}
+
+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 *const ext = devattr->component_data;
+	struct counter_device *const counter = dev_get_drvdata(dev);
+	struct counter_count *const count = devattr->component;
+
+	return ext->read(counter, 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 *const ext = devattr->component_data;
+	struct counter_device *const counter = dev_get_drvdata(dev);
+	struct counter_count *const count = devattr->component;
+
+	return ext->write(counter, count, ext->priv, buf, len);
+}
+
+static int counter_count_ext_register(const char *const prefix,
+	struct counter_count *const count,
+	struct counter_device_state *const device_state)
+{
+	const size_t num_ext = count->num_ext;
+	size_t i;
+	const struct counter_count_ext *ext;
+	int err;
+
+	/* Return early if no extensions */
+	if (!count->ext || !num_ext)
+		return 0;
+
+	/* Create an attribute for each extension */
+	for (i = 0 ; i < num_ext; i++) {
+		ext = count->ext + i;
+		err = counter_attribute_create(prefix, ext->name,
+			(ext->read) ? counter_count_ext_show : NULL,
+			(ext->write) ? counter_count_ext_store : NULL,
+			count, ext, device_state);
+		if (err)
+			return err;
+	}
+
+	return 0;
+}
+
+static int counter_count_attributes_create(const char *const count_attr_name,
+	const struct counter_device *const counter,
+	struct counter_count *const count)
+{
+	struct counter_device_state *const device_state = counter->device_state;
+	int err;
+	const char *prefix;
+
+	/* Create main Count attribute */
+	err = counter_attribute_create("", count_attr_name,
+		(counter->count_read) ? counter_count_show : NULL,
+		(counter->count_write) ? counter_count_store : NULL,
+		count, NULL, device_state);
+	if (err)
+		return err;
+
+	prefix = kasprintf(GFP_KERNEL, "%s_", count_attr_name);
+	if (!prefix)
+		return -ENOMEM;
+
+	/* Create Count function attribute */
+	err = counter_attribute_create(prefix, "function",
+		(counter->function_get) ? counter_function_show : NULL,
+		(counter->function_set) ? counter_function_store : NULL,
+		count, NULL, device_state);
+	if (err)
+		goto err_free_prefix;
+
+	/* Create Count function_available attribute */
+	err = counter_attribute_create(prefix, "function_available",
+		counter_device_attr_available_show, NULL, count->functions,
+		&count->num_functions, device_state);
+	if (err)
+		goto err_free_prefix;
+
+	/* Create Count synapses attribute */
+	err = counter_attribute_create(prefix, "synapses",
+		counter_count_synapses_show, NULL, count, NULL, device_state);
+	if (err)
+		goto err_free_prefix;
+
+	/* Create Count name attribute */
+	if (count->name) {
+		err = counter_attribute_create(prefix, "name",
+			counter_device_attr_name_show,	NULL, count->name, NULL,
+			device_state);
+		if (err)
+			goto err_free_prefix;
+	}
+
+	/* Register Count extension attributes */
+	err = counter_count_ext_register(prefix, count, device_state);
+	if (err)
+		goto err_free_prefix;
+
+	kfree(prefix);
+
+	return 0;
+
+err_free_prefix:
+	kfree(prefix);
+	return err;
+}
+
+static int counter_counts_register(const struct counter_device *const counter)
+{
+	const size_t num_counts = counter->num_counts;
+	struct device *const dev = &counter->device_state->dev;
+	size_t i;
+	struct counter_count *count;
+	const char *name;
+	int err;
+
+	/* At least one Count must be defined */
+	if (!counter->counts || !num_counts) {
+		dev_err(dev, "Counts undefined\n");
+		return -EINVAL;
+	}
+
+	/* Register each Count */
+	for (i = 0; i < num_counts; i++) {
+		count = counter->counts + i;
+
+		/* At least one function mode must be defined for each Count */
+		if (!count->functions || !count->num_functions) {
+			dev_err(dev, "Count '%d' function modes undefined\n",
+				count->id);
+			return -EINVAL;
+		}
+
+		/* Generate attribute name */
+		name = kasprintf(GFP_KERNEL, "count%d", count->id);
+		if (!name)
+			return -ENOMEM;
+
+		/* Register the Synapses associated with each Count */
+		err = counter_synapses_register(counter, count, name);
+		if (err)
+			goto err_free_name;
+
+		/* Create all attributes associated with Count */
+		err = counter_count_attributes_create(name, counter, count);
+		if (err)
+			goto err_free_name;
+
+		kfree(name);
+	}
+
+	return 0;
+
+err_free_name:
+	kfree(name);
+	return err;
+}
+
+static struct bus_type counter_bus_type = {
+	.name = "counter"
+};
+
+static dev_t counter_devt;
+
+#define COUNTER_DEV_MAX 256
+
+static int __init counter_init(void)
+{
+	int err;
+
+	err = bus_register(&counter_bus_type);

drivers/iio/counter/generic-counter.c new file +201 -0

+	}
+
+	return 0;
+}
+
+static void __exit counter_exit(void)
+{
+	if (counter_devt)
+		unregister_chrdev_region(counter_devt, COUNTER_DEV_MAX);
+	bus_unregister(&counter_bus_type);
+}
+
+static void free_counter_device_state_attr_list(struct list_head *attr_list)
+{
+	struct counter_device_attr *p, *n;
+
+	list_for_each_entry_safe(p, n, attr_list, l) {
+		kfree(p->dev_attr.attr.name);
+		list_del(&p->l);
+		kfree(p);
+	}
+}
+
+/* Provides a unique ID for each counter device */
+static DEFINE_IDA(counter_ida);
+
+static void counter_device_release(struct device *dev)
+{
+	struct counter_device *const counter = dev_get_drvdata(dev);
+	struct counter_device_state *const device_state = counter->device_state;
+
+	kfree(device_state->attr_group.attrs);
+	free_counter_device_state_attr_list(&device_state->attr_list);
+	ida_simple_remove(&counter_ida, device_state->id);
+	kfree(device_state);
+}
+
+static struct device_type counter_device_type = {
+	.name = "counter_device",
+	.release = counter_device_release
+};
+
+static int counter_chrdev_open(struct inode *inode, struct file *filp)
+{
+	struct counter_device_state *const device_state = container_of(
+		inode->i_cdev, struct counter_device_state, chrdev);
+	struct device *const dev = &device_state->dev;
+	struct counter_device *const counter = dev_get_drvdata(dev);
+
+	get_device(dev);
+	filp->private_data = counter;
+
+	return 0;
+}
+
+static int counter_chrdev_release(struct inode *inode, struct file *filp)
+{
+	struct counter_device_state *const device_state = container_of(
+		inode->i_cdev, struct counter_device_state, chrdev);
+
+	put_device(&device_state->dev);
+
+	return 0;
+}
+
+static const struct file_operations counter_fileops = {
+	.owner = THIS_MODULE,
+	.open = counter_chrdev_open,
+	.release = counter_chrdev_release
+};
+
+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_device_ext *const ext = devattr->component_data;
+	struct counter_device *const counter = dev_get_drvdata(dev);
+
+	return ext->read(counter, 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_device_ext *const ext = devattr->component_data;
+	struct counter_device *const counter = dev_get_drvdata(dev);
+
+	return ext->write(counter, ext->priv, buf, len);
+}
+
+static int counter_device_ext_register(struct counter_device *const counter)
+{
+	const size_t num_ext = counter->num_ext;
+	size_t i;
+	const struct counter_device_ext *ext;
+	int err;
+
+	/* Return early if no extensions */
+	if (!counter->ext || !num_ext)
+		return 0;
+
+	/* Create an attribute for each extension */
+	for (i = 0 ; i < num_ext; i++) {
+		ext = counter->ext + i;
+		err = counter_attribute_create("", ext->name,
+			(ext->read) ? counter_device_ext_show : NULL,
+			(ext->write) ? counter_device_ext_store : NULL,
+			NULL, ext, counter->device_state);
+		if (err)
+			return err;
+	}
+
+	return 0;
+}
+
+static ssize_t counter_name_show(struct device *dev,
+	struct device_attribute *attr, char *buf)
+{
+	const struct counter_device *const counter = dev_get_drvdata(dev);
+
+	return snprintf(buf, PAGE_SIZE, "%s\n", counter->name);
+}
+
+static DEVICE_ATTR_RO(counter_name);
+
+/**
+ * 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)
+{
+	int err;
+	struct counter_device_state *device_state;
+	struct counter_device_attr *p;
+	size_t i = 0;
+
+	if (!counter)
+		return -EINVAL;
+
+	/* Allocate internal state container for Counter device */
+	device_state = kzalloc(sizeof(*device_state), GFP_KERNEL);
+	if (!device_state)
+		return -ENOMEM;
+	counter->device_state = device_state;
+
+	/* Acquire unique ID */
+	device_state->id = ida_simple_get(&counter_ida, 0, 0, GFP_KERNEL);
+	if (device_state->id < 0) {
+		err = device_state->id;
+		goto err_free_device_state;
+	}
+
+	/* Configure device structure for Counter */
+	device_state->dev.type = &counter_device_type;
+	device_state->dev.bus = &counter_bus_type;
+	if (counter->parent) {
+		device_state->dev.parent = counter->parent;
+		device_state->dev.of_node = counter->parent->of_node;
+	}
+	dev_set_name(&device_state->dev, "counter%d", device_state->id);
+	device_initialize(&device_state->dev);
+	dev_set_drvdata(&device_state->dev, counter);
+	device_state->dev.devt = MKDEV(MAJOR(counter_devt), device_state->id);
+
+	/* Initialize attribute list */
+	INIT_LIST_HEAD(&device_state->attr_list);
+
+	/* Verify Signals are valid and register */
+	err = counter_signals_register(counter);
+	if (err)
+		goto err_free_attributes;
+
+	/* Verify Counts and respective Synapses are valid and register */
+	err = counter_counts_register(counter);
+	if (err)
+		goto err_free_attributes;
+
+	/* Register Counter device extension attributes */
+	err = counter_device_ext_register(counter);
+	if (err)
+		goto err_free_attributes;
+
+	/* Account for name attribute */
+	if (counter->name)
+		device_state->num_attr++;
+
+	/* Allocate space for attribute pointers in attribute group */
+	device_state->attr_group.attrs = kcalloc(device_state->num_attr + 1,
+		sizeof(*device_state->attr_group.attrs), GFP_KERNEL);
+	if (!device_state->attr_group.attrs) {
+		err = -ENOMEM;
+		goto err_free_attributes;
+	}
+
+	/* Add attribute pointers to attribute group */
+	list_for_each_entry(p, &device_state->attr_list, l)

drivers/iio/counter/generic-counter.c new file +116 -0

+	device_state->chrdev.owner = THIS_MODULE;
+	err = cdev_device_add(&device_state->chrdev, &device_state->dev);
+	if (err)
+		goto err_free_attr_group_attrs;
+
+	return 0;
+
+err_free_attr_group_attrs:
+	kfree(counter->device_state->attr_group.attrs);
+err_free_attributes:
+	free_counter_device_state_attr_list(&counter->device_state->attr_list);
+	ida_simple_remove(&counter_ida, counter->device_state->id);
+err_free_device_state:
+	kfree(counter->device_state);
+	return err;
+}
+EXPORT_SYMBOL(counter_register);
+
+/**
+ * counter_unregister - unregister Counter from the system
+ * @counter: pointer to Counter to unregister
+ *
+ * The Counter is unregistered from the system; all allocated memory is freed.
+ */
+void counter_unregister(struct counter_device *const counter)
+{
+	struct cdev *cdev;
+	struct device *dev;
+
+	if (counter) {
+		cdev = &counter->device_state->chrdev;
+		dev = &counter->device_state->dev;
+
+		cdev_device_del(cdev, dev);
+		put_device(dev);
+	}
+}
+EXPORT_SYMBOL(counter_unregister);
+
+static void devm_counter_unreg(struct device *dev, void *res)
+{
+	counter_unregister(*(struct counter_device **)res);
+}
+
+/**
+ * devm_counter_register - Resource-managed counter_register
+ * @dev: device to allocate counter_device for
+ * @counter: pointer to Counter to register
+ *
+ * Managed counter_register. The Counter registered with this function is
+ * automatically unregistered on driver detach. This function calls
+ * counter_register internally. Refer to that function for more information.
+ *
+ * If an Counter registered with this function needs to be unregistered
+ * separately, devm_counter_unregister must be used.
+ *
+ * RETURNS:
+ * 0 on success, negative error number on failure.
+ */
+int devm_counter_register(struct device *dev,
+	struct counter_device *const counter)
+{
+	struct counter_device **ptr;
+	int ret;
+
+	ptr = devres_alloc(devm_counter_unreg, sizeof(*ptr), GFP_KERNEL);
+	if (!ptr)
+		return -ENOMEM;
+
+	ret = counter_register(counter);
+	if (!ret) {
+		*ptr = counter;
+		devres_add(dev, ptr);
+	} else
+		devres_free(ptr);
+
+	return ret;
+}
+EXPORT_SYMBOL(devm_counter_register);
+
+static int devm_counter_match(struct device *dev, void *res, void *data)
+{
+	struct counter_device **r = res;
+
+	if (!r || !*r) {
+		WARN_ON(!r || !*r);
+		return 0;
+	}
+
+	return *r == data;
+}
+
+/**
+ * devm_counter_unregister - Resource-managed counter_unregister
+ * @dev: device this counter_device belongs to
+ * @counter: the Counter associated with the device
+ *
+ * Unregister Counter registered with devm_counter_register.
+ */
+void devm_counter_unregister(struct device *dev,
+	struct counter_device *const counter)
+{
+	int rc;
+
+	rc = devres_release(dev, devm_counter_unreg,
+		devm_counter_match, counter);
+	WARN_ON(rc);
+}
+EXPORT_SYMBOL(devm_counter_unregister);
+
+subsys_initcall(counter_init);
+module_exit(counter_exit);
+
+MODULE_AUTHOR("William Breathitt Gray <[email protected]>");
+MODULE_DESCRIPTION("Generic Counter interface");
+MODULE_LICENSE("GPL v2");

include/linux/iio/counter.h new file +87 -0

new file mode 100644
index 000000000000..070ed8fd53fb
@@ -0,0 +1,239 @@
+/*
+ * Counter interface
+ * Copyright (C) 2017 William Breathitt Gray
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+#ifndef _COUNTER_H_
+#define _COUNTER_H_
+
+#include <linux/cdev.h>
+#include <linux/device.h>
+#include <linux/sysfs.h>
+#include <linux/types.h>
+
+struct counter_device;
+struct counter_signal;
+
+/**
+ * struct counter_signal_ext - Counter Signal extensions
+ * @name:	[DRIVER] attribute name
+ * @read:	[DRIVER] read callback for this attribute; may be NULL
+ * @write:	[DRIVER] write callback for this attribute; may be NULL
+ * @priv:	[DRIVER] data private to the driver
+ */
+struct counter_signal_ext {
+	const char	*name;
+	ssize_t		(*read)(struct counter_device *counter,
+				struct counter_signal *signal, void *priv,
+				char *buf);
+	ssize_t		(*write)(struct counter_device *counter,
+				struct counter_signal *signal, void *priv,
+				const char *buf, size_t len);
+	void		*priv;
+};
+
+/**
+ * struct counter_signal - Counter Signal node
+ * @id:		[DRIVER] unique ID used to identify signal
+ * @name:	[DRIVER] device-specific signal name
+ * @ext:	[DRIVER] optional array of Counter Signal extensions
+ * @num_ext:	[DRIVER] number of Counter Signal extensions specified in @ext
+ * @priv:	[DRIVER] optional private data supplied by driver
+ */
+struct counter_signal {
+	int		id;
+	const char	*name;
+
+	const struct counter_signal_ext	*ext;
+	size_t				num_ext;
+
+	void	*priv;
+};
+
+/**
+ * struct counter_synapse - Counter Synapse node
+ * @action:		[DRIVER] current action mode
+ * @actions:		[DRIVER] available action modes
+ * @num_actions:	[DRIVER] number of action modes specified in @actions
+ * @signal:		[DRIVER] pointer to associated signal
+ */
+struct counter_synapse {
+	size_t			action;
+	const char *const	*actions;
+	size_t			num_actions;
+	struct counter_signal	*signal;
+};
+
+struct counter_count;
+
+/**
+ * struct counter_count_ext - Counter Count extension
+ * @name:	[DRIVER] attribute name
+ * @read:	[DRIVER] read callback for this attribute; may be NULL
+ * @write:	[DRIVER] write callback for this attribute; may be NULL
+ * @priv:	[DRIVER] data private to the driver
+ */
+struct counter_count_ext {
+	const char	*name;
+	ssize_t		(*read)(struct counter_device *counter,
+				struct counter_count *count, void *priv,

include/linux/iio/counter.h new file +18 -0

+	const char		*name;
+	size_t			function;
+	const char *const	*functions;
+	size_t			num_functions;
+
+	struct counter_synapse	*synapses;
+	size_t			num_synapses;
+
+	const struct counter_count_ext	*ext;
+	size_t				num_ext;
+
+	void	*priv;
+};
+
+/**
+ * struct counter_device_state - internal state container for a Counter device
+ * @id:		unique ID used to identify the Counter
+ * @dev:	internal device structure

include/linux/iio/counter.h new file +8 -0

+ * @read:	[DRIVER] read callback for this attribute; may be NULL
+ * @write:	[DRIVER] write callback for this attribute; may be NULL
+ * @priv:	[DRIVER] data private to the driver
+ */
+struct counter_device_ext {
+	const char	*name;
+	ssize_t		(*read)(struct counter_device *counter, void *priv,
+				char *buf);

include/linux/iio/counter.h new file +74 -0

+ * @signal_read:	[DRIVER] read callback for Signal attribute; may be NULL
+ * @signal_write:	[DRIVER] write callback for Signal attribute; may be
+ *			NULL
+ * @count_read:		[DRIVER] read callback for Count attribute; may be NULL
+ * @count_write:	[DRIVER] write callback for Count attribute; may be NULL
+ * @function_get:	[DRIVER] function to get the current count function
+ *			mode. Returns 0 on success and negative error code on
+ *			error. The index of the respective Count's returned
+ *			function mode should be passed back via the function
+ *			parameter.
+ * @function_set:	[DRIVER] function to set the count function mode.
+ *			function is the index of the requested function mode
+ *			from the respective Count's functions array.
+ * @action_get:		[DRIVER] function to get the current action mode.
+ *			Returns 0 on success and negative error code on error.
+ *			The index of the respective Signal's returned action
+ *			mode should be passed back via the action parameter.
+ * @action_set:		[DRIVER] function to set the action mode. action is the
+ *			index of the requested action mode from the respective
+ *			Synapse's actions array.
+ * @signals:		[DRIVER] array of Signals
+ * @num_signals:	[DRIVER] number of Signals specified in @signals
+ * @counts:		[DRIVER] array of Counts
+ * @num_counts:		[DRIVER] number of Counts specified in @counts
+ * @ext:		[DRIVER] optional array of Counter device extensions
+ * @num_ext:		[DRIVER] number of Counter device extensions specified
+ *			in @ext
+ * @priv:		[DRIVER] optional private data supplied by driver
+ */
+struct counter_device {
+	const char			*name;
+	struct device			*parent;
+	struct counter_device_state	*device_state;
+
+	ssize_t	(*signal_read)(struct counter_device *counter,
+			struct counter_signal *signal, char *buf);
+	ssize_t	(*signal_write)(struct counter_device *counter,
+			struct counter_signal *signal, const char *buf,
+			size_t len);
+	ssize_t	(*count_read)(struct counter_device *counter,
+			struct counter_count *count, char *buf);
+	ssize_t (*count_write)(struct counter_device *counter,
+			struct counter_count *count, const char *buf,
+			size_t len);
+	int	(*function_get)(struct counter_device *counter,
+			struct counter_count *count, size_t *function);
+	int	(*function_set)(struct counter_device *counter,
+			struct counter_count *count, size_t function);
+	int	(*action_get)(struct counter_device *counter,
+			struct counter_count *count,
+			struct counter_synapse *synapse, size_t *action);
+	int	(*action_set)(struct counter_device *counter,
+			struct counter_count *count,
+			struct counter_synapse *synapse, size_t action);
+
+	struct counter_signal	*signals;
+	size_t			num_signals;
+	struct counter_count	*counts;
+	size_t			num_counts;
+
+	const struct counter_device_ext	*ext;
+	size_t				num_ext;
+
+	void	*priv;
+};
+
+extern int counter_register(struct counter_device *const counter);
+extern void counter_unregister(struct counter_device *const counter);
+extern int devm_counter_register(struct device *dev,
+	struct counter_device *const counter);
+extern void devm_counter_unregister(struct device *dev,
+	struct counter_device *const counter);
+
+#endif /* _COUNTER_H_ */

This patch adds standard documentation for the userspace sysfs attributes of the Generic Counter interface.

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

---
 .../ABI/testing/sysfs-bus-counter-generic-sysfs    | 73 ++++++++++++++++++++++
 MAINTAINERS                                        |  1 +
 2 files changed, 74 insertions(+)
 create mode 100644 Documentation/ABI/testing/sysfs-bus-counter-generic-sysfs

Documentation/ABI/testing/sysfs-bus-counter-generic-sysfs new file +4 -0

new file mode 100644
index 000000000000..3b1c3c4498d1
@@ -0,0 +1,73 @@
+What:		/sys/bus/counter/devices/counterX/countY
+KernelVersion:	4.16
+Contact:	[email protected]
+Description:

Documentation/ABI/testing/sysfs-bus-counter-generic-sysfs new file +4 -0

+
+What:		/sys/bus/counter/devices/counterX/countY_function_available
+KernelVersion:	4.16
+Contact:	[email protected]

Documentation/ABI/testing/sysfs-bus-counter-generic-sysfs new file +6 -0

+
+What:		/sys/bus/counter/devices/counterX/countY_signalZ_action
+KernelVersion:	4.16
+Contact:	[email protected]
+Description:
+		Action mode of Count Y for Signal Z. This attribute indicates

MAINTAINERS +1 -0

index 07dd7b933bfa..38da1bc615b3 100644
@@ -3665,6 +3665,7 @@ COUNTER INTERFACE
 M:	William Breathitt Gray <[email protected]>
 L:	[email protected]
 S:	Maintained
+F:	Documentation/ABI/testing/sysfs-bus-counter-*
 F:	drivers/iio/counter/
 F:	include/linux/iio/counter.h
 

This patch adds high-level documentation about the Generic Counter interface.

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

---
 Documentation/driver-api/iio/generic-counter.rst | 434 +++++++++++++++++++++++
 Documentation/driver-api/iio/index.rst           |   1 +
 MAINTAINERS                                      |   1 +
 3 files changed, 436 insertions(+)
 create mode 100644 Documentation/driver-api/iio/generic-counter.rst

Documentation/driver-api/iio/generic-counter.rst new file +28 -0

new file mode 100644
index 000000000000..219c571e90ce
@@ -0,0 +1,434 @@
+=========================
+Generic Counter Interface
+=========================
+
+Introduction
+============
+
+Counter devices are prevalent within a diverse spectrum of industries.
+The ubiquitous presence of these devices necessitates a common interface
+and standard of interaction and exposure. This driver API attempts to
+resolve the issue of duplicate code found among existing counter device
+drivers by introducing a generic counter interface for consumption. The
+Generic Counter interface enables drivers to support and expose a common
+set of components and functionality present in counter devices.
+
+Theory
+======
+
+Counter devices can vary greatly in design, but regardless of whether
+some devices are quadrature encoder counters or tally counters, all
+counter devices consist of a core set of components. This core set of
+components, shared by all counter devices, is what forms the essence of
+the Generic Counter interface.
+
+There are three core components to a counter:
+
+        COUNT
+        -----

Documentation/driver-api/iio/generic-counter.rst new file +39 -0

+
+        SYNAPSE
+        -------
+        A Synapse represents the association of a Signal with a
+        respective Count. Signal data affects respective Count data, and
+        the Synapse represents this relationship. The Synapse action
+        mode (e.g. "rising edge" or "double pulse") specifies the Signal
+        data condition which triggers the respective Count's count
+        function evaluation to update the count data. It is possible for
+        the Synapse action mode to be "none" if a Signal is associated
+        with a Count but does not trigger the count function (e.g. the
+        direction signal line for a Pulse-Direction encoding counter).
+
+A counter is defined as a set of input signals associated to count data
+that are generated by the evaluation of the state of the associated
+input signals as defined by the respective count functions. Within the
+context of the Generic Counter interface, a counter consists of Counts
+each associated to a set of Signals, whose respective Synapse instances
+represent the count function update conditions for the associated
+Counts.
+
+Paradigm
+========
+
+The most basic counter device may be expressed as a single Count
+associated with a single Signal via a single Synapse. Take for example
+a counter device which simply accumulates a count of rising edges on a
+source input line.
+
+        Count                Synapse        Signal
+        -----                -------        ------
++---------------------+
+| Data: Count         |    Rising Edge     ________
+| Function: Increase  |  <-------------   / Source \
+|                     |                  ____________
++---------------------+
+
+In this example, the Signal is a source input line with a pulsing
+voltage, while the Count is a persistent count value which is repeatedly

Documentation/driver-api/iio/generic-counter.rst new file +4 -0

+example, a quadrature encoder counter device can keep track of position
+based on the states of two input lines.
+
+           Count                 Synapse     Signal

Documentation/driver-api/iio/generic-counter.rst new file +53 -0

+
+In this example, two Signals (quadrature encoder lines A and B) are
+associated to a single Count: a rising or falling edge on either A or B
+triggers the "Quadrature x4" function which determines the direction of
+movement and updates the respective position data. The "Quadrature x4"
+function is likely implemented in the hardware of the quadrature encoder
+counter device; the Count, Signals, and Synapses simply represent this
+hardware behavior and functionality.
+
+Signals associated to the same Count can have differing Synapse action
+mode conditions. For example, a quadrature encoder counter device
+operating in a non-quadrature Pulse-Direction mode could have one input
+line dedicated for movement and a second input line dedicated for
+direction.
+
+           Count                   Synapse      Signal
+           -----                   -------      ------
++---------------------------+
+| Data: Position            |    Rising Edge     ___
+| Function: Pulse-Direction |  <-------------   / A \ (Movement)
+|                           |                  _______
+|                           |
+|                           |       None         ___
+|                           |  <-------------   / B \ (Direction)
+|                           |                  _______
++---------------------------+
+
+Only Signal A triggers the "Pulse-Direction" update function, but the
+instantaneous state of Signal B is still required in order to know the
+direction so that the position data may be properly updated. Ultimately,
+both Signals are associated to the same Count via two respective
+Synapses, but only one Synapse has an active action mode condition which
+triggers the respective count function while the other is left with a
+"None" condition action mode to indicate its respective Signal's
+availability for state evaluation despite its non-triggering mode.
+
+The flexibility of Synapses allows for the representation of counters
+whose respective Count Signal relationships would be difficult to
+represent as isolated inputs. For example a tri-color LED color counter
+can easily be represented with three Synapses:
+
+           Count          Synapse      Signal
+           -----          -------      ------
++------------------+
+| Data: Count      |    Both Edges     _______
+| Function: Purple |  <------------   /  Red  \
+|                  |                 ___________
+|                  |
+|                  |    Both Edges     _______
+|                  |  <------------   / Green \
+|                  |                 ___________
+|                  |
+|                  |    Both Edges     _______

Documentation/driver-api/iio/generic-counter.rst new file +38 -0

+
+Although the examples thus far have been representations of physical
+devices, this is not a necessity. A counter simply represent the
+evaluation (Count) of input data (Signals) triggered by specific
+conditions (Synapses). A counter can be the representation of more
+abstract components.
+
+For example, suppose a counter representation is desired for a DNA
+sequence analysizer which detects possible genetic diseases.
+
+        Count                     Synapse            Signal
+        -----                     -------            ------
++---------------------+
+| Data: Diseases      |    Gene Transcript (EST)     _____
+| Function: Cancers   |  <-----------------------   / DNA \ (GAAGTGC...)
+|                     |                            _________
++---------------------+
+
+In this scenario, the Signal is a stream of DNA nucleotide bases (As,
+Ts, Cs, and Gs), the Synapse action modes consist of the various
+expressed sequence tags (ESTs), and the Count is a list of diseases
+discovered (in this particular example the function is evaluating for
+possible cancers). Note how the Signal in this example does not
+represent a physical voltage line, nor does the Synapse action mode
+represent a physical voltage line state change, nor does the Count
+represent a strictly decimal data value.
+
+The DNA sequence analysizer example is contrived to illustrate the
+flexibility of the generic counter paradigm by demonstrating its
+capability of representing abstract concepts; however, physical devices
+are likely to be more fitting for such a representation.
+
+The key concept is that the Signal, Synapse, and Count are abstract
+representations which do not need to be closely married to their
+respective physical sources. This allows the user of a counter to
+divorce themselves from the nuances of physical components (such as
+whether an input line is differential or single-ended) and focus on the
+core idea of what the data and process represent (e.g. an accumulated

Documentation/driver-api/iio/generic-counter.rst new file +27 -0

+
+Through these sysfs attributes, programs and scripts may interact with
+the Generic Counter paradigm Counts, Signals, and Synapses of respective
+counter devices.
+
+Driver API
+==========
+
+Driver authors may utilize the Generic Counter interface in their code
+by including the include/linux/iio/counter.h header file. This header
+file provides several core data structures and function prototypes for
+defining a generic counter.
+
+
+struct counter_signal_ext
+-------------------------
+
+This structure defines a Generic Counter Signal extension attribute.
+These attributes expose auxiliary configuration and functionality
+specific to the respective Generic Counter Signal.
+
+        name:   Attribute name
+        read:   Read callback for this attribute; may be NULL
+        write:  Write callback for this attribute; may be NULL
+        priv:   Data private to the driver
+
+struct counter_signal

Documentation/driver-api/iio/generic-counter.rst new file +4 -0

+        ext:            optional array of Counter Signal extensions
+        num_ext:        number of Counter Signal extensions specified in
+                        ext
+        priv:           optional private data supplied by driver

Documentation/driver-api/iio/generic-counter.rst new file +18 -0

+        num_actions:    number of action modes specified in actions
+        signal:         pointer to associated signal
+
+struct counter_count_ext
+------------------------
+
+This structure defines a Generic Counter Count extension attribute.
+These attributes expose auxiliary configuration and functionality
+specific to the respective Generic Counter Count.
+
+        name:   attribute name
+        read:   read callback for this attribute; may be NULL
+        write:  write callback for this attribute; may be NULL
+        priv:   data private to the driver
+
+struct counter_count
+--------------------
+

Documentation/driver-api/iio/generic-counter.rst new file +101 -0

+        functions:      available function modes
+        num_functions:  number of functions specified in @functions
+        synapses:       array of synapses for initialization
+        num_synapses:   number of synapses specified in @synapses
+        ext:            optional array of Counter Count extensions
+        num_ext:        number of Counter Count extensions specified in
+                        ext
+        priv:           optional private data supplied by driver
+
+struct counter_device_ext
+-------------------------
+
+This structure defines a Generic Counter extension attribute. These
+attributes expose auxiliary configuration and functionality specific to
+the respective Generic Counter.
+
+        name:   attribute name
+        read:   read callback for this attribute; may be NULL
+        write:  write callback for this attribute; may be NULL
+        priv:   data private to the driver
+
+struct counter_device
+---------------------
+
+This is the main data structure for a Generic Counter device. Access to
+all respective Counts, Signals, and Synapses is possible from this
+structure. This structure requires the configuration of a name, Generic
+Counter Signals, and Generic Counter Counts:
+
+name:           name of the device
+parent:         optional parent device providing the counters
+signal_read:    read callback for Signal attribute; may be NULL
+signal_write:   write callback for Signal attribute; may be NULL
+count_read:     read callback for Count attribute; may be NULL
+count_write:    write callback for Count attribute; may be NULL
+function_get:   function to get the current count function mode. Returns
+                0 on success and negative error code on error. The index
+                of the respective Count's returned function mode should
+                be passed back via the function parameter.
+function_set:   function to set the count function mode. function is the
+                index of the requested function mode from the respective
+                Count's functions array.
+action_get:     function to get the current action mode. Returns 0 on
+                success and negative error code on error. The index of
+                the respective Signal's returned action mode should be
+                passed back via the action parameter.
+action_set:     function to set the action mode. action is the index of
+                the requested action mode from the respective Synapse's
+                actions array.
+signals:        array of Signals
+num_signals:    number of Signals specified in @signals
+counts:         array of Counts
+num_counts:     number of Counts specified in @counts
+ext:            optional array of Counter device extensions
+num_ext:        number of Counter device extensions specified in ext
+priv:           optional private data supplied by driver
+
+Registration functions
+----------------------
+
+A counter device is registered to the system by passing the respective
+initialized counter_device structure to the counter_register function;
+similarly, the counter_unregister function unregisters the respective
+Counter. The devm_counter_register and devm_counter_unregister functions
+serve as device memory-managed versions of the counter_register and
+counter_unregister functions respectively.
+
+Implementation
+==============
+
+To support a counter device, a driver must first allocate the available
+Counter Signals via counter_signal structures. These Signals should
+be stored as an array and set to the signals array member of an
+allocated counter_device structure before the Counter is registered to
+the system.
+
+Counter Counts may be allocated via counter_count structures, and
+respective Counter Signal associations (Synapses) made via
+counter_synapse structures. Associated counter_synapse structures are
+stored as an array and set to the the synapses array member of the
+respective counter_count structure. These counter_count structures are
+set to the counts array member of an allocated counter_device structure
+before the Counter is registered to the system.
+
+Driver callbacks should be provided to the counter_device structure in
+order to communicate with the device: to read and write various Signals
+and Counts, and to set and get the "action mode" and "function mode" for
+various Synapses and Counts respectively.
+
+A defined counter_device structure may be registered to the system by
+passing it to the counter_register function, and unregistered by passing
+it to the counter_unregister function. Similarly, the
+devm_counter_register and devm_counter_unregister functions may be used
+if device memory-managed registration is desired.
+
+Extension sysfs attributes can be created for auxiliary functionality
+and data by passing in defined counter_device_ext, counter_count_ext,
+and counter_signal_ext structures. In these cases, the
+counter_device_ext structure is used for global configuration of the
+respective Counter device, while the counter_count_ext and
+counter_signal_ext structures allow for auxiliary exposure and

Documentation/driver-api/iio/generic-counter.rst new file +32 -0

+
+Counter devices are registered to the system via the counter_register
+function, and later removed via the counter_unregister function. The
+counter_register function establishes a unique ID for the Counter device
+and creates an associated device node under /dev called counterX, where
+X is the mentioned unique ID. A respective sysfs directory is created
+for the Counter device with a similar naming scheme:
+
+    /sys/bus/counter/devices/counterX
+
+Sysfs attributes are created within the counterX directory to expose
+functionality, configurations, and data relating to the Counts, Signals,
+and Synapses of the Counter device, as well as options and information
+for the Counter device itself.
+
+For a more detailed breakdown of the available Generic Counter interface
+sysfs attributes, please refer to the
+Documentation/ABI/testing/sys-bus-counter-generic-sysfs file.
+
+The Signals and Counts associated with the Counter device are registered
+to the system as well by the counter_register function. The
+signal_read/signal_write driver callbacks are associated to their
+respective Signal attributes, while the count_read/count_write and
+function_get/function_set driver callbacks are associated to their
+respective Count attributes; similarly, the same is true for the
+action_get/action_set driver callbacks and their respective Synapse
+attributes. If a driver callback is left undefined, then the respective
+read/write permission is left disabled for the relevant attributes.
+
+Similarly, extension sysfs attributes are created for the defined
+counter_device_ext, counter_count_ext, and counter_signal_ext
+structures that are passed in.

Documentation/driver-api/iio/index.rst +0 -0

index e5c3922d1b6f..e6c5b75c2e03 100644

MAINTAINERS +1 -0

index 38da1bc615b3..08eba78057e4 100644
@@ -3665,6 +3665,7 @@ COUNTER INTERFACE
 M:	William Breathitt Gray <[email protected]>
 L:	[email protected]
 S:	Maintained
+F:	Documentation/driver-api/counter/
 F:	Documentation/ABI/testing/sysfs-bus-counter-*
 F:	drivers/iio/counter/
 F:	include/linux/iio/counter.h

This patch introduces the Simple Counter interface. The Simple Counter interface serves as an API to provide support for simple hardware counter devices. The Simple Counter interface is built on top of the Generic Counter interface.

A simple hardware counter device is a counter device that has a single signal associated with each count value; Signals may have a value of "low" or "high," and edge trigger the count function which either increases or decreases the respective count value.

The Simple Counter interface provides two count function modes:

SIMPLE_COUNTER_FUNCTION_INCREASE: "increase" SIMPLE_COUNTER_FUNCTION_DECREASE: "decrease"

The Simple Counter interface provides four action modes:

SIMPLE_COUNTER_ACTION_NONE: "none"

SIMPLE_COUNTER_ACTION_RISING_EDGE: "rising edge" SIMPLE_COUNTER_ACTION_FALLING_EDGE: "falling edge" SIMPLE_COUNTER_ACTION_BOTH_EDGES: "both edges"

Signals may be represented by two possible states:

SIMPLE_COUNTER_SIGNAL_LOW: "low"
SIMPLE_COUNTER_SIGNAL_HIGH: "high"

Since the Simple Counter interface utilizes the Generic Counter interface underneath, all the expected functionality of the Generic Counter interface such as sysfs attributes is exposed to userspace for end user consumption. The Simple Counter interface serves as a convenience API for supporting a common class of counter devices without the need to manually configure the more cumbersome Generic Counter interface for use.

To use the Simple Counter interface, create an array of simple_counter_count structures to represent the desired counts and signals of the counter device, allocate a simple_counter_device structure and populate it with respective driver callbacks and the simple_counter_count array created earlier, then register the counter by calling the simple_counter_register function. The simple_counter_unregister function may be used to unregistered a previously registered counter.

Memory-managed versions of simple_counter_register and simple_counter_unregister functions are provided by the devm_simple_counter_register and devm_simple_counter_unregister functions respectively.

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

---
 drivers/iio/counter/Kconfig          |   4 +-
 drivers/iio/counter/Makefile         |   1 +
 drivers/iio/counter/simple-counter.c | 734 +++++++++++++++++++++++++++++++++++
 include/linux/iio/counter.h          | 199 ++++++++++
 4 files changed, 937 insertions(+), 1 deletion(-)
 create mode 100644 drivers/iio/counter/simple-counter.c

drivers/iio/counter/Kconfig +3 -1

index 4eaf4e53c5aa..6b9a43180d2c 100644
@@ -8,7 +8,9 @@ menuconfig COUNTER
 	help
 	  Provides support for Counter devices. The Generic Counter API provides
 	  rudimentary support for counters and serves as building blocks to
-	  create more complex counter interfaces.
+	  create more complex counter interfaces. The Simple Counter API
+	  provides support for simple hardware counter devices that have a
+	  one-to-one mapping between their Signals and Counts.
 
 if COUNTER
 

drivers/iio/counter/Makefile +1 -0

index 513c49d832d4..7450dee97446 100644
@@ -6,6 +6,7 @@
 
 obj-$(CONFIG_COUNTER) += counter.o
 counter-$(CONFIG_COUNTER) += generic-counter.o
+counter-$(CONFIG_COUNTER) += simple-counter.o
 
 obj-$(CONFIG_104_QUAD_8)	+= 104-quad-8.o
 obj-$(CONFIG_STM32_LPTIMER_CNT)	+= stm32-lptimer-cnt.o

drivers/iio/counter/simple-counter.c new file +582 -0

new file mode 100644
index 000000000000..e061db0860fd
@@ -0,0 +1,734 @@
+/*
+ * Simple Counter interface
+ * Copyright (C) 2017 William Breathitt Gray
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/export.h>
+#include <linux/gfp.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/types.h>
+
+#include <linux/iio/counter.h>
+
+static const char *const simple_counter_signal_level_names[] = {
+	[SIMPLE_COUNTER_SIGNAL_LOW] = "low",
+	[SIMPLE_COUNTER_SIGNAL_HIGH] = "high"
+};
+
+static ssize_t simple_counter_signal_read(struct counter_device *counter_dev,
+	struct counter_signal *counter_sig, char *buf)
+{
+	struct simple_counter_device *const counter = counter_dev->priv;
+	struct simple_counter_signal *const signal = counter_sig->priv;
+	int err;
+	enum simple_counter_signal_level level;
+
+	err = counter->signal_read(counter, signal, &level);
+	if (err)
+		return err;
+
+	return scnprintf(buf, PAGE_SIZE, "%s\n",
+		simple_counter_signal_level_names[level]);
+}
+
+static ssize_t simple_counter_signal_write(struct counter_device *counter_dev,
+	struct counter_signal *counter_sig, const char *buf, size_t len)
+{
+	struct simple_counter_device *const counter = counter_dev->priv;
+	struct simple_counter_signal *const signal = counter_sig->priv;
+	int level;
+	int err;
+
+	level = sysfs_match_string(simple_counter_signal_level_names, buf);
+	if (level < 0)
+		return level;
+
+	err = counter->signal_write(counter, signal, level);
+	if (err)
+		return err;
+
+	return len;
+}
+
+static ssize_t simple_counter_count_read(struct counter_device *counter_dev,
+	struct counter_count *counter_cnt, char *buf)
+{
+	struct simple_counter_device *const counter = counter_dev->priv;
+	struct simple_counter_count *const count = counter_cnt->priv;
+	int err;
+	long val;
+
+	err = counter->count_read(counter, count, &val);
+	if (err)
+		return err;
+
+	return scnprintf(buf, PAGE_SIZE, "%ld\n", val);
+}
+
+static ssize_t simple_counter_count_write(struct counter_device *counter_dev,
+	struct counter_count *counter_cnt, const char *buf, size_t len)
+{
+	struct simple_counter_device *const counter = counter_dev->priv;
+	struct simple_counter_count *const count = counter_cnt->priv;
+	int err;
+	long val;
+
+	err = kstrtol(buf, 0, &val);
+	if (err)
+		return err;
+
+	err = counter->count_write(counter, count, val);
+	if (err)
+		return err;
+
+	return len;
+}
+
+static int simple_counter_function_get(struct counter_device *counter_dev,
+	struct counter_count *counter_cnt, size_t *counter_func)
+{
+	int err;
+	struct simple_counter_device *const counter = counter_dev->priv;
+	struct simple_counter_count *const count = counter_cnt->priv;
+	enum simple_counter_function function;
+
+	err = counter->function_get(counter, count, &function);
+	if (err)
+		return err;
+
+	count->function = function;
+
+	*counter_func = function;
+
+	return 0;
+}
+
+static int simple_counter_function_set(struct counter_device *counter_dev,
+	struct counter_count *counter_cnt, size_t function)
+{
+	struct simple_counter_device *const counter = counter_dev->priv;
+	struct simple_counter_count *const count = counter_cnt->priv;
+	int err;
+
+	err = counter->function_set(counter, count, function);
+	if (err)
+		return err;
+
+	count->function = function;
+
+	return 0;
+}
+
+static int simple_counter_action_get(struct counter_device *counter_dev,
+	struct counter_count *counter_cnt, struct counter_synapse *counter_syn,
+	size_t *counter_act)
+{
+	int err;
+	struct simple_counter_device *const counter = counter_dev->priv;
+	struct simple_counter_count *const count = counter_cnt->priv;
+	enum simple_counter_action action;
+
+	err = counter->action_get(counter, count, &action);
+	if (err)
+		return err;
+
+	count->action = action;
+
+	*counter_act = action;
+
+	return 0;
+}
+
+static int simple_counter_action_set(struct counter_device *counter_dev,
+	struct counter_count *counter_cnt, struct counter_synapse *counter_syn,
+	size_t action)
+{
+	struct simple_counter_device *const counter = counter_dev->priv;
+	struct simple_counter_count *const count = counter_cnt->priv;
+	int err;
+
+	err = counter->action_set(counter, count, action);
+	if (err)
+		return err;
+
+	count->action = action;
+
+	return 0;
+}
+
+static ssize_t simple_counter_signal_ext_read(struct counter_device *dev,
+	struct counter_signal *signal, void *priv, char *buf)
+{
+	const struct simple_counter_signal_ext *const ext = priv;
+	struct simple_counter_device *const counter = dev->priv;
+	struct simple_counter_signal *const simple_signal = signal->priv;
+
+	return ext->read(counter, simple_signal, ext->priv, buf);
+}
+
+static ssize_t simple_counter_signal_ext_write(struct counter_device *dev,
+	struct counter_signal *signal, void *priv, const char *buf, size_t len)
+{
+	const struct simple_counter_signal_ext *const ext = priv;
+	struct simple_counter_device *const counter = dev->priv;
+	struct simple_counter_signal *const simple_signal = signal->priv;
+
+	return ext->write(counter, simple_signal, ext->priv, buf, len);
+}
+
+static int simple_counter_counter_signal_ext_register(
+	const struct simple_counter_signal *const simple_signal,
+	struct counter_signal *const signal)
+{
+	const struct simple_counter_signal_ext *const simple_ext =
+		simple_signal->ext;
+	const size_t num_ext = simple_signal->num_ext;
+	struct counter_signal_ext *ext;
+	size_t i;
+
+	/* Return early if no extensions */
+	if (!simple_ext || !num_ext)
+		return 0;
+
+	/* Allocate space for counter_signal_ext array */
+	ext = kmalloc_array(num_ext, sizeof(*ext), GFP_KERNEL);
+	if (!ext)
+		return -ENOMEM;
+
+	/* Register simple_counter_signal_ext via counter_signal_ext */
+	for (i = 0; i < num_ext; i++) {
+		ext[i].name = simple_ext[i].name;
+		ext[i].read = (simple_ext[i].read) ?
+			simple_counter_signal_ext_read : NULL;
+		ext[i].write = (simple_ext[i].write) ?
+			simple_counter_signal_ext_write : NULL;
+		ext[i].priv = simple_ext + i;
+	}
+
+	/* Register Counter Signal extensions */
+	signal->ext = ext;
+	signal->num_ext = num_ext;
+
+	return 0;
+}
+
+static int simple_counter_counter_signals_register(
+	const struct simple_counter_device *const counter)
+{
+	const size_t num_counts = counter->num_counts;
+	struct counter_signal *signals;
+	const size_t num_signals = num_counts;
+	struct simple_counter_count *const simple_counts = counter->counts;
+	size_t i;
+	struct counter_signal *signal;
+	struct simple_counter_signal *simple_signal;
+	int err;
+	struct counter_device *const counter_dev = counter->counter_dev;
+
+	/* Allocate space for signals array */
+	signals = kcalloc(num_signals, sizeof(*signals), GFP_KERNEL);
+	if (!signals)
+		return -ENOMEM;
+
+	/* Configure Signals */
+	for (i = 0; i < num_signals; i++) {
+		signal = signals + i;
+		simple_signal = &simple_counts[i].signal;
+
+		signal->id = simple_signal->id;
+		signal->name = simple_signal->name;
+		signal->priv = simple_signal;
+
+		/* Register Counter Signal extensions */
+		err = simple_counter_counter_signal_ext_register(simple_signal,
+			signal);
+		if (err)
+			goto err_free_signals;
+	}
+
+	/* Register Signals to Counter device container */
+	counter_dev->signals = signals;
+	counter_dev->num_signals = num_signals;
+
+	return 0;
+
+err_free_signals:
+	while (i--)
+		kfree(signals[i].ext);
+	kfree(signals);
+	return err;
+}
+
+static const char *const simple_counter_function_names[] = {
+	[SIMPLE_COUNTER_FUNCTION_INCREASE] = "increase",
+	[SIMPLE_COUNTER_FUNCTION_DECREASE] = "decrease"
+};
+
+static const char *const simple_counter_action_names[] = {
+	[SIMPLE_COUNTER_ACTION_NONE] = "none",
+	[SIMPLE_COUNTER_ACTION_RISING_EDGE] = "rising edge",
+	[SIMPLE_COUNTER_ACTION_FALLING_EDGE] = "falling edge",
+	[SIMPLE_COUNTER_ACTION_BOTH_EDGES] = "both edges"
+};
+
+static int simple_counter_counter_synapse_register(
+	struct counter_signal *const signal, struct counter_count *const count)
+{
+	struct counter_synapse *synapse;
+
+	/* Allocate space for Counter Synapse */
+	synapse = kzalloc(sizeof(*synapse), GFP_KERNEL);
+	if (!synapse)
+		return -ENOMEM;
+
+	/* Configure Synapse */
+	synapse->signal = signal;
+	synapse->actions = simple_counter_action_names;
+	synapse->num_actions = ARRAY_SIZE(simple_counter_action_names);
+
+	/* Register Counter Synapse */
+	count->synapses = synapse;
+	count->num_synapses = 1;
+
+	return 0;
+}
+
+static ssize_t simple_counter_count_ext_read(struct counter_device *dev,
+	struct counter_count *count, void *priv, char *buf)
+{
+	const struct simple_counter_count_ext *const ext = priv;
+	struct simple_counter_device *const counter = dev->priv;
+	struct simple_counter_count *const simple_count = count->priv;
+
+	return ext->read(counter, simple_count, ext->priv, buf);
+}
+
+static ssize_t simple_counter_count_ext_write(struct counter_device *dev,
+	struct counter_count *count, void *priv, const char *buf, size_t len)
+{
+	const struct simple_counter_count_ext *const ext = priv;
+	struct simple_counter_device *const counter = dev->priv;
+	struct simple_counter_count *const simple_count = count->priv;
+
+	return ext->write(counter, simple_count, ext->priv, buf, len);
+}
+
+static int simple_counter_counter_count_ext_register(
+	const struct simple_counter_count *const simple_count,
+	struct counter_count *const count)
+{
+	const struct simple_counter_count_ext *const simple_ext =
+		simple_count->ext;
+	const size_t num_ext = simple_count->num_ext;
+	struct counter_count_ext *ext;
+	size_t i;
+
+	/* Return early if no extensions */
+	if (!simple_ext || !num_ext)
+		return 0;
+
+	/* Allocate space for Counter Count extensions array */
+	ext = kmalloc_array(num_ext, sizeof(*ext), GFP_KERNEL);
+	if (!ext)
+		return -ENOMEM;
+
+	/* Register simple_counter_count_ext via counter_count_ext */
+	for (i = 0; i < num_ext; i++) {
+		ext[i].name = simple_ext[i].name;
+		ext[i].read = (simple_ext[i].read) ?
+			simple_counter_count_ext_read : NULL;
+		ext[i].write = (simple_ext[i].write) ?
+			simple_counter_count_ext_write : NULL;
+		ext[i].priv = simple_ext + i;
+	}
+
+	/* Register Counter Count extensions */
+	count->ext = ext;
+	count->num_ext = num_ext;
+
+	return 0;
+}
+
+static void simple_counter_counter_synapse_unregister(
+	const struct counter_count *const count)
+{
+	kfree(count->synapses);
+}
+
+static int simple_counter_counter_count_init(
+	struct counter_count *const count,
+	struct simple_counter_count *const simple_count,
+	struct counter_signal *const signal)
+{
+	int err;
+
+	count->id = simple_count->id;
+	count->name = simple_count->name;
+	count->functions = simple_counter_function_names;
+	count->num_functions = ARRAY_SIZE(simple_counter_function_names);
+	count->priv = simple_count;
+
+	/* Register Counter Synapse */
+	err = simple_counter_counter_synapse_register(signal, count);
+	if (err)
+		return err;
+
+	/* Register Counter Count extensions */
+	err = simple_counter_counter_count_ext_register(simple_count, count);
+	if (err)
+		goto err_unregister_synapse;
+
+	return 0;
+
+err_unregister_synapse:
+	simple_counter_counter_synapse_unregister(count);
+	return err;
+}
+
+static void simple_counter_counter_count_ext_unregister(
+	const struct counter_count *const count)
+{
+	kfree(count->ext);
+}
+
+static void simple_counter_counter_count_free(
+	const struct counter_count *const count)
+{
+	simple_counter_counter_count_ext_unregister(count);
+	simple_counter_counter_synapse_unregister(count);
+}
+
+static int simple_counter_counter_counts_register(
+	const struct simple_counter_device *const counter)
+{
+	struct counter_device *const counter_dev = counter->counter_dev;
+	struct counter_count *counts;
+	const size_t num_counts = counter->num_counts;
+	size_t i;
+	struct simple_counter_count *const simple_counts = counter->counts;
+	struct counter_signal *const signals = counter_dev->signals;
+	int err;
+
+	/* Allocate space for counts array */
+	counts = kcalloc(num_counts, sizeof(*counts), GFP_KERNEL);
+	if (!counts)
+		return -ENOMEM;
+
+	/* Initialize Counts */
+	for (i = 0; i < num_counts; i++) {
+		err = simple_counter_counter_count_init(counts + i,
+			simple_counts + i, signals + i);
+		if (err)
+			goto err_free_counts;
+	}
+
+	/* Register Counts to Counter device container */
+	counter_dev->counts = counts;
+	counter_dev->num_counts = num_counts;
+
+	return 0;
+
+err_free_counts:
+	while (i--)
+		simple_counter_counter_count_free(counts + i);
+	kfree(counts);
+	return err;
+}
+
+static void simple_counter_counter_signals_unregister(
+	const struct counter_device *const counter_dev)
+{
+	const struct counter_signal *const signals = counter_dev->signals;
+	size_t num_signals = counter_dev->num_signals;
+
+	while (num_signals--)
+		kfree(signals[num_signals].ext);
+	kfree(signals);
+}
+
+static int simple_counter_counts_register(
+	struct simple_counter_device *const counter)
+{
+	const struct simple_counter_count *const simple_counts =
+		counter->counts;
+	const size_t num_counts = counter->num_counts;
+	int err;
+
+	/* At least one Count must be defined */
+	if (!simple_counts || !num_counts) {
+		pr_err("simple-counter: Simple Counter Counts undefined\n");
+		return -EINVAL;
+	}
+
+	/* Register Counter Signals */
+	err = simple_counter_counter_signals_register(counter);
+	if (err)
+		return err;
+
+	/* Register Counter Counts */
+	err = simple_counter_counter_counts_register(counter);
+	if (err)
+		goto err_unregister_signals;
+
+	return 0;
+
+err_unregister_signals:
+	simple_counter_counter_signals_unregister(counter->counter_dev);
+	return err;
+}
+
+static ssize_t simple_counter_device_ext_read(struct counter_device *dev,
+	void *priv, char *buf)
+{
+	const struct simple_counter_device_ext *const ext = priv;
+	struct simple_counter_device *const counter = dev->priv;
+
+	return ext->read(counter, ext->priv, buf);
+}
+
+static ssize_t simple_counter_device_ext_write(struct counter_device *dev,
+	void *priv, const char *buf, size_t len)
+{
+	const struct simple_counter_device_ext *const ext = priv;
+	struct simple_counter_device *const counter = dev->priv;
+
+	return ext->write(counter, ext->priv, buf, len);
+}
+
+static int simple_counter_device_ext_register(
+	struct simple_counter_device *const counter)
+{
+	const struct simple_counter_device_ext *const simple_ext = counter->ext;
+	const size_t num_ext = counter->num_ext;
+	struct counter_device_ext *ext;
+	size_t i;
+	struct counter_device *const counter_dev = counter->counter_dev;
+
+	/* Return early if no extensions */
+	if (!simple_ext || !num_ext)
+		return 0;
+
+	/* Allocate space for Counter device extensions array */
+	ext = kmalloc_array(num_ext, sizeof(*ext), GFP_KERNEL);
+	if (!ext)
+		return -ENOMEM;
+
+	/* Register simple_counter_device_ext via counter_device_ext */
+	for (i = 0; i < num_ext; i++) {
+		ext[i].name = simple_ext[i].name;
+		ext[i].read = (simple_ext[i].read) ?
+			simple_counter_device_ext_read : NULL;
+		ext[i].write = (simple_ext[i].write) ?
+			simple_counter_device_ext_write : NULL;
+		ext[i].priv = simple_ext + i;
+	}
+
+	/* Register Counter device extensions */
+	counter_dev->ext = ext;
+	counter_dev->num_ext = num_ext;
+
+	return 0;
+}
+
+static void simple_counter_counter_counts_unregister(
+	const struct counter_device *const counter)
+{
+	const struct counter_count *const counts = counter->counts;
+	size_t num_counts = counter->num_counts;
+
+	while (num_counts--)
+		simple_counter_counter_count_free(counts + num_counts);
+	kfree(counts);
+}
+
+static void simple_counter_counts_unregister(
+	const struct simple_counter_device *const counter)
+{
+	const struct counter_device *const counter_dev = counter->counter_dev;
+
+	simple_counter_counter_counts_unregister(counter_dev);
+	simple_counter_counter_signals_unregister(counter_dev);
+}
+
+/**
+ * simple_counter_register - register Simple Counter to the system
+ * @counter: pointer to Simple Counter to register
+ *
+ * This function registers a Simple Counter to the system. A sysfs "counter"
+ * directory will be created and populated with sysfs attributes correlating
+ * with the Simple Counter Signals, Synapses, and Counts respectively.
+ */
+int simple_counter_register(struct simple_counter_device *const counter)
+{
+	struct counter_device *counter_dev;
+	int err;
+
+	if (!counter)
+		return -EINVAL;
+
+	/* Allocate internal Counter container */

drivers/iio/counter/simple-counter.c new file +142 -0

+	counter_dev->signal_write = (counter->signal_write) ?
+		simple_counter_signal_write : NULL;
+	counter_dev->count_read = (counter->count_read) ?
+		simple_counter_count_read : NULL;
+	counter_dev->count_write = (counter->count_write) ?
+		simple_counter_count_write : NULL;
+	counter_dev->function_get = (counter->function_get) ?
+		simple_counter_function_get : NULL;
+	counter_dev->function_set = (counter->function_set) ?
+		simple_counter_function_set : NULL;
+	counter_dev->action_get = (counter->action_get) ?
+		simple_counter_action_get : NULL;
+	counter_dev->action_set = (counter->action_set) ?
+		simple_counter_action_set : NULL;
+	counter_dev->priv = counter;
+
+	/* Register Simple Counter Counts */
+	err = simple_counter_counts_register(counter);
+	if (err)
+		goto err_free_counter_dev;
+
+	/* Register Simple Counter device extension attributes */
+	err = simple_counter_device_ext_register(counter);
+	if (err)
+		goto err_unregister_counts;
+
+	/* Register internal Counter to the system */
+	err = counter_register(counter_dev);
+	if (err)
+		goto err_free_ext;
+
+	return 0;
+
+err_free_ext:
+	kfree(counter_dev->ext);
+err_unregister_counts:
+	simple_counter_counts_unregister(counter);
+err_free_counter_dev:
+	kfree(counter_dev);
+	return err;
+}
+EXPORT_SYMBOL(simple_counter_register);
+
+/**
+ * simple_counter_unregister - unregister Simple Counter from the system
+ * @counter: pointer to Simple Counter to unregister
+ *
+ * The Simple Counter is unregistered from the system; all allocated memory is
+ * freed.
+ */
+void simple_counter_unregister(struct simple_counter_device *const counter)
+{
+	struct counter_device *counter_dev;
+
+	if (!counter)
+		return;
+
+	counter_dev = counter->counter_dev;
+
+	counter_unregister(counter_dev);
+
+	kfree(counter_dev->ext);
+	simple_counter_counts_unregister(counter);
+	kfree(counter_dev);
+}
+EXPORT_SYMBOL(simple_counter_unregister);
+
+static void devm_simple_counter_unreg(struct device *dev, void *res)
+{
+	simple_counter_unregister(*(struct simple_counter_device **)res);
+}
+
+/**
+ * devm_simple_counter_register - Resource-managed simple_counter_register
+ * @dev: device to allocate simple_counter_device for
+ * @counter: pointer to Simple Counter to register
+ *
+ * Managed simple_counter_register. The Simple Counter registered with this
+ * function is automatically unregistered on driver detach. This function calls
+ * simple_counter_register internally. Refer to that function for more
+ * information.
+ *
+ * If an Simple Counter registered with this function needs to be unregistered
+ * separately, devm_simple_counter_unregister must be used.
+ *
+ * RETURNS:
+ * 0 on success, negative error number on failure.
+ */
+int devm_simple_counter_register(struct device *dev,
+	struct simple_counter_device *const counter)
+{
+	struct simple_counter_device **ptr;
+	int ret;
+
+	ptr = devres_alloc(devm_simple_counter_unreg, sizeof(*ptr), GFP_KERNEL);
+	if (!ptr)
+		return -ENOMEM;
+
+	ret = simple_counter_register(counter);
+	if (!ret) {
+		*ptr = counter;
+		devres_add(dev, ptr);
+	} else
+		devres_free(ptr);
+
+	return ret;
+}
+EXPORT_SYMBOL(devm_simple_counter_register);
+
+static int devm_simple_counter_match(struct device *dev, void *res, void *data)
+{
+	struct simple_counter_device **r = res;
+
+	if (!r || !*r) {
+		WARN_ON(!r || !*r);
+		return 0;
+	}
+
+	return *r == data;
+}
+
+/**
+ * devm_simple_counter_unregister - Resource-managed simple_counter_unregister
+ * @dev: device this simple_counter_device belongs to
+ * @counter: the Simple Counter associated with the device
+ *
+ * Unregister Simple Counter registered with devm_simple_counter_register.
+ */
+void devm_simple_counter_unregister(struct device *dev,
+	struct simple_counter_device *const counter)
+{
+	int rc;
+
+	rc = devres_release(dev, devm_simple_counter_unreg,
+		devm_simple_counter_match, counter);
+	WARN_ON(rc);
+}
+EXPORT_SYMBOL(devm_simple_counter_unregister);
+
+MODULE_AUTHOR("William Breathitt Gray <[email protected]>");
+MODULE_DESCRIPTION("Simple Counter interface");
+MODULE_LICENSE("GPL v2");

include/linux/iio/counter.h +114 -0

index 070ed8fd53fb..0967ea2a9bef 100644
@@ -236,4 +236,203 @@ extern int devm_counter_register(struct device *dev,
 extern void devm_counter_unregister(struct device *dev,
 	struct counter_device *const counter);
 
+struct simple_counter_device;
+struct simple_counter_signal;
+
+/**
+ * struct simple_counter_signal_ext - Simple Counter Signal extension
+ * @name:	[DRIVER] attribute name
+ * @read:	[DRIVER] read callback for this attribute; may be NULL
+ * @write:	[DRIVER] write callback for this attribute; may be NULL
+ * @priv:	[DRIVER] data private to the driver
+ */
+struct simple_counter_signal_ext {
+	const char	*name;
+	ssize_t		(*read)(struct simple_counter_device *counter,
+				struct simple_counter_signal *signal,
+				void *priv, char *buf);
+	ssize_t		(*write)(struct simple_counter_device *counter,
+				struct simple_counter_signal *signal,
+				void *priv, const char *buf, size_t len);
+	void		*priv;
+};
+
+/**
+ * struct simple_counter_signal - Simple Counter Signal node
+ * @id:		[DRIVER] unique ID used to identify signal
+ * @name:	[DRIVER] device-specific signal name
+ * @ext:	[DRIVER] optional array of Simple Counter Signal extensions
+ * @num_ext:	[DRIVER] number of Simple Counter Signal extensions specified in
+ *		@ext
+ * @priv:	[DRIVER] optional private data supplied by driver
+ */
+struct simple_counter_signal {
+	int		id;
+	const char	*name;
+
+	const struct simple_counter_signal_ext	*ext;
+	size_t					num_ext;
+
+	void	*priv;
+};
+
+enum simple_counter_signal_level {
+	SIMPLE_COUNTER_SIGNAL_LOW = 0,
+	SIMPLE_COUNTER_SIGNAL_HIGH
+};
+
+struct simple_counter_count;
+
+enum simple_counter_function {
+	SIMPLE_COUNTER_FUNCTION_INCREASE = 0,
+	SIMPLE_COUNTER_FUNCTION_DECREASE
+};
+
+enum simple_counter_action {
+	SIMPLE_COUNTER_ACTION_NONE = 0,
+	SIMPLE_COUNTER_ACTION_RISING_EDGE,
+	SIMPLE_COUNTER_ACTION_FALLING_EDGE,
+	SIMPLE_COUNTER_ACTION_BOTH_EDGES
+};
+
+/**
+ * struct simple_counter_count_ext - Simple Counter Count extension
+ * @name:	[DRIVER] attribute name
+ * @read:	[DRIVER] read callback for this attribute; may be NULL
+ * @write:	[DRIVER] write callback for this attribute; may be NULL
+ * @priv:	[DRIVER] data private to the driver
+ */
+struct simple_counter_count_ext {
+	const char	*name;
+	ssize_t		(*read)(struct simple_counter_device *counter,
+				struct simple_counter_count *count, void *priv,
+				char *buf);
+	ssize_t		(*write)(struct simple_counter_device *counter,
+				struct simple_counter_count *count, void *priv,
+				const char *buf, size_t len);
+	void		*priv;
+};
+
+/**
+ * struct simple_counter_count - Simple Counter Count node
+ * @id:		[DRIVER] unique ID used to identify Count
+ * @name:	[DRIVER] device-specific Count name
+ * @function:	[DRIVER] current function mode
+ * @action:	[DRIVER] current action mode
+ * @signal:	[DRIVER] associated signal
+ * @ext:	[DRIVER] optional array of Simple Counter Count extensions
+ * @num_ext:	[DRIVER] number of Simple Counter Count extensions specified in
+ *		@ext
+ * @priv:	[DRIVER] optional private data supplied by driver
+ */
+struct simple_counter_count {
+	int				id;
+	const char			*name;
+	enum simple_counter_function	function;
+	enum simple_counter_action	action;
+
+	struct simple_counter_signal	signal;
+
+	const struct simple_counter_count_ext	*ext;
+	size_t					num_ext;
+
+	void	*priv;
+};
+
+/**
+ * struct simple_counter_device_ext - Simple Counter device extension
+ * @name:	[DRIVER] attribute name
+ * @read:	[DRIVER] read callback for this attribute; may be NULL
+ * @write:	[DRIVER] write callback for this attribute; may be NULL
+ * @priv:	[DRIVER] data private to the driver
+ */
+struct simple_counter_device_ext {
+	const char	*name;
+	ssize_t		(*read)(struct simple_counter_device *counter,
+				void *priv, char *buf);

include/linux/iio/counter.h +25 -0

+ * @signal_read:	[DRIVER] read callback for Signal attribute; may be
+ *			NULL. Returns 0 on success and negative error code on
+ *			error. The respective Signal's returned	level should be
+ *			passed back via the level parameter.
+ * @signal_write:	[DRIVER] write callback for Signal attribute; may be
+ *			NULL
+ * @count_read:		[DRIVER] read callback for Count attribute; may be NULL.
+ *			Returns 0 on success and negative error code on error.
+ *			The respective Count's returned value should be passed
+ *			back via the val parameter.
+ * @count_write:	[DRIVER] write callback for Count attribute; may be NULL
+ * @function_get:	[DRIVER] function to get the current count function
+ *			mode. Returns 0 on success and negative error code on
+ *			error. The respective Count's returned function mode
+ *			should be passed back via the function parameter.
+ * @function_set:	[DRIVER] function to set the count function mode
+ * @action_get:		[DRIVER] function to get the current action mode.
+ *			Returns 0 on success and negative error code on error.
+ *			The respective Signal's returned action mode should be
+ *			passed back via the action parameter.
+ * @action_set:		[DRIVER] function to set the action mode
+ * @counts:		[DRIVER] array of Simple Counter Counts
+ * @num_counts:		[DRIVER] number of Simple Counter Counts specified in
+ *			@counts
+ * @ext:		[DRIVER] optional array of Simple Counter device

include/linux/iio/counter.h +40 -0

+	int	(*signal_read)(struct simple_counter_device *counter,
+			struct simple_counter_signal *signal,
+			enum simple_counter_signal_level *level);
+	int	(*signal_write)(struct simple_counter_device *counter,
+			struct simple_counter_signal *signal,
+			enum simple_counter_signal_level level);
+	int	(*count_read)(struct simple_counter_device *counter,
+			struct simple_counter_count *count, long *val);
+	int	(*count_write)(struct simple_counter_device *counter,
+			struct simple_counter_count *count, long val);
+	int	(*function_get)(struct simple_counter_device *counter,
+			struct simple_counter_count *count,
+			enum simple_counter_function *function);
+	int	(*function_set)(struct simple_counter_device *counter,
+			struct simple_counter_count *count,
+			enum simple_counter_function function);
+	int	(*action_get)(struct simple_counter_device *counter,
+			struct simple_counter_count *count,
+			enum simple_counter_action *action);
+	int	(*action_set)(struct simple_counter_device *counter,
+			struct simple_counter_count *count,
+			enum simple_counter_action action);
+
+	struct simple_counter_count	*counts;
+	size_t				num_counts;
+
+	const struct simple_counter_device_ext	*ext;
+	size_t					num_ext;
+
+	void	*priv;
+};
+
+extern int simple_counter_register(struct simple_counter_device *const counter);
+extern void simple_counter_unregister(
+	struct simple_counter_device *const counter);
+extern int devm_simple_counter_register(struct device *dev,
+	struct simple_counter_device *const counter);
+extern void devm_simple_counter_unregister(struct device *dev,
+	struct simple_counter_device *const counter);
+
 #endif /* _COUNTER_H_ */

This patch adds standard documentation for the userspace sysfs attributes of the Simple Counter interface.

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

---
 .../ABI/testing/sysfs-bus-counter-simple-sysfs     | 61 ++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 Documentation/ABI/testing/sysfs-bus-counter-simple-sysfs

Documentation/ABI/testing/sysfs-bus-counter-simple-sysfs new file +11 -0

new file mode 100644
index 000000000000..e1f32c64c667
@@ -0,0 +1,61 @@
+What:		/sys/bus/counter/devices/counterX/countY
+KernelVersion:	4.16
+Contact:	[email protected]
+Description:
+		Count data of Count Y. This is a signed integer value that
+		represents the accumulated count.
+
+What:		/sys/bus/counter/devices/counterX/countY_function
+KernelVersion:	4.16
+Contact:	[email protected]
+Description:

Documentation/ABI/testing/sysfs-bus-counter-simple-sysfs new file +5 -0

+
+What:		/sys/bus/counter/devices/counterX/countY_min
+KernelVersion:	4.16
+Contact:	[email protected]
+Description:

Documentation/ABI/testing/sysfs-bus-counter-simple-sysfs new file +19 -0

+
+		None:
+			Signal does not trigger the count function.
+
+		Rising Edge:
+			Low state transitions to High state.
+
+		Falling Edge:
+			High state transitions to Low state.
+
+		Both Edges:
+			Any state transition.
+
+What:		/sys/bus/counter/devices/counterX/signalY
+KernelVersion:	4.16
+Contact:	[email protected]
+Description:
+		Signal data of Signal Y. This is the respective input level
+		represented by two available states: low and high.

This patch adds high-level documentation about the Simple Counter interface.

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

---
 Documentation/driver-api/iio/index.rst          |   1 +
 Documentation/driver-api/iio/simple-counter.rst | 393 ++++++++++++++++++++++++
 2 files changed, 394 insertions(+)
 create mode 100644 Documentation/driver-api/iio/simple-counter.rst

Documentation/driver-api/iio/index.rst +1 -0

index e6c5b75c2e03..60e17f16cfb8 100644
@@ -16,3 +16,4 @@ Contents:
    triggers
    triggered-buffers
    generic-counter
+   simple-counter

Documentation/driver-api/iio/simple-counter.rst new file +46 -0

new file mode 100644
index 000000000000..fa34f689e99f
@@ -0,0 +1,393 @@
+========================
+Simple Counter Interface
+========================
+
+Introduction
+============
+
+The most basic counter device may be expressed as a single Count
+associated with a single Signal via a single Synapse. This is a popular
+type of Counter implemented by hardware devices, and also what commonly
+comes to mind when one thinks of a "counter device." This driver API
+provides a basic Counter interface and standard of interaction and
+exposure for these simple counter devices. The Simple Counter interface
+enables drivers to support and expose simple counter devices in a more
+apt and well-defined way, without the hassles and imprecisions of
+utilizing a more generic interface.
+
+Theory
+======
+
+The Simple Counter interface may be considered a subclass of the
+Generic Counter interface; the same paradigm core components apply:
+Counts, Signals, and Synapses. However, the Simple Counter interface
+goes a bit further and defines aspects of those core components to
+properly represent Simple Counter devices.
+
+The three core components of a Simple Counter:
+
+        COUNT
+        -----
+        A Count represents the count data for a set of Signals. The
+        count data for a Simple Counter is a signed integer representing
+        the accumulated count of Simple Signal action conditions.
+
+        A Count has a count function mode which represents the update
+        behavior for the count data. The following two count function
+        modes are possible for a Simple Count:
+
+                * Increase:
+                        Accumulated count is incremented.
+                * Decrease:
+                        Accumulated count is decremented.
+
+        A Simple Count has one associated Simple Signal.
+
+        SIGNAL