arch/nios2nommu/drivers/altps2.c

   1 /*
   2  *  altera DE2 PS/2
   3  *
   4  *  linux/drivers/input/serio/sa1111ps2.c
   5  *
   6  *  Copyright (C) 2002 Russell King
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License.
  11  */
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/input.h>
  15 #include <linux/serio.h>
  16 #include <linux/errno.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/ioport.h>
  19 #include <linux/delay.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/slab.h>
  22
  23 #include <asm/io.h>
  24 #include <asm/system.h>
  25
  26
  27 struct ps2if {
  28         struct serio            *io;
  29         struct platform_device  *dev;
  30         unsigned base;
  31         unsigned irq;
  32 };
  33
  34 /*
  35  * Read all bytes waiting in the PS2 port.  There should be
  36  * at the most one, but we loop for safety.  If there was a
  37  * framing error, we have to manually clear the status.
  38  */
  39 static irqreturn_t ps2_rxint(int irq, void *dev_id)
  40 {
  41         struct ps2if *ps2if = dev_id;
  42         unsigned int status;
  43         int handled = IRQ_NONE;
  44
  45         while ((status = inl(ps2if->base)) & 0xffff0000) {
  46                 serio_interrupt(ps2if->io, status & 0xff, 0);
  47                 handled = IRQ_HANDLED;
  48         }
  49         return handled;
  50 }
  51
  52 /*
  53  * Write a byte to the PS2 port.  We have to wait for the
  54  * port to indicate that the transmitter is empty.
  55  */
  56 static int ps2_write(struct serio *io, unsigned char val)
  57 {
  58         struct ps2if *ps2if = io->port_data;
  59         outl(val,ps2if->base);
  60         // should check command send error
  61         if (inl(ps2if->base+4) & (1<<10))
  62           {
  63             // printk("ps2 write error %02x\n",val);
  64           }
  65         return 0;
  66 }
  67
  68 static int ps2_open(struct serio *io)
  69 {
  70         struct ps2if *ps2if = io->port_data;
  71         int ret;
  72
  73         ret = request_irq(ps2if->irq, ps2_rxint, 0,
  74                           "altps2", ps2if);
  75         if (ret) {
  76                 printk(KERN_ERR "altps2: could not allocate IRQ%d: %d\n",
  77                         ps2if->irq, ret);
  78                 return ret;
  79         }
  80         outl(1,ps2if->base+4);  // enable rx irq
  81         return 0;
  82 }
  83
  84 static void ps2_close(struct serio *io)
  85 {
  86         struct ps2if *ps2if = io->port_data;
  87         outl(0,ps2if->base);  // disable rx irq
  88         free_irq(ps2if->irq, ps2if);
  89 }
  90
  91 /*
  92  * Add one device to this driver.
  93  */
  94 static int ps2_probe(struct platform_device *dev)
  95 {
  96         struct ps2if *ps2if;
  97         struct serio *serio;
  98         unsigned int status;
  99         int ret;
 100
 101         ps2if = kmalloc(sizeof(struct ps2if), GFP_KERNEL);
 102         serio = kmalloc(sizeof(struct serio), GFP_KERNEL);
 103         if (!ps2if || !serio) {
 104                 ret = -ENOMEM;
 105                 goto free;
 106         }
 107
 108         memset(ps2if, 0, sizeof(struct ps2if));
 109         memset(serio, 0, sizeof(struct serio));
 110
 111         serio->id.type          = SERIO_8042;
 112         serio->write            = ps2_write;
 113         serio->open             = ps2_open;
 114         serio->close            = ps2_close;
 115         strlcpy(serio->name, dev->dev.bus_id, sizeof(serio->name));
 116         strlcpy(serio->phys, dev->dev.bus_id, sizeof(serio->phys));
 117         serio->port_data        = ps2if;
 118         serio->dev.parent       = &dev->dev;
 119         ps2if->io               = serio;
 120         ps2if->dev              = dev;
 121         platform_set_drvdata(dev, ps2if);
 122
 123         /*
 124          * Request the physical region for this PS2 port.
 125          */
 126         if (dev->num_resources < 2) {
 127                 ret = -ENODEV;
 128                 goto out;
 129         }
 130         if (!request_mem_region(dev->resource[0].start,
 131                                 4,
 132                                 "altps2")) {
 133                 ret = -EBUSY;
 134                 goto free;
 135         }
 136         ps2if->base = dev->resource[0].start;
 137         ps2if->irq  = dev->resource[1].start;
 138         printk("altps2 : base %08x irq %d\n",ps2if->base,ps2if->irq);
 139         // clear fifo
 140         while ((status = inl(ps2if->base)) & 0xffff0000) {
 141         }
 142
 143         serio_register_port(ps2if->io);
 144         return 0;
 145
 146  out:
 147         release_mem_region(dev->resource[0].start,4);
 148  free:
 149         platform_set_drvdata(dev, NULL);
 150         kfree(ps2if);
 151         kfree(serio);
 152         return ret;
 153 }
 154
 155 /*
 156  * Remove one device from this driver.
 157  */
 158 static int ps2_remove(struct platform_device *dev)
 159 {
 160         struct ps2if *ps2if = platform_get_drvdata(dev);
 161
 162         platform_set_drvdata(dev, NULL);
 163         serio_unregister_port(ps2if->io);
 164         release_mem_region(dev->resource[0].start,4);
 165
 166         kfree(ps2if);
 167
 168         return 0;
 169 }
 170
 171 /*
 172  * Our device driver structure
 173  */
 174 static struct platform_driver ps2_driver = {
 175         .probe          = ps2_probe,
 176         .remove         = ps2_remove,
 177         .driver = {
 178                 .name   = "altps2",
 179         },
 180 };
 181
 182 static int __init ps2_init(void)
 183 {
 184         return platform_driver_register(&ps2_driver);
 185 }
 186
 187 static void __exit ps2_exit(void)
 188 {
 189         platform_driver_unregister(&ps2_driver);
 190 }
 191
 192 module_init(ps2_init);
 193 module_exit(ps2_exit);