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