Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Generic linux-input device driver for axis-bearing devices | |
3 | * | |
4 | * Copyright (c) 2001 Brian S. Julin | |
5 | * All rights reserved. | |
6 | * | |
7 | * Redistribution and use in source and binary forms, with or without | |
8 | * modification, are permitted provided that the following conditions | |
9 | * are met: | |
10 | * 1. Redistributions of source code must retain the above copyright | |
11 | * notice, this list of conditions, and the following disclaimer, | |
12 | * without modification. | |
13 | * 2. The name of the author may not be used to endorse or promote products | |
14 | * derived from this software without specific prior written permission. | |
15 | * | |
16 | * Alternatively, this software may be distributed under the terms of the | |
17 | * GNU General Public License ("GPL"). | |
18 | * | |
19 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND | |
20 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
21 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
22 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR | |
23 | * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
24 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
25 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
26 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
27 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
28 | * | |
29 | * References: | |
30 | * HP-HIL Technical Reference Manual. Hewlett Packard Product No. 45918A | |
31 | * | |
32 | */ | |
33 | ||
34 | #include <linux/hil.h> | |
35 | #include <linux/input.h> | |
36 | #include <linux/serio.h> | |
37 | #include <linux/kernel.h> | |
38 | #include <linux/module.h> | |
39 | #include <linux/init.h> | |
40 | #include <linux/slab.h> | |
41 | #include <linux/pci_ids.h> | |
42 | ||
43 | #define PREFIX "HIL PTR: " | |
44 | #define HIL_GENERIC_NAME "HIL pointer device" | |
45 | ||
46 | MODULE_AUTHOR("Brian S. Julin <bri@calyx.com>"); | |
47 | MODULE_DESCRIPTION(HIL_GENERIC_NAME " driver"); | |
48 | MODULE_LICENSE("Dual BSD/GPL"); | |
49 | ||
50 | ||
51 | #define TABLET_SIMULATES_MOUSE /* allow tablet to be used as mouse */ | |
52 | #undef TABLET_AUTOADJUST /* auto-adjust valid tablet ranges */ | |
53 | ||
54 | ||
55 | #define HIL_PTR_MAX_LENGTH 16 | |
56 | ||
57 | struct hil_ptr { | |
58 | struct input_dev dev; | |
59 | struct serio *serio; | |
60 | ||
61 | /* Input buffer and index for packets from HIL bus. */ | |
62 | hil_packet data[HIL_PTR_MAX_LENGTH]; | |
63 | int idx4; /* four counts per packet */ | |
64 | ||
65 | /* Raw device info records from HIL bus, see hil.h for fields. */ | |
66 | char idd[HIL_PTR_MAX_LENGTH]; /* DID byte and IDD record */ | |
67 | char rsc[HIL_PTR_MAX_LENGTH]; /* RSC record */ | |
68 | char exd[HIL_PTR_MAX_LENGTH]; /* EXD record */ | |
69 | char rnm[HIL_PTR_MAX_LENGTH + 1]; /* RNM record + NULL term. */ | |
70 | ||
71 | /* Extra device details not contained in struct input_dev. */ | |
72 | unsigned int nbtn, naxes; | |
73 | unsigned int btnmap[7]; | |
74 | ||
75 | /* Something to sleep around with. */ | |
76 | struct semaphore sem; | |
77 | }; | |
78 | ||
79 | /* Process a complete packet after transfer from the HIL */ | |
80 | static void hil_ptr_process_record(struct hil_ptr *ptr) | |
81 | { | |
82 | struct input_dev *dev = &ptr->dev; | |
83 | hil_packet *data = ptr->data; | |
84 | hil_packet p; | |
85 | int idx, i, cnt, laxis; | |
86 | int ax16, absdev; | |
87 | ||
88 | idx = ptr->idx4/4; | |
89 | p = data[idx - 1]; | |
90 | ||
91 | if ((p & ~HIL_CMDCT_POL) == | |
92 | (HIL_ERR_INT | HIL_PKT_CMD | HIL_CMD_POL)) goto report; | |
93 | if ((p & ~HIL_CMDCT_RPL) == | |
94 | (HIL_ERR_INT | HIL_PKT_CMD | HIL_CMD_RPL)) goto report; | |
95 | ||
96 | /* Not a poll response. See if we are loading config records. */ | |
97 | switch (p & HIL_PKT_DATA_MASK) { | |
98 | case HIL_CMD_IDD: | |
99 | for (i = 0; i < idx; i++) | |
100 | ptr->idd[i] = ptr->data[i] & HIL_PKT_DATA_MASK; | |
101 | for (; i < HIL_PTR_MAX_LENGTH; i++) | |
102 | ptr->idd[i] = 0; | |
103 | break; | |
104 | case HIL_CMD_RSC: | |
105 | for (i = 0; i < idx; i++) | |
106 | ptr->rsc[i] = ptr->data[i] & HIL_PKT_DATA_MASK; | |
107 | for (; i < HIL_PTR_MAX_LENGTH; i++) | |
108 | ptr->rsc[i] = 0; | |
109 | break; | |
110 | case HIL_CMD_EXD: | |
111 | for (i = 0; i < idx; i++) | |
112 | ptr->exd[i] = ptr->data[i] & HIL_PKT_DATA_MASK; | |
113 | for (; i < HIL_PTR_MAX_LENGTH; i++) | |
114 | ptr->exd[i] = 0; | |
115 | break; | |
116 | case HIL_CMD_RNM: | |
117 | for (i = 0; i < idx; i++) | |
118 | ptr->rnm[i] = ptr->data[i] & HIL_PKT_DATA_MASK; | |
119 | for (; i < HIL_PTR_MAX_LENGTH + 1; i++) | |
120 | ptr->rnm[i] = '\0'; | |
121 | break; | |
122 | default: | |
123 | /* These occur when device isn't present */ | |
124 | if (p == (HIL_ERR_INT | HIL_PKT_CMD)) break; | |
125 | /* Anything else we'd like to know about. */ | |
126 | printk(KERN_WARNING PREFIX "Device sent unknown record %x\n", p); | |
127 | break; | |
128 | } | |
129 | goto out; | |
130 | ||
131 | report: | |
132 | if ((p & HIL_CMDCT_POL) != idx - 1) { | |
133 | printk(KERN_WARNING PREFIX "Malformed poll packet %x (idx = %i)\n", p, idx); | |
134 | goto out; | |
135 | } | |
136 | ||
137 | i = (ptr->data[0] & HIL_POL_AXIS_ALT) ? 3 : 0; | |
138 | laxis = ptr->data[0] & HIL_POL_NUM_AXES_MASK; | |
139 | laxis += i; | |
140 | ||
141 | ax16 = ptr->idd[1] & HIL_IDD_HEADER_16BIT; /* 8 or 16bit resolution */ | |
142 | absdev = ptr->idd[1] & HIL_IDD_HEADER_ABS; | |
143 | ||
144 | for (cnt = 1; i < laxis; i++) { | |
145 | unsigned int lo,hi,val; | |
146 | lo = ptr->data[cnt++] & HIL_PKT_DATA_MASK; | |
147 | hi = ax16 ? (ptr->data[cnt++] & HIL_PKT_DATA_MASK) : 0; | |
148 | if (absdev) { | |
149 | val = lo + (hi<<8); | |
150 | #ifdef TABLET_AUTOADJUST | |
151 | if (val < ptr->dev.absmin[ABS_X + i]) | |
152 | ptr->dev.absmin[ABS_X + i] = val; | |
153 | if (val > ptr->dev.absmax[ABS_X + i]) | |
154 | ptr->dev.absmax[ABS_X + i] = val; | |
155 | #endif | |
156 | if (i%3) val = ptr->dev.absmax[ABS_X + i] - val; | |
157 | input_report_abs(dev, ABS_X + i, val); | |
158 | } else { | |
159 | val = (int) (((int8_t)lo) | ((int8_t)hi<<8)); | |
160 | if (i%3) val *= -1; | |
161 | input_report_rel(dev, REL_X + i, val); | |
162 | } | |
163 | } | |
164 | ||
165 | while (cnt < idx - 1) { | |
166 | unsigned int btn; | |
167 | int up; | |
168 | btn = ptr->data[cnt++]; | |
169 | up = btn & 1; | |
170 | btn &= 0xfe; | |
171 | if (btn == 0x8e) { | |
172 | continue; /* TODO: proximity == touch? */ | |
173 | } | |
174 | else if ((btn > 0x8c) || (btn < 0x80)) continue; | |
175 | btn = (btn - 0x80) >> 1; | |
176 | btn = ptr->btnmap[btn]; | |
177 | input_report_key(dev, btn, !up); | |
178 | } | |
179 | input_sync(dev); | |
180 | out: | |
181 | ptr->idx4 = 0; | |
182 | up(&ptr->sem); | |
183 | } | |
184 | ||
185 | static void hil_ptr_process_err(struct hil_ptr *ptr) { | |
186 | printk(KERN_WARNING PREFIX "errored HIL packet\n"); | |
187 | ptr->idx4 = 0; | |
188 | up(&ptr->sem); | |
189 | return; | |
190 | } | |
191 | ||
192 | static irqreturn_t hil_ptr_interrupt(struct serio *serio, | |
193 | unsigned char data, unsigned int flags, struct pt_regs *regs) | |
194 | { | |
195 | struct hil_ptr *ptr; | |
196 | hil_packet packet; | |
197 | int idx; | |
198 | ||
6ab0f5cd | 199 | ptr = serio_get_drvdata(serio); |
1da177e4 LT |
200 | if (ptr == NULL) { |
201 | BUG(); | |
202 | return IRQ_HANDLED; | |
203 | } | |
204 | ||
205 | if (ptr->idx4 >= (HIL_PTR_MAX_LENGTH * sizeof(hil_packet))) { | |
206 | hil_ptr_process_err(ptr); | |
207 | return IRQ_HANDLED; | |
208 | } | |
209 | idx = ptr->idx4/4; | |
210 | if (!(ptr->idx4 % 4)) ptr->data[idx] = 0; | |
211 | packet = ptr->data[idx]; | |
212 | packet |= ((hil_packet)data) << ((3 - (ptr->idx4 % 4)) * 8); | |
213 | ptr->data[idx] = packet; | |
214 | ||
215 | /* Records of N 4-byte hil_packets must terminate with a command. */ | |
216 | if ((++(ptr->idx4)) % 4) return IRQ_HANDLED; | |
217 | if ((packet & 0xffff0000) != HIL_ERR_INT) { | |
218 | hil_ptr_process_err(ptr); | |
219 | return IRQ_HANDLED; | |
220 | } | |
221 | if (packet & HIL_PKT_CMD) | |
222 | hil_ptr_process_record(ptr); | |
223 | return IRQ_HANDLED; | |
224 | } | |
225 | ||
226 | static void hil_ptr_disconnect(struct serio *serio) | |
227 | { | |
228 | struct hil_ptr *ptr; | |
229 | ||
6ab0f5cd | 230 | ptr = serio_get_drvdata(serio); |
1da177e4 LT |
231 | if (ptr == NULL) { |
232 | BUG(); | |
233 | return; | |
234 | } | |
235 | ||
236 | input_unregister_device(&ptr->dev); | |
237 | serio_close(serio); | |
238 | kfree(ptr); | |
239 | } | |
240 | ||
6ab0f5cd | 241 | static int hil_ptr_connect(struct serio *serio, struct serio_driver *driver) |
1da177e4 LT |
242 | { |
243 | struct hil_ptr *ptr; | |
244 | char *txt; | |
245 | unsigned int i, naxsets, btntype; | |
246 | uint8_t did, *idd; | |
247 | ||
b39787a9 ES |
248 | if (!(ptr = kzalloc(sizeof(struct hil_ptr), GFP_KERNEL))) |
249 | return -ENOMEM; | |
1da177e4 | 250 | |
b39787a9 ES |
251 | if (serio_open(serio, driver)) |
252 | goto bail0; | |
1da177e4 | 253 | |
6ab0f5cd | 254 | serio_set_drvdata(serio, ptr); |
1da177e4 LT |
255 | ptr->serio = serio; |
256 | ptr->dev.private = ptr; | |
257 | ||
258 | init_MUTEX_LOCKED(&(ptr->sem)); | |
259 | ||
260 | /* Get device info. MLC driver supplies devid/status/etc. */ | |
261 | serio->write(serio, 0); | |
262 | serio->write(serio, 0); | |
263 | serio->write(serio, HIL_PKT_CMD >> 8); | |
264 | serio->write(serio, HIL_CMD_IDD); | |
265 | down(&(ptr->sem)); | |
266 | ||
267 | serio->write(serio, 0); | |
268 | serio->write(serio, 0); | |
269 | serio->write(serio, HIL_PKT_CMD >> 8); | |
270 | serio->write(serio, HIL_CMD_RSC); | |
271 | down(&(ptr->sem)); | |
272 | ||
273 | serio->write(serio, 0); | |
274 | serio->write(serio, 0); | |
275 | serio->write(serio, HIL_PKT_CMD >> 8); | |
276 | serio->write(serio, HIL_CMD_RNM); | |
277 | down(&(ptr->sem)); | |
278 | ||
279 | serio->write(serio, 0); | |
280 | serio->write(serio, 0); | |
281 | serio->write(serio, HIL_PKT_CMD >> 8); | |
282 | serio->write(serio, HIL_CMD_EXD); | |
283 | down(&(ptr->sem)); | |
284 | ||
285 | up(&(ptr->sem)); | |
286 | ||
287 | init_input_dev(&ptr->dev); | |
288 | did = ptr->idd[0]; | |
289 | idd = ptr->idd + 1; | |
290 | txt = "unknown"; | |
291 | if ((did & HIL_IDD_DID_TYPE_MASK) == HIL_IDD_DID_TYPE_REL) { | |
292 | ptr->dev.evbit[0] = BIT(EV_REL); | |
293 | txt = "relative"; | |
294 | } | |
295 | ||
296 | if ((did & HIL_IDD_DID_TYPE_MASK) == HIL_IDD_DID_TYPE_ABS) { | |
297 | ptr->dev.evbit[0] = BIT(EV_ABS); | |
298 | txt = "absolute"; | |
299 | } | |
300 | if (!ptr->dev.evbit[0]) { | |
301 | goto bail1; | |
302 | } | |
303 | ||
304 | ptr->nbtn = HIL_IDD_NUM_BUTTONS(idd); | |
305 | if (ptr->nbtn) ptr->dev.evbit[0] |= BIT(EV_KEY); | |
306 | ||
307 | naxsets = HIL_IDD_NUM_AXSETS(*idd); | |
308 | ptr->naxes = HIL_IDD_NUM_AXES_PER_SET(*idd); | |
309 | ||
310 | printk(KERN_INFO PREFIX "HIL pointer device found (did: 0x%02x, axis: %s)\n", | |
311 | did, txt); | |
312 | printk(KERN_INFO PREFIX "HIL pointer has %i buttons and %i sets of %i axes\n", | |
313 | ptr->nbtn, naxsets, ptr->naxes); | |
314 | ||
315 | btntype = BTN_MISC; | |
316 | if ((did & HIL_IDD_DID_ABS_TABLET_MASK) == HIL_IDD_DID_ABS_TABLET) | |
317 | #ifdef TABLET_SIMULATES_MOUSE | |
318 | btntype = BTN_TOUCH; | |
319 | #else | |
320 | btntype = BTN_DIGI; | |
321 | #endif | |
322 | if ((did & HIL_IDD_DID_ABS_TSCREEN_MASK) == HIL_IDD_DID_ABS_TSCREEN) | |
323 | btntype = BTN_TOUCH; | |
324 | ||
325 | if ((did & HIL_IDD_DID_REL_MOUSE_MASK) == HIL_IDD_DID_REL_MOUSE) | |
326 | btntype = BTN_MOUSE; | |
327 | ||
328 | for (i = 0; i < ptr->nbtn; i++) { | |
329 | set_bit(btntype | i, ptr->dev.keybit); | |
330 | ptr->btnmap[i] = btntype | i; | |
331 | } | |
332 | ||
333 | if (btntype == BTN_MOUSE) { | |
334 | /* Swap buttons 2 and 3 */ | |
335 | ptr->btnmap[1] = BTN_MIDDLE; | |
336 | ptr->btnmap[2] = BTN_RIGHT; | |
337 | } | |
338 | ||
339 | if ((did & HIL_IDD_DID_TYPE_MASK) == HIL_IDD_DID_TYPE_REL) { | |
340 | for (i = 0; i < ptr->naxes; i++) { | |
341 | set_bit(REL_X + i, ptr->dev.relbit); | |
342 | } | |
343 | for (i = 3; (i < ptr->naxes + 3) && (naxsets > 1); i++) { | |
344 | set_bit(REL_X + i, ptr->dev.relbit); | |
345 | } | |
346 | } else { | |
347 | for (i = 0; i < ptr->naxes; i++) { | |
348 | set_bit(ABS_X + i, ptr->dev.absbit); | |
349 | ptr->dev.absmin[ABS_X + i] = 0; | |
350 | ptr->dev.absmax[ABS_X + i] = | |
351 | HIL_IDD_AXIS_MAX((ptr->idd + 1), i); | |
352 | } | |
353 | for (i = 3; (i < ptr->naxes + 3) && (naxsets > 1); i++) { | |
354 | set_bit(ABS_X + i, ptr->dev.absbit); | |
355 | ptr->dev.absmin[ABS_X + i] = 0; | |
356 | ptr->dev.absmax[ABS_X + i] = | |
357 | HIL_IDD_AXIS_MAX((ptr->idd + 1), (i - 3)); | |
358 | } | |
359 | #ifdef TABLET_AUTOADJUST | |
360 | for (i = 0; i < ABS_MAX; i++) { | |
361 | int diff = ptr->dev.absmax[ABS_X + i] / 10; | |
362 | ptr->dev.absmin[ABS_X + i] += diff; | |
363 | ptr->dev.absmax[ABS_X + i] -= diff; | |
364 | } | |
365 | #endif | |
366 | } | |
367 | ||
368 | ptr->dev.name = strlen(ptr->rnm) ? ptr->rnm : HIL_GENERIC_NAME; | |
369 | ||
370 | ptr->dev.id.bustype = BUS_HIL; | |
371 | ptr->dev.id.vendor = PCI_VENDOR_ID_HP; | |
372 | ptr->dev.id.product = 0x0001; /* TODO: get from ptr->rsc */ | |
373 | ptr->dev.id.version = 0x0100; /* TODO: get from ptr->rsc */ | |
374 | ptr->dev.dev = &serio->dev; | |
375 | ||
376 | input_register_device(&ptr->dev); | |
377 | printk(KERN_INFO "input: %s (%s), ID: %d\n", | |
378 | ptr->dev.name, | |
379 | (btntype == BTN_MOUSE) ? "HIL mouse":"HIL tablet or touchpad", | |
380 | did); | |
381 | ||
6ab0f5cd | 382 | return 0; |
1da177e4 LT |
383 | bail1: |
384 | serio_close(serio); | |
385 | bail0: | |
386 | kfree(ptr); | |
6ab0f5cd MW |
387 | serio_set_drvdata(serio, NULL); |
388 | return -ENODEV; | |
1da177e4 LT |
389 | } |
390 | ||
6ab0f5cd MW |
391 | static struct serio_device_id hil_ptr_ids[] = { |
392 | { | |
393 | .type = SERIO_HIL_MLC, | |
394 | .proto = SERIO_HIL, | |
395 | .id = SERIO_ANY, | |
396 | .extra = SERIO_ANY, | |
397 | }, | |
398 | { 0 } | |
399 | }; | |
1da177e4 LT |
400 | |
401 | static struct serio_driver hil_ptr_serio_driver = { | |
402 | .driver = { | |
403 | .name = "hil_ptr", | |
404 | }, | |
405 | .description = "HP HIL mouse/tablet driver", | |
6ab0f5cd MW |
406 | .id_table = hil_ptr_ids, |
407 | .connect = hil_ptr_connect, | |
408 | .disconnect = hil_ptr_disconnect, | |
409 | .interrupt = hil_ptr_interrupt | |
1da177e4 LT |
410 | }; |
411 | ||
412 | static int __init hil_ptr_init(void) | |
413 | { | |
414 | serio_register_driver(&hil_ptr_serio_driver); | |
415 | return 0; | |
416 | } | |
417 | ||
418 | static void __exit hil_ptr_exit(void) | |
419 | { | |
420 | serio_unregister_driver(&hil_ptr_serio_driver); | |
421 | } | |
422 | ||
423 | module_init(hil_ptr_init); | |
424 | module_exit(hil_ptr_exit); |