Loading...
Note: File does not exist in v4.6.
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
23#define DRIVER_NAME "ps2-gpio"
24
25#define PS2_MODE_RX 0
26#define PS2_MODE_TX 1
27
28#define PS2_START_BIT 0
29#define PS2_DATA_BIT0 1
30#define PS2_DATA_BIT1 2
31#define PS2_DATA_BIT2 3
32#define PS2_DATA_BIT3 4
33#define PS2_DATA_BIT4 5
34#define PS2_DATA_BIT5 6
35#define PS2_DATA_BIT6 7
36#define PS2_DATA_BIT7 8
37#define PS2_PARITY_BIT 9
38#define PS2_STOP_BIT 10
39#define PS2_TX_TIMEOUT 11
40#define PS2_ACK_BIT 12
41
42#define PS2_DEV_RET_ACK 0xfa
43#define PS2_DEV_RET_NACK 0xfe
44
45#define PS2_CMD_RESEND 0xfe
46
47struct ps2_gpio_data {
48 struct device *dev;
49 struct serio *serio;
50 unsigned char mode;
51 struct gpio_desc *gpio_clk;
52 struct gpio_desc *gpio_data;
53 bool write_enable;
54 int irq;
55 unsigned char rx_cnt;
56 unsigned char rx_byte;
57 unsigned char tx_cnt;
58 unsigned char tx_byte;
59 struct completion tx_done;
60 struct mutex tx_mutex;
61 struct delayed_work tx_work;
62};
63
64static int ps2_gpio_open(struct serio *serio)
65{
66 struct ps2_gpio_data *drvdata = serio->port_data;
67
68 enable_irq(drvdata->irq);
69 return 0;
70}
71
72static void ps2_gpio_close(struct serio *serio)
73{
74 struct ps2_gpio_data *drvdata = serio->port_data;
75
76 flush_delayed_work(&drvdata->tx_work);
77 disable_irq(drvdata->irq);
78}
79
80static int __ps2_gpio_write(struct serio *serio, unsigned char val)
81{
82 struct ps2_gpio_data *drvdata = serio->port_data;
83
84 disable_irq_nosync(drvdata->irq);
85 gpiod_direction_output(drvdata->gpio_clk, 0);
86
87 drvdata->mode = PS2_MODE_TX;
88 drvdata->tx_byte = val;
89
90 schedule_delayed_work(&drvdata->tx_work, usecs_to_jiffies(200));
91
92 return 0;
93}
94
95static int ps2_gpio_write(struct serio *serio, unsigned char val)
96{
97 struct ps2_gpio_data *drvdata = serio->port_data;
98 int ret = 0;
99
100 if (in_task()) {
101 mutex_lock(&drvdata->tx_mutex);
102 __ps2_gpio_write(serio, val);
103 if (!wait_for_completion_timeout(&drvdata->tx_done,
104 msecs_to_jiffies(10000)))
105 ret = SERIO_TIMEOUT;
106 mutex_unlock(&drvdata->tx_mutex);
107 } else {
108 __ps2_gpio_write(serio, val);
109 }
110
111 return ret;
112}
113
114static void ps2_gpio_tx_work_fn(struct work_struct *work)
115{
116 struct delayed_work *dwork = to_delayed_work(work);
117 struct ps2_gpio_data *drvdata = container_of(dwork,
118 struct ps2_gpio_data,
119 tx_work);
120
121 enable_irq(drvdata->irq);
122 gpiod_direction_output(drvdata->gpio_data, 0);
123 gpiod_direction_input(drvdata->gpio_clk);
124}
125
126static irqreturn_t ps2_gpio_irq_rx(struct ps2_gpio_data *drvdata)
127{
128 unsigned char byte, cnt;
129 int data;
130 int rxflags = 0;
131 static unsigned long old_jiffies;
132
133 byte = drvdata->rx_byte;
134 cnt = drvdata->rx_cnt;
135
136 if (old_jiffies == 0)
137 old_jiffies = jiffies;
138
139 if ((jiffies - old_jiffies) > usecs_to_jiffies(100)) {
140 dev_err(drvdata->dev,
141 "RX: timeout, probably we missed an interrupt\n");
142 goto err;
143 }
144 old_jiffies = jiffies;
145
146 data = gpiod_get_value(drvdata->gpio_data);
147 if (unlikely(data < 0)) {
148 dev_err(drvdata->dev, "RX: failed to get data gpio val: %d\n",
149 data);
150 goto err;
151 }
152
153 switch (cnt) {
154 case PS2_START_BIT:
155 /* start bit should be low */
156 if (unlikely(data)) {
157 dev_err(drvdata->dev, "RX: start bit should be low\n");
158 goto err;
159 }
160 break;
161 case PS2_DATA_BIT0:
162 case PS2_DATA_BIT1:
163 case PS2_DATA_BIT2:
164 case PS2_DATA_BIT3:
165 case PS2_DATA_BIT4:
166 case PS2_DATA_BIT5:
167 case PS2_DATA_BIT6:
168 case PS2_DATA_BIT7:
169 /* processing data bits */
170 if (data)
171 byte |= (data << (cnt - 1));
172 break;
173 case PS2_PARITY_BIT:
174 /* check odd parity */
175 if (!((hweight8(byte) & 1) ^ data)) {
176 rxflags |= SERIO_PARITY;
177 dev_warn(drvdata->dev, "RX: parity error\n");
178 if (!drvdata->write_enable)
179 goto err;
180 }
181
182 /* Do not send spurious ACK's and NACK's when write fn is
183 * not provided.
184 */
185 if (!drvdata->write_enable) {
186 if (byte == PS2_DEV_RET_NACK)
187 goto err;
188 else if (byte == PS2_DEV_RET_ACK)
189 break;
190 }
191
192 /* Let's send the data without waiting for the stop bit to be
193 * sent. It may happen that we miss the stop bit. When this
194 * happens we have no way to recover from this, certainly
195 * missing the parity bit would be recognized when processing
196 * the stop bit. When missing both, data is lost.
197 */
198 serio_interrupt(drvdata->serio, byte, rxflags);
199 dev_dbg(drvdata->dev, "RX: sending byte 0x%x\n", byte);
200 break;
201 case PS2_STOP_BIT:
202 /* stop bit should be high */
203 if (unlikely(!data)) {
204 dev_err(drvdata->dev, "RX: stop bit should be high\n");
205 goto err;
206 }
207 cnt = byte = 0;
208 old_jiffies = 0;
209 goto end; /* success */
210 default:
211 dev_err(drvdata->dev, "RX: got out of sync with the device\n");
212 goto err;
213 }
214
215 cnt++;
216 goto end; /* success */
217
218err:
219 cnt = byte = 0;
220 old_jiffies = 0;
221 __ps2_gpio_write(drvdata->serio, PS2_CMD_RESEND);
222end:
223 drvdata->rx_cnt = cnt;
224 drvdata->rx_byte = byte;
225 return IRQ_HANDLED;
226}
227
228static irqreturn_t ps2_gpio_irq_tx(struct ps2_gpio_data *drvdata)
229{
230 unsigned char byte, cnt;
231 int data;
232 static unsigned long old_jiffies;
233
234 cnt = drvdata->tx_cnt;
235 byte = drvdata->tx_byte;
236
237 if (old_jiffies == 0)
238 old_jiffies = jiffies;
239
240 if ((jiffies - old_jiffies) > usecs_to_jiffies(100)) {
241 dev_err(drvdata->dev,
242 "TX: timeout, probably we missed an interrupt\n");
243 goto err;
244 }
245 old_jiffies = jiffies;
246
247 switch (cnt) {
248 case PS2_START_BIT:
249 /* should never happen */
250 dev_err(drvdata->dev,
251 "TX: start bit should have been sent already\n");
252 goto err;
253 case PS2_DATA_BIT0:
254 case PS2_DATA_BIT1:
255 case PS2_DATA_BIT2:
256 case PS2_DATA_BIT3:
257 case PS2_DATA_BIT4:
258 case PS2_DATA_BIT5:
259 case PS2_DATA_BIT6:
260 case PS2_DATA_BIT7:
261 data = byte & BIT(cnt - 1);
262 gpiod_set_value(drvdata->gpio_data, data);
263 break;
264 case PS2_PARITY_BIT:
265 /* do odd parity */
266 data = !(hweight8(byte) & 1);
267 gpiod_set_value(drvdata->gpio_data, data);
268 break;
269 case PS2_STOP_BIT:
270 /* release data line to generate stop bit */
271 gpiod_direction_input(drvdata->gpio_data);
272 break;
273 case PS2_TX_TIMEOUT:
274 /* Devices generate one extra clock pulse before sending the
275 * acknowledgment.
276 */
277 break;
278 case PS2_ACK_BIT:
279 gpiod_direction_input(drvdata->gpio_data);
280 data = gpiod_get_value(drvdata->gpio_data);
281 if (data) {
282 dev_warn(drvdata->dev, "TX: received NACK, retry\n");
283 goto err;
284 }
285
286 drvdata->mode = PS2_MODE_RX;
287 complete(&drvdata->tx_done);
288
289 cnt = 1;
290 old_jiffies = 0;
291 goto end; /* success */
292 default:
293 /* Probably we missed the stop bit. Therefore we release data
294 * line and try again.
295 */
296 gpiod_direction_input(drvdata->gpio_data);
297 dev_err(drvdata->dev, "TX: got out of sync with the device\n");
298 goto err;
299 }
300
301 cnt++;
302 goto end; /* success */
303
304err:
305 cnt = 1;
306 old_jiffies = 0;
307 gpiod_direction_input(drvdata->gpio_data);
308 __ps2_gpio_write(drvdata->serio, drvdata->tx_byte);
309end:
310 drvdata->tx_cnt = cnt;
311 return IRQ_HANDLED;
312}
313
314static irqreturn_t ps2_gpio_irq(int irq, void *dev_id)
315{
316 struct ps2_gpio_data *drvdata = dev_id;
317
318 return drvdata->mode ? ps2_gpio_irq_tx(drvdata) :
319 ps2_gpio_irq_rx(drvdata);
320}
321
322static int ps2_gpio_get_props(struct device *dev,
323 struct ps2_gpio_data *drvdata)
324{
325 drvdata->gpio_data = devm_gpiod_get(dev, "data", GPIOD_IN);
326 if (IS_ERR(drvdata->gpio_data)) {
327 dev_err(dev, "failed to request data gpio: %ld",
328 PTR_ERR(drvdata->gpio_data));
329 return PTR_ERR(drvdata->gpio_data);
330 }
331
332 drvdata->gpio_clk = devm_gpiod_get(dev, "clk", GPIOD_IN);
333 if (IS_ERR(drvdata->gpio_clk)) {
334 dev_err(dev, "failed to request clock gpio: %ld",
335 PTR_ERR(drvdata->gpio_clk));
336 return PTR_ERR(drvdata->gpio_clk);
337 }
338
339 drvdata->write_enable = device_property_read_bool(dev,
340 "write-enable");
341
342 return 0;
343}
344
345static int ps2_gpio_probe(struct platform_device *pdev)
346{
347 struct ps2_gpio_data *drvdata;
348 struct serio *serio;
349 struct device *dev = &pdev->dev;
350 int error;
351
352 drvdata = devm_kzalloc(dev, sizeof(struct ps2_gpio_data), GFP_KERNEL);
353 serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
354 if (!drvdata || !serio) {
355 error = -ENOMEM;
356 goto err_free_serio;
357 }
358
359 error = ps2_gpio_get_props(dev, drvdata);
360 if (error)
361 goto err_free_serio;
362
363 if (gpiod_cansleep(drvdata->gpio_data) ||
364 gpiod_cansleep(drvdata->gpio_clk)) {
365 dev_err(dev, "GPIO data or clk are connected via slow bus\n");
366 error = -EINVAL;
367 goto err_free_serio;
368 }
369
370 drvdata->irq = platform_get_irq(pdev, 0);
371 if (drvdata->irq < 0) {
372 error = drvdata->irq;
373 goto err_free_serio;
374 }
375
376 error = devm_request_irq(dev, drvdata->irq, ps2_gpio_irq,
377 IRQF_NO_THREAD, DRIVER_NAME, drvdata);
378 if (error) {
379 dev_err(dev, "failed to request irq %d: %d\n",
380 drvdata->irq, error);
381 goto err_free_serio;
382 }
383
384 /* Keep irq disabled until serio->open is called. */
385 disable_irq(drvdata->irq);
386
387 serio->id.type = SERIO_8042;
388 serio->open = ps2_gpio_open;
389 serio->close = ps2_gpio_close;
390 /* Write can be enabled in platform/dt data, but possibly it will not
391 * work because of the tough timings.
392 */
393 serio->write = drvdata->write_enable ? ps2_gpio_write : NULL;
394 serio->port_data = drvdata;
395 serio->dev.parent = dev;
396 strlcpy(serio->name, dev_name(dev), sizeof(serio->name));
397 strlcpy(serio->phys, dev_name(dev), sizeof(serio->phys));
398
399 drvdata->serio = serio;
400 drvdata->dev = dev;
401 drvdata->mode = PS2_MODE_RX;
402
403 /* Tx count always starts at 1, as the start bit is sent implicitly by
404 * host-to-device communication initialization.
405 */
406 drvdata->tx_cnt = 1;
407
408 INIT_DELAYED_WORK(&drvdata->tx_work, ps2_gpio_tx_work_fn);
409 init_completion(&drvdata->tx_done);
410 mutex_init(&drvdata->tx_mutex);
411
412 serio_register_port(serio);
413 platform_set_drvdata(pdev, drvdata);
414
415 return 0; /* success */
416
417err_free_serio:
418 kfree(serio);
419 return error;
420}
421
422static int ps2_gpio_remove(struct platform_device *pdev)
423{
424 struct ps2_gpio_data *drvdata = platform_get_drvdata(pdev);
425
426 serio_unregister_port(drvdata->serio);
427 return 0;
428}
429
430#if defined(CONFIG_OF)
431static const struct of_device_id ps2_gpio_match[] = {
432 { .compatible = "ps2-gpio", },
433 { },
434};
435MODULE_DEVICE_TABLE(of, ps2_gpio_match);
436#endif
437
438static struct platform_driver ps2_gpio_driver = {
439 .probe = ps2_gpio_probe,
440 .remove = ps2_gpio_remove,
441 .driver = {
442 .name = DRIVER_NAME,
443 .of_match_table = of_match_ptr(ps2_gpio_match),
444 },
445};
446module_platform_driver(ps2_gpio_driver);
447
448MODULE_AUTHOR("Danilo Krummrich <danilokrummrich@dk-develop.de>");
449MODULE_DESCRIPTION("GPIO PS2 driver");
450MODULE_LICENSE("GPL v2");