drivers/staging/iio/industrialio-trigger.c - kernel/skids - Git at Google

 /* The industrial I/O core, trigger handling functions
  *
  * Copyright (c) 2008 Jonathan Cameron
  *
  * 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/kernel.h>
 #include <linux/module.h>
 #include <linux/idr.h>
 #include <linux/err.h>
 #include <linux/device.h>
 #include <linux/interrupt.h>
 #include <linux/list.h>
 #include <linux/slab.h>

 #include "iio.h"
 #include "trigger.h"
 #include "trigger_consumer.h"

 /* RFC - Question of approach
  * Make the common case (single sensor single trigger)
  * simple by starting trigger capture from when first sensors
  * is added.
  *
  * Complex simultaneous start requires use of 'hold' functionality
  * of the trigger. (not implemented)
  *
  * Any other suggestions?
  */


 static DEFINE_IDR(iio_trigger_idr);
 static DEFINE_SPINLOCK(iio_trigger_idr_lock);

 /* Single list of all available triggers */
 static LIST_HEAD(iio_trigger_list);
 static DEFINE_MUTEX(iio_trigger_list_lock);

 /**
  * iio_trigger_register_sysfs() - create a device for this trigger
  * @trig_info:	the trigger
  *
  * Also adds any control attribute registered by the trigger driver
  **/
 static int iio_trigger_register_sysfs(struct iio_trigger *trig_info)
 {
 	int ret = 0;

 	if (trig_info->control_attrs)
 		ret = sysfs_create_group(&trig_info->dev.kobj,
 					 trig_info->control_attrs);

 	return ret;
 }

 static void iio_trigger_unregister_sysfs(struct iio_trigger *trig_info)
 {
 	if (trig_info->control_attrs)
 		sysfs_remove_group(&trig_info->dev.kobj,
 				   trig_info->control_attrs);
 }


 /**
  * iio_trigger_register_id() - get a unique id for this trigger
  * @trig_info:	the trigger
  **/
 static int iio_trigger_register_id(struct iio_trigger *trig_info)
 {
 	int ret = 0;

 idr_again:
 	if (unlikely(idr_pre_get(&iio_trigger_idr, GFP_KERNEL) == 0))
 		return -ENOMEM;

 	spin_lock(&iio_trigger_idr_lock);
 	ret = idr_get_new(&iio_trigger_idr, NULL, &trig_info->id);
 	spin_unlock(&iio_trigger_idr_lock);
 	if (unlikely(ret == -EAGAIN))
 		goto idr_again;
 	else if (likely(!ret))
 		trig_info->id = trig_info->id & MAX_ID_MASK;

 	return ret;
 }

 /**
  * iio_trigger_unregister_id() - free up unique id for use by another trigger
  * @trig_info: the trigger
  **/
 static void iio_trigger_unregister_id(struct iio_trigger *trig_info)
 {
 	spin_lock(&iio_trigger_idr_lock);
 	idr_remove(&iio_trigger_idr, trig_info->id);
 	spin_unlock(&iio_trigger_idr_lock);
 }

 int iio_trigger_register(struct iio_trigger *trig_info)
 {
 	int ret;

 	ret = iio_trigger_register_id(trig_info);
 	if (ret)
 		goto error_ret;
 	/* Set the name used for the sysfs directory etc */
 	dev_set_name(&trig_info->dev, "trigger%ld",
 		     (unsigned long) trig_info->id);

 	ret = device_add(&trig_info->dev);
 	if (ret)
 		goto error_unregister_id;

 	ret = iio_trigger_register_sysfs(trig_info);
 	if (ret)
 		goto error_device_del;

 	/* Add to list of available triggers held by the IIO core */
 	mutex_lock(&iio_trigger_list_lock);
 	list_add_tail(&trig_info->list, &iio_trigger_list);
 	mutex_unlock(&iio_trigger_list_lock);

 	return 0;

 error_device_del:
 	device_del(&trig_info->dev);
 error_unregister_id:
 	iio_trigger_unregister_id(trig_info);
 error_ret:
 	return ret;
 }
 EXPORT_SYMBOL(iio_trigger_register);

 void iio_trigger_unregister(struct iio_trigger *trig_info)
 {
 	struct iio_trigger *cursor;

 	mutex_lock(&iio_trigger_list_lock);
 	list_for_each_entry(cursor, &iio_trigger_list, list)
 		if (cursor == trig_info) {
 			list_del(&cursor->list);
 			break;
 		}
 	mutex_unlock(&iio_trigger_list_lock);

 	iio_trigger_unregister_sysfs(trig_info);
 	iio_trigger_unregister_id(trig_info);
 	/* Possible issue in here */
 	device_unregister(&trig_info->dev);
 }
 EXPORT_SYMBOL(iio_trigger_unregister);

 struct iio_trigger *iio_trigger_find_by_name(const char *name, size_t len)
 {
 	struct iio_trigger *trig;
 	bool found = false;

 	if (len && name[len - 1] == '\n')
 		len--;

 	mutex_lock(&iio_trigger_list_lock);
 	list_for_each_entry(trig, &iio_trigger_list, list) {
 		if (strncmp(trig->name, name, len) == 0) {
 			found = true;
 			break;
 		}
 	}
 	mutex_unlock(&iio_trigger_list_lock);

 	return found ? trig : NULL;
 }
 EXPORT_SYMBOL(iio_trigger_find_by_name);

 void iio_trigger_poll(struct iio_trigger *trig)
 {
 	struct iio_poll_func *pf_cursor;

 	list_for_each_entry(pf_cursor, &trig->pollfunc_list, list) {
 		if (pf_cursor->poll_func_immediate) {
 			pf_cursor->poll_func_immediate(pf_cursor->private_data);
 			trig->use_count++;
 		}
 	}
 	list_for_each_entry(pf_cursor, &trig->pollfunc_list, list) {
 		if (pf_cursor->poll_func_main) {
 			pf_cursor->poll_func_main(pf_cursor->private_data);
 			trig->use_count++;
 		}
 	}
 }
 EXPORT_SYMBOL(iio_trigger_poll);

 void iio_trigger_notify_done(struct iio_trigger *trig)
 {
 	trig->use_count--;
 	if (trig->use_count == 0 && trig->try_reenable)
 		if (trig->try_reenable(trig)) {
 			/* Missed and interrupt so launch new poll now */
 			trig->timestamp = 0;
 			iio_trigger_poll(trig);
 		}
 }
 EXPORT_SYMBOL(iio_trigger_notify_done);

 /**
  * iio_trigger_read_name() - retrieve useful identifying name
  **/
 ssize_t iio_trigger_read_name(struct device *dev,
 			      struct device_attribute *attr,
 			      char *buf)
 {
 	struct iio_trigger *trig = dev_get_drvdata(dev);
 	return sprintf(buf, "%s\n", trig->name);
 }
 EXPORT_SYMBOL(iio_trigger_read_name);

 /* Trigger Consumer related functions */

 /* Complexity in here.  With certain triggers (datardy) an acknowledgement
  * may be needed if the pollfuncs do not include the data read for the
  * triggering device.
  * This is not currently handled.  Alternative of not enabling trigger unless
  * the relevant function is in there may be the best option.
  */
 /* Worth protecting against double additions?*/
 int iio_trigger_attach_poll_func(struct iio_trigger *trig,
 				 struct iio_poll_func *pf)
 {
 	int ret = 0;
 	unsigned long flags;

 	spin_lock_irqsave(&trig->pollfunc_list_lock, flags);
 	list_add_tail(&pf->list, &trig->pollfunc_list);
 	spin_unlock_irqrestore(&trig->pollfunc_list_lock, flags);

 	if (trig->set_trigger_state)
 		ret = trig->set_trigger_state(trig, true);
 	if (ret) {
 		printk(KERN_ERR "set trigger state failed\n");
 		list_del(&pf->list);
 	}
 	return ret;
 }
 EXPORT_SYMBOL(iio_trigger_attach_poll_func);

 int iio_trigger_dettach_poll_func(struct iio_trigger *trig,
 				  struct iio_poll_func *pf)
 {
 	struct iio_poll_func *pf_cursor;
 	unsigned long flags;
 	int ret = -EINVAL;

 	spin_lock_irqsave(&trig->pollfunc_list_lock, flags);
 	list_for_each_entry(pf_cursor, &trig->pollfunc_list, list)
 		if (pf_cursor == pf) {
 			ret = 0;
 			break;
 		}
 	if (!ret) {
 		if (list_is_singular(&trig->pollfunc_list)
 		    && trig->set_trigger_state) {
 			spin_unlock_irqrestore(&trig->pollfunc_list_lock,
 					       flags);
 			/* May sleep hence cannot hold the spin lock */
 			ret = trig->set_trigger_state(trig, false);
 			if (ret)
 				goto error_ret;
 			spin_lock_irqsave(&trig->pollfunc_list_lock, flags);
 		}
 		/*
 		 * Now we can delete safe in the knowledge that, if this is
 		 * the last pollfunc then we have disabled the trigger anyway
 		 * and so nothing should be able to call the pollfunc.
 		 */
 		list_del(&pf_cursor->list);
 	}
 	spin_unlock_irqrestore(&trig->pollfunc_list_lock, flags);

 error_ret:
 	return ret;
 }
 EXPORT_SYMBOL(iio_trigger_dettach_poll_func);

 /**
  * iio_trigger_read_currrent() trigger consumer sysfs query which trigger
  *
  * For trigger consumers the current_trigger interface allows the trigger
  * used by the device to be queried.
  **/
 static ssize_t iio_trigger_read_current(struct device *dev,
 					struct device_attribute *attr,
 					char *buf)
 {
 	struct iio_dev *dev_info = dev_get_drvdata(dev);
 	int len = 0;
 	if (dev_info->trig)
 		len = snprintf(buf,
 			       IIO_TRIGGER_NAME_LENGTH,
 			       "%s\n",
 			       dev_info->trig->name);
 	return len;
 }

 /**
  * iio_trigger_write_current() trigger consumer sysfs set current trigger
  *
  * For trigger consumers the current_trigger interface allows the trigger
  * used for this device to be specified at run time based on the triggers
  * name.
  **/
 static ssize_t iio_trigger_write_current(struct device *dev,
 					 struct device_attribute *attr,
 					 const char *buf,
 					 size_t len)
 {
 	struct iio_dev *dev_info = dev_get_drvdata(dev);
 	struct iio_trigger *oldtrig = dev_info->trig;
 	mutex_lock(&dev_info->mlock);
 	if (dev_info->currentmode == INDIO_RING_TRIGGERED) {
 		mutex_unlock(&dev_info->mlock);
 		return -EBUSY;
 	}
 	mutex_unlock(&dev_info->mlock);

 	len = len < IIO_TRIGGER_NAME_LENGTH ? len : IIO_TRIGGER_NAME_LENGTH;

 	dev_info->trig = iio_trigger_find_by_name(buf, len);
 	if (oldtrig && dev_info->trig != oldtrig)
 		iio_put_trigger(oldtrig);
 	if (dev_info->trig)
 		iio_get_trigger(dev_info->trig);

 	return len;
 }

 static DEVICE_ATTR(current_trigger, S_IRUGO | S_IWUSR,
 		   iio_trigger_read_current,
 		   iio_trigger_write_current);

 static struct attribute *iio_trigger_consumer_attrs[] = {
 	&dev_attr_current_trigger.attr,
 	NULL,
 };

 static const struct attribute_group iio_trigger_consumer_attr_group = {
 	.name = "trigger",
 	.attrs = iio_trigger_consumer_attrs,
 };

 static void iio_trig_release(struct device *device)
 {
 	struct iio_trigger *trig = to_iio_trigger(device);
 	kfree(trig);
 	iio_put();
 }

 static struct device_type iio_trig_type = {
 	.release = iio_trig_release,
 };

 struct iio_trigger *iio_allocate_trigger(void)
 {
 	struct iio_trigger *trig;
 	trig = kzalloc(sizeof *trig, GFP_KERNEL);
 	if (trig) {
 		trig->dev.type = &iio_trig_type;
 		trig->dev.bus = &iio_bus_type;
 		device_initialize(&trig->dev);
 		dev_set_drvdata(&trig->dev, (void *)trig);
 		spin_lock_init(&trig->pollfunc_list_lock);
 		INIT_LIST_HEAD(&trig->list);
 		INIT_LIST_HEAD(&trig->pollfunc_list);
 		iio_get();
 	}
 	return trig;
 }
 EXPORT_SYMBOL(iio_allocate_trigger);

 void iio_free_trigger(struct iio_trigger *trig)
 {
 	if (trig)
 		put_device(&trig->dev);
 }
 EXPORT_SYMBOL(iio_free_trigger);

 int iio_device_register_trigger_consumer(struct iio_dev *dev_info)
 {
 	int ret;
 	ret = sysfs_create_group(&dev_info->dev.kobj,
 				 &iio_trigger_consumer_attr_group);
 	return ret;
 }
 EXPORT_SYMBOL(iio_device_register_trigger_consumer);

 int iio_device_unregister_trigger_consumer(struct iio_dev *dev_info)
 {
 	sysfs_remove_group(&dev_info->dev.kobj,
 			   &iio_trigger_consumer_attr_group);
 	return 0;
 }
 EXPORT_SYMBOL(iio_device_unregister_trigger_consumer);
	/* The industrial I/O core, trigger handling functions
	*
	* Copyright (c) 2008 Jonathan Cameron
	*
	* 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/kernel.h>
	#include <linux/module.h>
	#include <linux/idr.h>
	#include <linux/err.h>
	#include <linux/device.h>
	#include <linux/interrupt.h>
	#include <linux/list.h>
	#include <linux/slab.h>

	#include "iio.h"
	#include "trigger.h"
	#include "trigger_consumer.h"

	/* RFC - Question of approach
	* Make the common case (single sensor single trigger)
	* simple by starting trigger capture from when first sensors
	* is added.
	*
	* Complex simultaneous start requires use of 'hold' functionality
	* of the trigger. (not implemented)
	*
	* Any other suggestions?
	*/


	static DEFINE_IDR(iio_trigger_idr);
	static DEFINE_SPINLOCK(iio_trigger_idr_lock);

	/* Single list of all available triggers */
	static LIST_HEAD(iio_trigger_list);
	static DEFINE_MUTEX(iio_trigger_list_lock);

	/**
	* iio_trigger_register_sysfs() - create a device for this trigger
	* @trig_info: the trigger
	*
	* Also adds any control attribute registered by the trigger driver
	**/
	static int iio_trigger_register_sysfs(struct iio_trigger *trig_info)
	{
	int ret = 0;

	if (trig_info->control_attrs)
	ret = sysfs_create_group(&trig_info->dev.kobj,
	trig_info->control_attrs);

	return ret;
	}

	static void iio_trigger_unregister_sysfs(struct iio_trigger *trig_info)
	{
	if (trig_info->control_attrs)
	sysfs_remove_group(&trig_info->dev.kobj,
	trig_info->control_attrs);
	}


	/**
	* iio_trigger_register_id() - get a unique id for this trigger
	* @trig_info: the trigger
	**/
	static int iio_trigger_register_id(struct iio_trigger *trig_info)
	{
	int ret = 0;

	idr_again:
	if (unlikely(idr_pre_get(&iio_trigger_idr, GFP_KERNEL) == 0))
	return -ENOMEM;

	spin_lock(&iio_trigger_idr_lock);
	ret = idr_get_new(&iio_trigger_idr, NULL, &trig_info->id);
	spin_unlock(&iio_trigger_idr_lock);
	if (unlikely(ret == -EAGAIN))
	goto idr_again;
	else if (likely(!ret))
	trig_info->id = trig_info->id & MAX_ID_MASK;

	return ret;
	}

	/**
	* iio_trigger_unregister_id() - free up unique id for use by another trigger
	* @trig_info: the trigger
	**/
	static void iio_trigger_unregister_id(struct iio_trigger *trig_info)
	{
	spin_lock(&iio_trigger_idr_lock);
	idr_remove(&iio_trigger_idr, trig_info->id);
	spin_unlock(&iio_trigger_idr_lock);
	}

	int iio_trigger_register(struct iio_trigger *trig_info)
	{
	int ret;

	ret = iio_trigger_register_id(trig_info);
	if (ret)
	goto error_ret;
	/* Set the name used for the sysfs directory etc */
	dev_set_name(&trig_info->dev, "trigger%ld",
	(unsigned long) trig_info->id);

	ret = device_add(&trig_info->dev);
	if (ret)
	goto error_unregister_id;

	ret = iio_trigger_register_sysfs(trig_info);
	if (ret)
	goto error_device_del;

	/* Add to list of available triggers held by the IIO core */
	mutex_lock(&iio_trigger_list_lock);
	list_add_tail(&trig_info->list, &iio_trigger_list);
	mutex_unlock(&iio_trigger_list_lock);

	return 0;

	error_device_del:
	device_del(&trig_info->dev);
	error_unregister_id:
	iio_trigger_unregister_id(trig_info);
	error_ret:
	return ret;
	}
	EXPORT_SYMBOL(iio_trigger_register);

	void iio_trigger_unregister(struct iio_trigger *trig_info)
	{
	struct iio_trigger *cursor;

	mutex_lock(&iio_trigger_list_lock);
	list_for_each_entry(cursor, &iio_trigger_list, list)
	if (cursor == trig_info) {
	list_del(&cursor->list);
	break;
	}
	mutex_unlock(&iio_trigger_list_lock);

	iio_trigger_unregister_sysfs(trig_info);
	iio_trigger_unregister_id(trig_info);
	/* Possible issue in here */
	device_unregister(&trig_info->dev);
	}
	EXPORT_SYMBOL(iio_trigger_unregister);

	struct iio_trigger iio_trigger_find_by_name(const char name, size_t len)
	{
	struct iio_trigger *trig;
	bool found = false;

	if (len && name[len - 1] == '\n')
	len--;

	mutex_lock(&iio_trigger_list_lock);
	list_for_each_entry(trig, &iio_trigger_list, list) {
	if (strncmp(trig->name, name, len) == 0) {
	found = true;
	break;
	}
	}
	mutex_unlock(&iio_trigger_list_lock);

	return found ? trig : NULL;
	}
	EXPORT_SYMBOL(iio_trigger_find_by_name);

	void iio_trigger_poll(struct iio_trigger *trig)
	{
	struct iio_poll_func *pf_cursor;

	list_for_each_entry(pf_cursor, &trig->pollfunc_list, list) {
	if (pf_cursor->poll_func_immediate) {
	pf_cursor->poll_func_immediate(pf_cursor->private_data);
	trig->use_count++;
	}
	}
	list_for_each_entry(pf_cursor, &trig->pollfunc_list, list) {
	if (pf_cursor->poll_func_main) {
	pf_cursor->poll_func_main(pf_cursor->private_data);
	trig->use_count++;
	}
	}
	}
	EXPORT_SYMBOL(iio_trigger_poll);

	void iio_trigger_notify_done(struct iio_trigger *trig)
	{
	trig->use_count--;
	if (trig->use_count == 0 && trig->try_reenable)
	if (trig->try_reenable(trig)) {
	/* Missed and interrupt so launch new poll now */
	trig->timestamp = 0;
	iio_trigger_poll(trig);
	}
	}
	EXPORT_SYMBOL(iio_trigger_notify_done);

	/**
	* iio_trigger_read_name() - retrieve useful identifying name
	**/
	ssize_t iio_trigger_read_name(struct device *dev,
	struct device_attribute *attr,
	char *buf)
	{
	struct iio_trigger *trig = dev_get_drvdata(dev);
	return sprintf(buf, "%s\n", trig->name);
	}
	EXPORT_SYMBOL(iio_trigger_read_name);

	/* Trigger Consumer related functions */

	/* Complexity in here. With certain triggers (datardy) an acknowledgement
	* may be needed if the pollfuncs do not include the data read for the
	* triggering device.
	* This is not currently handled. Alternative of not enabling trigger unless
	* the relevant function is in there may be the best option.
	*/
	/* Worth protecting against double additions?*/
	int iio_trigger_attach_poll_func(struct iio_trigger *trig,
	struct iio_poll_func *pf)
	{
	int ret = 0;
	unsigned long flags;

	spin_lock_irqsave(&trig->pollfunc_list_lock, flags);
	list_add_tail(&pf->list, &trig->pollfunc_list);
	spin_unlock_irqrestore(&trig->pollfunc_list_lock, flags);

	if (trig->set_trigger_state)
	ret = trig->set_trigger_state(trig, true);
	if (ret) {
	printk(KERN_ERR "set trigger state failed\n");
	list_del(&pf->list);
	}
	return ret;
	}
	EXPORT_SYMBOL(iio_trigger_attach_poll_func);

	int iio_trigger_dettach_poll_func(struct iio_trigger *trig,
	struct iio_poll_func *pf)
	{
	struct iio_poll_func *pf_cursor;
	unsigned long flags;
	int ret = -EINVAL;

	spin_lock_irqsave(&trig->pollfunc_list_lock, flags);
	list_for_each_entry(pf_cursor, &trig->pollfunc_list, list)
	if (pf_cursor == pf) {
	ret = 0;
	break;
	}
	if (!ret) {
	if (list_is_singular(&trig->pollfunc_list)
	&& trig->set_trigger_state) {
	spin_unlock_irqrestore(&trig->pollfunc_list_lock,
	flags);
	/* May sleep hence cannot hold the spin lock */
	ret = trig->set_trigger_state(trig, false);
	if (ret)
	goto error_ret;
	spin_lock_irqsave(&trig->pollfunc_list_lock, flags);
	}
	/*
	* Now we can delete safe in the knowledge that, if this is
	* the last pollfunc then we have disabled the trigger anyway
	* and so nothing should be able to call the pollfunc.
	*/
	list_del(&pf_cursor->list);
	}
	spin_unlock_irqrestore(&trig->pollfunc_list_lock, flags);

	error_ret:
	return ret;
	}
	EXPORT_SYMBOL(iio_trigger_dettach_poll_func);

	/**
	* iio_trigger_read_currrent() trigger consumer sysfs query which trigger
	*
	* For trigger consumers the current_trigger interface allows the trigger
	* used by the device to be queried.
	**/
	static ssize_t iio_trigger_read_current(struct device *dev,
	struct device_attribute *attr,
	char *buf)
	{
	struct iio_dev *dev_info = dev_get_drvdata(dev);
	int len = 0;
	if (dev_info->trig)
	len = snprintf(buf,
	IIO_TRIGGER_NAME_LENGTH,
	"%s\n",
	dev_info->trig->name);
	return len;
	}

	/**
	* iio_trigger_write_current() trigger consumer sysfs set current trigger
	*
	* For trigger consumers the current_trigger interface allows the trigger
	* used for this device to be specified at run time based on the triggers
	* name.
	**/
	static ssize_t iio_trigger_write_current(struct device *dev,
	struct device_attribute *attr,
	const char *buf,
	size_t len)
	{
	struct iio_dev *dev_info = dev_get_drvdata(dev);
	struct iio_trigger *oldtrig = dev_info->trig;
	mutex_lock(&dev_info->mlock);
	if (dev_info->currentmode == INDIO_RING_TRIGGERED) {
	mutex_unlock(&dev_info->mlock);
	return -EBUSY;
	}
	mutex_unlock(&dev_info->mlock);

	len = len < IIO_TRIGGER_NAME_LENGTH ? len : IIO_TRIGGER_NAME_LENGTH;

	dev_info->trig = iio_trigger_find_by_name(buf, len);
	if (oldtrig && dev_info->trig != oldtrig)
	iio_put_trigger(oldtrig);
	if (dev_info->trig)
	iio_get_trigger(dev_info->trig);

	return len;
	}

	static DEVICE_ATTR(current_trigger, S_IRUGO \| S_IWUSR,
	iio_trigger_read_current,
	iio_trigger_write_current);

	static struct attribute *iio_trigger_consumer_attrs[] = {
	&dev_attr_current_trigger.attr,
	NULL,
	};

	static const struct attribute_group iio_trigger_consumer_attr_group = {
	.name = "trigger",
	.attrs = iio_trigger_consumer_attrs,
	};

	static void iio_trig_release(struct device *device)
	{
	struct iio_trigger *trig = to_iio_trigger(device);
	kfree(trig);
	iio_put();
	}

	static struct device_type iio_trig_type = {
	.release = iio_trig_release,
	};

	struct iio_trigger *iio_allocate_trigger(void)
	{
	struct iio_trigger *trig;
	trig = kzalloc(sizeof *trig, GFP_KERNEL);
	if (trig) {
	trig->dev.type = &iio_trig_type;
	trig->dev.bus = &iio_bus_type;
	device_initialize(&trig->dev);
	dev_set_drvdata(&trig->dev, (void *)trig);
	spin_lock_init(&trig->pollfunc_list_lock);
	INIT_LIST_HEAD(&trig->list);
	INIT_LIST_HEAD(&trig->pollfunc_list);
	iio_get();
	}
	return trig;
	}
	EXPORT_SYMBOL(iio_allocate_trigger);

	void iio_free_trigger(struct iio_trigger *trig)
	{
	if (trig)
	put_device(&trig->dev);
	}
	EXPORT_SYMBOL(iio_free_trigger);

	int iio_device_register_trigger_consumer(struct iio_dev *dev_info)
	{
	int ret;
	ret = sysfs_create_group(&dev_info->dev.kobj,
	&iio_trigger_consumer_attr_group);
	return ret;
	}
	EXPORT_SYMBOL(iio_device_register_trigger_consumer);

	int iio_device_unregister_trigger_consumer(struct iio_dev *dev_info)
	{
	sysfs_remove_group(&dev_info->dev.kobj,
	&iio_trigger_consumer_attr_group);
	return 0;
	}
	EXPORT_SYMBOL(iio_device_unregister_trigger_consumer);