High frequency software trigger

Hi,

I have recently begun looking at utilizing iio for the input part of a robotics system but have some doubts about its usability for which I would like your comments.

Today we have (in our embedded system) a number of custom written drivers interfacing SPI attached accelerometers and AD converters, utilizing hrtimers for software triggering of sampling at 50 to 250 Hz. Herein lays my current question, has anyone used the IIO system with these type of sampling rates? The RTC based trigger seems to only give second or higher intervals.

I will be looking at converting our special drivers to be acceptable for upstream submission, same for a hrtimers based trigger, should that be a good idea.

Best regards
Marten Svanfeldt

I recently submitted a trigger source driver that utilizes Blackfin hardware timer.

http://wiki.analog.com/software/linux/docs/iio/iio-trig-bfin-timer

Not sure what your platform is, but there might be similar peripherals, that can generate sub second cyclic interrupts.

I successfully used it on a fast Blackfin processor at frequencies of 10kHz and above, with this simple demo application.

http://wiki.analog.com/software/linux/docs/iio/iio_netscope

Quoted 3 lines

I recently submitted a trigger source driver that utilizes Blackfin hardware timer.

http://wiki.analog.com/software/linux/docs/iio/iio-trig-bfin-timer

Thank you, this had passed me by. Looking at the source, it seems that a hrtimer based trigger would be something similar, except not tied to any specific platform.

Quoted 3 lines

Not sure what your platform is, but there might be similar peripherals, that can generate sub second cyclic interrupts.

The platform in question is an TI OMAP3 (3530) based system, but my goal would be to utilize hrtimers as they are not tied to a specific platform. They are supposed to work on our target platform, but I haven't had time to test them extensively yet.

Quoted 5 lines

I successfully used it on a fast Blackfin processor at frequencies of 10kHz and above, with this simple demo application.

http://wiki.analog.com/software/linux/docs/iio/iio_netscope

10kHz sounds reassuring, in my case it is about 250Hz max, but some 13 or so channels. Did you get any idea where the limitations lies in terms of system load etc? Of course this depends on the exact setup, just trying to find all possible sides of moving our code over to be IIO-based.

I'm only superficially familiar with the abilities of hrtimers. Perhaps you could post your current code as an RFC so we can get an idea of exactly how this would work?

This driver provide a way to utilize hrtimer as an IIO trigger source.

Signed-off-by Marten Svanfeldt <[email protected]>

---
 drivers/staging/iio/trigger/Kconfig            |    6 +
 drivers/staging/iio/trigger/Makefile           |    2 +
 drivers/staging/iio/trigger/iio-trig-hrtimer.c |  208 ++++++++++++++++++++++++
 3 files changed, 216 insertions(+), 0 deletions(-)
 create mode 100644 drivers/staging/iio/trigger/iio-trig-hrtimer.c

drivers/staging/iio/trigger/Kconfig +0 -0

index d842a58..35d676a 100644

drivers/staging/iio/trigger/Kconfig +4 -0

+        help
+          Provides support for using hrtimer as periodic IIO
+          trigger.
+
 endif # IIO_TRIGGER

drivers/staging/iio/trigger/Makefile +0 -0

index 10aeca5..d178c66 100644

drivers/staging/iio/trigger/Makefile +1 -0

+

drivers/staging/iio/trigger/iio-trig-hrtimer.c new file +12 -0

new file mode 100644
index 0000000..16b5af5
@@ -0,0 +1,208 @@
+/**
+ * The industrial I/O periodic hrtimer trigger driver
+ *
+ * Copyright (C) Intuitive Aerial AB
+ * Written by Marten Svanfeldt, [email protected]
+ *
+ * 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.
+ *
+ */
+

drivers/staging/iio/trigger/iio-trig-hrtimer.c new file +34 -0

