drivers/input/serio/ps2-gpio.c

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