iio: core: Introduce IIO software triggers

A software trigger associates an IIO device trigger with a software
interrupt source (e.g: timer, sysfs). This patch adds the generic
infrastructure for handling software triggers.

Software interrupts sources are kept in a iio_trigger_types_list and
registered separately when the associated kernel module is loaded.

Software triggers can be created directly from drivers or from user
space via configfs interface.

To sum up, this dynamically creates "triggers" group to be found under
/config/iio/triggers and offers the possibility of dynamically
creating trigger types groups. The first supported trigger type is
"hrtimer" found under /config/iio/triggers/hrtimer.

Signed-off-by: Daniel Baluta <daniel.baluta@intel.com>
Signed-off-by: Jonathan Cameron <jic23@kernel.org>

diff --git a/drivers/iio/Kconfig b/drivers/iio/Kconfig
index 9509b8a..ac8715e 100644 (file)
--- a/drivers/iio/Kconfig
+++ b/drivers/iio/Kconfig
@@ -46,6 +46,14 @@ config IIO_CONSUMERS_PER_TRIGGER
        This value controls the maximum number of consumers that a
        given trigger may handle. Default is 2.
 
+config IIO_SW_TRIGGER
+       tristate "Enable software triggers support"
+       select IIO_CONFIGFS
+       help
+        Provides IIO core support for software triggers. A software
+        trigger can be created via configfs or directly by a driver
+        using the API provided.
+
 config IIO_TRIGGERED_EVENT
        tristate
        select IIO_TRIGGER

diff --git a/drivers/iio/Makefile b/drivers/iio/Makefile
index 39d119f..f670b82 100644 (file)
--- a/drivers/iio/Makefile
+++ b/drivers/iio/Makefile
@@ -8,6 +8,7 @@ industrialio-$(CONFIG_IIO_BUFFER) += industrialio-buffer.o
 industrialio-$(CONFIG_IIO_TRIGGER) += industrialio-trigger.o
 
 obj-$(CONFIG_IIO_CONFIGFS) += industrialio-configfs.o
+obj-$(CONFIG_IIO_SW_TRIGGER) += industrialio-sw-trigger.o
 obj-$(CONFIG_IIO_TRIGGERED_EVENT) += industrialio-triggered-event.o
 
 obj-y += accel/

