drivers/staging/iio/trigger/iio-trig-gpio.c

   1 /*
   2  * Industrial I/O - gpio based trigger support
   3  *
   4  * Copyright (c) 2008 Jonathan Cameron
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  *
  10  * Currently this is more of a functioning proof of concept that a fully
  11  * fledged trigger driver.
  12  *
  13  * TODO:
  14  *
  15  * Add board config elements to allow specification of startup settings.
  16  * Add configuration settings (irq type etc)
  17  */
  18
  19 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/gpio.h>
  24
  25 #include "../iio.h"
  26 #include "../trigger.h"
  27
  28 LIST_HEAD(iio_gpio_trigger_list);
  29 DEFINE_MUTEX(iio_gpio_trigger_list_lock);
  30
  31 struct iio_gpio_trigger_info {
  32         struct mutex in_use;
  33         int gpio;
  34 };
  35 /*
  36  * Need to reference count these triggers and only enable gpio interrupts
  37  * as appropriate.
  38  */
  39
  40 /* So what functionality do we want in here?... */
  41 /* set high / low as interrupt type? */
  42
  43 static irqreturn_t iio_gpio_trigger_poll(int irq, void *private)
  44 {
  45         iio_trigger_poll(private);
  46         return IRQ_HANDLED;
  47 }
  48
  49 static DEVICE_ATTR(name, S_IRUGO, iio_trigger_read_name, NULL);
  50
  51 static struct attribute *iio_gpio_trigger_attrs[] = {
  52         &dev_attr_name.attr,
  53         NULL,
  54 };
  55
  56 static const struct attribute_group iio_gpio_trigger_attr_group = {
  57         .attrs = iio_gpio_trigger_attrs,
  58 };
  59
  60 static int iio_gpio_trigger_probe(struct platform_device *dev)
  61 {
  62         int *pdata = dev->dev.platform_data;
  63         struct iio_gpio_trigger_info *trig_info;
  64         struct iio_trigger *trig, *trig2;
  65         int i, irq, ret = 0;
  66         if (!pdata) {
  67                 printk(KERN_ERR "No IIO gpio trigger platform data found\n");
  68                 goto error_ret;
  69         }
  70         for (i = 0;; i++) {
  71                 if (!gpio_is_valid(pdata[i]))
  72                         break;
  73                 trig = iio_allocate_trigger();
  74                 if (!trig) {
  75                         ret = -ENOMEM;
  76                         goto error_free_completed_registrations;
  77                 }
  78
  79                 trig_info = kzalloc(sizeof(*trig_info), GFP_KERNEL);
  80                 if (!trig_info) {
  81                         ret = -ENOMEM;
  82                         goto error_put_trigger;
  83                 }
  84                 trig->control_attrs = &iio_gpio_trigger_attr_group;
  85                 trig->private_data = trig_info;
  86                 trig_info->gpio = pdata[i];
  87                 trig->owner = THIS_MODULE;
  88                 trig->name = kmalloc(IIO_TRIGGER_NAME_LENGTH, GFP_KERNEL);
  89                 if (!trig->name) {
  90                         ret = -ENOMEM;
  91                         goto error_free_trig_info;
  92                 }
  93                 snprintf((char *)trig->name,
  94                          IIO_TRIGGER_NAME_LENGTH,
  95                          "gpiotrig%d",
  96                          pdata[i]);
  97                 ret = gpio_request(trig_info->gpio, trig->name);
  98                 if (ret)
  99                         goto error_free_name;
 100
 101                 ret = gpio_direction_input(trig_info->gpio);
 102                 if (ret)
 103                         goto error_release_gpio;
 104
 105                 irq = gpio_to_irq(trig_info->gpio);
 106                 if (irq < 0) {
 107                         ret = irq;
 108                         goto error_release_gpio;
 109                 }
 110
 111                 ret = request_irq(irq, iio_gpio_trigger_poll,
 112                                   IRQF_TRIGGER_RISING,
 113                                   trig->name,
 114                                   trig);
 115                 if (ret)
 116                         goto error_release_gpio;
 117
 118                 ret = iio_trigger_register(trig);
 119                 if (ret)
 120                         goto error_release_irq;
 121
 122                 list_add_tail(&trig->alloc_list, &iio_gpio_trigger_list);
 123
 124         }
 125         return 0;
 126
 127 /* First clean up the partly allocated trigger */
 128 error_release_irq:
 129         free_irq(irq, trig);
 130 error_release_gpio:
 131         gpio_free(trig_info->gpio);
 132 error_free_name:
 133         kfree(trig->name);
 134 error_free_trig_info:
 135         kfree(trig_info);
 136 error_put_trigger:
 137         iio_put_trigger(trig);
 138 error_free_completed_registrations:
 139         /* The rest should have been added to the iio_gpio_trigger_list */
 140         list_for_each_entry_safe(trig,
 141                                  trig2,
 142                                  &iio_gpio_trigger_list,
 143                                  alloc_list) {
 144                 trig_info = trig->private_data;
 145                 free_irq(gpio_to_irq(trig_info->gpio), trig);
 146                 gpio_free(trig_info->gpio);
 147                 kfree(trig->name);
 148                 kfree(trig_info);
 149                 iio_trigger_unregister(trig);
 150         }
 151
 152 error_ret:
 153         return ret;
 154 }
 155
 156 static int iio_gpio_trigger_remove(struct platform_device *dev)
 157 {
 158         struct iio_trigger *trig, *trig2;
 159         struct iio_gpio_trigger_info *trig_info;
 160
 161         mutex_lock(&iio_gpio_trigger_list_lock);
 162         list_for_each_entry_safe(trig,
 163                                  trig2,
 164                                  &iio_gpio_trigger_list,
 165                                  alloc_list) {
 166                 trig_info = trig->private_data;
 167                 iio_trigger_unregister(trig);
 168                 free_irq(gpio_to_irq(trig_info->gpio), trig);
 169                 gpio_free(trig_info->gpio);
 170                 kfree(trig->name);
 171                 kfree(trig_info);
 172                 iio_put_trigger(trig);
 173         }
 174         mutex_unlock(&iio_gpio_trigger_list_lock);
 175
 176         return 0;
 177 }
 178
 179 static struct platform_driver iio_gpio_trigger_driver = {
 180         .probe = iio_gpio_trigger_probe,
 181         .remove = iio_gpio_trigger_remove,
 182         .driver = {
 183                 .name = "iio_gpio_trigger",
 184                 .owner = THIS_MODULE,
 185         },
 186 };
 187
 188 static int __init iio_gpio_trig_init(void)
 189 {
 190         return platform_driver_register(&iio_gpio_trigger_driver);
 191 }
 192 module_init(iio_gpio_trig_init);
 193
 194 static void __exit iio_gpio_trig_exit(void)
 195 {
 196         platform_driver_unregister(&iio_gpio_trigger_driver);
 197 }
 198 module_exit(iio_gpio_trig_exit);
 199
 200 MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>");
 201 MODULE_DESCRIPTION("Example gpio trigger for the iio subsystem");
 202 MODULE_LICENSE("GPL v2");