1 | /* |
2 | * Generic linux-input device driver for keyboard 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/completion.h> |
40 | #include <linux/slab.h> |
41 | #include <linux/pci_ids.h> |
42 | |
43 | #define PREFIX "HIL: " |
44 | |
45 | MODULE_AUTHOR("Brian S. Julin <bri@calyx.com>" ); |
46 | MODULE_DESCRIPTION("HIL keyboard/mouse driver" ); |
47 | MODULE_LICENSE("Dual BSD/GPL" ); |
48 | MODULE_ALIAS("serio:ty03pr25id00ex*" ); /* HIL keyboard */ |
49 | MODULE_ALIAS("serio:ty03pr25id0Fex*" ); /* HIL mouse */ |
50 | |
51 | #define HIL_PACKET_MAX_LENGTH 16 |
52 | |
53 | #define HIL_KBD_SET1_UPBIT 0x01 |
54 | #define HIL_KBD_SET1_SHIFT 1 |
55 | static unsigned int hil_kbd_set1[HIL_KEYCODES_SET1_TBLSIZE] __read_mostly = |
56 | { HIL_KEYCODES_SET1 }; |
57 | |
58 | #define HIL_KBD_SET2_UPBIT 0x01 |
59 | #define HIL_KBD_SET2_SHIFT 1 |
60 | /* Set2 is user defined */ |
61 | |
62 | #define HIL_KBD_SET3_UPBIT 0x80 |
63 | #define HIL_KBD_SET3_SHIFT 0 |
64 | static unsigned int hil_kbd_set3[HIL_KEYCODES_SET3_TBLSIZE] __read_mostly = |
65 | { HIL_KEYCODES_SET3 }; |
66 | |
67 | static const char hil_language[][16] = { HIL_LOCALE_MAP }; |
68 | |
69 | struct hil_dev { |
70 | struct input_dev *dev; |
71 | struct serio *serio; |
72 | |
73 | /* Input buffer and index for packets from HIL bus. */ |
74 | hil_packet data[HIL_PACKET_MAX_LENGTH]; |
75 | int idx4; /* four counts per packet */ |
76 | |
77 | /* Raw device info records from HIL bus, see hil.h for fields. */ |
78 | char idd[HIL_PACKET_MAX_LENGTH]; /* DID byte and IDD record */ |
79 | char rsc[HIL_PACKET_MAX_LENGTH]; /* RSC record */ |
80 | char exd[HIL_PACKET_MAX_LENGTH]; /* EXD record */ |
81 | char rnm[HIL_PACKET_MAX_LENGTH + 1]; /* RNM record + NULL term. */ |
82 | |
83 | struct completion cmd_done; |
84 | |
85 | bool is_pointer; |
86 | /* Extra device details needed for pointing devices. */ |
87 | unsigned int nbtn, naxes; |
88 | unsigned int btnmap[7]; |
89 | }; |
90 | |
91 | static bool hil_dev_is_command_response(hil_packet p) |
92 | { |
93 | if ((p & ~HIL_CMDCT_POL) == (HIL_ERR_INT | HIL_PKT_CMD | HIL_CMD_POL)) |
94 | return false; |
95 | |
96 | if ((p & ~HIL_CMDCT_RPL) == (HIL_ERR_INT | HIL_PKT_CMD | HIL_CMD_RPL)) |
97 | return false; |
98 | |
99 | return true; |
100 | } |
101 | |
102 | static void hil_dev_handle_command_response(struct hil_dev *dev) |
103 | { |
104 | hil_packet p; |
105 | char *buf; |
106 | int i, idx; |
107 | |
108 | idx = dev->idx4 / 4; |
109 | p = dev->data[idx - 1]; |
110 | |
111 | switch (p & HIL_PKT_DATA_MASK) { |
112 | case HIL_CMD_IDD: |
113 | buf = dev->idd; |
114 | break; |
115 | |
116 | case HIL_CMD_RSC: |
117 | buf = dev->rsc; |
118 | break; |
119 | |
120 | case HIL_CMD_EXD: |
121 | buf = dev->exd; |
122 | break; |
123 | |
124 | case HIL_CMD_RNM: |
125 | dev->rnm[HIL_PACKET_MAX_LENGTH] = 0; |
126 | buf = dev->rnm; |
127 | break; |
128 | |
129 | default: |
130 | /* These occur when device isn't present */ |
131 | if (p != (HIL_ERR_INT | HIL_PKT_CMD)) { |
132 | /* Anything else we'd like to know about. */ |
133 | printk(KERN_WARNING PREFIX "Device sent unknown record %x\n" , p); |
134 | } |
135 | goto out; |
136 | } |
137 | |
138 | for (i = 0; i < idx; i++) |
139 | buf[i] = dev->data[i] & HIL_PKT_DATA_MASK; |
140 | for (; i < HIL_PACKET_MAX_LENGTH; i++) |
141 | buf[i] = 0; |
142 | out: |
143 | complete(&dev->cmd_done); |
144 | } |
145 | |
146 | static void hil_dev_handle_kbd_events(struct hil_dev *kbd) |
147 | { |
148 | struct input_dev *dev = kbd->dev; |
149 | int idx = kbd->idx4 / 4; |
150 | int i; |
151 | |
152 | switch (kbd->data[0] & HIL_POL_CHARTYPE_MASK) { |
153 | case HIL_POL_CHARTYPE_NONE: |
154 | return; |
155 | |
156 | case HIL_POL_CHARTYPE_ASCII: |
157 | for (i = 1; i < idx - 1; i++) |
158 | input_report_key(dev, code: kbd->data[i] & 0x7f, value: 1); |
159 | break; |
160 | |
161 | case HIL_POL_CHARTYPE_RSVD1: |
162 | case HIL_POL_CHARTYPE_RSVD2: |
163 | case HIL_POL_CHARTYPE_BINARY: |
164 | for (i = 1; i < idx - 1; i++) |
165 | input_report_key(dev, code: kbd->data[i], value: 1); |
166 | break; |
167 | |
168 | case HIL_POL_CHARTYPE_SET1: |
169 | for (i = 1; i < idx - 1; i++) { |
170 | unsigned int key = kbd->data[i]; |
171 | int up = key & HIL_KBD_SET1_UPBIT; |
172 | |
173 | key &= (~HIL_KBD_SET1_UPBIT & 0xff); |
174 | key = hil_kbd_set1[key >> HIL_KBD_SET1_SHIFT]; |
175 | input_report_key(dev, code: key, value: !up); |
176 | } |
177 | break; |
178 | |
179 | case HIL_POL_CHARTYPE_SET2: |
180 | for (i = 1; i < idx - 1; i++) { |
181 | unsigned int key = kbd->data[i]; |
182 | int up = key & HIL_KBD_SET2_UPBIT; |
183 | |
184 | key &= (~HIL_KBD_SET1_UPBIT & 0xff); |
185 | key = key >> HIL_KBD_SET2_SHIFT; |
186 | input_report_key(dev, code: key, value: !up); |
187 | } |
188 | break; |
189 | |
190 | case HIL_POL_CHARTYPE_SET3: |
191 | for (i = 1; i < idx - 1; i++) { |
192 | unsigned int key = kbd->data[i]; |
193 | int up = key & HIL_KBD_SET3_UPBIT; |
194 | |
195 | key &= (~HIL_KBD_SET1_UPBIT & 0xff); |
196 | key = hil_kbd_set3[key >> HIL_KBD_SET3_SHIFT]; |
197 | input_report_key(dev, code: key, value: !up); |
198 | } |
199 | break; |
200 | } |
201 | |
202 | input_sync(dev); |
203 | } |
204 | |
205 | static void hil_dev_handle_ptr_events(struct hil_dev *ptr) |
206 | { |
207 | struct input_dev *dev = ptr->dev; |
208 | int idx = ptr->idx4 / 4; |
209 | hil_packet p = ptr->data[idx - 1]; |
210 | int i, cnt, laxis; |
211 | bool absdev, ax16; |
212 | |
213 | if ((p & HIL_CMDCT_POL) != idx - 1) { |
214 | printk(KERN_WARNING PREFIX |
215 | "Malformed poll packet %x (idx = %i)\n" , p, idx); |
216 | return; |
217 | } |
218 | |
219 | i = (p & HIL_POL_AXIS_ALT) ? 3 : 0; |
220 | laxis = (p & HIL_POL_NUM_AXES_MASK) + i; |
221 | |
222 | ax16 = ptr->idd[1] & HIL_IDD_HEADER_16BIT; /* 8 or 16bit resolution */ |
223 | absdev = ptr->idd[1] & HIL_IDD_HEADER_ABS; |
224 | |
225 | for (cnt = 1; i < laxis; i++) { |
226 | unsigned int lo, hi, val; |
227 | |
228 | lo = ptr->data[cnt++] & HIL_PKT_DATA_MASK; |
229 | hi = ax16 ? (ptr->data[cnt++] & HIL_PKT_DATA_MASK) : 0; |
230 | |
231 | if (absdev) { |
232 | val = lo + (hi << 8); |
233 | #ifdef TABLET_AUTOADJUST |
234 | if (val < input_abs_get_min(dev, ABS_X + i)) |
235 | input_abs_set_min(dev, ABS_X + i, val); |
236 | if (val > input_abs_get_max(dev, ABS_X + i)) |
237 | input_abs_set_max(dev, ABS_X + i, val); |
238 | #endif |
239 | if (i % 3) |
240 | val = input_abs_get_max(dev, ABS_X + i) - val; |
241 | input_report_abs(dev, ABS_X + i, value: val); |
242 | } else { |
243 | val = (int) (((int8_t) lo) | ((int8_t) hi << 8)); |
244 | if (i % 3) |
245 | val *= -1; |
246 | input_report_rel(dev, REL_X + i, value: val); |
247 | } |
248 | } |
249 | |
250 | while (cnt < idx - 1) { |
251 | unsigned int btn = ptr->data[cnt++]; |
252 | int up = btn & 1; |
253 | |
254 | btn &= 0xfe; |
255 | if (btn == 0x8e) |
256 | continue; /* TODO: proximity == touch? */ |
257 | if (btn > 0x8c || btn < 0x80) |
258 | continue; |
259 | btn = (btn - 0x80) >> 1; |
260 | btn = ptr->btnmap[btn]; |
261 | input_report_key(dev, code: btn, value: !up); |
262 | } |
263 | |
264 | input_sync(dev); |
265 | } |
266 | |
267 | static void hil_dev_process_err(struct hil_dev *dev) |
268 | { |
269 | printk(KERN_WARNING PREFIX "errored HIL packet\n" ); |
270 | dev->idx4 = 0; |
271 | complete(&dev->cmd_done); /* just in case somebody is waiting */ |
272 | } |
273 | |
274 | static irqreturn_t hil_dev_interrupt(struct serio *serio, |
275 | unsigned char data, unsigned int flags) |
276 | { |
277 | struct hil_dev *dev; |
278 | hil_packet packet; |
279 | int idx; |
280 | |
281 | dev = serio_get_drvdata(serio); |
282 | BUG_ON(dev == NULL); |
283 | |
284 | if (dev->idx4 >= HIL_PACKET_MAX_LENGTH * sizeof(hil_packet)) { |
285 | hil_dev_process_err(dev); |
286 | goto out; |
287 | } |
288 | |
289 | idx = dev->idx4 / 4; |
290 | if (!(dev->idx4 % 4)) |
291 | dev->data[idx] = 0; |
292 | packet = dev->data[idx]; |
293 | packet |= ((hil_packet)data) << ((3 - (dev->idx4 % 4)) * 8); |
294 | dev->data[idx] = packet; |
295 | |
296 | /* Records of N 4-byte hil_packets must terminate with a command. */ |
297 | if ((++dev->idx4 % 4) == 0) { |
298 | if ((packet & 0xffff0000) != HIL_ERR_INT) { |
299 | hil_dev_process_err(dev); |
300 | } else if (packet & HIL_PKT_CMD) { |
301 | if (hil_dev_is_command_response(p: packet)) |
302 | hil_dev_handle_command_response(dev); |
303 | else if (dev->is_pointer) |
304 | hil_dev_handle_ptr_events(ptr: dev); |
305 | else |
306 | hil_dev_handle_kbd_events(kbd: dev); |
307 | dev->idx4 = 0; |
308 | } |
309 | } |
310 | out: |
311 | return IRQ_HANDLED; |
312 | } |
313 | |
314 | static void hil_dev_disconnect(struct serio *serio) |
315 | { |
316 | struct hil_dev *dev = serio_get_drvdata(serio); |
317 | |
318 | BUG_ON(dev == NULL); |
319 | |
320 | serio_close(serio); |
321 | input_unregister_device(dev->dev); |
322 | serio_set_drvdata(serio, NULL); |
323 | kfree(objp: dev); |
324 | } |
325 | |
326 | static void hil_dev_keyboard_setup(struct hil_dev *kbd) |
327 | { |
328 | struct input_dev *input_dev = kbd->dev; |
329 | uint8_t did = kbd->idd[0]; |
330 | int i; |
331 | |
332 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP); |
333 | input_dev->ledbit[0] = BIT_MASK(LED_NUML) | BIT_MASK(LED_CAPSL) | |
334 | BIT_MASK(LED_SCROLLL); |
335 | |
336 | for (i = 0; i < 128; i++) { |
337 | __set_bit(hil_kbd_set1[i], input_dev->keybit); |
338 | __set_bit(hil_kbd_set3[i], input_dev->keybit); |
339 | } |
340 | __clear_bit(KEY_RESERVED, input_dev->keybit); |
341 | |
342 | input_dev->keycodemax = HIL_KEYCODES_SET1_TBLSIZE; |
343 | input_dev->keycodesize = sizeof(hil_kbd_set1[0]); |
344 | input_dev->keycode = hil_kbd_set1; |
345 | |
346 | input_dev->name = strlen(kbd->rnm) ? kbd->rnm : "HIL keyboard" ; |
347 | input_dev->phys = "hpkbd/input0" ; |
348 | |
349 | printk(KERN_INFO PREFIX "HIL keyboard found (did = 0x%02x, lang = %s)\n" , |
350 | did, hil_language[did & HIL_IDD_DID_TYPE_KB_LANG_MASK]); |
351 | } |
352 | |
353 | static void hil_dev_pointer_setup(struct hil_dev *ptr) |
354 | { |
355 | struct input_dev *input_dev = ptr->dev; |
356 | uint8_t did = ptr->idd[0]; |
357 | uint8_t *idd = ptr->idd + 1; |
358 | unsigned int naxsets = HIL_IDD_NUM_AXSETS(*idd); |
359 | unsigned int i, btntype; |
360 | const char *txt; |
361 | |
362 | ptr->naxes = HIL_IDD_NUM_AXES_PER_SET(*idd); |
363 | |
364 | switch (did & HIL_IDD_DID_TYPE_MASK) { |
365 | case HIL_IDD_DID_TYPE_REL: |
366 | input_dev->evbit[0] = BIT_MASK(EV_REL); |
367 | |
368 | for (i = 0; i < ptr->naxes; i++) |
369 | __set_bit(REL_X + i, input_dev->relbit); |
370 | |
371 | for (i = 3; naxsets > 1 && i < ptr->naxes + 3; i++) |
372 | __set_bit(REL_X + i, input_dev->relbit); |
373 | |
374 | txt = "relative" ; |
375 | break; |
376 | |
377 | case HIL_IDD_DID_TYPE_ABS: |
378 | input_dev->evbit[0] = BIT_MASK(EV_ABS); |
379 | |
380 | for (i = 0; i < ptr->naxes; i++) |
381 | input_set_abs_params(dev: input_dev, ABS_X + i, |
382 | min: 0, HIL_IDD_AXIS_MAX(idd, i), fuzz: 0, flat: 0); |
383 | |
384 | for (i = 3; naxsets > 1 && i < ptr->naxes + 3; i++) |
385 | input_set_abs_params(dev: input_dev, ABS_X + i, |
386 | min: 0, HIL_IDD_AXIS_MAX(idd, i - 3), fuzz: 0, flat: 0); |
387 | |
388 | #ifdef TABLET_AUTOADJUST |
389 | for (i = 0; i < ABS_MAX; i++) { |
390 | int diff = input_abs_get_max(input_dev, ABS_X + i) / 10; |
391 | input_abs_set_min(input_dev, ABS_X + i, |
392 | input_abs_get_min(input_dev, ABS_X + i) + diff); |
393 | input_abs_set_max(input_dev, ABS_X + i, |
394 | input_abs_get_max(input_dev, ABS_X + i) - diff); |
395 | } |
396 | #endif |
397 | |
398 | txt = "absolute" ; |
399 | break; |
400 | |
401 | default: |
402 | BUG(); |
403 | } |
404 | |
405 | ptr->nbtn = HIL_IDD_NUM_BUTTONS(idd); |
406 | if (ptr->nbtn) |
407 | input_dev->evbit[0] |= BIT_MASK(EV_KEY); |
408 | |
409 | btntype = BTN_MISC; |
410 | if ((did & HIL_IDD_DID_ABS_TABLET_MASK) == HIL_IDD_DID_ABS_TABLET) |
411 | #ifdef TABLET_SIMULATES_MOUSE |
412 | btntype = BTN_TOUCH; |
413 | #else |
414 | btntype = BTN_DIGI; |
415 | #endif |
416 | if ((did & HIL_IDD_DID_ABS_TSCREEN_MASK) == HIL_IDD_DID_ABS_TSCREEN) |
417 | btntype = BTN_TOUCH; |
418 | |
419 | if ((did & HIL_IDD_DID_REL_MOUSE_MASK) == HIL_IDD_DID_REL_MOUSE) |
420 | btntype = BTN_MOUSE; |
421 | |
422 | for (i = 0; i < ptr->nbtn; i++) { |
423 | __set_bit(btntype | i, input_dev->keybit); |
424 | ptr->btnmap[i] = btntype | i; |
425 | } |
426 | |
427 | if (btntype == BTN_MOUSE) { |
428 | /* Swap buttons 2 and 3 */ |
429 | ptr->btnmap[1] = BTN_MIDDLE; |
430 | ptr->btnmap[2] = BTN_RIGHT; |
431 | } |
432 | |
433 | input_dev->name = strlen(ptr->rnm) ? ptr->rnm : "HIL pointer device" ; |
434 | |
435 | printk(KERN_INFO PREFIX |
436 | "HIL pointer device found (did: 0x%02x, axis: %s)\n" , |
437 | did, txt); |
438 | printk(KERN_INFO PREFIX |
439 | "HIL pointer has %i buttons and %i sets of %i axes\n" , |
440 | ptr->nbtn, naxsets, ptr->naxes); |
441 | } |
442 | |
443 | static int hil_dev_connect(struct serio *serio, struct serio_driver *drv) |
444 | { |
445 | struct hil_dev *dev; |
446 | struct input_dev *input_dev; |
447 | uint8_t did, *idd; |
448 | int error; |
449 | |
450 | dev = kzalloc(size: sizeof(*dev), GFP_KERNEL); |
451 | input_dev = input_allocate_device(); |
452 | if (!dev || !input_dev) { |
453 | error = -ENOMEM; |
454 | goto bail0; |
455 | } |
456 | |
457 | dev->serio = serio; |
458 | dev->dev = input_dev; |
459 | |
460 | error = serio_open(serio, drv); |
461 | if (error) |
462 | goto bail0; |
463 | |
464 | serio_set_drvdata(serio, data: dev); |
465 | |
466 | /* Get device info. MLC driver supplies devid/status/etc. */ |
467 | init_completion(x: &dev->cmd_done); |
468 | serio_write(serio, data: 0); |
469 | serio_write(serio, data: 0); |
470 | serio_write(serio, data: HIL_PKT_CMD >> 8); |
471 | serio_write(serio, data: HIL_CMD_IDD); |
472 | error = wait_for_completion_killable(x: &dev->cmd_done); |
473 | if (error) |
474 | goto bail1; |
475 | |
476 | reinit_completion(x: &dev->cmd_done); |
477 | serio_write(serio, data: 0); |
478 | serio_write(serio, data: 0); |
479 | serio_write(serio, data: HIL_PKT_CMD >> 8); |
480 | serio_write(serio, data: HIL_CMD_RSC); |
481 | error = wait_for_completion_killable(x: &dev->cmd_done); |
482 | if (error) |
483 | goto bail1; |
484 | |
485 | reinit_completion(x: &dev->cmd_done); |
486 | serio_write(serio, data: 0); |
487 | serio_write(serio, data: 0); |
488 | serio_write(serio, data: HIL_PKT_CMD >> 8); |
489 | serio_write(serio, data: HIL_CMD_RNM); |
490 | error = wait_for_completion_killable(x: &dev->cmd_done); |
491 | if (error) |
492 | goto bail1; |
493 | |
494 | reinit_completion(x: &dev->cmd_done); |
495 | serio_write(serio, data: 0); |
496 | serio_write(serio, data: 0); |
497 | serio_write(serio, data: HIL_PKT_CMD >> 8); |
498 | serio_write(serio, data: HIL_CMD_EXD); |
499 | error = wait_for_completion_killable(x: &dev->cmd_done); |
500 | if (error) |
501 | goto bail1; |
502 | |
503 | did = dev->idd[0]; |
504 | idd = dev->idd + 1; |
505 | |
506 | switch (did & HIL_IDD_DID_TYPE_MASK) { |
507 | case HIL_IDD_DID_TYPE_KB_INTEGRAL: |
508 | case HIL_IDD_DID_TYPE_KB_ITF: |
509 | case HIL_IDD_DID_TYPE_KB_RSVD: |
510 | case HIL_IDD_DID_TYPE_CHAR: |
511 | if (HIL_IDD_NUM_BUTTONS(idd) || |
512 | HIL_IDD_NUM_AXES_PER_SET(*idd)) { |
513 | printk(KERN_INFO PREFIX |
514 | "combo devices are not supported.\n" ); |
515 | error = -EINVAL; |
516 | goto bail1; |
517 | } |
518 | |
519 | dev->is_pointer = false; |
520 | hil_dev_keyboard_setup(kbd: dev); |
521 | break; |
522 | |
523 | case HIL_IDD_DID_TYPE_REL: |
524 | case HIL_IDD_DID_TYPE_ABS: |
525 | dev->is_pointer = true; |
526 | hil_dev_pointer_setup(ptr: dev); |
527 | break; |
528 | |
529 | default: |
530 | goto bail1; |
531 | } |
532 | |
533 | input_dev->id.bustype = BUS_HIL; |
534 | input_dev->id.vendor = PCI_VENDOR_ID_HP; |
535 | input_dev->id.product = 0x0001; /* TODO: get from kbd->rsc */ |
536 | input_dev->id.version = 0x0100; /* TODO: get from kbd->rsc */ |
537 | input_dev->dev.parent = &serio->dev; |
538 | |
539 | if (!dev->is_pointer) { |
540 | serio_write(serio, data: 0); |
541 | serio_write(serio, data: 0); |
542 | serio_write(serio, data: HIL_PKT_CMD >> 8); |
543 | /* Enable Keyswitch Autorepeat 1 */ |
544 | serio_write(serio, data: HIL_CMD_EK1); |
545 | /* No need to wait for completion */ |
546 | } |
547 | |
548 | error = input_register_device(input_dev); |
549 | if (error) |
550 | goto bail1; |
551 | |
552 | return 0; |
553 | |
554 | bail1: |
555 | serio_close(serio); |
556 | serio_set_drvdata(serio, NULL); |
557 | bail0: |
558 | input_free_device(dev: input_dev); |
559 | kfree(objp: dev); |
560 | return error; |
561 | } |
562 | |
563 | static const struct serio_device_id hil_dev_ids[] = { |
564 | { |
565 | .type = SERIO_HIL_MLC, |
566 | .proto = SERIO_HIL, |
567 | .id = SERIO_ANY, |
568 | .extra = SERIO_ANY, |
569 | }, |
570 | { 0 } |
571 | }; |
572 | |
573 | MODULE_DEVICE_TABLE(serio, hil_dev_ids); |
574 | |
575 | static struct serio_driver hil_serio_drv = { |
576 | .driver = { |
577 | .name = "hil_dev" , |
578 | }, |
579 | .description = "HP HIL keyboard/mouse/tablet driver" , |
580 | .id_table = hil_dev_ids, |
581 | .connect = hil_dev_connect, |
582 | .disconnect = hil_dev_disconnect, |
583 | .interrupt = hil_dev_interrupt |
584 | }; |
585 | |
586 | module_serio_driver(hil_serio_drv); |
587 | |