Loading...
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/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
40struct pcips2_data {
41 struct serio *io;
42 unsigned int base;
43 struct pci_dev *dev;
44};
45
46static 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
61static 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
88static 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
102static 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
120static 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
129static int 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 = kzalloc(sizeof(struct pcips2_data), GFP_KERNEL);
144 serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
145 if (!ps2if || !serio) {
146 ret = -ENOMEM;
147 goto release;
148 }
149
150
151 serio->id.type = SERIO_8042;
152 serio->write = pcips2_write;
153 serio->open = pcips2_open;
154 serio->close = pcips2_close;
155 strlcpy(serio->name, pci_name(dev), sizeof(serio->name));
156 strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys));
157 serio->port_data = ps2if;
158 serio->dev.parent = &dev->dev;
159 ps2if->io = serio;
160 ps2if->dev = dev;
161 ps2if->base = pci_resource_start(dev, 0);
162
163 pci_set_drvdata(dev, ps2if);
164
165 serio_register_port(ps2if->io);
166 return 0;
167
168 release:
169 kfree(ps2if);
170 kfree(serio);
171 pci_release_regions(dev);
172 disable:
173 pci_disable_device(dev);
174 out:
175 return ret;
176}
177
178static void pcips2_remove(struct pci_dev *dev)
179{
180 struct pcips2_data *ps2if = pci_get_drvdata(dev);
181
182 serio_unregister_port(ps2if->io);
183 kfree(ps2if);
184 pci_release_regions(dev);
185 pci_disable_device(dev);
186}
187
188static const struct pci_device_id pcips2_ids[] = {
189 {
190 .vendor = 0x14f2, /* MOBILITY */
191 .device = 0x0123, /* Keyboard */
192 .subvendor = PCI_ANY_ID,
193 .subdevice = PCI_ANY_ID,
194 .class = PCI_CLASS_INPUT_KEYBOARD << 8,
195 .class_mask = 0xffff00,
196 },
197 {
198 .vendor = 0x14f2, /* MOBILITY */
199 .device = 0x0124, /* Mouse */
200 .subvendor = PCI_ANY_ID,
201 .subdevice = PCI_ANY_ID,
202 .class = PCI_CLASS_INPUT_MOUSE << 8,
203 .class_mask = 0xffff00,
204 },
205 { 0, }
206};
207MODULE_DEVICE_TABLE(pci, pcips2_ids);
208
209static struct pci_driver pcips2_driver = {
210 .name = "pcips2",
211 .id_table = pcips2_ids,
212 .probe = pcips2_probe,
213 .remove = pcips2_remove,
214};
215
216module_pci_driver(pcips2_driver);
217
218MODULE_LICENSE("GPL");
219MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
220MODULE_DESCRIPTION("PCI PS/2 keyboard/mouse driver");
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
41struct pcips2_data {
42 struct serio *io;
43 unsigned int base;
44 struct pci_dev *dev;
45};
46
47static 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
62static 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
89static 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
103static 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
121static 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
130static 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
179static 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
190static 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
210static 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
217static int __init pcips2_init(void)
218{
219 return pci_register_driver(&pcips2_driver);
220}
221
222static void __exit pcips2_exit(void)
223{
224 pci_unregister_driver(&pcips2_driver);
225}
226
227module_init(pcips2_init);
228module_exit(pcips2_exit);
229
230MODULE_LICENSE("GPL");
231MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
232MODULE_DESCRIPTION("PCI PS/2 keyboard/mouse driver");
233MODULE_DEVICE_TABLE(pci, pcips2_ids);