Merge commit 'origin/master' into next
[linux-2.6] / drivers / hid / hid-ntrig.c
1 /*
2  *  HID driver for N-Trig touchscreens
3  *
4  *  Copyright (c) 2008 Rafi Rubin
5  *  Copyright (c) 2009 Stephane Chatty
6  *
7  */
8
9 /*
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License as published by the Free
12  * Software Foundation; either version 2 of the License, or (at your option)
13  * any later version.
14  */
15
16 #include <linux/device.h>
17 #include <linux/hid.h>
18 #include <linux/module.h>
19
20 #include "hid-ids.h"
21
22 #define NTRIG_DUPLICATE_USAGES  0x001
23
24 #define nt_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
25                                         EV_KEY, (c))
26
27 struct ntrig_data {
28         __s32 x, y, id, w, h;
29         char reading_a_point, found_contact_id;
30 };
31
32 /*
33  * this driver is aimed at two firmware versions in circulation:
34  *  - dual pen/finger single touch
35  *  - finger multitouch, pen not working
36  */
37
38 static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi,
39                 struct hid_field *field, struct hid_usage *usage,
40                 unsigned long **bit, int *max)
41 {
42         switch (usage->hid & HID_USAGE_PAGE) {
43
44         case HID_UP_GENDESK:
45                 switch (usage->hid) {
46                 case HID_GD_X:
47                         hid_map_usage(hi, usage, bit, max,
48                                         EV_ABS, ABS_MT_POSITION_X);
49                         input_set_abs_params(hi->input, ABS_X,
50                                         field->logical_minimum,
51                                         field->logical_maximum, 0, 0);
52                         return 1;
53                 case HID_GD_Y:
54                         hid_map_usage(hi, usage, bit, max,
55                                         EV_ABS, ABS_MT_POSITION_Y);
56                         input_set_abs_params(hi->input, ABS_Y,
57                                         field->logical_minimum,
58                                         field->logical_maximum, 0, 0);
59                         return 1;
60                 }
61                 return 0;
62
63         case HID_UP_DIGITIZER:
64                 switch (usage->hid) {
65                 /* we do not want to map these for now */
66                 case HID_DG_INVERT: /* value is always 0 */
67                 case HID_DG_ERASER: /* value is always 0 */
68                 case HID_DG_CONTACTID: /* value is useless */
69                 case HID_DG_BARRELSWITCH:  /* doubtful */
70                 case HID_DG_INPUTMODE:
71                 case HID_DG_DEVICEINDEX:
72                 case HID_DG_CONTACTCOUNT:
73                 case HID_DG_CONTACTMAX:
74                         return -1;
75
76                 /* original mapping by Rafi Rubin */
77                 case HID_DG_CONFIDENCE:
78                         nt_map_key_clear(BTN_TOOL_DOUBLETAP);
79                         return 1;
80
81                 /* width/height mapped on TouchMajor/TouchMinor/Orientation */
82                 case HID_DG_WIDTH:
83                         hid_map_usage(hi, usage, bit, max,
84                                         EV_ABS, ABS_MT_TOUCH_MAJOR);
85                         return 1;
86                 case HID_DG_HEIGHT:
87                         hid_map_usage(hi, usage, bit, max,
88                                         EV_ABS, ABS_MT_TOUCH_MINOR);
89                         input_set_abs_params(hi->input, ABS_MT_ORIENTATION,
90                                         0, 1, 0, 0);
91                         return 1;
92                 }
93                 return 0;
94
95         case 0xff000000:
96                 /* we do not want to map these: no input-oriented meaning */
97                 return -1;
98         }
99
100         return 0;
101 }
102
103 static int ntrig_input_mapped(struct hid_device *hdev, struct hid_input *hi,
104                 struct hid_field *field, struct hid_usage *usage,
105                 unsigned long **bit, int *max)
106 {
107         if (usage->type == EV_KEY || usage->type == EV_REL
108                         || usage->type == EV_ABS)
109                 clear_bit(usage->code, *bit);
110
111         return 0;
112 }
113
114 /*
115  * this function is called upon all reports
116  * so that we can filter contact point information,
117  * decide whether we are in multi or single touch mode
118  * and call input_mt_sync after each point if necessary
119  */
120 static int ntrig_event (struct hid_device *hid, struct hid_field *field,
121                                         struct hid_usage *usage, __s32 value)
122 {
123         struct input_dev *input = field->hidinput->input;
124         struct ntrig_data *nd = hid_get_drvdata(hid);
125
126         if (hid->claimed & HID_CLAIMED_INPUT) {
127                 switch (usage->hid) {
128                 case HID_GD_X:
129                         nd->x = value;
130                         nd->reading_a_point = 1;
131                         break;
132                 case HID_GD_Y:
133                         nd->y = value;
134                         break;
135                 case HID_DG_CONTACTID:
136                         nd->id = value;
137                         /* we receive this only when in multitouch mode */
138                         nd->found_contact_id = 1;
139                         break;
140                 case HID_DG_WIDTH:
141                         nd->w = value;
142                         break;
143                 case HID_DG_HEIGHT:
144                         nd->h = value;
145                         /*
146                          * when in single touch mode, this is the last
147                          * report received in a finger event. We want
148                          * to emit a normal (X, Y) position
149                          */
150                         if (! nd->found_contact_id) {
151                                 input_event(input, EV_ABS, ABS_X, nd->x);
152                                 input_event(input, EV_ABS, ABS_Y, nd->y);
153                         }
154                         break;
155                 case HID_DG_TIPPRESSURE:
156                         /*
157                          * when in single touch mode, this is the last
158                          * report received in a pen event. We want
159                          * to emit a normal (X, Y) position
160                          */
161                         if (! nd->found_contact_id) {
162                                 input_event(input, EV_ABS, ABS_X, nd->x);
163                                 input_event(input, EV_ABS, ABS_Y, nd->y);
164                                 input_event(input, EV_ABS, ABS_PRESSURE, value);
165                         }
166                         break;
167                 case 0xff000002:
168                         /*
169                          * we receive this when the device is in multitouch
170                          * mode. The first of the three values tagged with
171                          * this usage tells if the contact point is real
172                          * or a placeholder
173                          */
174                         if (!nd->reading_a_point || value != 1)
175                                 break;
176                         /* emit a normal (X, Y) for the first point only */
177                         if (nd->id == 0) {
178                                 input_event(input, EV_ABS, ABS_X, nd->x);
179                                 input_event(input, EV_ABS, ABS_Y, nd->y);
180                         }
181                         input_event(input, EV_ABS, ABS_MT_POSITION_X, nd->x);
182                         input_event(input, EV_ABS, ABS_MT_POSITION_Y, nd->y);
183                         if (nd->w > nd->h) {
184                                 input_event(input, EV_ABS,
185                                                 ABS_MT_ORIENTATION, 1);
186                                 input_event(input, EV_ABS,
187                                                 ABS_MT_TOUCH_MAJOR, nd->w);
188                                 input_event(input, EV_ABS,
189                                                 ABS_MT_TOUCH_MINOR, nd->h);
190                         } else {
191                                 input_event(input, EV_ABS,
192                                                 ABS_MT_ORIENTATION, 0);
193                                 input_event(input, EV_ABS,
194                                                 ABS_MT_TOUCH_MAJOR, nd->h);
195                                 input_event(input, EV_ABS,
196                                                 ABS_MT_TOUCH_MINOR, nd->w);
197                         }
198                         input_mt_sync(field->hidinput->input);
199                         nd->reading_a_point = 0;
200                         nd->found_contact_id = 0;
201                         break;
202
203                 default:
204                         /* fallback to the generic hidinput handling */
205                         return 0;
206                 }
207         }
208
209         /* we have handled the hidinput part, now remains hiddev */
210         if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
211                 hid->hiddev_hid_event(hid, field, usage, value);
212
213         return 1;
214 }
215
216 static int ntrig_probe(struct hid_device *hdev, const struct hid_device_id *id)
217 {
218         int ret;
219         struct ntrig_data *nd;
220
221         nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL);
222         if (!nd) {
223                 dev_err(&hdev->dev, "cannot allocate N-Trig data\n");
224                 return -ENOMEM;
225         }
226         nd->reading_a_point = 0;
227         nd->found_contact_id = 0;
228         hid_set_drvdata(hdev, nd);
229
230         ret = hid_parse(hdev);
231         if (!ret)
232                 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
233
234         if (ret)
235                 kfree (nd);
236         return ret;
237 }
238
239 static void ntrig_remove(struct hid_device *hdev)
240 {
241         hid_hw_stop(hdev);
242         kfree(hid_get_drvdata(hdev));
243 }
244
245 static const struct hid_device_id ntrig_devices[] = {
246         { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN),
247                 .driver_data = NTRIG_DUPLICATE_USAGES },
248         { }
249 };
250 MODULE_DEVICE_TABLE(hid, ntrig_devices);
251
252 static const struct hid_usage_id ntrig_grabbed_usages[] = {
253         { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
254         { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
255 };
256
257 static struct hid_driver ntrig_driver = {
258         .name = "ntrig",
259         .id_table = ntrig_devices,
260         .probe = ntrig_probe,
261         .remove = ntrig_remove,
262         .input_mapping = ntrig_input_mapping,
263         .input_mapped = ntrig_input_mapped,
264         .usage_table = ntrig_grabbed_usages,
265         .event = ntrig_event,
266 };
267
268 static int ntrig_init(void)
269 {
270         return hid_register_driver(&ntrig_driver);
271 }
272
273 static void ntrig_exit(void)
274 {
275         hid_unregister_driver(&ntrig_driver);
276 }
277
278 module_init(ntrig_init);
279 module_exit(ntrig_exit);
280 MODULE_LICENSE("GPL");