1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (c) 2021 Pengutronix, Oleksij Rempel <kernel@pengutronix.de> |
4 | */ |
5 | |
6 | #include <linux/counter.h> |
7 | #include <linux/gpio/consumer.h> |
8 | #include <linux/interrupt.h> |
9 | #include <linux/irq.h> |
10 | #include <linux/mod_devicetable.h> |
11 | #include <linux/module.h> |
12 | #include <linux/platform_device.h> |
13 | #include <linux/types.h> |
14 | |
15 | #define INTERRUPT_CNT_NAME "interrupt-cnt" |
16 | |
17 | struct interrupt_cnt_priv { |
18 | atomic_t count; |
19 | struct gpio_desc *gpio; |
20 | int irq; |
21 | bool enabled; |
22 | struct counter_signal signals; |
23 | struct counter_synapse synapses; |
24 | struct counter_count cnts; |
25 | }; |
26 | |
27 | static irqreturn_t interrupt_cnt_isr(int irq, void *dev_id) |
28 | { |
29 | struct counter_device *counter = dev_id; |
30 | struct interrupt_cnt_priv *priv = counter_priv(counter); |
31 | |
32 | atomic_inc(v: &priv->count); |
33 | |
34 | counter_push_event(counter, event: COUNTER_EVENT_CHANGE_OF_STATE, channel: 0); |
35 | |
36 | return IRQ_HANDLED; |
37 | } |
38 | |
39 | static int interrupt_cnt_enable_read(struct counter_device *counter, |
40 | struct counter_count *count, u8 *enable) |
41 | { |
42 | struct interrupt_cnt_priv *priv = counter_priv(counter); |
43 | |
44 | *enable = priv->enabled; |
45 | |
46 | return 0; |
47 | } |
48 | |
49 | static int interrupt_cnt_enable_write(struct counter_device *counter, |
50 | struct counter_count *count, u8 enable) |
51 | { |
52 | struct interrupt_cnt_priv *priv = counter_priv(counter); |
53 | |
54 | if (priv->enabled == enable) |
55 | return 0; |
56 | |
57 | if (enable) { |
58 | priv->enabled = true; |
59 | enable_irq(irq: priv->irq); |
60 | } else { |
61 | disable_irq(irq: priv->irq); |
62 | priv->enabled = false; |
63 | } |
64 | |
65 | return 0; |
66 | } |
67 | |
68 | static struct counter_comp interrupt_cnt_ext[] = { |
69 | COUNTER_COMP_ENABLE(interrupt_cnt_enable_read, |
70 | interrupt_cnt_enable_write), |
71 | }; |
72 | |
73 | static const enum counter_synapse_action interrupt_cnt_synapse_actions[] = { |
74 | COUNTER_SYNAPSE_ACTION_RISING_EDGE, |
75 | }; |
76 | |
77 | static int interrupt_cnt_action_read(struct counter_device *counter, |
78 | struct counter_count *count, |
79 | struct counter_synapse *synapse, |
80 | enum counter_synapse_action *action) |
81 | { |
82 | *action = COUNTER_SYNAPSE_ACTION_RISING_EDGE; |
83 | |
84 | return 0; |
85 | } |
86 | |
87 | static int interrupt_cnt_read(struct counter_device *counter, |
88 | struct counter_count *count, u64 *val) |
89 | { |
90 | struct interrupt_cnt_priv *priv = counter_priv(counter); |
91 | |
92 | *val = atomic_read(v: &priv->count); |
93 | |
94 | return 0; |
95 | } |
96 | |
97 | static int interrupt_cnt_write(struct counter_device *counter, |
98 | struct counter_count *count, const u64 val) |
99 | { |
100 | struct interrupt_cnt_priv *priv = counter_priv(counter); |
101 | |
102 | if (val != (typeof(priv->count.counter))val) |
103 | return -ERANGE; |
104 | |
105 | atomic_set(v: &priv->count, i: val); |
106 | |
107 | return 0; |
108 | } |
109 | |
110 | static const enum counter_function interrupt_cnt_functions[] = { |
111 | COUNTER_FUNCTION_INCREASE, |
112 | }; |
113 | |
114 | static int interrupt_cnt_function_read(struct counter_device *counter, |
115 | struct counter_count *count, |
116 | enum counter_function *function) |
117 | { |
118 | *function = COUNTER_FUNCTION_INCREASE; |
119 | |
120 | return 0; |
121 | } |
122 | |
123 | static int interrupt_cnt_signal_read(struct counter_device *counter, |
124 | struct counter_signal *signal, |
125 | enum counter_signal_level *level) |
126 | { |
127 | struct interrupt_cnt_priv *priv = counter_priv(counter); |
128 | int ret; |
129 | |
130 | if (!priv->gpio) |
131 | return -EINVAL; |
132 | |
133 | ret = gpiod_get_value(desc: priv->gpio); |
134 | if (ret < 0) |
135 | return ret; |
136 | |
137 | *level = ret ? COUNTER_SIGNAL_LEVEL_HIGH : COUNTER_SIGNAL_LEVEL_LOW; |
138 | |
139 | return 0; |
140 | } |
141 | |
142 | static int interrupt_cnt_watch_validate(struct counter_device *counter, |
143 | const struct counter_watch *watch) |
144 | { |
145 | if (watch->channel != 0 || |
146 | watch->event != COUNTER_EVENT_CHANGE_OF_STATE) |
147 | return -EINVAL; |
148 | |
149 | return 0; |
150 | } |
151 | |
152 | static const struct counter_ops interrupt_cnt_ops = { |
153 | .action_read = interrupt_cnt_action_read, |
154 | .count_read = interrupt_cnt_read, |
155 | .count_write = interrupt_cnt_write, |
156 | .function_read = interrupt_cnt_function_read, |
157 | .signal_read = interrupt_cnt_signal_read, |
158 | .watch_validate = interrupt_cnt_watch_validate, |
159 | }; |
160 | |
161 | static int interrupt_cnt_probe(struct platform_device *pdev) |
162 | { |
163 | struct device *dev = &pdev->dev; |
164 | struct counter_device *counter; |
165 | struct interrupt_cnt_priv *priv; |
166 | int ret; |
167 | |
168 | counter = devm_counter_alloc(dev, sizeof_priv: sizeof(*priv)); |
169 | if (!counter) |
170 | return -ENOMEM; |
171 | priv = counter_priv(counter); |
172 | |
173 | priv->irq = platform_get_irq_optional(pdev, 0); |
174 | if (priv->irq == -ENXIO) |
175 | priv->irq = 0; |
176 | else if (priv->irq < 0) |
177 | return dev_err_probe(dev, err: priv->irq, fmt: "failed to get IRQ\n" ); |
178 | |
179 | priv->gpio = devm_gpiod_get_optional(dev, NULL, flags: GPIOD_IN); |
180 | if (IS_ERR(ptr: priv->gpio)) |
181 | return dev_err_probe(dev, err: PTR_ERR(ptr: priv->gpio), fmt: "failed to get GPIO\n" ); |
182 | |
183 | if (!priv->irq && !priv->gpio) { |
184 | dev_err(dev, "IRQ and GPIO are not found. At least one source should be provided\n" ); |
185 | return -ENODEV; |
186 | } |
187 | |
188 | if (!priv->irq) { |
189 | int irq = gpiod_to_irq(desc: priv->gpio); |
190 | |
191 | if (irq < 0) |
192 | return dev_err_probe(dev, err: irq, fmt: "failed to get IRQ from GPIO\n" ); |
193 | |
194 | priv->irq = irq; |
195 | } |
196 | |
197 | priv->signals.name = devm_kasprintf(dev, GFP_KERNEL, fmt: "IRQ %d" , |
198 | priv->irq); |
199 | if (!priv->signals.name) |
200 | return -ENOMEM; |
201 | |
202 | counter->signals = &priv->signals; |
203 | counter->num_signals = 1; |
204 | |
205 | priv->synapses.actions_list = interrupt_cnt_synapse_actions; |
206 | priv->synapses.num_actions = ARRAY_SIZE(interrupt_cnt_synapse_actions); |
207 | priv->synapses.signal = &priv->signals; |
208 | |
209 | priv->cnts.name = "Channel 0 Count" ; |
210 | priv->cnts.functions_list = interrupt_cnt_functions; |
211 | priv->cnts.num_functions = ARRAY_SIZE(interrupt_cnt_functions); |
212 | priv->cnts.synapses = &priv->synapses; |
213 | priv->cnts.num_synapses = 1; |
214 | priv->cnts.ext = interrupt_cnt_ext; |
215 | priv->cnts.num_ext = ARRAY_SIZE(interrupt_cnt_ext); |
216 | |
217 | counter->name = dev_name(dev); |
218 | counter->parent = dev; |
219 | counter->ops = &interrupt_cnt_ops; |
220 | counter->counts = &priv->cnts; |
221 | counter->num_counts = 1; |
222 | |
223 | irq_set_status_flags(irq: priv->irq, set: IRQ_NOAUTOEN); |
224 | ret = devm_request_irq(dev, irq: priv->irq, handler: interrupt_cnt_isr, |
225 | IRQF_TRIGGER_RISING | IRQF_NO_THREAD, |
226 | devname: dev_name(dev), dev_id: counter); |
227 | if (ret) |
228 | return ret; |
229 | |
230 | ret = devm_counter_add(dev, counter); |
231 | if (ret < 0) |
232 | return dev_err_probe(dev, err: ret, fmt: "Failed to add counter\n" ); |
233 | |
234 | return 0; |
235 | } |
236 | |
237 | static const struct of_device_id interrupt_cnt_of_match[] = { |
238 | { .compatible = "interrupt-counter" , }, |
239 | {} |
240 | }; |
241 | MODULE_DEVICE_TABLE(of, interrupt_cnt_of_match); |
242 | |
243 | static struct platform_driver interrupt_cnt_driver = { |
244 | .probe = interrupt_cnt_probe, |
245 | .driver = { |
246 | .name = INTERRUPT_CNT_NAME, |
247 | .of_match_table = interrupt_cnt_of_match, |
248 | }, |
249 | }; |
250 | module_platform_driver(interrupt_cnt_driver); |
251 | |
252 | MODULE_ALIAS("platform:interrupt-counter" ); |
253 | MODULE_AUTHOR("Oleksij Rempel <o.rempel@pengutronix.de>" ); |
254 | MODULE_DESCRIPTION("Interrupt counter driver" ); |
255 | MODULE_LICENSE("GPL v2" ); |
256 | MODULE_IMPORT_NS(COUNTER); |
257 | |