+	return HRTIMER_RESTART;
+}
+
+static int iio_trig_hrtimer_set_state(struct iio_trigger *trig, bool state)
+{
+	struct iio_hrtimer_trig_info *trig_info = trig->private_data;
+	if(trig_info->frequency == 0)
+		return -EINVAL;
+
+	if(state) {
+		hrtimer_start(&trig_info->timer,
+				ktime_set(0, NSEC_PER_SEC/trig_info->frequency),
+				HRTIMER_MODE_REL);
+	} else {
+		hrtimer_cancel(&trig_info->timer);
+	}
+
+	return 0;
+}
+
+static ssize_t iio_trig_hrtimer_read_freq(struct device *dev,
+					  struct device_attribute *attr,
+					  char *buf)
+{
+	struct iio_trigger *trig = dev_get_drvdata(dev);
+	struct iio_hrtimer_trig_info *trig_info = trig->private_data;
+	return sprintf(buf, "%u\n", trig_info->frequency);
+}
+
+static ssize_t iio_trig_hrtimer_write_freq(struct device *dev,
+					   struct device_attribute *attr,
+					   const char *buf,
+					   size_t len)
+{

drivers/staging/iio/trigger/iio-trig-hrtimer.c new file +20 -0

+
+	return len;
+
+error_ret:
+	return ret;
+}
+
+static IIO_TRIGGER_NAME_ATTR;
+static DEVICE_ATTR(frequency, S_IRUGO | S_IWUSR,
+		iio_trig_hrtimer_read_freq,
+		iio_trig_hrtimer_write_freq);
+
+static struct attribute *iio_trig_hrtimer_attrs[] = {
+	&dev_attr_name.attr,
+	&dev_attr_frequency.attr,
+	NULL,
+};
+
+static const struct attribute_group iio_trig_hrtimer_attr_group = {
+	.attrs = iio_trig_hrtimer_attrs,

drivers/staging/iio/trigger/iio-trig-hrtimer.c new file +102 -0

+	for(i = 0;; i++) {
+		if(pdata[i] == NULL)
+			break;
+
+		trig = iio_allocate_trigger();
+		if(!trig) {
+			ret = -ENOMEM;
+			goto err_free_completed_reg;
+		}
+		list_add(&trig->alloc_list, &iio_hrtimer_trigger_list);
+
+		trig_info = kzalloc(sizeof(struct iio_hrtimer_trig_info), GFP_KERNEL);
+		if(!trig_info) {
+			ret = -ENOMEM;
+			goto err_put_trigger;
+		}
+		trig_info->trigger = trig;
+		trig->private_data = trig_info;
+		trig->owner = THIS_MODULE;
+		trig->set_trigger_state = &iio_trig_hrtimer_set_state;
+		trig->name = kasprintf(GFP_KERNEL, "hrtimer%s", pdata[i]);
+		if(!trig->name) {
+			ret = -ENOMEM;
+			goto err_free_trig_info;
+		}
+
+		// Setup a hrtimer
+		hrtimer_init(&trig_info->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+		trig_info->timer.function = iio_trig_hrtimer_trig;
+
+		ret = iio_trigger_register(trig);
+		if(ret)
+			goto err_free_name;
+	}
+
+	return 0;
+err_free_name:
+	kfree(trig->name);
+err_free_trig_info:
+	kfree(trig_info);
+err_put_trigger:
+	list_del(&trig->alloc_list);
+	iio_put_trigger(trig);
+err_free_completed_reg:
+	list_for_each_entry_safe(trig,
+				 trig2,
+				 &iio_hrtimer_trigger_list,
+				 alloc_list) {
+		trig_info = trig->private_data;
+		kfree(trig->name);
+		kfree(trig_info);
+		iio_trigger_unregister(trig);
+	}
+
+	return ret;
+}
+
+static int iio_trig_hrtimer_remove(struct platform_device *dev)
+{
+	struct iio_trigger *trig, *trig2;
+	struct iio_hrtimer_trig_info *trig_info;
+
+	list_for_each_entry_safe(trig,
+				 trig2,
+				 &iio_hrtimer_trigger_list,
+				 alloc_list) {
+		trig_info = trig->private_data;
+		hrtimer_cancel(&trig_info->timer);
+		kfree(trig->name);
+		kfree(trig_info);
+		iio_trigger_unregister(trig);
+	}
+
+	return 0;
+}
+
+static struct platform_driver iio_trig_hrtimer_driver = {
+	.driver = {
+		.name = "iio_hrtimer_trigger",
+		.owner = THIS_MODULE
+	},
+	.probe = iio_trig_hrtimer_probe,
+	.remove = iio_trig_hrtimer_remove,
+};
+
+static int __init iio_trig_hrtimer_init(void)
+{
+	return platform_driver_register(&iio_trig_hrtimer_driver);
+}
+
+static void __exit iio_trig_hrtimer_exit(void)
+{
+	return platform_driver_unregister(&iio_trig_hrtimer_driver);
+}
+
+module_init(iio_trig_hrtimer_init);
+module_exit(iio_trig_hrtimer_exit);
+MODULE_AUTHOR("Marten Svanfeldt <[email protected]>");
+MODULE_DESCRIPTION("Periodic hrtimer trigger for the iio subsystem");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platofrm:iio-trig-hrtimer");
+

Obviously run checkpatch over it at some point.

Otherwise, nice clean little trigger driver. After cleanup and testing I would be happy to see this in IIO. Never realised it would be this simple :)

drivers/staging/iio/trigger/iio-trig-hrtimer.c line 32

Quoted 5 lines

drivers/staging/iio/trigger/iio-trig-hrtimer.c new file +5 -0

+static enum hrtimer_restart iio_trig_hrtimer_trig(struct hrtimer *timer)
+{
+	struct iio_hrtimer_trig_info *trig_info = container_of(timer, struct iio_hrtimer_trig_info, timer);
+
+	iio_trigger_poll(trig_info->trigger, 0);

Out of curiosity, how suceptible to drift is this? I guess the timer doesn't take into account the amout of time this function takes, e.g how late are we by the time the timer is restarted?

Review

Quoted 2 lines

(quoted diff) +2 -0

+
+	trig_info->frequency = val;

Only applied on trigger being stopped and restarted I think? Maybe return -EBUSY if the trigger is running to make this obvious to userspace.