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->driver_type = RC_DRIVER_IR_RAW;
  86         rcdev->allowed_protos = RC_TYPE_ALL;
  87         rcdev->input_name = GPIO_IR_DEVICE_NAME;
  88         rcdev->input_id.bustype = BUS_HOST;
  89         rcdev->driver_name = GPIO_IR_DRIVER_NAME;
  90         rcdev->map_name = RC_MAP_EMPTY;
  91
  92         gpio_dev->rcdev = rcdev;
  93         gpio_dev->gpio_nr = pdata->gpio_nr;
  94         gpio_dev->active_low = pdata->active_low;
  95
  96         rc = gpio_request(pdata->gpio_nr, "gpio-ir-recv");
  97         if (rc < 0)
  98                 goto err_gpio_request;
  99         rc  = gpio_direction_input(pdata->gpio_nr);
 100         if (rc < 0)
 101                 goto err_gpio_direction_input;
 102
 103         rc = rc_register_device(rcdev);
 104         if (rc < 0) {
 105                 dev_err(&pdev->dev, "failed to register rc device\n");
 106                 goto err_register_rc_device;
 107         }
 108
 109         platform_set_drvdata(pdev, gpio_dev);
 110
 111         rc = request_any_context_irq(gpio_to_irq(pdata->gpio_nr),
 112                                 gpio_ir_recv_irq,
 113                         IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
 114                                         "gpio-ir-recv-irq", gpio_dev);
 115         if (rc < 0)
 116                 goto err_request_irq;
 117
 118         return 0;
 119
 120 err_request_irq:
 121         platform_set_drvdata(pdev, NULL);
 122         rc_unregister_device(rcdev);
 123 err_register_rc_device:
 124 err_gpio_direction_input:
 125         gpio_free(pdata->gpio_nr);
 126 err_gpio_request:
 127         rc_free_device(rcdev);
 128         rcdev = NULL;
 129 err_allocate_device:
 130         kfree(gpio_dev);
 131         return rc;
 132 }
 133
 134 static int __devexit gpio_ir_recv_remove(struct platform_device *pdev)
 135 {
 136         struct gpio_rc_dev *gpio_dev = platform_get_drvdata(pdev);
 137
 138         free_irq(gpio_to_irq(gpio_dev->gpio_nr), gpio_dev);
 139         platform_set_drvdata(pdev, NULL);
 140         rc_unregister_device(gpio_dev->rcdev);
 141         gpio_free(gpio_dev->gpio_nr);
 142         rc_free_device(gpio_dev->rcdev);
 143         kfree(gpio_dev);
 144         return 0;
 145 }
 146
 147 #ifdef CONFIG_PM
 148 static int gpio_ir_recv_suspend(struct device *dev)
 149 {
 150         struct platform_device *pdev = to_platform_device(dev);
 151         struct gpio_rc_dev *gpio_dev = platform_get_drvdata(pdev);
 152
 153         if (device_may_wakeup(dev))
 154                 enable_irq_wake(gpio_to_irq(gpio_dev->gpio_nr));
 155         else
 156                 disable_irq(gpio_to_irq(gpio_dev->gpio_nr));
 157
 158         return 0;
 159 }
 160
 161 static int gpio_ir_recv_resume(struct device *dev)
 162 {
 163         struct platform_device *pdev = to_platform_device(dev);
 164         struct gpio_rc_dev *gpio_dev = platform_get_drvdata(pdev);
 165
 166         if (device_may_wakeup(dev))
 167                 disable_irq_wake(gpio_to_irq(gpio_dev->gpio_nr));
 168         else
 169                 enable_irq(gpio_to_irq(gpio_dev->gpio_nr));
 170
 171         return 0;
 172 }
 173
 174 static const struct dev_pm_ops gpio_ir_recv_pm_ops = {
 175         .suspend        = gpio_ir_recv_suspend,
 176         .resume         = gpio_ir_recv_resume,
 177 };
 178 #endif
 179
 180 static struct platform_driver gpio_ir_recv_driver = {
 181         .probe  = gpio_ir_recv_probe,
 182         .remove = __devexit_p(gpio_ir_recv_remove),
 183         .driver = {
 184                 .name   = GPIO_IR_DRIVER_NAME,
 185                 .owner  = THIS_MODULE,
 186 #ifdef CONFIG_PM
 187                 .pm     = &gpio_ir_recv_pm_ops,
 188 #endif
 189         },
 190 };
 191
 192 static int __init gpio_ir_recv_init(void)
 193 {
 194         return platform_driver_register(&gpio_ir_recv_driver);
 195 }
 196 module_init(gpio_ir_recv_init);
 197
 198 static void __exit gpio_ir_recv_exit(void)
 199 {
 200         platform_driver_unregister(&gpio_ir_recv_driver);
 201 }
 202 module_exit(gpio_ir_recv_exit);
 203
 204 MODULE_DESCRIPTION("GPIO IR Receiver driver");
 205 MODULE_LICENSE("GPL v2");