drivers/input/serio/sa1111ps2.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  linux/drivers/input/serio/sa1111ps2.c
   4  *
   5  *  Copyright (C) 2002 Russell King
   6  */
   7 #include <linux/module.h>
   8 #include <linux/init.h>
   9 #include <linux/input.h>
  10 #include <linux/serio.h>
  11 #include <linux/errno.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/ioport.h>
  14 #include <linux/delay.h>
  15 #include <linux/device.h>
  16 #include <linux/slab.h>
  17 #include <linux/spinlock.h>
  18
  19 #include <asm/io.h>
  20
  21 #include <asm/hardware/sa1111.h>
  22
  23 #define PS2CR           0x0000
  24 #define PS2STAT         0x0004
  25 #define PS2DATA         0x0008
  26 #define PS2CLKDIV       0x000c
  27 #define PS2PRECNT       0x0010
  28
  29 #define PS2CR_ENA       0x08
  30 #define PS2CR_FKD       0x02
  31 #define PS2CR_FKC       0x01
  32
  33 #define PS2STAT_STP     0x0100
  34 #define PS2STAT_TXE     0x0080
  35 #define PS2STAT_TXB     0x0040
  36 #define PS2STAT_RXF     0x0020
  37 #define PS2STAT_RXB     0x0010
  38 #define PS2STAT_ENA     0x0008
  39 #define PS2STAT_RXP     0x0004
  40 #define PS2STAT_KBD     0x0002
  41 #define PS2STAT_KBC     0x0001
  42
  43 struct ps2if {
  44         struct serio            *io;
  45         struct sa1111_dev       *dev;
  46         void __iomem            *base;
  47         int                     rx_irq;
  48         int                     tx_irq;
  49         unsigned int            open;
  50         spinlock_t              lock;
  51         unsigned int            head;
  52         unsigned int            tail;
  53         unsigned char           buf[4];
  54 };
  55
  56 /*
  57  * Read all bytes waiting in the PS2 port.  There should be
  58  * at the most one, but we loop for safety.  If there was a
  59  * framing error, we have to manually clear the status.
  60  */
  61 static irqreturn_t ps2_rxint(int irq, void *dev_id)
  62 {
  63         struct ps2if *ps2if = dev_id;
  64         unsigned int scancode, flag, status;
  65
  66         status = readl_relaxed(ps2if->base + PS2STAT);
  67         while (status & PS2STAT_RXF) {
  68                 if (status & PS2STAT_STP)
  69                         writel_relaxed(PS2STAT_STP, ps2if->base + PS2STAT);
  70
  71                 flag = (status & PS2STAT_STP ? SERIO_FRAME : 0) |
  72                        (status & PS2STAT_RXP ? 0 : SERIO_PARITY);
  73
  74                 scancode = readl_relaxed(ps2if->base + PS2DATA) & 0xff;
  75
  76                 if (hweight8(scancode) & 1)
  77                         flag ^= SERIO_PARITY;
  78
  79                 serio_interrupt(ps2if->io, scancode, flag);
  80
  81                 status = readl_relaxed(ps2if->base + PS2STAT);
  82         }
  83
  84         return IRQ_HANDLED;
  85 }
  86
  87 /*
  88  * Completion of ps2 write
  89  */
  90 static irqreturn_t ps2_txint(int irq, void *dev_id)
  91 {
  92         struct ps2if *ps2if = dev_id;
  93         unsigned int status;
  94
  95         guard(spinlock)(&ps2if->lock);
  96
  97         status = readl_relaxed(ps2if->base + PS2STAT);
  98         if (ps2if->head == ps2if->tail) {
  99                 disable_irq_nosync(irq);
 100                 /* done */
 101         } else if (status & PS2STAT_TXE) {
 102                 writel_relaxed(ps2if->buf[ps2if->tail], ps2if->base + PS2DATA);
 103                 ps2if->tail = (ps2if->tail + 1) & (sizeof(ps2if->buf) - 1);
 104         }
 105
 106         return IRQ_HANDLED;
 107 }
 108
 109 /*
 110  * Write a byte to the PS2 port.  We have to wait for the
 111  * port to indicate that the transmitter is empty.
 112  */
 113 static int ps2_write(struct serio *io, unsigned char val)
 114 {
 115         struct ps2if *ps2if = io->port_data;
 116         unsigned int head;
 117
 118         guard(spinlock_irqsave)(&ps2if->lock);
 119
 120         /*
 121          * If the TX register is empty, we can go straight out.
 122          */
 123         if (readl_relaxed(ps2if->base + PS2STAT) & PS2STAT_TXE) {
 124                 writel_relaxed(val, ps2if->base + PS2DATA);
 125         } else {
 126                 if (ps2if->head == ps2if->tail)
 127                         enable_irq(ps2if->tx_irq);
 128                 head = (ps2if->head + 1) & (sizeof(ps2if->buf) - 1);
 129                 if (head != ps2if->tail) {
 130                         ps2if->buf[ps2if->head] = val;
 131                         ps2if->head = head;
 132                 }
 133         }
 134
 135         return 0;
 136 }
 137
 138 static int ps2_open(struct serio *io)
 139 {
 140         struct ps2if *ps2if = io->port_data;
 141         int ret;
 142
 143         ret = sa1111_enable_device(ps2if->dev);
 144         if (ret)
 145                 return ret;
 146
 147         ret = request_irq(ps2if->rx_irq, ps2_rxint, 0,
 148                           SA1111_DRIVER_NAME(ps2if->dev), ps2if);
 149         if (ret) {
 150                 printk(KERN_ERR "sa1111ps2: could not allocate IRQ%d: %d\n",
 151                         ps2if->rx_irq, ret);
 152                 sa1111_disable_device(ps2if->dev);
 153                 return ret;
 154         }
 155
 156         ret = request_irq(ps2if->tx_irq, ps2_txint, 0,
 157                           SA1111_DRIVER_NAME(ps2if->dev), ps2if);
 158         if (ret) {
 159                 printk(KERN_ERR "sa1111ps2: could not allocate IRQ%d: %d\n",
 160                         ps2if->tx_irq, ret);
 161                 free_irq(ps2if->rx_irq, ps2if);
 162                 sa1111_disable_device(ps2if->dev);
 163                 return ret;
 164         }
 165
 166         ps2if->open = 1;
 167
 168         enable_irq_wake(ps2if->rx_irq);
 169
 170         writel_relaxed(PS2CR_ENA, ps2if->base + PS2CR);
 171         return 0;
 172 }
 173
 174 static void ps2_close(struct serio *io)
 175 {
 176         struct ps2if *ps2if = io->port_data;
 177
 178         writel_relaxed(0, ps2if->base + PS2CR);
 179
 180         disable_irq_wake(ps2if->rx_irq);
 181
 182         ps2if->open = 0;
 183
 184         free_irq(ps2if->tx_irq, ps2if);
 185         free_irq(ps2if->rx_irq, ps2if);
 186
 187         sa1111_disable_device(ps2if->dev);
 188 }
 189
 190 /*
 191  * Clear the input buffer.
 192  */
 193 static void ps2_clear_input(struct ps2if *ps2if)
 194 {
 195         int maxread = 100;
 196
 197         while (maxread--) {
 198                 if ((readl_relaxed(ps2if->base + PS2DATA) & 0xff) == 0xff)
 199                         break;
 200         }
 201 }
 202
 203 static unsigned int ps2_test_one(struct ps2if *ps2if,
 204                                            unsigned int mask)
 205 {
 206         unsigned int val;
 207
 208         writel_relaxed(PS2CR_ENA | mask, ps2if->base + PS2CR);
 209
 210         udelay(10);
 211
 212         val = readl_relaxed(ps2if->base + PS2STAT);
 213         return val & (PS2STAT_KBC | PS2STAT_KBD);
 214 }
 215
 216 /*
 217  * Test the keyboard interface.  We basically check to make sure that
 218  * we can drive each line to the keyboard independently of each other.
 219  */
 220 static int ps2_test(struct ps2if *ps2if)
 221 {
 222         unsigned int stat;
 223         int ret = 0;
 224
 225         stat = ps2_test_one(ps2if, PS2CR_FKC);
 226         if (stat != PS2STAT_KBD) {
 227                 printk("PS/2 interface test failed[1]: %02x\n", stat);
 228                 ret = -ENODEV;
 229         }
 230
 231         stat = ps2_test_one(ps2if, 0);
 232         if (stat != (PS2STAT_KBC | PS2STAT_KBD)) {
 233                 printk("PS/2 interface test failed[2]: %02x\n", stat);
 234                 ret = -ENODEV;
 235         }
 236
 237         stat = ps2_test_one(ps2if, PS2CR_FKD);
 238         if (stat != PS2STAT_KBC) {
 239                 printk("PS/2 interface test failed[3]: %02x\n", stat);
 240                 ret = -ENODEV;
 241         }
 242
 243         writel_relaxed(0, ps2if->base + PS2CR);
 244
 245         return ret;
 246 }
 247
 248 /*
 249  * Add one device to this driver.
 250  */
 251 static int ps2_probe(struct sa1111_dev *dev)
 252 {
 253         struct ps2if *ps2if;
 254         struct serio *serio;
 255         int ret;
 256
 257         ps2if = kzalloc(sizeof(*ps2if), GFP_KERNEL);
 258         serio = kzalloc(sizeof(*serio), GFP_KERNEL);
 259         if (!ps2if || !serio) {
 260                 ret = -ENOMEM;
 261                 goto free;
 262         }
 263
 264         serio->id.type          = SERIO_8042;
 265         serio->write            = ps2_write;
 266         serio->open             = ps2_open;
 267         serio->close            = ps2_close;
 268         strscpy(serio->name, dev_name(&dev->dev), sizeof(serio->name));
 269         strscpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys));
 270         serio->port_data        = ps2if;
 271         serio->dev.parent       = &dev->dev;
 272         ps2if->io               = serio;
 273         ps2if->dev              = dev;
 274         sa1111_set_drvdata(dev, ps2if);
 275
 276         spin_lock_init(&ps2if->lock);
 277
 278         ps2if->rx_irq = sa1111_get_irq(dev, 0);
 279         if (ps2if->rx_irq <= 0) {
 280                 ret = ps2if->rx_irq ? : -ENXIO;
 281                 goto free;
 282         }
 283
 284         ps2if->tx_irq = sa1111_get_irq(dev, 1);
 285         if (ps2if->tx_irq <= 0) {
 286                 ret = ps2if->tx_irq ? : -ENXIO;
 287                 goto free;
 288         }
 289
 290         /*
 291          * Request the physical region for this PS2 port.
 292          */
 293         if (!request_mem_region(dev->res.start,
 294                                 dev->res.end - dev->res.start + 1,
 295                                 SA1111_DRIVER_NAME(dev))) {
 296                 ret = -EBUSY;
 297                 goto free;
 298         }
 299
 300         /*
 301          * Our parent device has already mapped the region.
 302          */
 303         ps2if->base = dev->mapbase;
 304
 305         sa1111_enable_device(ps2if->dev);
 306
 307         /* Incoming clock is 8MHz */
 308         writel_relaxed(0, ps2if->base + PS2CLKDIV);
 309         writel_relaxed(127, ps2if->base + PS2PRECNT);
 310
 311         /*
 312          * Flush any pending input.
 313          */
 314         ps2_clear_input(ps2if);
 315
 316         /*
 317          * Test the keyboard interface.
 318          */
 319         ret = ps2_test(ps2if);
 320         if (ret)
 321                 goto out;
 322
 323         /*
 324          * Flush any pending input.
 325          */
 326         ps2_clear_input(ps2if);
 327
 328         sa1111_disable_device(ps2if->dev);
 329         serio_register_port(ps2if->io);
 330         return 0;
 331
 332  out:
 333         sa1111_disable_device(ps2if->dev);
 334         release_mem_region(dev->res.start, resource_size(&dev->res));
 335  free:
 336         sa1111_set_drvdata(dev, NULL);
 337         kfree(ps2if);
 338         kfree(serio);
 339         return ret;
 340 }
 341
 342 /*
 343  * Remove one device from this driver.
 344  */
 345 static void ps2_remove(struct sa1111_dev *dev)
 346 {
 347         struct ps2if *ps2if = sa1111_get_drvdata(dev);
 348
 349         serio_unregister_port(ps2if->io);
 350         release_mem_region(dev->res.start, resource_size(&dev->res));
 351         sa1111_set_drvdata(dev, NULL);
 352
 353         kfree(ps2if);
 354 }
 355
 356 /*
 357  * Our device driver structure
 358  */
 359 static struct sa1111_driver ps2_driver = {
 360         .drv = {
 361                 .name   = "sa1111-ps2",
 362                 .owner  = THIS_MODULE,
 363         },
 364         .devid          = SA1111_DEVID_PS2,
 365         .probe          = ps2_probe,
 366         .remove         = ps2_remove,
 367 };
 368
 369 static int __init ps2_init(void)
 370 {
 371         return sa1111_driver_register(&ps2_driver);
 372 }
 373
 374 static void __exit ps2_exit(void)
 375 {
 376         sa1111_driver_unregister(&ps2_driver);
 377 }
 378
 379 module_init(ps2_init);
 380 module_exit(ps2_exit);
 381
 382 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
 383 MODULE_DESCRIPTION("SA1111 PS2 controller driver");
 384 MODULE_LICENSE("GPL");