1 /* 2 * linux/drivers/input/serio/pcips2.c 3 * 4 * Copyright (C) 2003 Russell King, All Rights Reserved. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License. 9 * 10 * I'm not sure if this is a generic PS/2 PCI interface or specific to 11 * the Mobility Electronics docking station. 12 */ 13 #include <linux/module.h> 14 #include <linux/interrupt.h> 15 #include <linux/ioport.h> 16 #include <linux/input.h> 17 #include <linux/pci.h> 18 #include <linux/slab.h> 19 #include <linux/init.h> 20 #include <linux/serio.h> 21 #include <linux/delay.h> 22 #include <asm/io.h> 23 24 #define PS2_CTRL (0) 25 #define PS2_STATUS (1) 26 #define PS2_DATA (2) 27 28 #define PS2_CTRL_CLK (1<<0) 29 #define PS2_CTRL_DAT (1<<1) 30 #define PS2_CTRL_TXIRQ (1<<2) 31 #define PS2_CTRL_ENABLE (1<<3) 32 #define PS2_CTRL_RXIRQ (1<<4) 33 34 #define PS2_STAT_CLK (1<<0) 35 #define PS2_STAT_DAT (1<<1) 36 #define PS2_STAT_PARITY (1<<2) 37 #define PS2_STAT_RXFULL (1<<5) 38 #define PS2_STAT_TXBUSY (1<<6) 39 #define PS2_STAT_TXEMPTY (1<<7) 40 41 struct pcips2_data { 42 struct serio *io; 43 unsigned int base; 44 struct pci_dev *dev; 45 }; 46 47 static int pcips2_write(struct serio *io, unsigned char val) 48 { 49 struct pcips2_data *ps2if = io->port_data; 50 unsigned int stat; 51 52 do { 53 stat = inb(ps2if->base + PS2_STATUS); 54 cpu_relax(); 55 } while (!(stat & PS2_STAT_TXEMPTY)); 56 57 outb(val, ps2if->base + PS2_DATA); 58 59 return 0; 60 } 61 62 static irqreturn_t pcips2_interrupt(int irq, void *devid) 63 { 64 struct pcips2_data *ps2if = devid; 65 unsigned char status, scancode; 66 int handled = 0; 67 68 do { 69 unsigned int flag; 70 71 status = inb(ps2if->base + PS2_STATUS); 72 if (!(status & PS2_STAT_RXFULL)) 73 break; 74 handled = 1; 75 scancode = inb(ps2if->base + PS2_DATA); 76 if (status == 0xff && scancode == 0xff) 77 break; 78 79 flag = (status & PS2_STAT_PARITY) ? 0 : SERIO_PARITY; 80 81 if (hweight8(scancode) & 1) 82 flag ^= SERIO_PARITY; 83 84 serio_interrupt(ps2if->io, scancode, flag); 85 } while (1); 86 return IRQ_RETVAL(handled); 87 } 88 89 static void pcips2_flush_input(struct pcips2_data *ps2if) 90 { 91 unsigned char status, scancode; 92 93 do { 94 status = inb(ps2if->base + PS2_STATUS); 95 if (!(status & PS2_STAT_RXFULL)) 96 break; 97 scancode = inb(ps2if->base + PS2_DATA); 98 if (status == 0xff && scancode == 0xff) 99 break; 100 } while (1); 101 } 102 103 static int pcips2_open(struct serio *io) 104 { 105 struct pcips2_data *ps2if = io->port_data; 106 int ret, val = 0; 107 108 outb(PS2_CTRL_ENABLE, ps2if->base); 109 pcips2_flush_input(ps2if); 110 111 ret = request_irq(ps2if->dev->irq, pcips2_interrupt, IRQF_SHARED, 112 "pcips2", ps2if); 113 if (ret == 0) 114 val = PS2_CTRL_ENABLE | PS2_CTRL_RXIRQ; 115 116 outb(val, ps2if->base); 117 118 return ret; 119 } 120 121 static void pcips2_close(struct serio *io) 122 { 123 struct pcips2_data *ps2if = io->port_data; 124 125 outb(0, ps2if->base); 126 127 free_irq(ps2if->dev->irq, ps2if); 128 } 129 130 static int __devinit pcips2_probe(struct pci_dev *dev, const struct pci_device_id *id) 131 { 132 struct pcips2_data *ps2if; 133 struct serio *serio; 134 int ret; 135 136 ret = pci_enable_device(dev); 137 if (ret) 138 goto out; 139 140 ret = pci_request_regions(dev, "pcips2"); 141 if (ret) 142 goto disable; 143 144 ps2if = kzalloc(sizeof(struct pcips2_data), GFP_KERNEL); 145 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); 146 if (!ps2if || !serio) { 147 ret = -ENOMEM; 148 goto release; 149 } 150 151 152 serio->id.type = SERIO_8042; 153 serio->write = pcips2_write; 154 serio->open = pcips2_open; 155 serio->close = pcips2_close; 156 strlcpy(serio->name, pci_name(dev), sizeof(serio->name)); 157 strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys)); 158 serio->port_data = ps2if; 159 serio->dev.parent = &dev->dev; 160 ps2if->io = serio; 161 ps2if->dev = dev; 162 ps2if->base = pci_resource_start(dev, 0); 163 164 pci_set_drvdata(dev, ps2if); 165 166 serio_register_port(ps2if->io); 167 return 0; 168 169 release: 170 kfree(ps2if); 171 kfree(serio); 172 pci_release_regions(dev); 173 disable: 174 pci_disable_device(dev); 175 out: 176 return ret; 177 } 178 179 static void __devexit pcips2_remove(struct pci_dev *dev) 180 { 181 struct pcips2_data *ps2if = pci_get_drvdata(dev); 182 183 serio_unregister_port(ps2if->io); 184 pci_set_drvdata(dev, NULL); 185 kfree(ps2if); 186 pci_release_regions(dev); 187 pci_disable_device(dev); 188 } 189 190 static const struct pci_device_id pcips2_ids[] = { 191 { 192 .vendor = 0x14f2, /* MOBILITY */ 193 .device = 0x0123, /* Keyboard */ 194 .subvendor = PCI_ANY_ID, 195 .subdevice = PCI_ANY_ID, 196 .class = PCI_CLASS_INPUT_KEYBOARD << 8, 197 .class_mask = 0xffff00, 198 }, 199 { 200 .vendor = 0x14f2, /* MOBILITY */ 201 .device = 0x0124, /* Mouse */ 202 .subvendor = PCI_ANY_ID, 203 .subdevice = PCI_ANY_ID, 204 .class = PCI_CLASS_INPUT_MOUSE << 8, 205 .class_mask = 0xffff00, 206 }, 207 { 0, } 208 }; 209 210 static struct pci_driver pcips2_driver = { 211 .name = "pcips2", 212 .id_table = pcips2_ids, 213 .probe = pcips2_probe, 214 .remove = __devexit_p(pcips2_remove), 215 }; 216 217 static int __init pcips2_init(void) 218 { 219 return pci_register_driver(&pcips2_driver); 220 } 221 222 static void __exit pcips2_exit(void) 223 { 224 pci_unregister_driver(&pcips2_driver); 225 } 226 227 module_init(pcips2_init); 228 module_exit(pcips2_exit); 229 230 MODULE_LICENSE("GPL"); 231 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); 232 MODULE_DESCRIPTION("PCI PS/2 keyboard/mouse driver"); 233 MODULE_DEVICE_TABLE(pci, pcips2_ids); 234