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         spin_lock(&ps2if->lock);
  96         status = readl_relaxed(ps2if->base + PS2STAT);
  97         if (ps2if->head == ps2if->tail) {
  98                 disable_irq_nosync(irq);
  99                 /* done */
 100         } else if (status & PS2STAT_TXE) {
 101                 writel_relaxed(ps2if->buf[ps2if->tail], ps2if->base + PS2DATA);
 102                 ps2if->tail = (ps2if->tail + 1) & (sizeof(ps2if->buf) - 1);
 103         }
 104         spin_unlock(&ps2if->lock);
 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 long flags;
 117         unsigned int head;
 118
 119         spin_lock_irqsave(&ps2if->lock, flags);
 120
 121         /*
 122          * If the TX register is empty, we can go straight out.
 123          */
 124         if (readl_relaxed(ps2if->base + PS2STAT) & PS2STAT_TXE) {
 125                 writel_relaxed(val, ps2if->base + PS2DATA);
 126         } else {
 127                 if (ps2if->head == ps2if->tail)
 128                         enable_irq(ps2if->tx_irq);
 129                 head = (ps2if->head + 1) & (sizeof(ps2if->buf) - 1);
 130                 if (head != ps2if->tail) {
 131                         ps2if->buf[ps2if->head] = val;
 132                         ps2if->head = head;
 133                 }
 134         }
 135
 136         spin_unlock_irqrestore(&ps2if->lock, flags);
 137         return 0;
 138 }
 139
 140 static int ps2_open(struct serio *io)
 141 {
 142         struct ps2if *ps2if = io->port_data;
 143         int ret;
 144
 145         ret = sa1111_enable_device(ps2if->dev);
 146         if (ret)
 147                 return ret;
 148
 149         ret = request_irq(ps2if->rx_irq, ps2_rxint, 0,
 150                           SA1111_DRIVER_NAME(ps2if->dev), ps2if);
 151         if (ret) {
 152                 printk(KERN_ERR "sa1111ps2: could not allocate IRQ%d: %d\n",
 153                         ps2if->rx_irq, ret);
 154                 sa1111_disable_device(ps2if->dev);
 155                 return ret;
 156         }
 157
 158         ret = request_irq(ps2if->tx_irq, ps2_txint, 0,
 159                           SA1111_DRIVER_NAME(ps2if->dev), ps2if);
 160         if (ret) {
 161                 printk(KERN_ERR "sa1111ps2: could not allocate IRQ%d: %d\n",
 162                         ps2if->tx_irq, ret);
 163                 free_irq(ps2if->rx_irq, ps2if);
 164                 sa1111_disable_device(ps2if->dev);
 165                 return ret;
 166         }
 167
 168         ps2if->open = 1;
 169
 170         enable_irq_wake(ps2if->rx_irq);
 171
 172         writel_relaxed(PS2CR_ENA, ps2if->base + PS2CR);
 173         return 0;
 174 }
 175
 176 static void ps2_close(struct serio *io)
 177 {
 178         struct ps2if *ps2if = io->port_data;
 179
 180         writel_relaxed(0, ps2if->base + PS2CR);
 181
 182         disable_irq_wake(ps2if->rx_irq);
 183
 184         ps2if->open = 0;
 185
 186         free_irq(ps2if->tx_irq, ps2if);
 187         free_irq(ps2if->rx_irq, ps2if);
 188
 189         sa1111_disable_device(ps2if->dev);
 190 }
 191
 192 /*
 193  * Clear the input buffer.
 194  */
 195 static void ps2_clear_input(struct ps2if *ps2if)
 196 {
 197         int maxread = 100;
 198
 199         while (maxread--) {
 200                 if ((readl_relaxed(ps2if->base + PS2DATA) & 0xff) == 0xff)
 201                         break;
 202         }
 203 }
 204
 205 static unsigned int ps2_test_one(struct ps2if *ps2if,
 206                                            unsigned int mask)
 207 {
 208         unsigned int val;
 209
 210         writel_relaxed(PS2CR_ENA | mask, ps2if->base + PS2CR);
 211
 212         udelay(10);
 213
 214         val = readl_relaxed(ps2if->base + PS2STAT);
 215         return val & (PS2STAT_KBC | PS2STAT_KBD);
 216 }
 217
 218 /*
 219  * Test the keyboard interface.  We basically check to make sure that
 220  * we can drive each line to the keyboard independently of each other.
 221  */
 222 static int ps2_test(struct ps2if *ps2if)
 223 {
 224         unsigned int stat;
 225         int ret = 0;
 226
 227         stat = ps2_test_one(ps2if, PS2CR_FKC);
 228         if (stat != PS2STAT_KBD) {
 229                 printk("PS/2 interface test failed[1]: %02x\n", stat);
 230                 ret = -ENODEV;
 231         }
 232
 233         stat = ps2_test_one(ps2if, 0);
 234         if (stat != (PS2STAT_KBC | PS2STAT_KBD)) {
 235                 printk("PS/2 interface test failed[2]: %02x\n", stat);
 236                 ret = -ENODEV;
 237         }
 238
 239         stat = ps2_test_one(ps2if, PS2CR_FKD);
 240         if (stat != PS2STAT_KBC) {
 241                 printk("PS/2 interface test failed[3]: %02x\n", stat);
 242                 ret = -ENODEV;
 243         }
 244
 245         writel_relaxed(0, ps2if->base + PS2CR);
 246
 247         return ret;
 248 }
 249
 250 /*
 251  * Add one device to this driver.
 252  */
 253 static int ps2_probe(struct sa1111_dev *dev)
 254 {
 255         struct ps2if *ps2if;
 256         struct serio *serio;
 257         int ret;
 258
 259         ps2if = kzalloc(sizeof(struct ps2if), GFP_KERNEL);
 260         serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
 261         if (!ps2if || !serio) {
 262                 ret = -ENOMEM;
 263                 goto free;
 264         }
 265
 266         serio->id.type          = SERIO_8042;
 267         serio->write            = ps2_write;
 268         serio->open             = ps2_open;
 269         serio->close            = ps2_close;
 270         strlcpy(serio->name, dev_name(&dev->dev), sizeof(serio->name));
 271         strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys));
 272         serio->port_data        = ps2if;
 273         serio->dev.parent       = &dev->dev;
 274         ps2if->io               = serio;
 275         ps2if->dev              = dev;
 276         sa1111_set_drvdata(dev, ps2if);
 277
 278         spin_lock_init(&ps2if->lock);
 279
 280         ps2if->rx_irq = sa1111_get_irq(dev, 0);
 281         if (ps2if->rx_irq <= 0) {
 282                 ret = ps2if->rx_irq ? : -ENXIO;
 283                 goto free;
 284         }
 285
 286         ps2if->tx_irq = sa1111_get_irq(dev, 1);
 287         if (ps2if->tx_irq <= 0) {
 288                 ret = ps2if->tx_irq ? : -ENXIO;
 289                 goto free;
 290         }
 291
 292         /*
 293          * Request the physical region for this PS2 port.
 294          */
 295         if (!request_mem_region(dev->res.start,
 296                                 dev->res.end - dev->res.start + 1,
 297                                 SA1111_DRIVER_NAME(dev))) {
 298                 ret = -EBUSY;
 299                 goto free;
 300         }
 301
 302         /*
 303          * Our parent device has already mapped the region.
 304          */
 305         ps2if->base = dev->mapbase;
 306
 307         sa1111_enable_device(ps2if->dev);
 308
 309         /* Incoming clock is 8MHz */
 310         writel_relaxed(0, ps2if->base + PS2CLKDIV);
 311         writel_relaxed(127, ps2if->base + PS2PRECNT);
 312
 313         /*
 314          * Flush any pending input.
 315          */
 316         ps2_clear_input(ps2if);
 317
 318         /*
 319          * Test the keyboard interface.
 320          */
 321         ret = ps2_test(ps2if);
 322         if (ret)
 323                 goto out;
 324
 325         /*
 326          * Flush any pending input.
 327          */
 328         ps2_clear_input(ps2if);
 329
 330         sa1111_disable_device(ps2if->dev);
 331         serio_register_port(ps2if->io);
 332         return 0;
 333
 334  out:
 335         sa1111_disable_device(ps2if->dev);
 336         release_mem_region(dev->res.start, resource_size(&dev->res));
 337  free:
 338         sa1111_set_drvdata(dev, NULL);
 339         kfree(ps2if);
 340         kfree(serio);
 341         return ret;
 342 }
 343
 344 /*
 345  * Remove one device from this driver.
 346  */
 347 static int ps2_remove(struct sa1111_dev *dev)
 348 {
 349         struct ps2if *ps2if = sa1111_get_drvdata(dev);
 350
 351         serio_unregister_port(ps2if->io);
 352         release_mem_region(dev->res.start, resource_size(&dev->res));
 353         sa1111_set_drvdata(dev, NULL);
 354
 355         kfree(ps2if);
 356
 357         return 0;
 358 }
 359
 360 /*
 361  * Our device driver structure
 362  */
 363 static struct sa1111_driver ps2_driver = {
 364         .drv = {
 365                 .name   = "sa1111-ps2",
 366                 .owner  = THIS_MODULE,
 367         },
 368         .devid          = SA1111_DEVID_PS2,
 369         .probe          = ps2_probe,
 370         .remove         = ps2_remove,
 371 };
 372
 373 static int __init ps2_init(void)
 374 {
 375         return sa1111_driver_register(&ps2_driver);
 376 }
 377
 378 static void __exit ps2_exit(void)
 379 {
 380         sa1111_driver_unregister(&ps2_driver);
 381 }
 382
 383 module_init(ps2_init);
 384 module_exit(ps2_exit);
 385
 386 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
 387 MODULE_DESCRIPTION("SA1111 PS2 controller driver");
 388 MODULE_LICENSE("GPL");