| Message ID | cover.1625471640.git.vilhelm.gray@gmail.com (mailing list archive) |
|---|---|
| Headers | show |
| Series | Introduce the Counter character device interface | expand |
Hi On 7/5/21 11:18 AM, William Breathitt Gray wrote: > To summarize the main points of this patchset: there are no changes to > the existing Counter sysfs userspace interface; a Counter character > device interface is introduced that allows Counter events and associated > data to be read() by userspace; the events_configure() and > watch_validate() driver callbacks are introduced to support Counter > events; and IRQ support is added to the 104-QUAD-8 driver, serving as an > example of how to support the new Counter events functionality. > I quickly tested this set on top of linux-next next-20210706 and didn't see any issue with intel-qep.c. However I noticed two mutex issues in patch 15/17. Perhaps visible due the CONFIG_DEBUG_MUTEXES=y etc. I have on. I'll be out of office next few weeks so cannot test if you have a new version meanwhile but wanted to share no show stopper from intel-qep.c and those two mutex warnings. Jarkko
On Tue, Jul 06, 2021 at 02:40:01PM +0300, Jarkko Nikula wrote: > Hi > > On 7/5/21 11:18 AM, William Breathitt Gray wrote: > > To summarize the main points of this patchset: there are no changes to > > the existing Counter sysfs userspace interface; a Counter character > > device interface is introduced that allows Counter events and associated > > data to be read() by userspace; the events_configure() and > > watch_validate() driver callbacks are introduced to support Counter > > events; and IRQ support is added to the 104-QUAD-8 driver, serving as an > > example of how to support the new Counter events functionality. > > > I quickly tested this set on top of linux-next next-20210706 and didn't > see any issue with intel-qep.c. However I noticed two mutex issues in > patch 15/17. Perhaps visible due the CONFIG_DEBUG_MUTEXES=y etc. I have on. > > I'll be out of office next few weeks so cannot test if you have a new > version meanwhile but wanted to share no show stopper from intel-qep.c > and those two mutex warnings. > > Jarkko Thanks, these seem pretty straightforward to fix so I'll wait a week or so to see if any other issues pop up before making a v13 submission. William Breathitt Gray
On Mon, 5 Jul 2021 17:18:54 +0900 William Breathitt Gray <vilhelm.gray@gmail.com> wrote: > This is a reimplementation of the Generic Counter driver interface. > There are no modifications to the Counter subsystem userspace interface, > so existing userspace applications should continue to run seamlessly. > > The purpose of this patch is to internalize the sysfs interface code > among the various counter drivers into a shared module. Counter drivers > pass and take data natively (i.e. u8, u64, etc.) and the shared counter > module handles the translation between the sysfs interface and the > device drivers. This guarantees a standard userspace interface for all > counter drivers, and helps generalize the Generic Counter driver ABI in > order to support the Generic Counter chrdev interface (introduced in a > subsequent patch) without significant changes to the existing counter > drivers. > > Note, Counter device registration is the same as before: drivers > populate a struct counter_device with components and callbacks, then > pass the structure to the devm_counter_register function. However, > what's different now is how the Counter subsystem code handles this > registration internally. > > Whereas before callbacks would interact directly with sysfs data, this > interaction is now abstracted and instead callbacks interact with native > C data types. The counter_comp structure forms the basis for Counter > extensions. > > The counter-sysfs.c file contains the code to parse through the > counter_device structure and register the requested components and > extensions. Attributes are created and populated based on type, with > respective translation functions to handle the mapping between sysfs and > the counter driver callbacks. > > The translation performed for each attribute is straightforward: the > attribute type and data is parsed from the counter_attribute structure, > the respective counter driver read/write callback is called, and sysfs > I/O is handled before or after the driver read/write function is called. > > Cc: Syed Nayyar Waris <syednwaris@gmail.com> > Cc: Jarkko Nikula <jarkko.nikula@linux.intel.com> > Cc: Patrick Havelange <patrick.havelange@essensium.com> > Cc: Kamel Bouhara <kamel.bouhara@bootlin.com> > Cc: Fabrice Gasnier <fabrice.gasnier@st.com> > Cc: Maxime Coquelin <mcoquelin.stm32@gmail.com> > Cc: Alexandre Torgue <alexandre.torgue@st.com> > Cc: Dan Carpenter <dan.carpenter@oracle.com> > Reviewed-by: David Lechner <david@lechnology.com> > Tested-by: David Lechner <david@lechnology.com> > Signed-off-by: William Breathitt Gray <vilhelm.gray@gmail.com> Hi William, There is some type confusion going on in the stm32_lptim driver that should be cleaned up. A few other minor things but basically looks good to me so I probably won't look through this one again for v13 unless some discussion starts! One to note is that Andy just moved the kstrtoxx definitions to a new header, so we should include that where they are used going forwards. Can do that as a cleanup later though given you probably don't want to rebase this on a mid merge window state. Jonathan > --- ... > diff --git a/drivers/counter/counter-sysfs.c b/drivers/counter/counter-sysfs.c > new file mode 100644 > index 000000000000..07588130600a > --- /dev/null > +++ b/drivers/counter/counter-sysfs.c ... > +static ssize_t counter_comp_u8_show(struct device *dev, > + struct device_attribute *attr, char *buf) > +{ > + const struct counter_attribute *const a = to_counter_attribute(attr); > + struct counter_device *const counter = dev_get_drvdata(dev); > + int err; > + u8 data = 0; > + > + switch (a->scope) { > + case COUNTER_SCOPE_DEVICE: > + err = a->comp.device_u8_read(counter, &data); > + break; > + case COUNTER_SCOPE_SIGNAL: > + err = a->comp.signal_u8_read(counter, a->parent, &data); > + break; > + case COUNTER_SCOPE_COUNT: > + err = a->comp.count_u8_read(counter, a->parent, &data); > + break; > + default: > + return -EINVAL; > + } > + if (err < 0) > + return err; > + > + if (a->comp.type == COUNTER_COMP_BOOL) > + data = !!data; You have some drivers that do this internally then you replicate it here? An example is cable_fault in the quad 8. That is not necessarily a problem, but perhaps a comment to say this one should be paranoia and expectation is drivers will deliver 0 or 1. > + > + return sprintf(buf, "%u\n", (unsigned int)data); > +} > + ... > +static int counter_sysfs_attr_add(struct counter_device *const counter, > + struct counter_attribute_group *group) As below, group is a confusing name, so I'd prefix it with something. > +{ > + const enum counter_scope scope = COUNTER_SCOPE_DEVICE; > + struct device *const dev = &counter->dev; > + int err; > + size_t i; > + > + /* Add Signals sysfs attributes */ > + err = counter_sysfs_signals_add(counter, group); > + if (err < 0) > + return err; > + group += counter->num_signals; > + > + /* Add Counts sysfs attributes */ > + err = counter_sysfs_counts_add(counter, group); > + if (err < 0) > + return err; > + group += counter->num_counts; > + > + /* Create name attribute */ > + err = counter_name_attr_create(dev, group, counter->name); > + if (err < 0) > + return err; > + > + /* Create num_signals attribute */ > + err = counter_attr_create(dev, group, &counter_num_signals_comp, scope, > + NULL); > + if (err < 0) > + return err; > + > + /* Create num_counts attribute */ > + err = counter_attr_create(dev, group, &counter_num_counts_comp, scope, > + NULL); > + if (err < 0) > + return err; > + > + /* Create an attribute for each extension */ > + for (i = 0; i < counter->num_ext; i++) { > + err = counter_attr_create(dev, group, counter->ext + i, scope, > + NULL); > + if (err < 0) > + return err; > + } > + > + return 0; > +} > + > +/** > + * counter_sysfs_add - Adds Counter sysfs attributes to the device structure > + * @counter: Pointer to the Counter device structure > + * > + * Counter sysfs attributes are created and added to the respective device > + * structure for later registration to the system. Resource-managed memory > + * allocation is performed by this function, and this memory should be freed > + * when no longer needed (automatically by a device_unregister call, or > + * manually by a devres_release_all call). > + */ > +int counter_sysfs_add(struct counter_device *const counter) > +{ > + struct device *const dev = &counter->dev; > + const size_t num_groups = counter->num_signals + counter->num_counts + 1; > + struct counter_attribute_group *groups; Naming is a bit too similar to 'group' to lead to nice readable code. Maybe cattr_groups or something like that? groups and dev->groups not being the same thing is definitely confusing! > + size_t i, j; > + int err; > + struct attribute_group *group; > + struct counter_attribute *p; > + > + /* Allocate space for attribute groups (signals, counts, and ext) */ > + groups = devm_kcalloc(dev, num_groups, sizeof(*groups), GFP_KERNEL); > + if (!groups) > + return -ENOMEM; > + > + /* Initialize attribute lists */ > + for (i = 0; i < num_groups; i++) > + INIT_LIST_HEAD(&groups[i].attr_list); > + > + /* Add Counter device sysfs attributes */ > + err = counter_sysfs_attr_add(counter, groups); > + if (err < 0) > + return err; > + > + /* Allocate attribute groups for association with device */ > + dev->groups = devm_kcalloc(dev, num_groups + 1, sizeof(*dev->groups), > + GFP_KERNEL); > + if (!dev->groups) > + return -ENOMEM; > + > + /* Prepare each group of attributes for association */ > + for (i = 0; i < num_groups; i++) { > + /* Allocate space for attribute group */ > + group = devm_kzalloc(dev, sizeof(*group), GFP_KERNEL); > + if (!group) > + return -ENOMEM; Slight nitpick, is I'd have been tempted to reduce the number of allocations by doing this as a single array allocation then use the groups within this loop. Really trivial though! > + group->name = groups[i].name; > + > + /* Allocate space for attribute pointers */ > + group->attrs = devm_kcalloc(dev, groups[i].num_attr + 1, > + sizeof(*group->attrs), GFP_KERNEL); > + if (!group->attrs) > + return -ENOMEM; > + > + /* Add attribute pointers to attribute group */ > + j = 0; > + list_for_each_entry(p, &groups[i].attr_list, l) > + group->attrs[j++] = &p->dev_attr.attr; > + > + /* Associate attribute group */ > + dev->groups[i] = group; > + } > + > + return 0; > +} ... > diff --git a/drivers/counter/stm32-lptimer-cnt.c b/drivers/counter/stm32-lptimer-cnt.c > index 13656957c45f..aef78a4217b5 100644 > --- a/drivers/counter/stm32-lptimer-cnt.c > +++ b/drivers/counter/stm32-lptimer-cnt.c > @@ -17,6 +17,7 @@ > #include <linux/module.h> > #include <linux/pinctrl/consumer.h> > #include <linux/platform_device.h> > +#include <linux/types.h> > > struct stm32_lptim_cnt { > struct counter_device counter; > @@ -130,32 +131,46 @@ static int stm32_lptim_setup(struct stm32_lptim_cnt *priv, int enable) > * +---------+----------+----------+---------+----------+---------+ > */ > enum stm32_lptim_cnt_function { > - STM32_LPTIM_COUNTER_INCREASE, > - STM32_LPTIM_ENCODER_BOTH_EDGE, > + STM32_LPTIM_COUNTER_INCREASE = COUNTER_FUNCTION_INCREASE, > + STM32_LPTIM_ENCODER_BOTH_EDGE = COUNTER_FUNCTION_QUADRATURE_X4, > }; > > static const enum counter_function stm32_lptim_cnt_functions[] = { > - [STM32_LPTIM_COUNTER_INCREASE] = COUNTER_FUNCTION_INCREASE, > - [STM32_LPTIM_ENCODER_BOTH_EDGE] = COUNTER_FUNCTION_QUADRATURE_X4, > + STM32_LPTIM_COUNTER_INCREASE, > + STM32_LPTIM_ENCODER_BOTH_EDGE, > }; > > enum stm32_lptim_synapse_action { > + /* Index must match with stm32_lptim_cnt_polarity[] (priv->polarity) */ > STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE, > STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE, > STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES, > STM32_LPTIM_SYNAPSE_ACTION_NONE, > }; > > -static const enum counter_synapse_action stm32_lptim_cnt_synapse_actions[] = { > - /* Index must match with stm32_lptim_cnt_polarity[] (priv->polarity) */ > +static const enum stm32_lptim_synapse_action stm32_lptim_c2l_actions_map[] = { > + [COUNTER_SYNAPSE_ACTION_RISING_EDGE] = STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE, > + [COUNTER_SYNAPSE_ACTION_FALLING_EDGE] = STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE, > + [COUNTER_SYNAPSE_ACTION_BOTH_EDGES] = STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES, > + [COUNTER_SYNAPSE_ACTION_NONE] = STM32_LPTIM_SYNAPSE_ACTION_NONE, > +}; > + > +static const enum counter_synapse_action stm32_lptim_l2c_actions_map[] = { > [STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE, > [STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE, > [STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES, > [STM32_LPTIM_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE, > }; > > +static const enum counter_synapse_action stm32_lptim_cnt_synapse_actions[] = { > + COUNTER_SYNAPSE_ACTION_RISING_EDGE, > + COUNTER_SYNAPSE_ACTION_FALLING_EDGE, > + COUNTER_SYNAPSE_ACTION_BOTH_EDGES, > + COUNTER_SYNAPSE_ACTION_NONE, > +}; > + > static int stm32_lptim_cnt_read(struct counter_device *counter, > - struct counter_count *count, unsigned long *val) > + struct counter_count *count, u64 *val) > { > struct stm32_lptim_cnt *const priv = counter->priv; > u32 cnt; > @@ -170,9 +185,9 @@ static int stm32_lptim_cnt_read(struct counter_device *counter, > return 0; > } > > -static int stm32_lptim_cnt_function_get(struct counter_device *counter, > - struct counter_count *count, > - size_t *function) > +static int stm32_lptim_cnt_function_read(struct counter_device *counter, > + struct counter_count *count, > + enum counter_function *function) > { > struct stm32_lptim_cnt *const priv = counter->priv; > > @@ -189,9 +204,9 @@ static int stm32_lptim_cnt_function_get(struct counter_device *counter, > return -EINVAL; > } > > -static int stm32_lptim_cnt_function_set(struct counter_device *counter, > - struct counter_count *count, > - size_t function) > +static int stm32_lptim_cnt_function_write(struct counter_device *counter, > + struct counter_count *count, > + enum counter_function function) As mentioned below, there is a bit of a mess of types here that you should clean up. > { > struct stm32_lptim_cnt *const priv = counter->priv; > > @@ -212,9 +227,9 @@ static int stm32_lptim_cnt_function_set(struct counter_device *counter, > } > } > > -static ssize_t stm32_lptim_cnt_enable_read(struct counter_device *counter, > - struct counter_count *count, > - void *private, char *buf) > +static int stm32_lptim_cnt_enable_read(struct counter_device *counter, > + struct counter_count *count, > + u8 *enable) > { > struct stm32_lptim_cnt *const priv = counter->priv; > int ret; > @@ -223,22 +238,18 @@ static ssize_t stm32_lptim_cnt_enable_read(struct counter_device *counter, > if (ret < 0) > return ret; > > - return scnprintf(buf, PAGE_SIZE, "%u\n", ret); > + *enable = ret; > + > + return 0; > } > > -static ssize_t stm32_lptim_cnt_enable_write(struct counter_device *counter, > - struct counter_count *count, > - void *private, > - const char *buf, size_t len) > +static int stm32_lptim_cnt_enable_write(struct counter_device *counter, > + struct counter_count *count, > + u8 enable) > { > struct stm32_lptim_cnt *const priv = counter->priv; > - bool enable; > int ret; > > - ret = kstrtobool(buf, &enable); > - if (ret) > - return ret; > - > /* Check nobody uses the timer, or already disabled/enabled */ > ret = stm32_lptim_is_enabled(priv); > if ((ret < 0) || (!ret && !enable)) > @@ -254,65 +265,54 @@ static ssize_t stm32_lptim_cnt_enable_write(struct counter_device *counter, > if (ret) > return ret; > > - return len; > + return 0; > } > > -static ssize_t stm32_lptim_cnt_ceiling_read(struct counter_device *counter, > - struct counter_count *count, > - void *private, char *buf) > +static int stm32_lptim_cnt_ceiling_read(struct counter_device *counter, > + struct counter_count *count, > + u64 *ceiling) > { > struct stm32_lptim_cnt *const priv = counter->priv; > > - return snprintf(buf, PAGE_SIZE, "%u\n", priv->ceiling); > + *ceiling = priv->ceiling; > + > + return 0; > } > > -static ssize_t stm32_lptim_cnt_ceiling_write(struct counter_device *counter, > - struct counter_count *count, > - void *private, > - const char *buf, size_t len) > +static int stm32_lptim_cnt_ceiling_write(struct counter_device *counter, > + struct counter_count *count, > + u64 ceiling) > { > struct stm32_lptim_cnt *const priv = counter->priv; > - unsigned int ceiling; > - int ret; > > if (stm32_lptim_is_enabled(priv)) > return -EBUSY; > > - ret = kstrtouint(buf, 0, &ceiling); > - if (ret) > - return ret; > - > if (ceiling > STM32_LPTIM_MAX_ARR) > return -ERANGE; > > priv->ceiling = ceiling; > > - return len; > + return 0; > } > > -static const struct counter_count_ext stm32_lptim_cnt_ext[] = { > - { > - .name = "enable", > - .read = stm32_lptim_cnt_enable_read, > - .write = stm32_lptim_cnt_enable_write > - }, > - { > - .name = "ceiling", > - .read = stm32_lptim_cnt_ceiling_read, > - .write = stm32_lptim_cnt_ceiling_write > - }, > +static struct counter_comp stm32_lptim_cnt_ext[] = { > + COUNTER_COMP_ENABLE(stm32_lptim_cnt_enable_read, > + stm32_lptim_cnt_enable_write), > + COUNTER_COMP_CEILING(stm32_lptim_cnt_ceiling_read, > + stm32_lptim_cnt_ceiling_write), > }; > > -static int stm32_lptim_cnt_action_get(struct counter_device *counter, > - struct counter_count *count, > - struct counter_synapse *synapse, > - size_t *action) > +static int stm32_lptim_cnt_action_read(struct counter_device *counter, > + struct counter_count *count, > + struct counter_synapse *synapse, > + enum counter_synapse_action *action) > { > struct stm32_lptim_cnt *const priv = counter->priv; > - size_t function; > + enum counter_function function; > int err; > > - err = stm32_lptim_cnt_function_get(counter, count, &function); > + err = stm32_lptim_cnt_function_read(counter, count, &function); > if (err) > return err; > > @@ -320,12 +320,12 @@ static int stm32_lptim_cnt_action_get(struct counter_device *counter, > case STM32_LPTIM_COUNTER_INCREASE: > /* LP Timer acts as up-counter on input 1 */ > if (synapse->signal->id == count->synapses[0].signal->id) > - *action = priv->polarity; > + *action = stm32_lptim_l2c_actions_map[priv->polarity]; > else > - *action = STM32_LPTIM_SYNAPSE_ACTION_NONE; > + *action = COUNTER_SYNAPSE_ACTION_NONE; > return 0; > case STM32_LPTIM_ENCODER_BOTH_EDGE: > - *action = priv->polarity; > + *action = stm32_lptim_l2c_actions_map[priv->polarity]; > return 0; > default: > /* should never reach this path */ > @@ -333,43 +333,39 @@ static int stm32_lptim_cnt_action_get(struct counter_device *counter, > } > } > > -static int stm32_lptim_cnt_action_set(struct counter_device *counter, > - struct counter_count *count, > - struct counter_synapse *synapse, > - size_t action) > +static int stm32_lptim_cnt_action_write(struct counter_device *counter, > + struct counter_count *count, > + struct counter_synapse *synapse, > + enum counter_synapse_action action) > { > struct stm32_lptim_cnt *const priv = counter->priv; > - size_t function; > + enum counter_function function; > int err; > > if (stm32_lptim_is_enabled(priv)) > return -EBUSY; > > - err = stm32_lptim_cnt_function_get(counter, count, &function); > + err = stm32_lptim_cnt_function_read(counter, count, &function); > if (err) > return err; > > /* only set polarity when in counter mode (on input 1) */ > - if (function == STM32_LPTIM_COUNTER_INCREASE > - && synapse->signal->id == count->synapses[0].signal->id) { > - switch (action) { > - case STM32_LPTIM_SYNAPSE_ACTION_RISING_EDGE: > - case STM32_LPTIM_SYNAPSE_ACTION_FALLING_EDGE: > - case STM32_LPTIM_SYNAPSE_ACTION_BOTH_EDGES: > - priv->polarity = action; > - return 0; > - } > - } > + if ((enum stm32_lptim_cnt_function)function != STM32_LPTIM_COUNTER_INCREASE This bothers me a little. Why are you casting from enum counter_function to enum stm32_lptim_cnt_function? That function is indeed putting an enum stm32_lptim_cnt_function into function and it really shouldn't be. Whilst the values of the enums are the same, it would be better to have explicit item by item conversion if that's necessary. I 'think' you can just get rid of the enum stm32_lptim_cnt_function though and use the counter one throughout the driver. If you want to keep changes minimal, put a conversion function in place. > + || synapse->signal->id != count->synapses[0].signal->id > + || action == COUNTER_SYNAPSE_ACTION_NONE) > + return -EINVAL; > > - return -EINVAL; > + priv->polarity = stm32_lptim_c2l_actions_map[action]; > + > + return 0; > } > > static const struct counter_ops stm32_lptim_cnt_ops = { > .count_read = stm32_lptim_cnt_read, > - .function_get = stm32_lptim_cnt_function_get, > - .function_set = stm32_lptim_cnt_function_set, > - .action_get = stm32_lptim_cnt_action_get, > - .action_set = stm32_lptim_cnt_action_set, > + .function_read = stm32_lptim_cnt_function_read, > + .function_write = stm32_lptim_cnt_function_write, > + .action_read = stm32_lptim_cnt_action_read, > + .action_write = stm32_lptim_cnt_action_write, > }; > > static struct counter_signal stm32_lptim_cnt_signals[] = {
On Mon, 5 Jul 2021 17:18:48 +0900 William Breathitt Gray <vilhelm.gray@gmail.com> wrote: > Changes in v12: > - Move unlock to after register set in quad8_count_ceiling_write() > - Add locking protection to counter_set_event_node() > - Fix sparse warning by using {} instead of {0} > - Clean up and organize comments for clarity > - Reduce boilerplate by utilizing devm_add_action_or_reset() > - Use switch statements in ti_eqep_action_read() to make possible cases > more obvious > > I pulled out a lot of bits and pieces to their own patches; hopefully > that makes reviewing this patchset much simpler than before. This > patchset is also available on my personal git repo for convenience: > https://gitlab.com/vilhelmgray/iio/-/tree/counter_chrdev_v12 > > The patches preceding "counter: Internalize sysfs interface code" are > primarily cleanup and fixes that can be picked up and applied now to the > IIO tree if so desired. The "counter: Internalize sysfs interface code" > patch as well may be considered for pickup because it is relatively safe > and makes no changes to the userspace interface. > > To summarize the main points of this patchset: there are no changes to > the existing Counter sysfs userspace interface; a Counter character > device interface is introduced that allows Counter events and associated > data to be read() by userspace; the events_configure() and > watch_validate() driver callbacks are introduced to support Counter > events; and IRQ support is added to the 104-QUAD-8 driver, serving as an > example of how to support the new Counter events functionality. > > Something that should still be discussed: should the struct > counter_event "status" member be 8 bits or 32 bits wide? This member > will provide the return status (system error number) of an event > operation. Hi william, I've looked through the lot and where I haven't commented, I had nothing much to add to David's comments. I'm not planning to go through the whole thing again unless major changes occur. Fingers crossed for v13. If it looks like there are still some unresolved issues after that, perhaps applying up to patch 8 or so makes sense to reduced the volume of code you are carrying. Let me know if you'd like me to do that. Thanks, Jonathan > > William Breathitt Gray (17): > counter: 104-quad-8: Return error when invalid mode during > ceiling_write > counter: Return error code on invalid modes > counter: Standardize to ERANGE for limit exceeded errors > counter: Rename counter_signal_value to counter_signal_level > counter: Rename counter_count_function to counter_function > counter: Internalize sysfs interface code > counter: Update counter.h comments to reflect sysfs internalization > docs: counter: Update to reflect sysfs internalization > counter: Move counter enums to uapi header > counter: Add character device interface > docs: counter: Document character device interface > tools/counter: Create Counter tools > counter: Implement signalZ_action_component_id sysfs attribute > counter: Implement *_component_id sysfs attributes > counter: Implement events_queue_size sysfs attribute > counter: 104-quad-8: Replace mutex with spinlock > counter: 104-quad-8: Add IRQ support for the ACCES 104-QUAD-8 > > Documentation/ABI/testing/sysfs-bus-counter | 38 +- > Documentation/driver-api/generic-counter.rst | 366 +++- > .../userspace-api/ioctl/ioctl-number.rst | 1 + > MAINTAINERS | 3 +- > drivers/counter/104-quad-8.c | 728 ++++---- > drivers/counter/Kconfig | 6 +- > drivers/counter/Makefile | 1 + > drivers/counter/counter-chrdev.c | 498 ++++++ > drivers/counter/counter-chrdev.h | 14 + > drivers/counter/counter-core.c | 182 ++ > drivers/counter/counter-sysfs.c | 953 +++++++++++ > drivers/counter/counter-sysfs.h | 13 + > drivers/counter/counter.c | 1496 ----------------- > drivers/counter/ftm-quaddec.c | 59 +- > drivers/counter/intel-qep.c | 150 +- > drivers/counter/interrupt-cnt.c | 73 +- > drivers/counter/microchip-tcb-capture.c | 103 +- > drivers/counter/stm32-lptimer-cnt.c | 176 +- > drivers/counter/stm32-timer-cnt.c | 147 +- > drivers/counter/ti-eqep.c | 205 ++- > include/linux/counter.h | 716 ++++---- > include/linux/counter_enum.h | 45 - > include/uapi/linux/counter.h | 133 ++ > tools/Makefile | 13 +- > tools/counter/Build | 1 + > tools/counter/Makefile | 53 + > tools/counter/counter_example.c | 95 ++ > 27 files changed, 3501 insertions(+), 2767 deletions(-) > create mode 100644 drivers/counter/counter-chrdev.c > create mode 100644 drivers/counter/counter-chrdev.h > create mode 100644 drivers/counter/counter-core.c > create mode 100644 drivers/counter/counter-sysfs.c > create mode 100644 drivers/counter/counter-sysfs.h > delete mode 100644 drivers/counter/counter.c > delete mode 100644 include/linux/counter_enum.h > create mode 100644 include/uapi/linux/counter.h > create mode 100644 tools/counter/Build > create mode 100644 tools/counter/Makefile > create mode 100644 tools/counter/counter_example.c > > > base-commit: 6cbb3aa0f9d5d23221df787cf36f74d3866fdb78
On Sun, Jul 11, 2021 at 02:48:28PM +0100, Jonathan Cameron wrote: > On Mon, 5 Jul 2021 17:18:48 +0900 > William Breathitt Gray <vilhelm.gray@gmail.com> wrote: > > > Changes in v12: > > - Move unlock to after register set in quad8_count_ceiling_write() > > - Add locking protection to counter_set_event_node() > > - Fix sparse warning by using {} instead of {0} > > - Clean up and organize comments for clarity > > - Reduce boilerplate by utilizing devm_add_action_or_reset() > > - Use switch statements in ti_eqep_action_read() to make possible cases > > more obvious > > > > I pulled out a lot of bits and pieces to their own patches; hopefully > > that makes reviewing this patchset much simpler than before. This > > patchset is also available on my personal git repo for convenience: > > https://gitlab.com/vilhelmgray/iio/-/tree/counter_chrdev_v12 > > > > The patches preceding "counter: Internalize sysfs interface code" are > > primarily cleanup and fixes that can be picked up and applied now to the > > IIO tree if so desired. The "counter: Internalize sysfs interface code" > > patch as well may be considered for pickup because it is relatively safe > > and makes no changes to the userspace interface. > > > > To summarize the main points of this patchset: there are no changes to > > the existing Counter sysfs userspace interface; a Counter character > > device interface is introduced that allows Counter events and associated > > data to be read() by userspace; the events_configure() and > > watch_validate() driver callbacks are introduced to support Counter > > events; and IRQ support is added to the 104-QUAD-8 driver, serving as an > > example of how to support the new Counter events functionality. > > > > Something that should still be discussed: should the struct > > counter_event "status" member be 8 bits or 32 bits wide? This member > > will provide the return status (system error number) of an event > > operation. > > Hi william, > > I've looked through the lot and where I haven't commented, I had nothing > much to add to David's comments. > > I'm not planning to go through the whole thing again unless major changes > occur. Fingers crossed for v13. > > If it looks like there are still some unresolved issues after that, perhaps > applying up to patch 8 or so makes sense to reduced the volume of code you > are carrying. Let me know if you'd like me to do that. > > Thanks, > > Jonathan Yes, much of the code has remained stable for some months now so I think we're pretty close. If we do need a v14, then applying up to patch 8 would help me a lot (most of the merge conflicts I encounter when I rebase are due to the large subsystem refactor in patch 06). William Breathitt Gray > > > > William Breathitt Gray (17): > > counter: 104-quad-8: Return error when invalid mode during > > ceiling_write > > counter: Return error code on invalid modes > > counter: Standardize to ERANGE for limit exceeded errors > > counter: Rename counter_signal_value to counter_signal_level > > counter: Rename counter_count_function to counter_function > > counter: Internalize sysfs interface code > > counter: Update counter.h comments to reflect sysfs internalization > > docs: counter: Update to reflect sysfs internalization > > counter: Move counter enums to uapi header > > counter: Add character device interface > > docs: counter: Document character device interface > > tools/counter: Create Counter tools > > counter: Implement signalZ_action_component_id sysfs attribute > > counter: Implement *_component_id sysfs attributes > > counter: Implement events_queue_size sysfs attribute > > counter: 104-quad-8: Replace mutex with spinlock > > counter: 104-quad-8: Add IRQ support for the ACCES 104-QUAD-8 > > > > Documentation/ABI/testing/sysfs-bus-counter | 38 +- > > Documentation/driver-api/generic-counter.rst | 366 +++- > > .../userspace-api/ioctl/ioctl-number.rst | 1 + > > MAINTAINERS | 3 +- > > drivers/counter/104-quad-8.c | 728 ++++---- > > drivers/counter/Kconfig | 6 +- > > drivers/counter/Makefile | 1 + > > drivers/counter/counter-chrdev.c | 498 ++++++ > > drivers/counter/counter-chrdev.h | 14 + > > drivers/counter/counter-core.c | 182 ++ > > drivers/counter/counter-sysfs.c | 953 +++++++++++ > > drivers/counter/counter-sysfs.h | 13 + > > drivers/counter/counter.c | 1496 ----------------- > > drivers/counter/ftm-quaddec.c | 59 +- > > drivers/counter/intel-qep.c | 150 +- > > drivers/counter/interrupt-cnt.c | 73 +- > > drivers/counter/microchip-tcb-capture.c | 103 +- > > drivers/counter/stm32-lptimer-cnt.c | 176 +- > > drivers/counter/stm32-timer-cnt.c | 147 +- > > drivers/counter/ti-eqep.c | 205 ++- > > include/linux/counter.h | 716 ++++---- > > include/linux/counter_enum.h | 45 - > > include/uapi/linux/counter.h | 133 ++ > > tools/Makefile | 13 +- > > tools/counter/Build | 1 + > > tools/counter/Makefile | 53 + > > tools/counter/counter_example.c | 95 ++ > > 27 files changed, 3501 insertions(+), 2767 deletions(-) > > create mode 100644 drivers/counter/counter-chrdev.c > > create mode 100644 drivers/counter/counter-chrdev.h > > create mode 100644 drivers/counter/counter-core.c > > create mode 100644 drivers/counter/counter-sysfs.c > > create mode 100644 drivers/counter/counter-sysfs.h > > delete mode 100644 drivers/counter/counter.c > > delete mode 100644 include/linux/counter_enum.h > > create mode 100644 include/uapi/linux/counter.h > > create mode 100644 tools/counter/Build > > create mode 100644 tools/counter/Makefile > > create mode 100644 tools/counter/counter_example.c > > > > > > base-commit: 6cbb3aa0f9d5d23221df787cf36f74d3866fdb78 >
Changes in v12: - Move unlock to after register set in quad8_count_ceiling_write() - Add locking protection to counter_set_event_node() - Fix sparse warning by using {} instead of {0} - Clean up and organize comments for clarity - Reduce boilerplate by utilizing devm_add_action_or_reset() - Use switch statements in ti_eqep_action_read() to make possible cases more obvious I pulled out a lot of bits and pieces to their own patches; hopefully that makes reviewing this patchset much simpler than before. This patchset is also available on my personal git repo for convenience: https://gitlab.com/vilhelmgray/iio/-/tree/counter_chrdev_v12 The patches preceding "counter: Internalize sysfs interface code" are primarily cleanup and fixes that can be picked up and applied now to the IIO tree if so desired. The "counter: Internalize sysfs interface code" patch as well may be considered for pickup because it is relatively safe and makes no changes to the userspace interface. To summarize the main points of this patchset: there are no changes to the existing Counter sysfs userspace interface; a Counter character device interface is introduced that allows Counter events and associated data to be read() by userspace; the events_configure() and watch_validate() driver callbacks are introduced to support Counter events; and IRQ support is added to the 104-QUAD-8 driver, serving as an example of how to support the new Counter events functionality. Something that should still be discussed: should the struct counter_event "status" member be 8 bits or 32 bits wide? This member will provide the return status (system error number) of an event operation. William Breathitt Gray (17): counter: 104-quad-8: Return error when invalid mode during ceiling_write counter: Return error code on invalid modes counter: Standardize to ERANGE for limit exceeded errors counter: Rename counter_signal_value to counter_signal_level counter: Rename counter_count_function to counter_function counter: Internalize sysfs interface code counter: Update counter.h comments to reflect sysfs internalization docs: counter: Update to reflect sysfs internalization counter: Move counter enums to uapi header counter: Add character device interface docs: counter: Document character device interface tools/counter: Create Counter tools counter: Implement signalZ_action_component_id sysfs attribute counter: Implement *_component_id sysfs attributes counter: Implement events_queue_size sysfs attribute counter: 104-quad-8: Replace mutex with spinlock counter: 104-quad-8: Add IRQ support for the ACCES 104-QUAD-8 Documentation/ABI/testing/sysfs-bus-counter | 38 +- Documentation/driver-api/generic-counter.rst | 366 +++- .../userspace-api/ioctl/ioctl-number.rst | 1 + MAINTAINERS | 3 +- drivers/counter/104-quad-8.c | 728 ++++---- drivers/counter/Kconfig | 6 +- drivers/counter/Makefile | 1 + drivers/counter/counter-chrdev.c | 498 ++++++ drivers/counter/counter-chrdev.h | 14 + drivers/counter/counter-core.c | 182 ++ drivers/counter/counter-sysfs.c | 953 +++++++++++ drivers/counter/counter-sysfs.h | 13 + drivers/counter/counter.c | 1496 ----------------- drivers/counter/ftm-quaddec.c | 59 +- drivers/counter/intel-qep.c | 150 +- drivers/counter/interrupt-cnt.c | 73 +- drivers/counter/microchip-tcb-capture.c | 103 +- drivers/counter/stm32-lptimer-cnt.c | 176 +- drivers/counter/stm32-timer-cnt.c | 147 +- drivers/counter/ti-eqep.c | 205 ++- include/linux/counter.h | 716 ++++---- include/linux/counter_enum.h | 45 - include/uapi/linux/counter.h | 133 ++ tools/Makefile | 13 +- tools/counter/Build | 1 + tools/counter/Makefile | 53 + tools/counter/counter_example.c | 95 ++ 27 files changed, 3501 insertions(+), 2767 deletions(-) create mode 100644 drivers/counter/counter-chrdev.c create mode 100644 drivers/counter/counter-chrdev.h create mode 100644 drivers/counter/counter-core.c create mode 100644 drivers/counter/counter-sysfs.c create mode 100644 drivers/counter/counter-sysfs.h delete mode 100644 drivers/counter/counter.c delete mode 100644 include/linux/counter_enum.h create mode 100644 include/uapi/linux/counter.h create mode 100644 tools/counter/Build create mode 100644 tools/counter/Makefile create mode 100644 tools/counter/counter_example.c base-commit: 6cbb3aa0f9d5d23221df787cf36f74d3866fdb78