Input: penmount - add PenMount 6000 support
[pandora-kernel.git] / drivers / input / touchscreen / penmount.c
1 /*
2  * Penmount serial touchscreen driver
3  *
4  * Copyright (c) 2006 Rick Koch <n1gp@hotmail.com>
5  * Copyright (c) 2011 John Sung <penmount.touch@gmail.com>
6  *
7  * Based on ELO driver (drivers/input/touchscreen/elo.c)
8  * Copyright (c) 2004 Vojtech Pavlik
9  */
10
11 /*
12  * This program is free software; you can redistribute it and/or modify it
13  * under the terms of the GNU General Public License version 2 as published
14  * by the Free Software Foundation.
15  */
16
17 #include <linux/errno.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/slab.h>
21 #include <linux/input.h>
22 #include <linux/serio.h>
23 #include <linux/init.h>
24
25 #define DRIVER_DESC     "PenMount serial touchscreen driver"
26
27 MODULE_AUTHOR("Rick Koch <n1gp@hotmail.com>");
28 MODULE_AUTHOR("John Sung <penmount.touch@gmail.com>");
29 MODULE_DESCRIPTION(DRIVER_DESC);
30 MODULE_LICENSE("GPL");
31
32 /*
33  * Definitions & global arrays.
34  */
35
36 #define PM_MAX_LENGTH   6
37
38 /*
39  * Per-touchscreen data.
40  */
41
42 struct pm {
43         struct input_dev *dev;
44         struct serio *serio;
45         int idx;
46         unsigned char data[PM_MAX_LENGTH];
47         char phys[32];
48         unsigned char packetsize;
49 };
50
51 /*
52  * pm_checkpacket() checks if data packet is valid
53  */
54
55 static bool pm_checkpacket(unsigned char *packet)
56 {
57         int total = 0;
58         int i;
59
60         for (i = 0; i < 5; i++)
61                 total += packet[i];
62
63         return packet[5] == (unsigned char)~(total & 0xff);
64 }
65
66 static irqreturn_t pm_interrupt(struct serio *serio,
67                 unsigned char data, unsigned int flags)
68 {
69         struct pm *pm = serio_get_drvdata(serio);
70         struct input_dev *dev = pm->dev;
71
72         pm->data[pm->idx] = data;
73
74         switch (pm->dev->id.product) {
75         case 0x9000:
76                 if (pm->data[0] & 0x80) {
77                         if (pm->packetsize == ++pm->idx) {
78                                 input_report_abs(dev, ABS_X, pm->data[1] * 128 + pm->data[2]);
79                                 input_report_abs(dev, ABS_Y, pm->data[3] * 128 + pm->data[4]);
80                                 input_report_key(dev, BTN_TOUCH, !!(pm->data[0] & 0x40));
81                                 input_sync(dev);
82                                 pm->idx = 0;
83                         }
84                 }
85                 break;
86
87         case 0x6000:
88                 if ((pm->data[0] & 0xbf) == 0x30) {
89                         if (pm->packetsize == ++pm->idx) {
90                                 if (pm_checkpacket(pm->data)) {
91                                         input_report_abs(dev, ABS_X,
92                                                         pm->data[2] * 256 + pm->data[1]);
93                                         input_report_abs(dev, ABS_Y,
94                                                         pm->data[4] * 256 + pm->data[3]);
95                                         input_report_key(dev, BTN_TOUCH, !!(pm->data[0] & 0x40));
96                                         input_sync(dev);
97                                 }
98                                 pm->idx = 0;
99                         }
100                 }
101                 break;
102         }
103
104         return IRQ_HANDLED;
105 }
106
107 /*
108  * pm_disconnect() is the opposite of pm_connect()
109  */
110
111 static void pm_disconnect(struct serio *serio)
112 {
113         struct pm *pm = serio_get_drvdata(serio);
114
115         input_get_device(pm->dev);
116         input_unregister_device(pm->dev);
117         serio_close(serio);
118         serio_set_drvdata(serio, NULL);
119         input_put_device(pm->dev);
120         kfree(pm);
121 }
122
123 /*
124  * pm_connect() is the routine that is called when someone adds a
125  * new serio device that supports PenMount protocol and registers it as
126  * an input device.
127  */
128
129 static int pm_connect(struct serio *serio, struct serio_driver *drv)
130 {
131         struct pm *pm;
132         struct input_dev *input_dev;
133         int err;
134
135         pm = kzalloc(sizeof(struct pm), GFP_KERNEL);
136         input_dev = input_allocate_device();
137         if (!pm || !input_dev) {
138                 err = -ENOMEM;
139                 goto fail1;
140         }
141
142         pm->serio = serio;
143         pm->dev = input_dev;
144         snprintf(pm->phys, sizeof(pm->phys), "%s/input0", serio->phys);
145
146         input_dev->name = "PenMount Serial TouchScreen";
147         input_dev->phys = pm->phys;
148         input_dev->id.bustype = BUS_RS232;
149         input_dev->id.vendor = SERIO_PENMOUNT;
150         input_dev->id.product = 0;
151         input_dev->id.version = 0x0100;
152         input_dev->dev.parent = &serio->dev;
153
154         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
155         input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
156         input_set_abs_params(pm->dev, ABS_X, 0, 0x3ff, 0, 0);
157         input_set_abs_params(pm->dev, ABS_Y, 0, 0x3ff, 0, 0);
158
159         switch (serio->id.id) {
160         default:
161         case 0:
162                 pm->packetsize = 5;
163                 input_dev->id.product = 0x9000;
164                 break;
165
166         case 1:
167                 pm->packetsize = 6;
168                 input_dev->id.product = 0x6000;
169                 break;
170         }
171
172         serio_set_drvdata(serio, pm);
173
174         err = serio_open(serio, drv);
175         if (err)
176                 goto fail2;
177
178         err = input_register_device(pm->dev);
179         if (err)
180                 goto fail3;
181
182         return 0;
183
184  fail3: serio_close(serio);
185  fail2: serio_set_drvdata(serio, NULL);
186  fail1: input_free_device(input_dev);
187         kfree(pm);
188         return err;
189 }
190
191 /*
192  * The serio driver structure.
193  */
194
195 static struct serio_device_id pm_serio_ids[] = {
196         {
197                 .type   = SERIO_RS232,
198                 .proto  = SERIO_PENMOUNT,
199                 .id     = SERIO_ANY,
200                 .extra  = SERIO_ANY,
201         },
202         { 0 }
203 };
204
205 MODULE_DEVICE_TABLE(serio, pm_serio_ids);
206
207 static struct serio_driver pm_drv = {
208         .driver         = {
209                 .name   = "serio-penmount",
210         },
211         .description    = DRIVER_DESC,
212         .id_table       = pm_serio_ids,
213         .interrupt      = pm_interrupt,
214         .connect        = pm_connect,
215         .disconnect     = pm_disconnect,
216 };
217
218 /*
219  * The functions for inserting/removing us as a module.
220  */
221
222 static int __init pm_init(void)
223 {
224         return serio_register_driver(&pm_drv);
225 }
226
227 static void __exit pm_exit(void)
228 {
229         serio_unregister_driver(&pm_drv);
230 }
231
232 module_init(pm_init);
233 module_exit(pm_exit);