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 
interrupt_cnt_isr(int irq,void * dev_id)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(&priv->count);
33 
34 	counter_push_event(counter, COUNTER_EVENT_CHANGE_OF_STATE, 0);
35 
36 	return IRQ_HANDLED;
37 }
38 
interrupt_cnt_enable_read(struct counter_device * counter,struct counter_count * count,u8 * enable)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 
interrupt_cnt_enable_write(struct counter_device * counter,struct counter_count * count,u8 enable)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(priv->irq);
60 	} else {
61 		disable_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 
interrupt_cnt_action_read(struct counter_device * counter,struct counter_count * count,struct counter_synapse * synapse,enum counter_synapse_action * action)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 
interrupt_cnt_read(struct counter_device * counter,struct counter_count * count,u64 * val)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(&priv->count);
93 
94 	return 0;
95 }
96 
interrupt_cnt_write(struct counter_device * counter,struct counter_count * count,const u64 val)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(&priv->count, val);
106 
107 	return 0;
108 }
109 
110 static const enum counter_function interrupt_cnt_functions[] = {
111 	COUNTER_FUNCTION_INCREASE,
112 };
113 
interrupt_cnt_function_read(struct counter_device * counter,struct counter_count * count,enum counter_function * function)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 
interrupt_cnt_signal_read(struct counter_device * counter,struct counter_signal * signal,enum counter_signal_level * level)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(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 
interrupt_cnt_watch_validate(struct counter_device * counter,const struct counter_watch * watch)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 
interrupt_cnt_probe(struct platform_device * pdev)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));
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, priv->irq, "failed to get IRQ\n");
178 
179 	priv->gpio = devm_gpiod_get_optional(dev, NULL, GPIOD_IN);
180 	if (IS_ERR(priv->gpio))
181 		return dev_err_probe(dev, PTR_ERR(priv->gpio), "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(priv->gpio);
190 
191 		if (irq < 0)
192 			return dev_err_probe(dev, irq, "failed to get IRQ from GPIO\n");
193 
194 		priv->irq = irq;
195 	}
196 
197 	priv->signals.name = devm_kasprintf(dev, GFP_KERNEL, "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(priv->irq, IRQ_NOAUTOEN);
224 	ret = devm_request_irq(dev, priv->irq, interrupt_cnt_isr,
225 			       IRQF_TRIGGER_RISING | IRQF_NO_THREAD,
226 			       dev_name(dev), 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, ret, "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