drivers/iio/trigger/iio-trig-sysfs.c

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