2 * Xilinx XPS PS/2 device driver
4 * (c) 2005 MontaVista Software, Inc.
5 * (c) 2008 Xilinx, Inc.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
12 * You should have received a copy of the GNU General Public License along
13 * with this program; if not, write to the Free Software Foundation, Inc.,
14 * 675 Mass Ave, Cambridge, MA 02139, USA.
18 #include <linux/module.h>
19 #include <linux/serio.h>
20 #include <linux/interrupt.h>
21 #include <linux/errno.h>
22 #include <linux/slab.h>
23 #include <linux/list.h>
25 #include <linux/of_address.h>
26 #include <linux/of_device.h>
27 #include <linux/of_irq.h>
28 #include <linux/of_platform.h>
30 #define DRIVER_NAME "xilinx_ps2"
32 /* Register offsets for the xps2 device */
33 #define XPS2_SRST_OFFSET 0x00000000 /* Software Reset register */
34 #define XPS2_STATUS_OFFSET 0x00000004 /* Status register */
35 #define XPS2_RX_DATA_OFFSET 0x00000008 /* Receive Data register */
36 #define XPS2_TX_DATA_OFFSET 0x0000000C /* Transmit Data register */
37 #define XPS2_GIER_OFFSET 0x0000002C /* Global Interrupt Enable reg */
38 #define XPS2_IPISR_OFFSET 0x00000030 /* Interrupt Status register */
39 #define XPS2_IPIER_OFFSET 0x00000038 /* Interrupt Enable register */
41 /* Reset Register Bit Definitions */
42 #define XPS2_SRST_RESET 0x0000000A /* Software Reset */
44 /* Status Register Bit Positions */
45 #define XPS2_STATUS_RX_FULL 0x00000001 /* Receive Full */
46 #define XPS2_STATUS_TX_FULL 0x00000002 /* Transmit Full */
48 /* Bit definitions for ISR/IER registers. Both the registers have the same bit
49 * definitions and are only defined once. */
50 #define XPS2_IPIXR_WDT_TOUT 0x00000001 /* Watchdog Timeout Interrupt */
51 #define XPS2_IPIXR_TX_NOACK 0x00000002 /* Transmit No ACK Interrupt */
52 #define XPS2_IPIXR_TX_ACK 0x00000004 /* Transmit ACK (Data) Interrupt */
53 #define XPS2_IPIXR_RX_OVF 0x00000008 /* Receive Overflow Interrupt */
54 #define XPS2_IPIXR_RX_ERR 0x00000010 /* Receive Error Interrupt */
55 #define XPS2_IPIXR_RX_FULL 0x00000020 /* Receive Data Interrupt */
57 /* Mask for all the Transmit Interrupts */
58 #define XPS2_IPIXR_TX_ALL (XPS2_IPIXR_TX_NOACK | XPS2_IPIXR_TX_ACK)
60 /* Mask for all the Receive Interrupts */
61 #define XPS2_IPIXR_RX_ALL (XPS2_IPIXR_RX_OVF | XPS2_IPIXR_RX_ERR | \
64 /* Mask for all the Interrupts */
65 #define XPS2_IPIXR_ALL (XPS2_IPIXR_TX_ALL | XPS2_IPIXR_RX_ALL | \
68 /* Global Interrupt Enable mask */
69 #define XPS2_GIER_GIE_MASK 0x80000000
74 void __iomem
*base_address
; /* virt. address of control registers */
76 struct serio
*serio
; /* serio */
80 /************************************/
81 /* XPS PS/2 data transmission calls */
82 /************************************/
85 * xps2_recv() - attempts to receive a byte from the PS/2 port.
86 * @drvdata: pointer to ps2 device private data structure
87 * @byte: address where the read data will be copied
89 * If there is any data available in the PS/2 receiver, this functions reads
90 * the data, otherwise it returns error.
92 static int xps2_recv(struct xps2data
*drvdata
, u8
*byte
)
97 /* If there is data available in the PS/2 receiver, read it */
98 sr
= in_be32(drvdata
->base_address
+ XPS2_STATUS_OFFSET
);
99 if (sr
& XPS2_STATUS_RX_FULL
) {
100 *byte
= in_be32(drvdata
->base_address
+ XPS2_RX_DATA_OFFSET
);
107 /*********************/
108 /* Interrupt handler */
109 /*********************/
110 static irqreturn_t
xps2_interrupt(int irq
, void *dev_id
)
112 struct xps2data
*drvdata
= dev_id
;
117 /* Get the PS/2 interrupts and clear them */
118 intr_sr
= in_be32(drvdata
->base_address
+ XPS2_IPISR_OFFSET
);
119 out_be32(drvdata
->base_address
+ XPS2_IPISR_OFFSET
, intr_sr
);
121 /* Check which interrupt is active */
122 if (intr_sr
& XPS2_IPIXR_RX_OVF
)
123 dev_warn(drvdata
->dev
, "receive overrun error\n");
125 if (intr_sr
& XPS2_IPIXR_RX_ERR
)
126 drvdata
->flags
|= SERIO_PARITY
;
128 if (intr_sr
& (XPS2_IPIXR_TX_NOACK
| XPS2_IPIXR_WDT_TOUT
))
129 drvdata
->flags
|= SERIO_TIMEOUT
;
131 if (intr_sr
& XPS2_IPIXR_RX_FULL
) {
132 status
= xps2_recv(drvdata
, &c
);
134 /* Error, if a byte is not received */
136 dev_err(drvdata
->dev
,
137 "wrong rcvd byte count (%d)\n", status
);
139 serio_interrupt(drvdata
->serio
, c
, drvdata
->flags
);
147 /*******************/
148 /* serio callbacks */
149 /*******************/
152 * sxps2_write() - sends a byte out through the PS/2 port.
153 * @pserio: pointer to the serio structure of the PS/2 port
154 * @c: data that needs to be written to the PS/2 port
156 * This function checks if the PS/2 transmitter is empty and sends a byte.
157 * Otherwise it returns error. Transmission fails only when nothing is connected
158 * to the PS/2 port. Thats why, we do not try to resend the data in case of a
161 static int sxps2_write(struct serio
*pserio
, unsigned char c
)
163 struct xps2data
*drvdata
= pserio
->port_data
;
168 spin_lock_irqsave(&drvdata
->lock
, flags
);
170 /* If the PS/2 transmitter is empty send a byte of data */
171 sr
= in_be32(drvdata
->base_address
+ XPS2_STATUS_OFFSET
);
172 if (!(sr
& XPS2_STATUS_TX_FULL
)) {
173 out_be32(drvdata
->base_address
+ XPS2_TX_DATA_OFFSET
, c
);
177 spin_unlock_irqrestore(&drvdata
->lock
, flags
);
183 * sxps2_open() - called when a port is opened by the higher layer.
184 * @pserio: pointer to the serio structure of the PS/2 device
186 * This function requests irq and enables interrupts for the PS/2 device.
188 static int sxps2_open(struct serio
*pserio
)
190 struct xps2data
*drvdata
= pserio
->port_data
;
194 error
= request_irq(drvdata
->irq
, &xps2_interrupt
, 0,
195 DRIVER_NAME
, drvdata
);
197 dev_err(drvdata
->dev
,
198 "Couldn't allocate interrupt %d\n", drvdata
->irq
);
202 /* start reception by enabling the interrupts */
203 out_be32(drvdata
->base_address
+ XPS2_GIER_OFFSET
, XPS2_GIER_GIE_MASK
);
204 out_be32(drvdata
->base_address
+ XPS2_IPIER_OFFSET
, XPS2_IPIXR_RX_ALL
);
205 (void)xps2_recv(drvdata
, &c
);
207 return 0; /* success */
211 * sxps2_close() - frees the interrupt.
212 * @pserio: pointer to the serio structure of the PS/2 device
214 * This function frees the irq and disables interrupts for the PS/2 device.
216 static void sxps2_close(struct serio
*pserio
)
218 struct xps2data
*drvdata
= pserio
->port_data
;
220 /* Disable the PS2 interrupts */
221 out_be32(drvdata
->base_address
+ XPS2_GIER_OFFSET
, 0x00);
222 out_be32(drvdata
->base_address
+ XPS2_IPIER_OFFSET
, 0x00);
223 free_irq(drvdata
->irq
, drvdata
);
227 * xps2_of_probe - probe method for the PS/2 device.
228 * @of_dev: pointer to OF device structure
229 * @match: pointer to the structure used for matching a device
231 * This function probes the PS/2 device in the device tree.
232 * It initializes the driver data structure and the hardware.
233 * It returns 0, if the driver is bound to the PS/2 device, or a negative
234 * value if there is an error.
236 static int xps2_of_probe(struct platform_device
*ofdev
)
238 struct resource r_mem
; /* IO mem resources */
239 struct xps2data
*drvdata
;
241 struct device
*dev
= &ofdev
->dev
;
242 resource_size_t remap_size
, phys_addr
;
246 dev_info(dev
, "Device Tree Probing \'%s\'\n",
247 ofdev
->dev
.of_node
->name
);
249 /* Get iospace for the device */
250 error
= of_address_to_resource(ofdev
->dev
.of_node
, 0, &r_mem
);
252 dev_err(dev
, "invalid address\n");
256 /* Get IRQ for the device */
257 irq
= irq_of_parse_and_map(ofdev
->dev
.of_node
, 0);
259 dev_err(dev
, "no IRQ found\n");
263 drvdata
= kzalloc(sizeof(struct xps2data
), GFP_KERNEL
);
264 serio
= kzalloc(sizeof(struct serio
), GFP_KERNEL
);
265 if (!drvdata
|| !serio
) {
270 spin_lock_init(&drvdata
->lock
);
272 drvdata
->serio
= serio
;
275 phys_addr
= r_mem
.start
;
276 remap_size
= resource_size(&r_mem
);
277 if (!request_mem_region(phys_addr
, remap_size
, DRIVER_NAME
)) {
278 dev_err(dev
, "Couldn't lock memory region at 0x%08llX\n",
279 (unsigned long long)phys_addr
);
284 /* Fill in configuration data and add them to the list */
285 drvdata
->base_address
= ioremap(phys_addr
, remap_size
);
286 if (drvdata
->base_address
== NULL
) {
287 dev_err(dev
, "Couldn't ioremap memory at 0x%08llX\n",
288 (unsigned long long)phys_addr
);
293 /* Disable all the interrupts, just in case */
294 out_be32(drvdata
->base_address
+ XPS2_IPIER_OFFSET
, 0);
296 /* Reset the PS2 device and abort any current transaction, to make sure
297 * we have the PS2 in a good state */
298 out_be32(drvdata
->base_address
+ XPS2_SRST_OFFSET
, XPS2_SRST_RESET
);
300 dev_info(dev
, "Xilinx PS2 at 0x%08llX mapped to 0x%p, irq=%d\n",
301 (unsigned long long)phys_addr
, drvdata
->base_address
,
304 serio
->id
.type
= SERIO_8042
;
305 serio
->write
= sxps2_write
;
306 serio
->open
= sxps2_open
;
307 serio
->close
= sxps2_close
;
308 serio
->port_data
= drvdata
;
309 serio
->dev
.parent
= dev
;
310 snprintf(serio
->name
, sizeof(serio
->name
),
311 "Xilinx XPS PS/2 at %08llX", (unsigned long long)phys_addr
);
312 snprintf(serio
->phys
, sizeof(serio
->phys
),
313 "xilinxps2/serio at %08llX", (unsigned long long)phys_addr
);
315 serio_register_port(serio
);
317 platform_set_drvdata(ofdev
, drvdata
);
318 return 0; /* success */
321 release_mem_region(phys_addr
, remap_size
);
330 * xps2_of_remove - unbinds the driver from the PS/2 device.
331 * @of_dev: pointer to OF device structure
333 * This function is called if a device is physically removed from the system or
334 * if the driver module is being unloaded. It frees any resources allocated to
337 static int xps2_of_remove(struct platform_device
*of_dev
)
339 struct xps2data
*drvdata
= platform_get_drvdata(of_dev
);
340 struct resource r_mem
; /* IO mem resources */
342 serio_unregister_port(drvdata
->serio
);
343 iounmap(drvdata
->base_address
);
345 /* Get iospace of the device */
346 if (of_address_to_resource(of_dev
->dev
.of_node
, 0, &r_mem
))
347 dev_err(drvdata
->dev
, "invalid address\n");
349 release_mem_region(r_mem
.start
, resource_size(&r_mem
));
356 /* Match table for of_platform binding */
357 static const struct of_device_id xps2_of_match
[] = {
358 { .compatible
= "xlnx,xps-ps2-1.00.a", },
359 { /* end of list */ },
361 MODULE_DEVICE_TABLE(of
, xps2_of_match
);
363 static struct platform_driver xps2_of_driver
= {
366 .of_match_table
= xps2_of_match
,
368 .probe
= xps2_of_probe
,
369 .remove
= xps2_of_remove
,
371 module_platform_driver(xps2_of_driver
);
373 MODULE_AUTHOR("Xilinx, Inc.");
374 MODULE_DESCRIPTION("Xilinx XPS PS/2 driver");
375 MODULE_LICENSE("GPL");