include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-2.6.git] / 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/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);