drivers/input/serio/arc_ps2.c

   1 /*
   2  * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * Driver is originally developed by Pavel Sokolov <[email protected]>
   9  */
  10
  11 #include <linux/err.h>
  12 #include <linux/module.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/input.h>
  15 #include <linux/serio.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/of.h>
  18 #include <linux/io.h>
  19 #include <linux/kernel.h>
  20 #include <linux/slab.h>
  21
  22 #define ARC_PS2_PORTS                   2
  23
  24 #define ARC_ARC_PS2_ID                  0x0001f609
  25
  26 #define STAT_TIMEOUT                    128
  27
  28 #define PS2_STAT_RX_FRM_ERR             (1)
  29 #define PS2_STAT_RX_BUF_OVER            (1 << 1)
  30 #define PS2_STAT_RX_INT_EN              (1 << 2)
  31 #define PS2_STAT_RX_VAL                 (1 << 3)
  32 #define PS2_STAT_TX_ISNOT_FUL           (1 << 4)
  33 #define PS2_STAT_TX_INT_EN              (1 << 5)
  34
  35 struct arc_ps2_port {
  36         void __iomem *data_addr;
  37         void __iomem *status_addr;
  38         struct serio *io;
  39 };
  40
  41 struct arc_ps2_data {
  42         struct arc_ps2_port port[ARC_PS2_PORTS];
  43         void __iomem *addr;
  44         unsigned int frame_error;
  45         unsigned int buf_overflow;
  46         unsigned int total_int;
  47 };
  48
  49 static void arc_ps2_check_rx(struct arc_ps2_data *arc_ps2,
  50                              struct arc_ps2_port *port)
  51 {
  52         unsigned int timeout = 1000;
  53         unsigned int flag, status;
  54         unsigned char data;
  55
  56         do {
  57                 status = ioread32(port->status_addr);
  58                 if (!(status & PS2_STAT_RX_VAL))
  59                         return;
  60
  61                 data = ioread32(port->data_addr) & 0xff;
  62
  63                 flag = 0;
  64                 arc_ps2->total_int++;
  65                 if (status & PS2_STAT_RX_FRM_ERR) {
  66                         arc_ps2->frame_error++;
  67                         flag |= SERIO_PARITY;
  68                 } else if (status & PS2_STAT_RX_BUF_OVER) {
  69                         arc_ps2->buf_overflow++;
  70                         flag |= SERIO_FRAME;
  71                 }
  72
  73                 serio_interrupt(port->io, data, flag);
  74         } while (--timeout);
  75
  76         dev_err(&port->io->dev, "PS/2 hardware stuck\n");
  77 }
  78
  79 static irqreturn_t arc_ps2_interrupt(int irq, void *dev)
  80 {
  81         struct arc_ps2_data *arc_ps2 = dev;
  82         int i;
  83
  84         for (i = 0; i < ARC_PS2_PORTS; i++)
  85                 arc_ps2_check_rx(arc_ps2, &arc_ps2->port[i]);
  86
  87         return IRQ_HANDLED;
  88 }
  89
  90 static int arc_ps2_write(struct serio *io, unsigned char val)
  91 {
  92         unsigned status;
  93         struct arc_ps2_port *port = io->port_data;
  94         int timeout = STAT_TIMEOUT;
  95
  96         do {
  97                 status = ioread32(port->status_addr);
  98                 cpu_relax();
  99
 100                 if (status & PS2_STAT_TX_ISNOT_FUL) {
 101                         iowrite32(val & 0xff, port->data_addr);
 102                         return 0;
 103                 }
 104
 105         } while (--timeout);
 106
 107         dev_err(&io->dev, "write timeout\n");
 108         return -ETIMEDOUT;
 109 }
 110
 111 static int arc_ps2_open(struct serio *io)
 112 {
 113         struct arc_ps2_port *port = io->port_data;
 114
 115         iowrite32(PS2_STAT_RX_INT_EN, port->status_addr);
 116
 117         return 0;
 118 }
 119
 120 static void arc_ps2_close(struct serio *io)
 121 {
 122         struct arc_ps2_port *port = io->port_data;
 123
 124         iowrite32(ioread32(port->status_addr) & ~PS2_STAT_RX_INT_EN,
 125                   port->status_addr);
 126 }
 127
 128 static void __iomem *arc_ps2_calc_addr(struct arc_ps2_data *arc_ps2,
 129                                                   int index, bool status)
 130 {
 131         void __iomem *addr;
 132
 133         addr = arc_ps2->addr + 4 + 4 * index;
 134         if (status)
 135                 addr += ARC_PS2_PORTS * 4;
 136
 137         return addr;
 138 }
 139
 140 static void arc_ps2_inhibit_ports(struct arc_ps2_data *arc_ps2)
 141 {
 142         void __iomem *addr;
 143         u32 val;
 144         int i;
 145
 146         for (i = 0; i < ARC_PS2_PORTS; i++) {
 147                 addr = arc_ps2_calc_addr(arc_ps2, i, true);
 148                 val = ioread32(addr);
 149                 val &= ~(PS2_STAT_RX_INT_EN | PS2_STAT_TX_INT_EN);
 150                 iowrite32(val, addr);
 151         }
 152 }
 153
 154 static int arc_ps2_create_port(struct platform_device *pdev,
 155                                          struct arc_ps2_data *arc_ps2,
 156                                          int index)
 157 {
 158         struct arc_ps2_port *port = &arc_ps2->port[index];
 159         struct serio *io;
 160
 161         io = kzalloc(sizeof(struct serio), GFP_KERNEL);
 162         if (!io)
 163                 return -ENOMEM;
 164
 165         io->id.type = SERIO_8042;
 166         io->write = arc_ps2_write;
 167         io->open = arc_ps2_open;
 168         io->close = arc_ps2_close;
 169         snprintf(io->name, sizeof(io->name), "ARC PS/2 port%d", index);
 170         snprintf(io->phys, sizeof(io->phys), "arc/serio%d", index);
 171         io->port_data = port;
 172
 173         port->io = io;
 174
 175         port->data_addr = arc_ps2_calc_addr(arc_ps2, index, false);
 176         port->status_addr = arc_ps2_calc_addr(arc_ps2, index, true);
 177
 178         dev_dbg(&pdev->dev, "port%d is allocated (data = 0x%p, status = 0x%p)\n",
 179                 index, port->data_addr, port->status_addr);
 180
 181         serio_register_port(port->io);
 182         return 0;
 183 }
 184
 185 static int arc_ps2_probe(struct platform_device *pdev)
 186 {
 187         struct arc_ps2_data *arc_ps2;
 188         struct resource *res;
 189         int irq;
 190         int error, id, i;
 191
 192         irq = platform_get_irq_byname(pdev, "arc_ps2_irq");
 193         if (irq < 0) {
 194                 dev_err(&pdev->dev, "no IRQ defined\n");
 195                 return -EINVAL;
 196         }
 197
 198         arc_ps2 = devm_kzalloc(&pdev->dev, sizeof(struct arc_ps2_data),
 199                                 GFP_KERNEL);
 200         if (!arc_ps2) {
 201                 dev_err(&pdev->dev, "out of memory\n");
 202                 return -ENOMEM;
 203         }
 204
 205         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 206         arc_ps2->addr = devm_ioremap_resource(&pdev->dev, res);
 207         if (IS_ERR(arc_ps2->addr))
 208                 return PTR_ERR(arc_ps2->addr);
 209
 210         dev_info(&pdev->dev, "irq = %d, address = 0x%p, ports = %i\n",
 211                  irq, arc_ps2->addr, ARC_PS2_PORTS);
 212
 213         id = ioread32(arc_ps2->addr);
 214         if (id != ARC_ARC_PS2_ID) {
 215                 dev_err(&pdev->dev, "device id does not match\n");
 216                 return -ENXIO;
 217         }
 218
 219         arc_ps2_inhibit_ports(arc_ps2);
 220
 221         error = devm_request_irq(&pdev->dev, irq, arc_ps2_interrupt,
 222                                  0, "arc_ps2", arc_ps2);
 223         if (error) {
 224                 dev_err(&pdev->dev, "Could not allocate IRQ\n");
 225                 return error;
 226         }
 227
 228         for (i = 0; i < ARC_PS2_PORTS; i++) {
 229                 error = arc_ps2_create_port(pdev, arc_ps2, i);
 230                 if (error) {
 231                         while (--i >= 0)
 232                                 serio_unregister_port(arc_ps2->port[i].io);
 233                         return error;
 234                 }
 235         }
 236
 237         platform_set_drvdata(pdev, arc_ps2);
 238
 239         return 0;
 240 }
 241
 242 static int arc_ps2_remove(struct platform_device *pdev)
 243 {
 244         struct arc_ps2_data *arc_ps2 = platform_get_drvdata(pdev);
 245         int i;
 246
 247         for (i = 0; i < ARC_PS2_PORTS; i++)
 248                 serio_unregister_port(arc_ps2->port[i].io);
 249
 250         dev_dbg(&pdev->dev, "interrupt count = %i\n", arc_ps2->total_int);
 251         dev_dbg(&pdev->dev, "frame error count = %i\n", arc_ps2->frame_error);
 252         dev_dbg(&pdev->dev, "buffer overflow count = %i\n",
 253                 arc_ps2->buf_overflow);
 254
 255         return 0;
 256 }
 257
 258 #ifdef CONFIG_OF
 259 static const struct of_device_id arc_ps2_match[] = {
 260         { .compatible = "snps,arc_ps2" },
 261         { },
 262 };
 263 MODULE_DEVICE_TABLE(of, arc_ps2_match);
 264 #endif
 265
 266 static struct platform_driver arc_ps2_driver = {
 267         .driver = {
 268                 .name           = "arc_ps2",
 269                 .of_match_table = of_match_ptr(arc_ps2_match),
 270         },
 271         .probe  = arc_ps2_probe,
 272         .remove = arc_ps2_remove,
 273 };
 274
 275 module_platform_driver(arc_ps2_driver);
 276
 277 MODULE_LICENSE("GPL");
 278 MODULE_AUTHOR("Pavel Sokolov <[email protected]>");
 279 MODULE_DESCRIPTION("ARC PS/2 Driver");