Commit | Line | Data |
---|---|---|
b6353f4f SC |
1 | /* |
2 | * HID driver for 3M PCT multitouch panels | |
3 | * | |
4 | * Copyright (c) 2009 Stephane Chatty <chatty@enac.fr> | |
5 | * | |
6 | */ | |
7 | ||
8 | /* | |
9 | * This program is free software; you can redistribute it and/or modify it | |
10 | * under the terms of the GNU General Public License as published by the Free | |
11 | * Software Foundation; either version 2 of the License, or (at your option) | |
12 | * any later version. | |
13 | */ | |
14 | ||
15 | #include <linux/device.h> | |
16 | #include <linux/hid.h> | |
17 | #include <linux/module.h> | |
18 | #include <linux/usb.h> | |
19 | ||
b6353f4f SC |
20 | MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>"); |
21 | MODULE_DESCRIPTION("3M PCT multitouch panels"); | |
22 | MODULE_LICENSE("GPL"); | |
23 | ||
24 | #include "hid-ids.h" | |
25 | ||
26 | struct mmm_finger { | |
27 | __s32 x, y; | |
28 | __u8 rank; | |
29 | bool touch, valid; | |
30 | }; | |
31 | ||
32 | struct mmm_data { | |
33 | struct mmm_finger f[10]; | |
34 | __u8 curid, num; | |
35 | bool touch, valid; | |
36 | }; | |
37 | ||
38 | static int mmm_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_BUTTON: | |
45 | return -1; | |
46 | ||
47 | case HID_UP_GENDESK: | |
48 | switch (usage->hid) { | |
49 | case HID_GD_X: | |
50 | hid_map_usage(hi, usage, bit, max, | |
51 | EV_ABS, ABS_MT_POSITION_X); | |
52 | /* touchscreen emulation */ | |
53 | input_set_abs_params(hi->input, ABS_X, | |
54 | field->logical_minimum, | |
55 | field->logical_maximum, 0, 0); | |
56 | return 1; | |
57 | case HID_GD_Y: | |
58 | hid_map_usage(hi, usage, bit, max, | |
59 | EV_ABS, ABS_MT_POSITION_Y); | |
60 | /* touchscreen emulation */ | |
61 | input_set_abs_params(hi->input, ABS_Y, | |
62 | field->logical_minimum, | |
63 | field->logical_maximum, 0, 0); | |
64 | return 1; | |
65 | } | |
66 | return 0; | |
67 | ||
68 | case HID_UP_DIGITIZER: | |
69 | switch (usage->hid) { | |
70 | /* we do not want to map these: no input-oriented meaning */ | |
71 | case 0x14: | |
72 | case 0x23: | |
73 | case HID_DG_INPUTMODE: | |
74 | case HID_DG_DEVICEINDEX: | |
75 | case HID_DG_CONTACTCOUNT: | |
76 | case HID_DG_CONTACTMAX: | |
77 | case HID_DG_INRANGE: | |
78 | case HID_DG_CONFIDENCE: | |
79 | return -1; | |
80 | case HID_DG_TIPSWITCH: | |
81 | /* touchscreen emulation */ | |
82 | hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH); | |
83 | return 1; | |
84 | case HID_DG_CONTACTID: | |
85 | hid_map_usage(hi, usage, bit, max, | |
86 | EV_ABS, ABS_MT_TRACKING_ID); | |
87 | return 1; | |
88 | } | |
89 | /* let hid-input decide for the others */ | |
90 | return 0; | |
91 | ||
92 | case 0xff000000: | |
93 | /* we do not want to map these: no input-oriented meaning */ | |
94 | return -1; | |
95 | } | |
96 | ||
97 | return 0; | |
98 | } | |
99 | ||
100 | static int mmm_input_mapped(struct hid_device *hdev, struct hid_input *hi, | |
101 | struct hid_field *field, struct hid_usage *usage, | |
102 | unsigned long **bit, int *max) | |
103 | { | |
104 | if (usage->type == EV_KEY || usage->type == EV_ABS) | |
105 | clear_bit(usage->code, *bit); | |
106 | ||
107 | return 0; | |
108 | } | |
109 | ||
110 | /* | |
111 | * this function is called when a whole packet has been received and processed, | |
112 | * so that it can decide what to send to the input layer. | |
113 | */ | |
114 | static void mmm_filter_event(struct mmm_data *md, struct input_dev *input) | |
115 | { | |
116 | struct mmm_finger *oldest = 0; | |
117 | bool pressed = false, released = false; | |
118 | int i; | |
119 | ||
120 | /* | |
121 | * we need to iterate on all fingers to decide if we have a press | |
122 | * or a release event in our touchscreen emulation. | |
123 | */ | |
124 | for (i = 0; i < 10; ++i) { | |
125 | struct mmm_finger *f = &md->f[i]; | |
126 | if (!f->valid) { | |
127 | /* this finger is just placeholder data, ignore */ | |
128 | } else if (f->touch) { | |
129 | /* this finger is on the screen */ | |
130 | input_event(input, EV_ABS, ABS_MT_TRACKING_ID, i); | |
131 | input_event(input, EV_ABS, ABS_MT_POSITION_X, f->x); | |
132 | input_event(input, EV_ABS, ABS_MT_POSITION_Y, f->y); | |
133 | input_mt_sync(input); | |
134 | /* | |
135 | * touchscreen emulation: maintain the age rank | |
136 | * of this finger, decide if we have a press | |
137 | */ | |
138 | if (f->rank == 0) { | |
139 | f->rank = ++(md->num); | |
140 | if (f->rank == 1) | |
141 | pressed = true; | |
142 | } | |
143 | if (f->rank == 1) | |
144 | oldest = f; | |
145 | } else { | |
146 | /* this finger took off the screen */ | |
147 | /* touchscreen emulation: maintain age rank of others */ | |
148 | int j; | |
149 | ||
150 | for (j = 0; j < 10; ++j) { | |
151 | struct mmm_finger *g = &md->f[j]; | |
152 | if (g->rank > f->rank) { | |
153 | g->rank--; | |
154 | if (g->rank == 1) | |
155 | oldest = g; | |
156 | } | |
157 | } | |
158 | f->rank = 0; | |
159 | --(md->num); | |
160 | if (md->num == 0) | |
161 | released = true; | |
162 | } | |
163 | f->valid = 0; | |
164 | } | |
165 | ||
166 | /* touchscreen emulation */ | |
167 | if (oldest) { | |
168 | if (pressed) | |
169 | input_event(input, EV_KEY, BTN_TOUCH, 1); | |
170 | input_event(input, EV_ABS, ABS_X, oldest->x); | |
171 | input_event(input, EV_ABS, ABS_Y, oldest->y); | |
172 | } else if (released) { | |
173 | input_event(input, EV_KEY, BTN_TOUCH, 0); | |
174 | } | |
175 | } | |
176 | ||
177 | /* | |
178 | * this function is called upon all reports | |
179 | * so that we can accumulate contact point information, | |
180 | * and call input_mt_sync after each point. | |
181 | */ | |
182 | static int mmm_event(struct hid_device *hid, struct hid_field *field, | |
183 | struct hid_usage *usage, __s32 value) | |
184 | { | |
185 | struct mmm_data *md = hid_get_drvdata(hid); | |
186 | /* | |
187 | * strangely, this function can be called before | |
188 | * field->hidinput is initialized! | |
189 | */ | |
190 | if (hid->claimed & HID_CLAIMED_INPUT) { | |
191 | struct input_dev *input = field->hidinput->input; | |
192 | switch (usage->hid) { | |
193 | case HID_DG_TIPSWITCH: | |
194 | md->touch = value; | |
195 | break; | |
196 | case HID_DG_CONFIDENCE: | |
197 | md->valid = value; | |
198 | break; | |
199 | case HID_DG_CONTACTID: | |
200 | if (md->valid) { | |
201 | md->curid = value; | |
202 | md->f[value].touch = md->touch; | |
203 | md->f[value].valid = 1; | |
204 | } | |
205 | break; | |
206 | case HID_GD_X: | |
207 | if (md->valid) | |
208 | md->f[md->curid].x = value; | |
209 | break; | |
210 | case HID_GD_Y: | |
211 | if (md->valid) | |
212 | md->f[md->curid].y = value; | |
213 | break; | |
214 | case HID_DG_CONTACTCOUNT: | |
215 | mmm_filter_event(md, input); | |
216 | break; | |
217 | } | |
218 | } | |
219 | ||
220 | /* we have handled the hidinput part, now remains hiddev */ | |
221 | if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event) | |
222 | hid->hiddev_hid_event(hid, field, usage, value); | |
223 | ||
224 | return 1; | |
225 | } | |
226 | ||
227 | static int mmm_probe(struct hid_device *hdev, const struct hid_device_id *id) | |
228 | { | |
229 | int ret; | |
230 | struct mmm_data *md; | |
231 | ||
232 | md = kzalloc(sizeof(struct mmm_data), GFP_KERNEL); | |
233 | if (!md) { | |
234 | dev_err(&hdev->dev, "cannot allocate 3M data\n"); | |
235 | return -ENOMEM; | |
236 | } | |
237 | hid_set_drvdata(hdev, md); | |
238 | ||
239 | ret = hid_parse(hdev); | |
240 | if (!ret) | |
241 | ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); | |
242 | ||
243 | if (ret) | |
244 | kfree(md); | |
245 | return ret; | |
246 | } | |
247 | ||
248 | static void mmm_remove(struct hid_device *hdev) | |
249 | { | |
250 | hid_hw_stop(hdev); | |
251 | kfree(hid_get_drvdata(hdev)); | |
252 | hid_set_drvdata(hdev, NULL); | |
253 | } | |
254 | ||
255 | static const struct hid_device_id mmm_devices[] = { | |
256 | { HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M1968) }, | |
257 | { } | |
258 | }; | |
259 | MODULE_DEVICE_TABLE(hid, mmm_devices); | |
260 | ||
261 | static const struct hid_usage_id mmm_grabbed_usages[] = { | |
262 | { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID }, | |
263 | { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1} | |
264 | }; | |
265 | ||
266 | static struct hid_driver mmm_driver = { | |
267 | .name = "3m-pct", | |
268 | .id_table = mmm_devices, | |
269 | .probe = mmm_probe, | |
270 | .remove = mmm_remove, | |
271 | .input_mapping = mmm_input_mapping, | |
272 | .input_mapped = mmm_input_mapped, | |
273 | .usage_table = mmm_grabbed_usages, | |
274 | .event = mmm_event, | |
275 | }; | |
276 | ||
277 | static int __init mmm_init(void) | |
278 | { | |
279 | return hid_register_driver(&mmm_driver); | |
280 | } | |
281 | ||
282 | static void __exit mmm_exit(void) | |
283 | { | |
284 | hid_unregister_driver(&mmm_driver); | |
285 | } | |
286 | ||
287 | module_init(mmm_init); | |
288 | module_exit(mmm_exit); | |
289 | MODULE_LICENSE("GPL"); | |
290 |