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