drivers/media/rc/gpio-ir-recv.c

   1 /* Copyright (c) 2012, Code Aurora Forum. All rights reserved.
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License version 2 and
   5  * only version 2 as published by the Free Software Foundation.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/init.h>
  15 #include <linux/module.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/gpio.h>
  18 #include <linux/slab.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/irq.h>
  21 #include <media/rc-core.h>
  22 #include <media/gpio-ir-recv.h>
  23
  24 #define GPIO_IR_DRIVER_NAME     "gpio-rc-recv"
  25 #define GPIO_IR_DEVICE_NAME     "gpio_ir_recv"
  26
  27 struct gpio_rc_dev {
  28         struct rc_dev *rcdev;
  29         int gpio_nr;
  30         bool active_low;
  31 };
  32
  33 static irqreturn_t gpio_ir_recv_irq(int irq, void *dev_id)
  34 {
  35         struct gpio_rc_dev *gpio_dev = dev_id;
  36         int gval;
  37         int rc = 0;
  38         enum raw_event_type type = IR_SPACE;
  39
  40         gval = gpio_get_value_cansleep(gpio_dev->gpio_nr);
  41
  42         if (gval < 0)
  43                 goto err_get_value;
  44
  45         if (gpio_dev->active_low)
  46                 gval = !gval;
  47
  48         if (gval == 1)
  49                 type = IR_PULSE;
  50
  51         rc = ir_raw_event_store_edge(gpio_dev->rcdev, type);
  52         if (rc < 0)
  53                 goto err_get_value;
  54
  55         ir_raw_event_handle(gpio_dev->rcdev);
  56
  57 err_get_value:
  58         return IRQ_HANDLED;
  59 }
  60
  61 static int __devinit gpio_ir_recv_probe(struct platform_device *pdev)
  62 {
  63         struct gpio_rc_dev *gpio_dev;
  64         struct rc_dev *rcdev;
  65         const struct gpio_ir_recv_platform_data *pdata =
  66                                         pdev->dev.platform_data;
  67         int rc;
  68
  69         if (!pdata)
  70                 return -EINVAL;
  71
  72         if (pdata->gpio_nr < 0)
  73                 return -EINVAL;
  74
  75         gpio_dev = kzalloc(sizeof(struct gpio_rc_dev), GFP_KERNEL);
  76         if (!gpio_dev)
  77                 return -ENOMEM;
  78
  79         rcdev = rc_allocate_device();
  80         if (!rcdev) {
  81                 rc = -ENOMEM;
  82                 goto err_allocate_device;
  83         }
  84
  85         rcdev->priv = gpio_dev;
  86         rcdev->driver_type = RC_DRIVER_IR_RAW;
  87         rcdev->input_name = GPIO_IR_DEVICE_NAME;
  88         rcdev->input_phys = GPIO_IR_DEVICE_NAME "/input0";
  89         rcdev->input_id.bustype = BUS_HOST;
  90         rcdev->input_id.vendor = 0x0001;
  91         rcdev->input_id.product = 0x0001;
  92         rcdev->input_id.version = 0x0100;
  93         rcdev->dev.parent = &pdev->dev;
  94         rcdev->driver_name = GPIO_IR_DRIVER_NAME;
  95         if (pdata->allowed_protos)
  96                 rcdev->allowed_protos = pdata->allowed_protos;
  97         else
  98                 rcdev->allowed_protos = RC_TYPE_ALL;
  99         rcdev->map_name = pdata->map_name ?: RC_MAP_EMPTY;
 100
 101         gpio_dev->rcdev = rcdev;
 102         gpio_dev->gpio_nr = pdata->gpio_nr;
 103         gpio_dev->active_low = pdata->active_low;
 104
 105         rc = gpio_request(pdata->gpio_nr, "gpio-ir-recv");
 106         if (rc < 0)
 107                 goto err_gpio_request;
 108         rc  = gpio_direction_input(pdata->gpio_nr);
 109         if (rc < 0)
 110                 goto err_gpio_direction_input;
 111
 112         rc = rc_register_device(rcdev);
 113         if (rc < 0) {
 114                 dev_err(&pdev->dev, "failed to register rc device\n");
 115                 goto err_register_rc_device;
 116         }
 117
 118         platform_set_drvdata(pdev, gpio_dev);
 119
 120         rc = request_any_context_irq(gpio_to_irq(pdata->gpio_nr),
 121                                 gpio_ir_recv_irq,
 122                         IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
 123                                         "gpio-ir-recv-irq", gpio_dev);
 124         if (rc < 0)
 125                 goto err_request_irq;
 126
 127         return 0;
 128
 129 err_request_irq:
 130         platform_set_drvdata(pdev, NULL);
 131         rc_unregister_device(rcdev);
 132 err_register_rc_device:
 133 err_gpio_direction_input:
 134         gpio_free(pdata->gpio_nr);
 135 err_gpio_request:
 136         rc_free_device(rcdev);
 137         rcdev = NULL;
 138 err_allocate_device:
 139         kfree(gpio_dev);
 140         return rc;
 141 }
 142
 143 static int __devexit gpio_ir_recv_remove(struct platform_device *pdev)
 144 {
 145         struct gpio_rc_dev *gpio_dev = platform_get_drvdata(pdev);
 146
 147         free_irq(gpio_to_irq(gpio_dev->gpio_nr), gpio_dev);
 148         platform_set_drvdata(pdev, NULL);
 149         rc_unregister_device(gpio_dev->rcdev);
 150         gpio_free(gpio_dev->gpio_nr);
 151         rc_free_device(gpio_dev->rcdev);
 152         kfree(gpio_dev);
 153         return 0;
 154 }
 155
 156 #ifdef CONFIG_PM
 157 static int gpio_ir_recv_suspend(struct device *dev)
 158 {
 159         struct platform_device *pdev = to_platform_device(dev);
 160         struct gpio_rc_dev *gpio_dev = platform_get_drvdata(pdev);
 161
 162         if (device_may_wakeup(dev))
 163                 enable_irq_wake(gpio_to_irq(gpio_dev->gpio_nr));
 164         else
 165                 disable_irq(gpio_to_irq(gpio_dev->gpio_nr));
 166
 167         return 0;
 168 }
 169
 170 static int gpio_ir_recv_resume(struct device *dev)
 171 {
 172         struct platform_device *pdev = to_platform_device(dev);
 173         struct gpio_rc_dev *gpio_dev = platform_get_drvdata(pdev);
 174
 175         if (device_may_wakeup(dev))
 176                 disable_irq_wake(gpio_to_irq(gpio_dev->gpio_nr));
 177         else
 178                 enable_irq(gpio_to_irq(gpio_dev->gpio_nr));
 179
 180         return 0;
 181 }
 182
 183 static const struct dev_pm_ops gpio_ir_recv_pm_ops = {
 184         .suspend        = gpio_ir_recv_suspend,
 185         .resume         = gpio_ir_recv_resume,
 186 };
 187 #endif
 188
 189 static struct platform_driver gpio_ir_recv_driver = {
 190         .probe  = gpio_ir_recv_probe,
 191         .remove = __devexit_p(gpio_ir_recv_remove),
 192         .driver = {
 193                 .name   = GPIO_IR_DRIVER_NAME,
 194                 .owner  = THIS_MODULE,
 195 #ifdef CONFIG_PM
 196                 .pm     = &gpio_ir_recv_pm_ops,
 197 #endif
 198         },
 199 };
 200 module_platform_driver(gpio_ir_recv_driver);
 201
 202 MODULE_DESCRIPTION("GPIO IR Receiver driver");
 203 MODULE_LICENSE("GPL v2");