root/drivers/input/serio/ps2-gpio.c

DEFINITIONS

1. ps2_gpio_open
2. ps2_gpio_close
3. __ps2_gpio_write
4. ps2_gpio_write
5. ps2_gpio_tx_work_fn
6. ps2_gpio_irq_rx
7. ps2_gpio_irq_tx
8. ps2_gpio_irq
9. ps2_gpio_get_props
10. ps2_gpio_probe
11. ps2_gpio_remove

   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");