Commit b662f809 authored by Daniel Baluta's avatar Daniel Baluta Committed by Jonathan Cameron
Browse files

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: default avatarDaniel Baluta <daniel.baluta@intel.com>
Signed-off-by: default avatarJonathan Cameron <jic23@kernel.org>
parent 8261d961

drivers/iio/Kconfig

+8 −0
Original line number Diff line number Diff line
@@ -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

drivers/iio/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -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/

drivers/iio/industrialio-sw-trigger.c

0 → 100644
+183 −0
Original line number Diff line number Diff line 
/*

 * 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");

include/linux/iio/sw_trigger.h

0 → 100644
+71 −0
Original line number Diff line number Diff line 
/*

 * 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 */

CRA Git | Maintained and supported by SUSTech CRA and CCSE