[PATCH] drivers/input/mouse: convert to dynamic input_dev allocation
[linux-2.6.git] / drivers / input / touchscreen / elo.c
1 /*
2  * Elo serial touchscreen driver
3  *
4  * Copyright (c) 2004 Vojtech Pavlik
5  */
6
7 /*
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License version 2 as published by
10  * the Free Software Foundation.
11  */
12
13 /*
14  * This driver can handle serial Elo touchscreens using either the Elo standard
15  * 'E271-2210' 10-byte protocol, Elo legacy 'E281A-4002' 6-byte protocol, Elo
16  * legacy 'E271-140' 4-byte protocol and Elo legacy 'E261-280' 3-byte protocol.
17  */
18
19 #include <linux/errno.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/input.h>
24 #include <linux/serio.h>
25 #include <linux/init.h>
26
27 #define DRIVER_DESC     "Elo serial touchscreen driver"
28
29 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
30 MODULE_DESCRIPTION(DRIVER_DESC);
31 MODULE_LICENSE("GPL");
32
33 /*
34  * Definitions & global arrays.
35  */
36
37 #define ELO_MAX_LENGTH  10
38
39 static char *elo_name = "Elo Serial TouchScreen";
40
41 /*
42  * Per-touchscreen data.
43  */
44
45 struct elo {
46         struct input_dev dev;
47         struct serio *serio;
48         int id;
49         int idx;
50         unsigned char csum;
51         unsigned char data[ELO_MAX_LENGTH];
52         char phys[32];
53 };
54
55 static void elo_process_data_10(struct elo* elo, unsigned char data, struct pt_regs *regs)
56 {
57         struct input_dev *dev = &elo->dev;
58
59         elo->csum += elo->data[elo->idx] = data;
60
61         switch (elo->idx++) {
62
63                 case 0:
64                         if (data != 'U') {
65                                 elo->idx = 0;
66                                 elo->csum = 0;
67                         }
68                         break;
69
70                 case 1:
71                         if (data != 'T') {
72                                 elo->idx = 0;
73                                 elo->csum = 0;
74                         }
75                         break;
76
77                 case 9:
78                         if (elo->csum) {
79                                 input_regs(dev, regs);
80                                 input_report_abs(dev, ABS_X, (elo->data[4] << 8) | elo->data[3]);
81                                 input_report_abs(dev, ABS_Y, (elo->data[6] << 8) | elo->data[5]);
82                                 input_report_abs(dev, ABS_PRESSURE, (elo->data[8] << 8) | elo->data[7]);
83                                 input_report_key(dev, BTN_TOUCH, elo->data[2] & 3);
84                                 input_sync(dev);
85                         }
86                         elo->idx = 0;
87                         elo->csum = 0;
88                         break;
89         }
90 }
91
92 static void elo_process_data_6(struct elo* elo, unsigned char data, struct pt_regs *regs)
93 {
94         struct input_dev *dev = &elo->dev;
95
96         elo->data[elo->idx] = data;
97
98         switch (elo->idx++) {
99
100                 case 0: if ((data & 0xc0) != 0xc0) elo->idx = 0; break;
101                 case 1: if ((data & 0xc0) != 0x80) elo->idx = 0; break;
102                 case 2: if ((data & 0xc0) != 0x40) elo->idx = 0; break;
103
104                 case 3:
105                         if (data & 0xc0) {
106                                 elo->idx = 0;
107                                 break;
108                         }
109
110                         input_regs(dev, regs);
111                         input_report_abs(dev, ABS_X, ((elo->data[0] & 0x3f) << 6) | (elo->data[1] & 0x3f));
112                         input_report_abs(dev, ABS_Y, ((elo->data[2] & 0x3f) << 6) | (elo->data[3] & 0x3f));
113
114                         if (elo->id == 2) {
115                                 input_report_key(dev, BTN_TOUCH, 1);
116                                 input_sync(dev);
117                                 elo->idx = 0;
118                         }
119
120                         break;
121
122                 case 4:
123                         if (data) {
124                                 input_sync(dev);
125                                 elo->idx = 0;
126                         }
127                         break;
128
129                 case 5:
130                         if ((data & 0xf0) == 0) {
131                                 input_report_abs(dev, ABS_PRESSURE, elo->data[5]);
132                                 input_report_key(dev, BTN_TOUCH, elo->data[5]);
133                         }
134                         input_sync(dev);
135                         elo->idx = 0;
136                         break;
137         }
138 }
139
140 static void elo_process_data_3(struct elo* elo, unsigned char data, struct pt_regs *regs)
141 {
142         struct input_dev *dev = &elo->dev;
143
144         elo->data[elo->idx] = data;
145
146         switch (elo->idx++) {
147
148                 case 0:
149                         if ((data & 0x7f) != 0x01)
150                                 elo->idx = 0;
151                         break;
152                 case 2:
153                         input_regs(dev, regs);
154                         input_report_key(dev, BTN_TOUCH, !(elo->data[1] & 0x80));
155                         input_report_abs(dev, ABS_X, elo->data[1]);
156                         input_report_abs(dev, ABS_Y, elo->data[2]);
157                         input_sync(dev);
158                         elo->idx = 0;
159                         break;
160         }
161 }
162
163 static irqreturn_t elo_interrupt(struct serio *serio,
164                 unsigned char data, unsigned int flags, struct pt_regs *regs)
165 {
166         struct elo* elo = serio_get_drvdata(serio);
167
168         switch(elo->id) {
169                 case 0:
170                         elo_process_data_10(elo, data, regs);
171                         break;
172
173                 case 1:
174                 case 2:
175                         elo_process_data_6(elo, data, regs);
176                         break;
177
178                 case 3:
179                         elo_process_data_3(elo, data, regs);
180                         break;
181         }
182
183         return IRQ_HANDLED;
184 }
185
186 /*
187  * elo_disconnect() is the opposite of elo_connect()
188  */
189
190 static void elo_disconnect(struct serio *serio)
191 {
192         struct elo* elo = serio_get_drvdata(serio);
193
194         input_unregister_device(&elo->dev);
195         serio_close(serio);
196         serio_set_drvdata(serio, NULL);
197         kfree(elo);
198 }
199
200 /*
201  * elo_connect() is the routine that is called when someone adds a
202  * new serio device that supports Gunze protocol and registers it as
203  * an input device.
204  */
205
206 static int elo_connect(struct serio *serio, struct serio_driver *drv)
207 {
208         struct elo *elo;
209         int err;
210
211         if (!(elo = kmalloc(sizeof(struct elo), GFP_KERNEL)))
212                 return -ENOMEM;
213
214         memset(elo, 0, sizeof(struct elo));
215
216         init_input_dev(&elo->dev);
217         elo->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
218         elo->dev.keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
219
220         elo->id = serio->id.id;
221
222         switch (elo->id) {
223
224                 case 0: /* 10-byte protocol */
225                         input_set_abs_params(&elo->dev, ABS_X, 96, 4000, 0, 0);
226                         input_set_abs_params(&elo->dev, ABS_Y, 96, 4000, 0, 0);
227                         input_set_abs_params(&elo->dev, ABS_PRESSURE, 0, 255, 0, 0);
228                         break;
229
230                 case 1: /* 6-byte protocol */
231                         input_set_abs_params(&elo->dev, ABS_PRESSURE, 0, 15, 0, 0);
232
233                 case 2: /* 4-byte protocol */
234                         input_set_abs_params(&elo->dev, ABS_X, 96, 4000, 0, 0);
235                         input_set_abs_params(&elo->dev, ABS_Y, 96, 4000, 0, 0);
236                         break;
237
238                 case 3: /* 3-byte protocol */
239                         input_set_abs_params(&elo->dev, ABS_X, 0, 255, 0, 0);
240                         input_set_abs_params(&elo->dev, ABS_Y, 0, 255, 0, 0);
241                         break;
242         }
243
244         elo->serio = serio;
245
246         sprintf(elo->phys, "%s/input0", serio->phys);
247
248         elo->dev.private = elo;
249         elo->dev.name = elo_name;
250         elo->dev.phys = elo->phys;
251         elo->dev.id.bustype = BUS_RS232;
252         elo->dev.id.vendor = SERIO_ELO;
253         elo->dev.id.product = elo->id;
254         elo->dev.id.version = 0x0100;
255
256         serio_set_drvdata(serio, elo);
257
258         err = serio_open(serio, drv);
259         if (err) {
260                 serio_set_drvdata(serio, NULL);
261                 kfree(elo);
262                 return err;
263         }
264
265         input_register_device(&elo->dev);
266
267         printk(KERN_INFO "input: %s on %s\n", elo_name, serio->phys);
268
269         return 0;
270 }
271
272 /*
273  * The serio driver structure.
274  */
275
276 static struct serio_device_id elo_serio_ids[] = {
277         {
278                 .type   = SERIO_RS232,
279                 .proto  = SERIO_ELO,
280                 .id     = SERIO_ANY,
281                 .extra  = SERIO_ANY,
282         },
283         { 0 }
284 };
285
286 MODULE_DEVICE_TABLE(serio, elo_serio_ids);
287
288 static struct serio_driver elo_drv = {
289         .driver         = {
290                 .name   = "elo",
291         },
292         .description    = DRIVER_DESC,
293         .id_table       = elo_serio_ids,
294         .interrupt      = elo_interrupt,
295         .connect        = elo_connect,
296         .disconnect     = elo_disconnect,
297 };
298
299 /*
300  * The functions for inserting/removing us as a module.
301  */
302
303 static int __init elo_init(void)
304 {
305         serio_register_driver(&elo_drv);
306         return 0;
307 }
308
309 static void __exit elo_exit(void)
310 {
311         serio_unregister_driver(&elo_drv);
312 }
313
314 module_init(elo_init);
315 module_exit(elo_exit);