[deliverable/linux.git] / drivers / iio / trigger / iio-trig-sysfs.c

/*
 * Copyright 2011 Analog Devices Inc.
 *
 * Licensed under the GPL-2.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/irq_work.h>

#include <linux/iio/iio.h>
#include <linux/iio/trigger.h>

struct iio_sysfs_trig {
	struct iio_trigger *trig;
	struct irq_work work;
	int id;
	struct list_head l;
};

static LIST_HEAD(iio_sysfs_trig_list);
static DEFINE_MUTEX(iio_sysfs_trig_list_mut);

static int iio_sysfs_trigger_probe(int id);
static ssize_t iio_sysfs_trig_add(struct device *dev,
				  struct device_attribute *attr,
				  const char *buf,
				  size_t len)
{
	int ret;
	unsigned long input;

	ret = kstrtoul(buf, 10, &input);
	if (ret)
		return ret;
	ret = iio_sysfs_trigger_probe(input);
	if (ret)
		return ret;
	return len;
}
static DEVICE_ATTR(add_trigger, S_IWUSR, NULL, &iio_sysfs_trig_add);

static int iio_sysfs_trigger_remove(int id);
static ssize_t iio_sysfs_trig_remove(struct device *dev,
				     struct device_attribute *attr,
				     const char *buf,
				     size_t len)
{
	int ret;
	unsigned long input;

	ret = kstrtoul(buf, 10, &input);
	if (ret)
		return ret;
	ret = iio_sysfs_trigger_remove(input);
	if (ret)
		return ret;
	return len;
}

static DEVICE_ATTR(remove_trigger, S_IWUSR, NULL, &iio_sysfs_trig_remove);

static struct attribute *iio_sysfs_trig_attrs[] = {
	&dev_attr_add_trigger.attr,
	&dev_attr_remove_trigger.attr,
	NULL,
};

static const struct attribute_group iio_sysfs_trig_group = {
	.attrs = iio_sysfs_trig_attrs,
};

static const struct attribute_group *iio_sysfs_trig_groups[] = {
	&iio_sysfs_trig_group,
	NULL
};


/* Nothing to actually do upon release */
static void iio_trigger_sysfs_release(struct device *dev)
{
}

static struct device iio_sysfs_trig_dev = {
	.bus = &iio_bus_type,
	.groups = iio_sysfs_trig_groups,
	.release = &iio_trigger_sysfs_release,
};

static void iio_sysfs_trigger_work(struct irq_work *work)
{
	struct iio_sysfs_trig *trig = container_of(work, struct iio_sysfs_trig,
							work);

	iio_trigger_poll(trig->trig, 0);
}

static ssize_t iio_sysfs_trigger_poll(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct iio_trigger *trig = to_iio_trigger(dev);
	struct iio_sysfs_trig *sysfs_trig = iio_trigger_get_drvdata(trig);

	irq_work_queue(&sysfs_trig->work);

	return count;
}

static DEVICE_ATTR(trigger_now, S_IWUSR, NULL, iio_sysfs_trigger_poll);

static struct attribute *iio_sysfs_trigger_attrs[] = {
	&dev_attr_trigger_now.attr,
	NULL,
};

static const struct attribute_group iio_sysfs_trigger_attr_group = {
	.attrs = iio_sysfs_trigger_attrs,
};

static const struct attribute_group *iio_sysfs_trigger_attr_groups[] = {
	&iio_sysfs_trigger_attr_group,
	NULL
};

static const struct iio_trigger_ops iio_sysfs_trigger_ops = {
	.owner = THIS_MODULE,
};

