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