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 47 struct 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 64 static 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 72 static 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 80 static 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 95 static 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 114 static 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 126 static 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 218 err: 219 cnt = byte = 0; 220 old_jiffies = 0; 221 __ps2_gpio_write(drvdata->serio, PS2_CMD_RESEND); 222 end: 223 drvdata->rx_cnt = cnt; 224 drvdata->rx_byte = byte; 225 return IRQ_HANDLED; 226 } 227 228 static 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 304 err: 305 cnt = 1; 306 old_jiffies = 0; 307 gpiod_direction_input(drvdata->gpio_data); 308 __ps2_gpio_write(drvdata->serio, drvdata->tx_byte); 309 end: 310 drvdata->tx_cnt = cnt; 311 return IRQ_HANDLED; 312 } 313 314 static 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 322 static 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 345 static 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 417 err_free_serio: 418 kfree(serio); 419 return error; 420 } 421 422 static 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) 431 static const struct of_device_id ps2_gpio_match[] = { 432 { .compatible = "ps2-gpio", }, 433 { }, 434 }; 435 MODULE_DEVICE_TABLE(of, ps2_gpio_match); 436 #endif 437 438 static 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 }; 446 module_platform_driver(ps2_gpio_driver); 447 448 MODULE_AUTHOR("Danilo Krummrich <danilokrummrich@dk-develop.de>"); 449 MODULE_DESCRIPTION("GPIO PS2 driver"); 450 MODULE_LICENSE("GPL v2"); 451