static int iio_sysfs_trigger_probe(int id)
{
	struct iio_sysfs_trig *t;
	int ret;
	bool foundit = false;
	mutex_lock(&iio_sysfs_trig_list_mut);
	list_for_each_entry(t, &iio_sysfs_trig_list, l)
		if (id == t->id) {
			foundit = true;
			break;
		}
	if (foundit) {
		ret = -EINVAL;
		goto out1;
	}
	t = kmalloc(sizeof(*t), GFP_KERNEL);
	if (t == NULL) {
		ret = -ENOMEM;
		goto out1;
	}
	t->id = id;
	t->trig = iio_trigger_alloc("sysfstrig%d", id);
	if (!t->trig) {
		ret = -ENOMEM;
		goto free_t;
	}

	t->trig->dev.groups = iio_sysfs_trigger_attr_groups;
	t->trig->ops = &iio_sysfs_trigger_ops;
	t->trig->dev.parent = &iio_sysfs_trig_dev;
	iio_trigger_set_drvdata(t->trig, t);

	init_irq_work(&t->work, iio_sysfs_trigger_work);

	ret = iio_trigger_register(t->trig);
	if (ret)
		goto out2;
	list_add(&t->l, &iio_sysfs_trig_list);
	__module_get(THIS_MODULE);
	mutex_unlock(&iio_sysfs_trig_list_mut);
	return 0;

out2:
	iio_trigger_put(t->trig);
free_t:
	kfree(t);
out1:
	mutex_unlock(&iio_sysfs_trig_list_mut);
	return ret;
}

static int iio_sysfs_trigger_remove(int id)
{
	bool foundit = false;
	struct iio_sysfs_trig *t;
	mutex_lock(&iio_sysfs_trig_list_mut);
	list_for_each_entry(t, &iio_sysfs_trig_list, l)
		if (id == t->id) {
			foundit = true;
			break;
		}
	if (!foundit) {
		mutex_unlock(&iio_sysfs_trig_list_mut);
		return -EINVAL;
	}

	iio_trigger_unregister(t->trig);
	iio_trigger_free(t->trig);

	list_del(&t->l);
	kfree(t);
	module_put(THIS_MODULE);
	mutex_unlock(&iio_sysfs_trig_list_mut);
	return 0;
}


static int __init iio_sysfs_trig_init(void)
{
	device_initialize(&iio_sysfs_trig_dev);
	dev_set_name(&iio_sysfs_trig_dev, "iio_sysfs_trigger");
	return device_add(&iio_sysfs_trig_dev);
}
module_init(iio_sysfs_trig_init);

static void __exit iio_sysfs_trig_exit(void)
{
	device_unregister(&iio_sysfs_trig_dev);
}
module_exit(iio_sysfs_trig_exit);

MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
MODULE_DESCRIPTION("Sysfs based trigger for the iio subsystem");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:iio-trig-sysfs");
Commit	Line	Data
f9a7e9b2 MH	1	/*
	2	* Copyright 2011 Analog Devices Inc.
	3	*
	4	* Licensed under the GPL-2.
	5	*
	6	*/
	7
	8	#include <linux/kernel.h>
	9	#include <linux/module.h>
	10	#include <linux/platform_device.h>
	11	#include <linux/slab.h>
1f785681	12	#include <linux/list.h>
f38bc926	13	#include <linux/irq_work.h>
f9a7e9b2	14
06458e27 JC	15	#include <linux/iio/iio.h>
06458e27 JC	16	#include <linux/iio/trigger.h>
f9a7e9b2	17
1f785681 JC	18	struct iio_sysfs_trig {
1f785681 JC	19	struct iio_trigger *trig;
f38bc926	20	struct irq_work work;
1f785681 JC	21	int id;
	22	struct list_head l;
	23	};
	24
	25	static LIST_HEAD(iio_sysfs_trig_list);
