GNU Linux-libre 4.9.282-gnu1
[releases.git] / drivers / iio / trigger / iio-trig-sysfs.c
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_free(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");