diff --git a/drivers/iio/industrialio-sw-trigger.c b/drivers/iio/industrialio-sw-trigger.c
new file mode 100644 (file)
index 0000000..4825cfd
--- /dev/null
+++ b/drivers/iio/industrialio-sw-trigger.c
@@ -0,0 +1,183 @@
+/*
+ * The Industrial I/O core, software trigger functions
+ *
+ * Copyright (c) 2015 Intel Corporation
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/kmod.h>
+#include <linux/list.h>
+#include <linux/slab.h>
+
+#include <linux/iio/sw_trigger.h>
+#include <linux/configfs.h>
+
+static struct config_group *iio_triggers_group;
+static struct config_item_type iio_trigger_type_group_type;
+
+static struct config_item_type iio_triggers_group_type = {
+       .ct_owner = THIS_MODULE,
+};
+
+static LIST_HEAD(iio_trigger_types_list);
+static DEFINE_MUTEX(iio_trigger_types_lock);
+
+static
+struct iio_sw_trigger_type *__iio_find_sw_trigger_type(const char *name,
+                                                      unsigned len)
+{
+       struct iio_sw_trigger_type *t = NULL, *iter;
+
+       list_for_each_entry(iter, &iio_trigger_types_list, list)
+               if (!strcmp(iter->name, name)) {
+                       t = iter;
+                       break;
+               }
+
+       return t;
+}
+
+int iio_register_sw_trigger_type(struct iio_sw_trigger_type *t)
+{
+       struct iio_sw_trigger_type *iter;
+       int ret = 0;
+
+       mutex_lock(&iio_trigger_types_lock);
+       iter = __iio_find_sw_trigger_type(t->name, strlen(t->name));
+       if (iter)
+               ret = -EBUSY;
+       else
+               list_add_tail(&t->list, &iio_trigger_types_list);
+       mutex_unlock(&iio_trigger_types_lock);
+
+       if (ret)
+               return ret;
+
+       t->group = configfs_register_default_group(iio_triggers_group, t->name,
+                                               &iio_trigger_type_group_type);
+       if (IS_ERR(t->group))
+               ret = PTR_ERR(t->group);
+
+       return ret;
+}
+EXPORT_SYMBOL(iio_register_sw_trigger_type);
+
+void iio_unregister_sw_trigger_type(struct iio_sw_trigger_type *t)
+{
+       struct iio_sw_trigger_type *iter;
+
+       mutex_lock(&iio_trigger_types_lock);
+       iter = __iio_find_sw_trigger_type(t->name, strlen(t->name));
+       if (iter)
+               list_del(&t->list);
+       mutex_unlock(&iio_trigger_types_lock);
+
+       configfs_unregister_default_group(t->group);
+}
+EXPORT_SYMBOL(iio_unregister_sw_trigger_type);
+
+static
+struct iio_sw_trigger_type *iio_get_sw_trigger_type(const char *name)
+{
+       struct iio_sw_trigger_type *t;
+
+       mutex_lock(&iio_trigger_types_lock);
+       t = __iio_find_sw_trigger_type(name, strlen(name));
+       if (t && !try_module_get(t->owner))
+               t = NULL;
+       mutex_unlock(&iio_trigger_types_lock);
+
+       return t;
+}
+
+struct iio_sw_trigger *iio_sw_trigger_create(const char *type, const char *name)
+{
+       struct iio_sw_trigger *t;
+       struct iio_sw_trigger_type *tt;
+
+       tt = iio_get_sw_trigger_type(type);
+       if (!tt) {
+               pr_err("Invalid trigger type: %s\n", type);
+               return ERR_PTR(-EINVAL);
+       }
+       t = tt->ops->probe(name);
+       if (IS_ERR(t))
+               goto out_module_put;
+
+       t->trigger_type = tt;
+
+       return t;
+out_module_put:
+       module_put(tt->owner);
+       return t;
+}
+EXPORT_SYMBOL(iio_sw_trigger_create);
+
+void iio_sw_trigger_destroy(struct iio_sw_trigger *t)
+{
+       struct iio_sw_trigger_type *tt = t->trigger_type;
+
+       tt->ops->remove(t);
+       module_put(tt->owner);
+}
+EXPORT_SYMBOL(iio_sw_trigger_destroy);
+
+static struct config_group *trigger_make_group(struct config_group *group,
+                                              const char *name)
+{
+       struct iio_sw_trigger *t;
+
+       t = iio_sw_trigger_create(group->cg_item.ci_name, name);
+       if (IS_ERR(t))
+               return ERR_CAST(t);
+
+       config_item_set_name(&t->group.cg_item, "%s", name);
+
+       return &t->group;
+}
+
+static void trigger_drop_group(struct config_group *group,
+                              struct config_item *item)
+{
+       struct iio_sw_trigger *t = to_iio_sw_trigger(item);
+
+       iio_sw_trigger_destroy(t);
+       config_item_put(item);
+}
+
+static struct configfs_group_operations trigger_ops = {
+       .make_group     = &trigger_make_group,
+       .drop_item      = &trigger_drop_group,
+};
+
+static struct config_item_type iio_trigger_type_group_type = {
+       .ct_group_ops = &trigger_ops,
+       .ct_owner       = THIS_MODULE,
+};
+
+static int __init iio_sw_trigger_init(void)
+{
+       iio_triggers_group =
+               configfs_register_default_group(&iio_configfs_subsys.su_group,
+                                               "triggers",
+                                               &iio_triggers_group_type);
+       if (IS_ERR(iio_triggers_group))
+               return PTR_ERR(iio_triggers_group);
+       return 0;
+}
+module_init(iio_sw_trigger_init);
+
+static void __exit iio_sw_trigger_exit(void)
+{
+       configfs_unregister_default_group(iio_triggers_group);
+}
+module_exit(iio_sw_trigger_exit);
+
+MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
+MODULE_DESCRIPTION("Industrial I/O software triggers support");
+MODULE_LICENSE("GPL v2");

diff --git a/include/linux/iio/sw_trigger.h b/include/linux/iio/sw_trigger.h
new file mode 100644 (file)
index 0000000..c2f33b2
--- /dev/null
+++ b/include/linux/iio/sw_trigger.h
@@ -0,0 +1,71 @@
+/*
+ * Industrial I/O software trigger interface
+ *
+ * Copyright (c) 2015 Intel Corporation
+ *
+ * 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.
+ */
+
+#ifndef __IIO_SW_TRIGGER
+#define __IIO_SW_TRIGGER
+
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/iio/iio.h>
+#include <linux/configfs.h>
+
+#define module_iio_sw_trigger_driver(__iio_sw_trigger_type) \
+       module_driver(__iio_sw_trigger_type, iio_register_sw_trigger_type, \
+                     iio_unregister_sw_trigger_type)
+
+extern struct configfs_subsystem iio_configfs_subsys;
+struct iio_sw_trigger_ops;
+
+struct iio_sw_trigger_type {
+       const char *name;
+       struct module *owner;
+       const struct iio_sw_trigger_ops *ops;
+       struct list_head list;
+       struct config_group *group;
+};
+
+struct iio_sw_trigger {
+       struct iio_trigger *trigger;
+       struct iio_sw_trigger_type *trigger_type;
+       struct config_group group;
+};
+
+struct iio_sw_trigger_ops {
+       struct iio_sw_trigger* (*probe)(const char *);
+       int (*remove)(struct iio_sw_trigger *);
+};
+
+static inline
+struct iio_sw_trigger *to_iio_sw_trigger(struct config_item *item)
+{
+       return container_of(to_config_group(item), struct iio_sw_trigger,
+                           group);
+}
+
+int iio_register_sw_trigger_type(struct iio_sw_trigger_type *tt);
+void iio_unregister_sw_trigger_type(struct iio_sw_trigger_type *tt);
+
+struct iio_sw_trigger *iio_sw_trigger_create(const char *, const char *);
+void iio_sw_trigger_destroy(struct iio_sw_trigger *);
+
+int iio_sw_trigger_type_configfs_register(struct iio_sw_trigger_type *tt);
+void iio_sw_trigger_type_configfs_unregister(struct iio_sw_trigger_type *tt);
+
+static inline
+void iio_swt_group_init_type_name(struct iio_sw_trigger *t,
+                                 const char *name,
+                                 struct config_item_type *type)
+{
+#ifdef CONFIG_CONFIGFS_FS
+       config_group_init_type_name(&t->group, name, type);
+#endif
+}
+
+#endif /* __IIO_SW_TRIGGER */