xref: /linux/drivers/input/serio/ps2-gpio.c (revision 3e51108c72e8adbcf3180ed40527a2a9d2d0123b)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * GPIO based serio bus driver for bit banging the PS/2 protocol
4  *
5  * Author: Danilo Krummrich <danilokrummrich@dk-develop.de>
6  */
7 
8 #include <linux/gpio/consumer.h>
9 #include <linux/interrupt.h>
10 #include <linux/module.h>
11 #include <linux/serio.h>
12 #include <linux/slab.h>
13 #include <linux/platform_device.h>
14 #include <linux/workqueue.h>
15 #include <linux/completion.h>
16 #include <linux/mutex.h>
17 #include <linux/preempt.h>
18 #include <linux/property.h>
19 #include <linux/of.h>
20 #include <linux/jiffies.h>
21 #include <linux/delay.h>
22 #include <linux/timekeeping.h>
23 
24 #define DRIVER_NAME		"ps2-gpio"
25 
26 #define PS2_MODE_RX		0
27 #define PS2_MODE_TX		1
28 
29 #define PS2_START_BIT		0
30 #define PS2_DATA_BIT0		1
31 #define PS2_DATA_BIT1		2
32 #define PS2_DATA_BIT2		3
33 #define PS2_DATA_BIT3		4
34 #define PS2_DATA_BIT4		5
35 #define PS2_DATA_BIT5		6
36 #define PS2_DATA_BIT6		7
37 #define PS2_DATA_BIT7		8
38 #define PS2_PARITY_BIT		9
39 #define PS2_STOP_BIT		10
40 #define PS2_ACK_BIT		11
41 
42 #define PS2_DEV_RET_ACK		0xfa
43 #define PS2_DEV_RET_NACK	0xfe
44 
45 #define PS2_CMD_RESEND		0xfe
46 
47 /*
48  * The PS2 protocol specifies a clock frequency between 10kHz and 16.7kHz,
49  * therefore the maximal interrupt interval should be 100us and the minimum
50  * interrupt interval should be ~60us. Let's allow +/- 20us for frequency
51  * deviations and interrupt latency.
52  *
53  * The data line must be samples after ~30us to 50us after the falling edge,
54  * since the device updates the data line at the rising edge.
55  *
56  * ___            ______            ______            ______            ___
57  *    \          /      \          /      \          /      \          /
58  *     \        /        \        /        \        /        \        /
59  *      \______/          \______/          \______/          \______/
60  *
61  *     |-----------------|                 |--------|
62  *          60us/100us                      30us/50us
63  */
64 #define PS2_CLK_FREQ_MIN_HZ		10000
65 #define PS2_CLK_FREQ_MAX_HZ		16700
66 #define PS2_CLK_MIN_INTERVAL_US		((1000 * 1000) / PS2_CLK_FREQ_MAX_HZ)
67 #define PS2_CLK_MAX_INTERVAL_US		((1000 * 1000) / PS2_CLK_FREQ_MIN_HZ)
68 #define PS2_IRQ_MIN_INTERVAL_US		(PS2_CLK_MIN_INTERVAL_US - 20)
69 #define PS2_IRQ_MAX_INTERVAL_US		(PS2_CLK_MAX_INTERVAL_US + 20)
70 
71 struct ps2_gpio_data {
72 	struct device *dev;
73 	struct serio *serio;
74 	unsigned char mode;
75 	struct gpio_desc *gpio_clk;
76 	struct gpio_desc *gpio_data;
77 	bool write_enable;
78 	int irq;
79 	ktime_t t_irq_now;
80 	ktime_t t_irq_last;
81 	struct {
82 		unsigned char cnt;
83 		unsigned char byte;
84 	} rx;
85 	struct {
86 		unsigned char cnt;
87 		unsigned char byte;
88 		ktime_t t_xfer_start;
89 		ktime_t t_xfer_end;
90 		struct completion complete;
91 		struct mutex mutex;
92 		struct delayed_work work;
93 	} tx;
94 };
95 
ps2_gpio_open(struct serio * serio)96 static int ps2_gpio_open(struct serio *serio)
97 {
98 	struct ps2_gpio_data *drvdata = serio->port_data;
99 
100 	drvdata->t_irq_last = 0;
101 	drvdata->tx.t_xfer_end = 0;
102 
103 	enable_irq(drvdata->irq);
104 	return 0;
105 }
106 
ps2_gpio_close(struct serio * serio)107 static void ps2_gpio_close(struct serio *serio)
108 {
109 	struct ps2_gpio_data *drvdata = serio->port_data;
110 
111 	flush_delayed_work(&drvdata->tx.work);
112 	disable_irq(drvdata->irq);
113 }
114 
__ps2_gpio_write(struct serio * serio,unsigned char val)115 static int __ps2_gpio_write(struct serio *serio, unsigned char val)
116 {
117 	struct ps2_gpio_data *drvdata = serio->port_data;
118 
119 	disable_irq_nosync(drvdata->irq);
120 	gpiod_direction_output(drvdata->gpio_clk, 0);
121 
122 	drvdata->mode = PS2_MODE_TX;
123 	drvdata->tx.byte = val;
124 
125 	schedule_delayed_work(&drvdata->tx.work, usecs_to_jiffies(200));
126 
127 	return 0;
128 }
129 
ps2_gpio_write(struct serio * serio,unsigned char val)130 static int ps2_gpio_write(struct serio *serio, unsigned char val)
131 {
132 	struct ps2_gpio_data *drvdata = serio->port_data;
133 	int ret = 0;
134 
135 	if (in_task()) {
136 		guard(mutex)(&drvdata->tx.mutex);
137 
138 		__ps2_gpio_write(serio, val);
139 		if (!wait_for_completion_timeout(&drvdata->tx.complete,
140 						 msecs_to_jiffies(10000)))
141 			ret = SERIO_TIMEOUT;
142 	} else {
143 		__ps2_gpio_write(serio, val);
144 	}
145 
146 	return ret;
147 }
148 
ps2_gpio_tx_work_fn(struct work_struct * work)149 static void ps2_gpio_tx_work_fn(struct work_struct *work)
150 {
151 	struct delayed_work *dwork = to_delayed_work(work);
152 	struct ps2_gpio_data *drvdata = container_of(dwork,
153 						     struct ps2_gpio_data,
154 						     tx.work);
155 
156 	drvdata->tx.t_xfer_start = ktime_get();
157 	enable_irq(drvdata->irq);
158 	gpiod_direction_output(drvdata->gpio_data, 0);
159 	gpiod_direction_input(drvdata->gpio_clk);
160 }
161 
ps2_gpio_irq_rx(struct ps2_gpio_data * drvdata)162 static irqreturn_t ps2_gpio_irq_rx(struct ps2_gpio_data *drvdata)
163 {
164 	unsigned char byte, cnt;
165 	int data;
166 	int rxflags = 0;
167 	s64 us_delta;
168 
169 	byte = drvdata->rx.byte;
170 	cnt = drvdata->rx.cnt;
171 
172 	drvdata->t_irq_now = ktime_get();
173 
174 	/*
175 	 * We need to consider spurious interrupts happening right after
176 	 * a TX xfer finished.
177 	 */
178 	us_delta = ktime_us_delta(drvdata->t_irq_now, drvdata->tx.t_xfer_end);
179 	if (unlikely(us_delta < PS2_IRQ_MIN_INTERVAL_US))
180 		goto end;
181 
182 	us_delta = ktime_us_delta(drvdata->t_irq_now, drvdata->t_irq_last);
183 	if (us_delta > PS2_IRQ_MAX_INTERVAL_US && cnt) {
184 		dev_err(drvdata->dev,
185 			"RX: timeout, probably we missed an interrupt\n");
186 		goto err;
187 	} else if (unlikely(us_delta < PS2_IRQ_MIN_INTERVAL_US)) {
188 		/* Ignore spurious IRQs. */
189 		goto end;
190 	}
191 	drvdata->t_irq_last = drvdata->t_irq_now;
192 
193 	data = gpiod_get_value(drvdata->gpio_data);
194 	if (unlikely(data < 0)) {
195 		dev_err(drvdata->dev, "RX: failed to get data gpio val: %d\n",
196 			data);
197 		goto err;
198 	}
199 
200 	switch (cnt) {
201 	case PS2_START_BIT:
202 		/* start bit should be low */
203 		if (unlikely(data)) {
204 			dev_err(drvdata->dev, "RX: start bit should be low\n");
205 			goto err;
206 		}
207 		break;
208 	case PS2_DATA_BIT0:
209 	case PS2_DATA_BIT1:
210 	case PS2_DATA_BIT2:
211 	case PS2_DATA_BIT3:
212 	case PS2_DATA_BIT4:
213 	case PS2_DATA_BIT5:
214 	case PS2_DATA_BIT6:
215 	case PS2_DATA_BIT7:
216 		/* processing data bits */
217 		if (data)
218 			byte |= (data << (cnt - 1));
219 		break;
220 	case PS2_PARITY_BIT:
221 		/* check odd parity */
222 		if (!((hweight8(byte) & 1) ^ data)) {
223 			rxflags |= SERIO_PARITY;
224 			dev_warn(drvdata->dev, "RX: parity error\n");
225 			if (!drvdata->write_enable)
226 				goto err;
227 		}
228 		break;
229 	case PS2_STOP_BIT:
230 		/* stop bit should be high */
231 		if (unlikely(!data)) {
232 			dev_err(drvdata->dev, "RX: stop bit should be high\n");
233 			goto err;
234 		}
235 
236 		/*
237 		 * Do not send spurious ACK's and NACK's when write fn is
238 		 * not provided.
239 		 */
240 		if (!drvdata->write_enable) {
241 			if (byte == PS2_DEV_RET_NACK)
242 				goto err;
243 			else if (byte == PS2_DEV_RET_ACK)
244 				break;
245 		}
246 
247 		serio_interrupt(drvdata->serio, byte, rxflags);
248 		dev_dbg(drvdata->dev, "RX: sending byte 0x%x\n", byte);
249 
250 		cnt = byte = 0;
251 
252 		goto end; /* success */
253 	default:
254 		dev_err(drvdata->dev, "RX: got out of sync with the device\n");
255 		goto err;
256 	}
257 
258 	cnt++;
259 	goto end; /* success */
260 
261 err:
262 	cnt = byte = 0;
263 	__ps2_gpio_write(drvdata->serio, PS2_CMD_RESEND);
264 end:
265 	drvdata->rx.cnt = cnt;
266 	drvdata->rx.byte = byte;
267 	return IRQ_HANDLED;
268 }
269 
ps2_gpio_irq_tx(struct ps2_gpio_data * drvdata)270 static irqreturn_t ps2_gpio_irq_tx(struct ps2_gpio_data *drvdata)
271 {
272 	unsigned char byte, cnt;
273 	int data;
274 	s64 us_delta;
275 
276 	cnt = drvdata->tx.cnt;
277 	byte = drvdata->tx.byte;
278 
279 	drvdata->t_irq_now = ktime_get();
280 
281 	/*
282 	 * There might be pending IRQs since we disabled IRQs in
283 	 * __ps2_gpio_write().  We can expect at least one clock period until
284 	 * the device generates the first falling edge after releasing the
285 	 * clock line.
286 	 */
287 	us_delta = ktime_us_delta(drvdata->t_irq_now,
288 				  drvdata->tx.t_xfer_start);
289 	if (unlikely(us_delta < PS2_CLK_MIN_INTERVAL_US))
290 		goto end;
291 
292 	us_delta = ktime_us_delta(drvdata->t_irq_now, drvdata->t_irq_last);
293 	if (us_delta > PS2_IRQ_MAX_INTERVAL_US && cnt > 1) {
294 		dev_err(drvdata->dev,
295 			"TX: timeout, probably we missed an interrupt\n");
296 		goto err;
297 	} else if (unlikely(us_delta < PS2_IRQ_MIN_INTERVAL_US)) {
298 		/* Ignore spurious IRQs. */
299 		goto end;
300 	}
301 	drvdata->t_irq_last = drvdata->t_irq_now;
302 
303 	switch (cnt) {
304 	case PS2_START_BIT:
305 		/* should never happen */
306 		dev_err(drvdata->dev,
307 			"TX: start bit should have been sent already\n");
308 		goto err;
309 	case PS2_DATA_BIT0:
310 	case PS2_DATA_BIT1:
311 	case PS2_DATA_BIT2:
312 	case PS2_DATA_BIT3:
313 	case PS2_DATA_BIT4:
314 	case PS2_DATA_BIT5:
315 	case PS2_DATA_BIT6:
316 	case PS2_DATA_BIT7:
317 		data = byte & BIT(cnt - 1);
318 		gpiod_set_value(drvdata->gpio_data, data);
319 		break;
320 	case PS2_PARITY_BIT:
321 		/* do odd parity */
322 		data = !(hweight8(byte) & 1);
323 		gpiod_set_value(drvdata->gpio_data, data);
324 		break;
325 	case PS2_STOP_BIT:
326 		/* release data line to generate stop bit */
327 		gpiod_direction_input(drvdata->gpio_data);
328 		break;
329 	case PS2_ACK_BIT:
330 		data = gpiod_get_value(drvdata->gpio_data);
331 		if (data) {
332 			dev_warn(drvdata->dev, "TX: received NACK, retry\n");
333 			goto err;
334 		}
335 
336 		drvdata->tx.t_xfer_end = ktime_get();
337 		drvdata->mode = PS2_MODE_RX;
338 		complete(&drvdata->tx.complete);
339 
340 		cnt = 1;
341 		goto end; /* success */
342 	default:
343 		/*
344 		 * Probably we missed the stop bit. Therefore we release data
345 		 * line and try again.
346 		 */
347 		gpiod_direction_input(drvdata->gpio_data);
348 		dev_err(drvdata->dev, "TX: got out of sync with the device\n");
349 		goto err;
350 	}
351 
352 	cnt++;
353 	goto end; /* success */
354 
355 err:
356 	cnt = 1;
357 	gpiod_direction_input(drvdata->gpio_data);
358 	__ps2_gpio_write(drvdata->serio, drvdata->tx.byte);
359 end:
360 	drvdata->tx.cnt = cnt;
361 	return IRQ_HANDLED;
362 }
363 
ps2_gpio_irq(int irq,void * dev_id)364 static irqreturn_t ps2_gpio_irq(int irq, void *dev_id)
365 {
366 	struct ps2_gpio_data *drvdata = dev_id;
367 
368 	return drvdata->mode ? ps2_gpio_irq_tx(drvdata) :
369 		ps2_gpio_irq_rx(drvdata);
370 }
371 
ps2_gpio_get_props(struct device * dev,struct ps2_gpio_data * drvdata)372 static int ps2_gpio_get_props(struct device *dev,
373 				 struct ps2_gpio_data *drvdata)
374 {
375 	enum gpiod_flags gflags;
376 
377 	/* Enforce open drain, since this is required by the PS/2 bus. */
378 	gflags = GPIOD_IN | GPIOD_FLAGS_BIT_OPEN_DRAIN;
379 
380 	drvdata->gpio_data = devm_gpiod_get(dev, "data", gflags);
381 	if (IS_ERR(drvdata->gpio_data)) {
382 		dev_err(dev, "failed to request data gpio: %ld",
383 			PTR_ERR(drvdata->gpio_data));
384 		return PTR_ERR(drvdata->gpio_data);
385 	}
386 
387 	drvdata->gpio_clk = devm_gpiod_get(dev, "clk", gflags);
388 	if (IS_ERR(drvdata->gpio_clk)) {
389 		dev_err(dev, "failed to request clock gpio: %ld",
390 			PTR_ERR(drvdata->gpio_clk));
391 		return PTR_ERR(drvdata->gpio_clk);
392 	}
393 
394 	drvdata->write_enable = device_property_read_bool(dev,
395 				"write-enable");
396 
397 	return 0;
398 }
399 
ps2_gpio_probe(struct platform_device * pdev)400 static int ps2_gpio_probe(struct platform_device *pdev)
401 {
402 	struct ps2_gpio_data *drvdata;
403 	struct serio *serio;
404 	struct device *dev = &pdev->dev;
405 	int error;
406 
407 	drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
408 	serio = kzalloc(sizeof(*serio), GFP_KERNEL);
409 	if (!drvdata || !serio) {
410 		error = -ENOMEM;
411 		goto err_free_serio;
412 	}
413 
414 	error = ps2_gpio_get_props(dev, drvdata);
415 	if (error)
416 		goto err_free_serio;
417 
418 	if (gpiod_cansleep(drvdata->gpio_data) ||
419 	    gpiod_cansleep(drvdata->gpio_clk)) {
420 		dev_err(dev, "GPIO data or clk are connected via slow bus\n");
421 		error = -EINVAL;
422 		goto err_free_serio;
423 	}
424 
425 	drvdata->irq = platform_get_irq(pdev, 0);
426 	if (drvdata->irq < 0) {
427 		error = drvdata->irq;
428 		goto err_free_serio;
429 	}
430 
431 	error = devm_request_irq(dev, drvdata->irq, ps2_gpio_irq,
432 				 IRQF_NO_THREAD | IRQF_NO_AUTOEN, DRIVER_NAME,
433 				 drvdata);
434 	if (error) {
435 		dev_err(dev, "failed to request irq %d: %d\n",
436 			drvdata->irq, error);
437 		goto err_free_serio;
438 	}
439 
440 	serio->id.type = SERIO_8042;
441 	serio->open = ps2_gpio_open;
442 	serio->close = ps2_gpio_close;
443 	/*
444 	 * Write can be enabled in platform/dt data, but possibly it will not
445 	 * work because of the tough timings.
446 	 */
447 	serio->write = drvdata->write_enable ? ps2_gpio_write : NULL;
448 	serio->port_data = drvdata;
449 	serio->dev.parent = dev;
450 	strscpy(serio->name, dev_name(dev), sizeof(serio->name));
451 	strscpy(serio->phys, dev_name(dev), sizeof(serio->phys));
452 
453 	drvdata->serio = serio;
454 	drvdata->dev = dev;
455 	drvdata->mode = PS2_MODE_RX;
456 
457 	/*
458 	 * Tx count always starts at 1, as the start bit is sent implicitly by
459 	 * host-to-device communication initialization.
460 	 */
461 	drvdata->tx.cnt = 1;
462 
463 	INIT_DELAYED_WORK(&drvdata->tx.work, ps2_gpio_tx_work_fn);
464 	init_completion(&drvdata->tx.complete);
465 	mutex_init(&drvdata->tx.mutex);
466 
467 	serio_register_port(serio);
468 	platform_set_drvdata(pdev, drvdata);
469 
470 	return 0;	/* success */
471 
472 err_free_serio:
473 	kfree(serio);
474 	return error;
475 }
476 
ps2_gpio_remove(struct platform_device * pdev)477 static void ps2_gpio_remove(struct platform_device *pdev)
478 {
479 	struct ps2_gpio_data *drvdata = platform_get_drvdata(pdev);
480 
481 	serio_unregister_port(drvdata->serio);
482 }
483 
484 #if defined(CONFIG_OF)
485 static const struct of_device_id ps2_gpio_match[] = {
486 	{ .compatible = "ps2-gpio", },
487 	{ },
488 };
489 MODULE_DEVICE_TABLE(of, ps2_gpio_match);
490 #endif
491 
492 static struct platform_driver ps2_gpio_driver = {
493 	.probe		= ps2_gpio_probe,
494 	.remove		= ps2_gpio_remove,
495 	.driver = {
496 		.name = DRIVER_NAME,
497 		.of_match_table = of_match_ptr(ps2_gpio_match),
498 	},
499 };
500 module_platform_driver(ps2_gpio_driver);
501 
502 MODULE_AUTHOR("Danilo Krummrich <danilokrummrich@dk-develop.de>");
503 MODULE_DESCRIPTION("GPIO PS2 driver");
504 MODULE_LICENSE("GPL v2");
505