10a485c5	26	static DEFINE_MUTEX(iio_sysfs_trig_list_mut);
1f785681 JC	27
	28	static int iio_sysfs_trigger_probe(int id);
	29	static ssize_t iio_sysfs_trig_add(struct device *dev,
	30	struct device_attribute *attr,
	31	const char *buf,
	32	size_t len)
	33	{
	34	int ret;
	35	unsigned long input;
	36
ddeb64f3	37	ret = kstrtoul(buf, 10, &input);
1f785681 JC	38	if (ret)
	39	return ret;
	40	ret = iio_sysfs_trigger_probe(input);
	41	if (ret)
	42	return ret;
	43	return len;
	44	}
	45	static DEVICE_ATTR(add_trigger, S_IWUSR, NULL, &iio_sysfs_trig_add);
	46
	47	static int iio_sysfs_trigger_remove(int id);
	48	static ssize_t iio_sysfs_trig_remove(struct device *dev,
	49	struct device_attribute *attr,
	50	const char *buf,
	51	size_t len)
	52	{
	53	int ret;
	54	unsigned long input;
	55
ddeb64f3	56	ret = kstrtoul(buf, 10, &input);
1f785681 JC	57	if (ret)
	58	return ret;
	59	ret = iio_sysfs_trigger_remove(input);
	60	if (ret)
	61	return ret;
	62	return len;
	63	}
	64
	65	static DEVICE_ATTR(remove_trigger, S_IWUSR, NULL, &iio_sysfs_trig_remove);
	66
	67	static struct attribute *iio_sysfs_trig_attrs[] = {
	68	&dev_attr_add_trigger.attr,
	69	&dev_attr_remove_trigger.attr,
	70	NULL,
	71	};
	72
	73	static const struct attribute_group iio_sysfs_trig_group = {
	74	.attrs = iio_sysfs_trig_attrs,
	75	};
	76
	77	static const struct attribute_group *iio_sysfs_trig_groups[] = {
	78	&iio_sysfs_trig_group,
	79	NULL
	80	};
	81
9c0c22bd JC	82
	83	/* Nothing to actually do upon release */
	84	static void iio_trigger_sysfs_release(struct device *dev)
	85	{
	86	}
	87
1f785681 JC	88	static struct device iio_sysfs_trig_dev = {
	89	.bus = &iio_bus_type,
	90	.groups = iio_sysfs_trig_groups,
9c0c22bd	91	.release = &iio_trigger_sysfs_release,
1f785681 JC	92	};
1f785681 JC	93
f38bc926 LPC	94	static void iio_sysfs_trigger_work(struct irq_work *work)
	95	{
	96	struct iio_sysfs_trig *trig = container_of(work, struct iio_sysfs_trig,
	97	work);
	98
	99	iio_trigger_poll(trig->trig, 0);
	100	}
	101
f9a7e9b2 MH	102	static ssize_t iio_sysfs_trigger_poll(struct device *dev,
	103	struct device_attribute attr, const char buf, size_t count)
	104	{
4bf81727	105	struct iio_trigger *trig = to_iio_trigger(dev);
1e9663c6	106	struct iio_sysfs_trig *sysfs_trig = iio_trigger_get_drvdata(trig);
f38bc926 LPC	107
f38bc926 LPC	108	irq_work_queue(&sysfs_trig->work);
f9a7e9b2 MH	109
	110	return count;
	111	}
	112
	113	static DEVICE_ATTR(trigger_now, S_IWUSR, NULL, iio_sysfs_trigger_poll);
f9a7e9b2 MH	114
	115	static struct attribute *iio_sysfs_trigger_attrs[] = {
	116	&dev_attr_trigger_now.attr,
f9a7e9b2 MH	117	NULL,
	118	};
	119
	120	static const struct attribute_group iio_sysfs_trigger_attr_group = {
	121	.attrs = iio_sysfs_trigger_attrs,
	122	};
	123
59c85e82 JC	124	static const struct attribute_group *iio_sysfs_trigger_attr_groups[] = {
	125	&iio_sysfs_trigger_attr_group,
	126	NULL
	127	};
	128
d29f73db JC	129	static const struct iio_trigger_ops iio_sysfs_trigger_ops = {
	130	.owner = THIS_MODULE,
	131	};
	132
