drivers: Final irq namespace conversion
[linux-2.6.git] / drivers / input / serio / ams_delta_serio.c
1 /*
2  *  Amstrad E3 (Delta) keyboard port driver
3  *
4  *  Copyright (c) 2006 Matt Callow
5  *  Copyright (c) 2010 Janusz Krzysztofik
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU General Public License version 2 as published by
9  * the Free Software Foundation.
10  *
11  * Thanks to Cliff Lawson for his help
12  *
13  * The Amstrad Delta keyboard (aka mailboard) uses normal PC-AT style serial
14  * transmission.  The keyboard port is formed of two GPIO lines, for clock
15  * and data.  Due to strict timing requirements of the interface,
16  * the serial data stream is read and processed by a FIQ handler.
17  * The resulting words are fetched by this driver from a circular buffer.
18  *
19  * Standard AT keyboard driver (atkbd) is used for handling the keyboard data.
20  * However, when used with the E3 mailboard that producecs non-standard
21  * scancodes, a custom key table must be prepared and loaded from userspace.
22  */
23 #include <linux/gpio.h>
24 #include <linux/irq.h>
25 #include <linux/serio.h>
26 #include <linux/slab.h>
27
28 #include <asm/mach-types.h>
29 #include <plat/board-ams-delta.h>
30
31 #include <mach/ams-delta-fiq.h>
32
33 MODULE_AUTHOR("Matt Callow");
34 MODULE_DESCRIPTION("AMS Delta (E3) keyboard port driver");
35 MODULE_LICENSE("GPL");
36
37 static struct serio *ams_delta_serio;
38
39 static int check_data(int data)
40 {
41         int i, parity = 0;
42
43         /* check valid stop bit */
44         if (!(data & 0x400)) {
45                 dev_warn(&ams_delta_serio->dev,
46                                 "invalid stop bit, data=0x%X\n",
47                                 data);
48                 return SERIO_FRAME;
49         }
50         /* calculate the parity */
51         for (i = 1; i < 10; i++) {
52                 if (data & (1 << i))
53                         parity++;
54         }
55         /* it should be odd */
56         if (!(parity & 0x01)) {
57                 dev_warn(&ams_delta_serio->dev,
58                                 "paritiy check failed, data=0x%X parity=0x%X\n",
59                                 data, parity);
60                 return SERIO_PARITY;
61         }
62         return 0;
63 }
64
65 static irqreturn_t ams_delta_serio_interrupt(int irq, void *dev_id)
66 {
67         int *circ_buff = &fiq_buffer[FIQ_CIRC_BUFF];
68         int data, dfl;
69         u8 scancode;
70
71         fiq_buffer[FIQ_IRQ_PEND] = 0;
72
73         /*
74          * Read data from the circular buffer, check it
75          * and then pass it on the serio
76          */
77         while (fiq_buffer[FIQ_KEYS_CNT] > 0) {
78
79                 data = circ_buff[fiq_buffer[FIQ_HEAD_OFFSET]++];
80                 fiq_buffer[FIQ_KEYS_CNT]--;
81                 if (fiq_buffer[FIQ_HEAD_OFFSET] == fiq_buffer[FIQ_BUF_LEN])
82                         fiq_buffer[FIQ_HEAD_OFFSET] = 0;
83
84                 dfl = check_data(data);
85                 scancode = (u8) (data >> 1) & 0xFF;
86                 serio_interrupt(ams_delta_serio, scancode, dfl);
87         }
88         return IRQ_HANDLED;
89 }
90
91 static int ams_delta_serio_open(struct serio *serio)
92 {
93         /* enable keyboard */
94         ams_delta_latch2_write(AMD_DELTA_LATCH2_KEYBRD_PWR,
95                         AMD_DELTA_LATCH2_KEYBRD_PWR);
96
97         return 0;
98 }
99
100 static void ams_delta_serio_close(struct serio *serio)
101 {
102         /* disable keyboard */
103         ams_delta_latch2_write(AMD_DELTA_LATCH2_KEYBRD_PWR, 0);
104 }
105
106 static int __init ams_delta_serio_init(void)
107 {
108         int err;
109
110         if (!machine_is_ams_delta())
111                 return -ENODEV;
112
113         ams_delta_serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
114         if (!ams_delta_serio)
115                 return -ENOMEM;
116
117         ams_delta_serio->id.type = SERIO_8042;
118         ams_delta_serio->open = ams_delta_serio_open;
119         ams_delta_serio->close = ams_delta_serio_close;
120         strlcpy(ams_delta_serio->name, "AMS DELTA keyboard adapter",
121                         sizeof(ams_delta_serio->name));
122         strlcpy(ams_delta_serio->phys, "GPIO/serio0",
123                         sizeof(ams_delta_serio->phys));
124
125         err = gpio_request(AMS_DELTA_GPIO_PIN_KEYBRD_DATA, "serio-data");
126         if (err) {
127                 pr_err("ams_delta_serio: Couldn't request gpio pin for data\n");
128                 goto serio;
129         }
130         gpio_direction_input(AMS_DELTA_GPIO_PIN_KEYBRD_DATA);
131
132         err = gpio_request(AMS_DELTA_GPIO_PIN_KEYBRD_CLK, "serio-clock");
133         if (err) {
134                 pr_err("ams_delta_serio: couldn't request gpio pin for clock\n");
135                 goto gpio_data;
136         }
137         gpio_direction_input(AMS_DELTA_GPIO_PIN_KEYBRD_CLK);
138
139         err = request_irq(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK),
140                         ams_delta_serio_interrupt, IRQ_TYPE_EDGE_RISING,
141                         "ams-delta-serio", 0);
142         if (err < 0) {
143                 pr_err("ams_delta_serio: couldn't request gpio interrupt %d\n",
144                                 gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK));
145                 goto gpio_clk;
146         }
147         /*
148          * Since GPIO register handling for keyboard clock pin is performed
149          * at FIQ level, switch back from edge to simple interrupt handler
150          * to avoid bad interaction.
151          */
152         irq_set_handler(gpio_to_irq(AMS_DELTA_GPIO_PIN_KEYBRD_CLK),
153                         handle_simple_irq);
154
155         serio_register_port(ams_delta_serio);
156         dev_info(&ams_delta_serio->dev, "%s\n", ams_delta_serio->name);
157
158         return 0;
159 gpio_clk:
160         gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_CLK);
161 gpio_data:
162         gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_DATA);
163 serio:
164         kfree(ams_delta_serio);
165         return err;
166 }
167 module_init(ams_delta_serio_init);
168
169 static void __exit ams_delta_serio_exit(void)
170 {
171         serio_unregister_port(ams_delta_serio);
172         free_irq(OMAP_GPIO_IRQ(AMS_DELTA_GPIO_PIN_KEYBRD_CLK), 0);
173         gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_CLK);
174         gpio_free(AMS_DELTA_GPIO_PIN_KEYBRD_DATA);
175 }
176 module_exit(ams_delta_serio_exit);