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