1f785681	133	static int iio_sysfs_trigger_probe(int id)
f9a7e9b2	134	{
1f785681	135	struct iio_sysfs_trig *t;
f9a7e9b2	136	int ret;
1f785681	137	bool foundit = false;
10a485c5	138	mutex_lock(&iio_sysfs_trig_list_mut);
1f785681 JC	139	list_for_each_entry(t, &iio_sysfs_trig_list, l)
	140	if (id == t->id) {
	141	foundit = true;
	142	break;
	143	}
	144	if (foundit) {
	145	ret = -EINVAL;
	146	goto out1;
	147	}
1f785681 JC	148	t = kmalloc(sizeof(*t), GFP_KERNEL);
1f785681 JC	149	if (t == NULL) {
f9a7e9b2	150	ret = -ENOMEM;
59c85e82	151	goto out1;
1f785681 JC	152	}
1f785681 JC	153	t->id = id;
7cbb7537	154	t->trig = iio_trigger_alloc("sysfstrig%d", id);
1f785681 JC	155	if (!t->trig) {
	156	ret = -ENOMEM;
	157	goto free_t;
f9a7e9b2 MH	158	}
f9a7e9b2 MH	159
59c85e82	160	t->trig->dev.groups = iio_sysfs_trigger_attr_groups;
d29f73db	161	t->trig->ops = &iio_sysfs_trigger_ops;
1f785681	162	t->trig->dev.parent = &iio_sysfs_trig_dev;
1e9663c6	163	iio_trigger_set_drvdata(t->trig, t);
f38bc926 LPC	164
f38bc926 LPC	165	init_irq_work(&t->work, iio_sysfs_trigger_work);
f9a7e9b2	166
1f785681 JC	167	ret = iio_trigger_register(t->trig);
	168	if (ret)
	169	goto out2;
	170	list_add(&t->l, &iio_sysfs_trig_list);
	171	__module_get(THIS_MODULE);
10a485c5	172	mutex_unlock(&iio_sysfs_trig_list_mut);
f9a7e9b2	173	return 0;
1f785681	174
f9a7e9b2	175	out2:
7cbb7537	176	iio_trigger_put(t->trig);
1f785681 JC	177	free_t:
1f785681 JC	178	kfree(t);
f9a7e9b2	179	out1:
10a485c5	180	mutex_unlock(&iio_sysfs_trig_list_mut);
f9a7e9b2 MH	181	return ret;
	182	}
	183
1f785681	184	static int iio_sysfs_trigger_remove(int id)
f9a7e9b2	185	{
1f785681 JC	186	bool foundit = false;
1f785681 JC	187	struct iio_sysfs_trig *t;
10a485c5	188	mutex_lock(&iio_sysfs_trig_list_mut);
1f785681 JC	189	list_for_each_entry(t, &iio_sysfs_trig_list, l)
	190	if (id == t->id) {
	191	foundit = true;
	192	break;
	193	}
	194	if (!foundit) {
10a485c5	195	mutex_unlock(&iio_sysfs_trig_list_mut);
1f785681 JC	196	return -EINVAL;
1f785681 JC	197	}
f9a7e9b2	198
1f785681	199	iio_trigger_unregister(t->trig);
7cbb7537	200	iio_trigger_free(t->trig);
f9a7e9b2	201
1f785681 JC	202	list_del(&t->l);
	203	kfree(t);
	204	module_put(THIS_MODULE);
10a485c5	205	mutex_unlock(&iio_sysfs_trig_list_mut);
f9a7e9b2 MH	206	return 0;
	207	}
	208
f9a7e9b2 MH	209
	210	static int __init iio_sysfs_trig_init(void)
	211	{
1f785681 JC	212	device_initialize(&iio_sysfs_trig_dev);
	213	dev_set_name(&iio_sysfs_trig_dev, "iio_sysfs_trigger");
	214	return device_add(&iio_sysfs_trig_dev);
f9a7e9b2 MH	215	}
	216	module_init(iio_sysfs_trig_init);
	217
	218	static void __exit iio_sysfs_trig_exit(void)
	219	{
1f785681	220	device_unregister(&iio_sysfs_trig_dev);
f9a7e9b2 MH	221	}
	222	module_exit(iio_sysfs_trig_exit);
	223
	224	MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
	225	MODULE_DESCRIPTION("Sysfs based trigger for the iio subsystem");
	226	MODULE_LICENSE("GPL v2");
	227	MODULE_ALIAS("platform:iio-trig-sysfs");