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>
12 #include <linux/list.h>
13 #include <linux/irq_work.h>
14 
15 #include <linux/iio/iio.h>
16 #include <linux/iio/trigger.h>
17 
18 struct iio_sysfs_trig {
19 	struct iio_trigger *trig;
20 	struct irq_work work;
21 	int id;
22 	struct list_head l;
23 };
24 
25 static LIST_HEAD(iio_sysfs_trig_list);
26 static DEFINE_MUTEX(iio_sysfs_trig_list_mut);
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 
37 	ret = kstrtoul(buf, 10, &input);
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 
56 	ret = kstrtoul(buf, 10, &input);
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 
82 
83 /* Nothing to actually do upon release */
84 static void iio_trigger_sysfs_release(struct device *dev)
85 {
86 }
87 
88 static struct device iio_sysfs_trig_dev = {
89 	.bus = &iio_bus_type,
90 	.groups = iio_sysfs_trig_groups,
91 	.release = &iio_trigger_sysfs_release,
92 };
93 
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);
100 }
101 
102 static ssize_t iio_sysfs_trigger_poll(struct device *dev,
103 		struct device_attribute *attr, const char *buf, size_t count)
104 {
105 	struct iio_trigger *trig = to_iio_trigger(dev);
106 	struct iio_sysfs_trig *sysfs_trig = iio_trigger_get_drvdata(trig);
107 
108 	irq_work_queue(&sysfs_trig->work);
109 
110 	return count;
111 }
112 
113 static DEVICE_ATTR(trigger_now, S_IWUSR, NULL, iio_sysfs_trigger_poll);
114 
115 static struct attribute *iio_sysfs_trigger_attrs[] = {
116 	&dev_attr_trigger_now.attr,
117 	NULL,
118 };
119 
120 static const struct attribute_group iio_sysfs_trigger_attr_group = {
121 	.attrs = iio_sysfs_trigger_attrs,
122 };
123 
124 static const struct attribute_group *iio_sysfs_trigger_attr_groups[] = {
125 	&iio_sysfs_trigger_attr_group,
126 	NULL
127 };
128 
129 static const struct iio_trigger_ops iio_sysfs_trigger_ops = {
130 	.owner = THIS_MODULE,
131 };
132 
133 static int iio_sysfs_trigger_probe(int id)
134 {
135 	struct iio_sysfs_trig *t;
136 	int ret;
137 	bool foundit = false;
138 
139 	mutex_lock(&iio_sysfs_trig_list_mut);
140 	list_for_each_entry(t, &iio_sysfs_trig_list, l)
141 		if (id == t->id) {
142 			foundit = true;
143 			break;
144 		}
145 	if (foundit) {
146 		ret = -EINVAL;
147 		goto out1;
148 	}
149 	t = kmalloc(sizeof(*t), GFP_KERNEL);
150 	if (t == NULL) {
151 		ret = -ENOMEM;
152 		goto out1;
153 	}
154 	t->id = id;
155 	t->trig = iio_trigger_alloc("sysfstrig%d", id);
156 	if (!t->trig) {
157 		ret = -ENOMEM;
158 		goto free_t;
159 	}
160 
161 	t->trig->dev.groups = iio_sysfs_trigger_attr_groups;
162 	t->trig->ops = &iio_sysfs_trigger_ops;
163 	t->trig->dev.parent = &iio_sysfs_trig_dev;
164 	iio_trigger_set_drvdata(t->trig, t);
165 
166 	init_irq_work(&t->work, iio_sysfs_trigger_work);
167 
168 	ret = iio_trigger_register(t->trig);
169 	if (ret)
170 		goto out2;
171 	list_add(&t->l, &iio_sysfs_trig_list);
172 	__module_get(THIS_MODULE);
173 	mutex_unlock(&iio_sysfs_trig_list_mut);
174 	return 0;
175 
176 out2:
177 	iio_trigger_put(t->trig);
178 free_t:
179 	kfree(t);
180 out1:
181 	mutex_unlock(&iio_sysfs_trig_list_mut);
182 	return ret;
183 }
184 
185 static int iio_sysfs_trigger_remove(int id)
186 {
187 	bool foundit = false;
188 	struct iio_sysfs_trig *t;
189 
190 	mutex_lock(&iio_sysfs_trig_list_mut);
191 	list_for_each_entry(t, &iio_sysfs_trig_list, l)
192 		if (id == t->id) {
193 			foundit = true;
194 			break;
195 		}
196 	if (!foundit) {
197 		mutex_unlock(&iio_sysfs_trig_list_mut);
198 		return -EINVAL;
199 	}
200 
201 	iio_trigger_unregister(t->trig);
202 	iio_trigger_free(t->trig);
203 
204 	list_del(&t->l);
205 	kfree(t);
206 	module_put(THIS_MODULE);
207 	mutex_unlock(&iio_sysfs_trig_list_mut);
208 	return 0;
209 }
210 
211 
212 static int __init iio_sysfs_trig_init(void)
213 {
214 	device_initialize(&iio_sysfs_trig_dev);
215 	dev_set_name(&iio_sysfs_trig_dev, "iio_sysfs_trigger");
216 	return device_add(&iio_sysfs_trig_dev);
217 }
218 module_init(iio_sysfs_trig_init);
219 
220 static void __exit iio_sysfs_trig_exit(void)
221 {
222 	device_unregister(&iio_sysfs_trig_dev);
223 }
224 module_exit(iio_sysfs_trig_exit);
225 
226 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
227 MODULE_DESCRIPTION("Sysfs based trigger for the iio subsystem");
228 MODULE_LICENSE("GPL v2");
229 MODULE_ALIAS("platform:iio-trig-sysfs");
230