1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* Copyright (c) 2012, Code Aurora Forum. All rights reserved. |
3 | */ |
4 | |
5 | #include <linux/kernel.h> |
6 | #include <linux/init.h> |
7 | #include <linux/module.h> |
8 | #include <linux/interrupt.h> |
9 | #include <linux/gpio/consumer.h> |
10 | #include <linux/slab.h> |
11 | #include <linux/of.h> |
12 | #include <linux/of_gpio.h> |
13 | #include <linux/platform_device.h> |
14 | #include <linux/pm_runtime.h> |
15 | #include <linux/pm_qos.h> |
16 | #include <linux/irq.h> |
17 | #include <media/rc-core.h> |
18 | |
19 | #define GPIO_IR_DEVICE_NAME "gpio_ir_recv" |
20 | |
21 | struct gpio_rc_dev { |
22 | struct rc_dev *rcdev; |
23 | struct gpio_desc *gpiod; |
24 | int irq; |
25 | struct device *pmdev; |
26 | struct pm_qos_request qos; |
27 | }; |
28 | |
29 | static irqreturn_t gpio_ir_recv_irq(int irq, void *dev_id) |
30 | { |
31 | int val; |
32 | struct gpio_rc_dev *gpio_dev = dev_id; |
33 | struct device *pmdev = gpio_dev->pmdev; |
34 | |
35 | /* |
36 | * For some cpuidle systems, not all: |
37 | * Respond to interrupt taking more latency when cpu in idle. |
38 | * Invoke asynchronous pm runtime get from interrupt context, |
39 | * this may introduce a millisecond delay to call resume callback, |
40 | * where to disable cpuilde. |
41 | * |
42 | * Two issues lead to fail to decode first frame, one is latency to |
43 | * respond to interrupt, another is delay introduced by async api. |
44 | */ |
45 | if (pmdev) |
46 | pm_runtime_get(dev: pmdev); |
47 | |
48 | val = gpiod_get_value(desc: gpio_dev->gpiod); |
49 | if (val >= 0) |
50 | ir_raw_event_store_edge(dev: gpio_dev->rcdev, pulse: val == 1); |
51 | |
52 | if (pmdev) { |
53 | pm_runtime_mark_last_busy(dev: pmdev); |
54 | pm_runtime_put_autosuspend(dev: pmdev); |
55 | } |
56 | |
57 | return IRQ_HANDLED; |
58 | } |
59 | |
60 | static int gpio_ir_recv_probe(struct platform_device *pdev) |
61 | { |
62 | struct device *dev = &pdev->dev; |
63 | struct device_node *np = dev->of_node; |
64 | struct gpio_rc_dev *gpio_dev; |
65 | struct rc_dev *rcdev; |
66 | u32 period = 0; |
67 | int rc; |
68 | |
69 | if (!np) |
70 | return -ENODEV; |
71 | |
72 | gpio_dev = devm_kzalloc(dev, size: sizeof(*gpio_dev), GFP_KERNEL); |
73 | if (!gpio_dev) |
74 | return -ENOMEM; |
75 | |
76 | gpio_dev->gpiod = devm_gpiod_get(dev, NULL, flags: GPIOD_IN); |
77 | if (IS_ERR(ptr: gpio_dev->gpiod)) |
78 | return dev_err_probe(dev, err: PTR_ERR(ptr: gpio_dev->gpiod), |
79 | fmt: "error getting gpio\n" ); |
80 | gpio_dev->irq = gpiod_to_irq(desc: gpio_dev->gpiod); |
81 | if (gpio_dev->irq < 0) |
82 | return gpio_dev->irq; |
83 | |
84 | rcdev = devm_rc_allocate_device(dev, RC_DRIVER_IR_RAW); |
85 | if (!rcdev) |
86 | return -ENOMEM; |
87 | |
88 | rcdev->priv = gpio_dev; |
89 | rcdev->device_name = GPIO_IR_DEVICE_NAME; |
90 | rcdev->input_phys = GPIO_IR_DEVICE_NAME "/input0" ; |
91 | rcdev->input_id.bustype = BUS_HOST; |
92 | rcdev->input_id.vendor = 0x0001; |
93 | rcdev->input_id.product = 0x0001; |
94 | rcdev->input_id.version = 0x0100; |
95 | rcdev->dev.parent = dev; |
96 | rcdev->driver_name = KBUILD_MODNAME; |
97 | rcdev->min_timeout = 1; |
98 | rcdev->timeout = IR_DEFAULT_TIMEOUT; |
99 | rcdev->max_timeout = 10 * IR_DEFAULT_TIMEOUT; |
100 | rcdev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER; |
101 | rcdev->map_name = of_get_property(node: np, name: "linux,rc-map-name" , NULL); |
102 | if (!rcdev->map_name) |
103 | rcdev->map_name = RC_MAP_EMPTY; |
104 | |
105 | gpio_dev->rcdev = rcdev; |
106 | if (of_property_read_bool(np, propname: "wakeup-source" )) |
107 | device_init_wakeup(dev, enable: true); |
108 | |
109 | rc = devm_rc_register_device(parent: dev, dev: rcdev); |
110 | if (rc < 0) { |
111 | dev_err(dev, "failed to register rc device (%d)\n" , rc); |
112 | return rc; |
113 | } |
114 | |
115 | of_property_read_u32(np, propname: "linux,autosuspend-period" , out_value: &period); |
116 | if (period) { |
117 | gpio_dev->pmdev = dev; |
118 | pm_runtime_set_autosuspend_delay(dev, delay: period); |
119 | pm_runtime_use_autosuspend(dev); |
120 | pm_runtime_set_suspended(dev); |
121 | pm_runtime_enable(dev); |
122 | } |
123 | |
124 | platform_set_drvdata(pdev, data: gpio_dev); |
125 | |
126 | return devm_request_irq(dev, irq: gpio_dev->irq, handler: gpio_ir_recv_irq, |
127 | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, |
128 | devname: "gpio-ir-recv-irq" , dev_id: gpio_dev); |
129 | } |
130 | |
131 | static void gpio_ir_recv_remove(struct platform_device *pdev) |
132 | { |
133 | struct gpio_rc_dev *gpio_dev = platform_get_drvdata(pdev); |
134 | struct device *pmdev = gpio_dev->pmdev; |
135 | |
136 | if (pmdev) { |
137 | pm_runtime_get_sync(dev: pmdev); |
138 | cpu_latency_qos_remove_request(req: &gpio_dev->qos); |
139 | |
140 | pm_runtime_disable(dev: pmdev); |
141 | pm_runtime_put_noidle(dev: pmdev); |
142 | pm_runtime_set_suspended(dev: pmdev); |
143 | } |
144 | } |
145 | |
146 | #ifdef CONFIG_PM |
147 | static int gpio_ir_recv_suspend(struct device *dev) |
148 | { |
149 | struct gpio_rc_dev *gpio_dev = dev_get_drvdata(dev); |
150 | |
151 | if (device_may_wakeup(dev)) |
152 | enable_irq_wake(irq: gpio_dev->irq); |
153 | else |
154 | disable_irq(irq: gpio_dev->irq); |
155 | |
156 | return 0; |
157 | } |
158 | |
159 | static int gpio_ir_recv_resume(struct device *dev) |
160 | { |
161 | struct gpio_rc_dev *gpio_dev = dev_get_drvdata(dev); |
162 | |
163 | if (device_may_wakeup(dev)) |
164 | disable_irq_wake(irq: gpio_dev->irq); |
165 | else |
166 | enable_irq(irq: gpio_dev->irq); |
167 | |
168 | return 0; |
169 | } |
170 | |
171 | static int gpio_ir_recv_runtime_suspend(struct device *dev) |
172 | { |
173 | struct gpio_rc_dev *gpio_dev = dev_get_drvdata(dev); |
174 | |
175 | cpu_latency_qos_remove_request(req: &gpio_dev->qos); |
176 | |
177 | return 0; |
178 | } |
179 | |
180 | static int gpio_ir_recv_runtime_resume(struct device *dev) |
181 | { |
182 | struct gpio_rc_dev *gpio_dev = dev_get_drvdata(dev); |
183 | |
184 | cpu_latency_qos_add_request(req: &gpio_dev->qos, value: 0); |
185 | |
186 | return 0; |
187 | } |
188 | |
189 | static const struct dev_pm_ops gpio_ir_recv_pm_ops = { |
190 | .suspend = gpio_ir_recv_suspend, |
191 | .resume = gpio_ir_recv_resume, |
192 | .runtime_suspend = gpio_ir_recv_runtime_suspend, |
193 | .runtime_resume = gpio_ir_recv_runtime_resume, |
194 | }; |
195 | #endif |
196 | |
197 | static const struct of_device_id gpio_ir_recv_of_match[] = { |
198 | { .compatible = "gpio-ir-receiver" , }, |
199 | { }, |
200 | }; |
201 | MODULE_DEVICE_TABLE(of, gpio_ir_recv_of_match); |
202 | |
203 | static struct platform_driver gpio_ir_recv_driver = { |
204 | .probe = gpio_ir_recv_probe, |
205 | .remove_new = gpio_ir_recv_remove, |
206 | .driver = { |
207 | .name = KBUILD_MODNAME, |
208 | .of_match_table = gpio_ir_recv_of_match, |
209 | #ifdef CONFIG_PM |
210 | .pm = &gpio_ir_recv_pm_ops, |
211 | #endif |
212 | }, |
213 | }; |
214 | module_platform_driver(gpio_ir_recv_driver); |
215 | |
216 | MODULE_DESCRIPTION("GPIO IR Receiver driver" ); |
217 | MODULE_LICENSE("GPL v2" ); |
218 | |