This source file includes following definitions.
- hgpk_mode_from_name
- approx_half
- hgpk_discard_decay_hack
- hgpk_reset_spew_detection
- hgpk_reset_hack_state
- hgpk_spewing_hack
- hgpk_is_byte_valid
- hgpk_process_advanced_packet
- hgpk_process_simple_packet
- hgpk_process_byte
- hgpk_select_mode
- hgpk_setup_input_device
- hgpk_reset_device
- hgpk_force_recalibrate
- hgpk_toggle_powersave
- hgpk_poll
- hgpk_reconnect
- hgpk_show_powered
- hgpk_set_powered
- attr_show_mode
- attr_set_mode
- hgpk_trigger_recal_show
- hgpk_trigger_recal
- hgpk_disconnect
- hgpk_recalib_work
- hgpk_register
- hgpk_init
- hgpk_get_model
- hgpk_detect
- hgpk_module_init
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29 #define DEBUG
30 #include <linux/slab.h>
31 #include <linux/input.h>
32 #include <linux/module.h>
33 #include <linux/serio.h>
34 #include <linux/libps2.h>
35 #include <linux/delay.h>
36 #include <asm/olpc.h>
37
38 #include "psmouse.h"
39 #include "hgpk.h"
40
41 #define ILLEGAL_XY 999999
42
43 static bool tpdebug;
44 module_param(tpdebug, bool, 0644);
45 MODULE_PARM_DESC(tpdebug, "enable debugging, dumping packets to KERN_DEBUG.");
46
47 static int recalib_delta = 100;
48 module_param(recalib_delta, int, 0644);
49 MODULE_PARM_DESC(recalib_delta,
50 "packets containing a delta this large will be discarded, and a "
51 "recalibration may be scheduled.");
52
53 static int jumpy_delay = 20;
54 module_param(jumpy_delay, int, 0644);
55 MODULE_PARM_DESC(jumpy_delay,
56 "delay (ms) before recal after jumpiness detected");
57
58 static int spew_delay = 1;
59 module_param(spew_delay, int, 0644);
60 MODULE_PARM_DESC(spew_delay,
61 "delay (ms) before recal after packet spew detected");
62
63 static int recal_guard_time;
64 module_param(recal_guard_time, int, 0644);
65 MODULE_PARM_DESC(recal_guard_time,
66 "interval (ms) during which recal will be restarted if packet received");
67
68 static int post_interrupt_delay = 40;
69 module_param(post_interrupt_delay, int, 0644);
70 MODULE_PARM_DESC(post_interrupt_delay,
71 "delay (ms) before recal after recal interrupt detected");
72
73 static bool autorecal = true;
74 module_param(autorecal, bool, 0644);
75 MODULE_PARM_DESC(autorecal, "enable recalibration in the driver");
76
77 static char hgpk_mode_name[16];
78 module_param_string(hgpk_mode, hgpk_mode_name, sizeof(hgpk_mode_name), 0644);
79 MODULE_PARM_DESC(hgpk_mode,
80 "default hgpk mode: mouse, glidesensor or pentablet");
81
82 static int hgpk_default_mode = HGPK_MODE_MOUSE;
83
84 static const char * const hgpk_mode_names[] = {
85 [HGPK_MODE_MOUSE] = "Mouse",
86 [HGPK_MODE_GLIDESENSOR] = "GlideSensor",
87 [HGPK_MODE_PENTABLET] = "PenTablet",
88 };
89
90 static int hgpk_mode_from_name(const char *buf, int len)
91 {
92 int i;
93
94 for (i = 0; i < ARRAY_SIZE(hgpk_mode_names); i++) {
95 const char *name = hgpk_mode_names[i];
96 if (strlen(name) == len && !strncasecmp(name, buf, len))
97 return i;
98 }
99
100 return HGPK_MODE_INVALID;
101 }
102
103
104
105
106 static int approx_half(int curr, int prev)
107 {
108 int belowhalf, abovehalf;
109
110 if (curr < 5 || prev < 5)
111 return 0;
112
113 belowhalf = (prev * 8) / 20;
114 abovehalf = (prev * 12) / 20;
115
116 return belowhalf < curr && curr <= abovehalf;
117 }
118
119
120
121
122
123
124 static int hgpk_discard_decay_hack(struct psmouse *psmouse, int x, int y)
125 {
126 struct hgpk_data *priv = psmouse->private;
127 int avx, avy;
128 bool do_recal = false;
129
130 avx = abs(x);
131 avy = abs(y);
132
133
134 if (avx > recalib_delta ||
135 (avx > recalib_delta / 2 && ((avx / 4) > priv->xlast))) {
136 psmouse_warn(psmouse, "detected %dpx jump in x\n", x);
137 priv->xbigj = avx;
138 } else if (approx_half(avx, priv->xbigj)) {
139 psmouse_warn(psmouse, "detected secondary %dpx jump in x\n", x);
140 priv->xbigj = avx;
141 priv->xsaw_secondary++;
142 } else {
143 if (priv->xbigj && priv->xsaw_secondary > 1)
144 do_recal = true;
145 priv->xbigj = 0;
146 priv->xsaw_secondary = 0;
147 }
148
149 if (avy > recalib_delta ||
150 (avy > recalib_delta / 2 && ((avy / 4) > priv->ylast))) {
151 psmouse_warn(psmouse, "detected %dpx jump in y\n", y);
152 priv->ybigj = avy;
153 } else if (approx_half(avy, priv->ybigj)) {
154 psmouse_warn(psmouse, "detected secondary %dpx jump in y\n", y);
155 priv->ybigj = avy;
156 priv->ysaw_secondary++;
157 } else {
158 if (priv->ybigj && priv->ysaw_secondary > 1)
159 do_recal = true;
160 priv->ybigj = 0;
161 priv->ysaw_secondary = 0;
162 }
163
164 priv->xlast = avx;
165 priv->ylast = avy;
166
167 if (do_recal && jumpy_delay) {
168 psmouse_warn(psmouse, "scheduling recalibration\n");
169 psmouse_queue_work(psmouse, &priv->recalib_wq,
170 msecs_to_jiffies(jumpy_delay));
171 }
172
173 return priv->xbigj || priv->ybigj;
174 }
175
176 static void hgpk_reset_spew_detection(struct hgpk_data *priv)
177 {
178 priv->spew_count = 0;
179 priv->dupe_count = 0;
180 priv->x_tally = 0;
181 priv->y_tally = 0;
182 priv->spew_flag = NO_SPEW;
183 }
184
185 static void hgpk_reset_hack_state(struct psmouse *psmouse)
186 {
187 struct hgpk_data *priv = psmouse->private;
188
189 priv->abs_x = priv->abs_y = -1;
190 priv->xlast = priv->ylast = ILLEGAL_XY;
191 priv->xbigj = priv->ybigj = 0;
192 priv->xsaw_secondary = priv->ysaw_secondary = 0;
193 hgpk_reset_spew_detection(priv);
194 }
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211 static void hgpk_spewing_hack(struct psmouse *psmouse,
212 int l, int r, int x, int y)
213 {
214 struct hgpk_data *priv = psmouse->private;
215
216
217
218 if (l || r)
219 return;
220
221
222 if (!spew_delay)
223 return;
224
225 if (abs(x) > 3 || abs(y) > 3) {
226
227 hgpk_reset_spew_detection(priv);
228 return;
229 }
230
231
232
233 priv->x_tally += x;
234 priv->y_tally += y;
235
236 switch (priv->spew_flag) {
237 case NO_SPEW:
238
239 priv->spew_flag = MAYBE_SPEWING;
240
241
242
243 case MAYBE_SPEWING:
244 priv->spew_count++;
245
246 if (priv->spew_count < SPEW_WATCH_COUNT)
247 break;
248
249
250 priv->spew_flag = SPEW_DETECTED;
251
252
253
254 case SPEW_DETECTED:
255
256
257
258
259 if (abs(priv->x_tally) < 3 && abs(priv->y_tally) < 3) {
260 psmouse_warn(psmouse, "packet spew detected (%d,%d)\n",
261 priv->x_tally, priv->y_tally);
262 priv->spew_flag = RECALIBRATING;
263 psmouse_queue_work(psmouse, &priv->recalib_wq,
264 msecs_to_jiffies(spew_delay));
265 }
266
267 break;
268 case RECALIBRATING:
269
270
271 break;
272 }
273 }
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306 static bool hgpk_is_byte_valid(struct psmouse *psmouse, unsigned char *packet)
307 {
308 struct hgpk_data *priv = psmouse->private;
309 int pktcnt = psmouse->pktcnt;
310 bool valid;
311
312 switch (priv->mode) {
313 case HGPK_MODE_MOUSE:
314 valid = (packet[0] & 0x0C) == 0x08;
315 break;
316
317 case HGPK_MODE_GLIDESENSOR:
318 valid = pktcnt == 1 ?
319 packet[0] == HGPK_GS : !(packet[pktcnt - 1] & 0x80);
320 break;
321
322 case HGPK_MODE_PENTABLET:
323 valid = pktcnt == 1 ?
324 packet[0] == HGPK_PT : !(packet[pktcnt - 1] & 0x80);
325 break;
326
327 default:
328 valid = false;
329 break;
330 }
331
332 if (!valid)
333 psmouse_dbg(psmouse,
334 "bad data, mode %d (%d) %*ph\n",
335 priv->mode, pktcnt, 6, psmouse->packet);
336
337 return valid;
338 }
339
340 static void hgpk_process_advanced_packet(struct psmouse *psmouse)
341 {
342 struct hgpk_data *priv = psmouse->private;
343 struct input_dev *idev = psmouse->dev;
344 unsigned char *packet = psmouse->packet;
345 int down = !!(packet[2] & 2);
346 int left = !!(packet[3] & 1);
347 int right = !!(packet[3] & 2);
348 int x = packet[1] | ((packet[2] & 0x78) << 4);
349 int y = packet[4] | ((packet[3] & 0x70) << 3);
350
351 if (priv->mode == HGPK_MODE_GLIDESENSOR) {
352 int pt_down = !!(packet[2] & 1);
353 int finger_down = !!(packet[2] & 2);
354 int z = packet[5];
355
356 input_report_abs(idev, ABS_PRESSURE, z);
357 if (tpdebug)
358 psmouse_dbg(psmouse, "pd=%d fd=%d z=%d",
359 pt_down, finger_down, z);
360 } else {
361
362
363
364
365 if (tpdebug)
366 psmouse_dbg(psmouse, "pd=%d ", down);
367 }
368
369 if (tpdebug)
370 psmouse_dbg(psmouse, "l=%d r=%d x=%d y=%d\n",
371 left, right, x, y);
372
373 input_report_key(idev, BTN_TOUCH, down);
374 input_report_key(idev, BTN_LEFT, left);
375 input_report_key(idev, BTN_RIGHT, right);
376
377
378
379
380
381 if (!down) {
382 hgpk_reset_hack_state(psmouse);
383 goto done;
384 }
385
386
387
388
389
390 if (x == priv->abs_x && y == priv->abs_y) {
391 if (++priv->dupe_count > SPEW_WATCH_COUNT) {
392 if (tpdebug)
393 psmouse_dbg(psmouse, "hard spew detected\n");
394 priv->spew_flag = RECALIBRATING;
395 psmouse_queue_work(psmouse, &priv->recalib_wq,
396 msecs_to_jiffies(spew_delay));
397 }
398 goto done;
399 }
400
401
402 priv->dupe_count = 0;
403
404
405 if (priv->mode != HGPK_MODE_PENTABLET && priv->abs_x != -1) {
406 int x_diff = priv->abs_x - x;
407 int y_diff = priv->abs_y - y;
408 if (hgpk_discard_decay_hack(psmouse, x_diff, y_diff)) {
409 if (tpdebug)
410 psmouse_dbg(psmouse, "discarding\n");
411 goto done;
412 }
413 hgpk_spewing_hack(psmouse, left, right, x_diff, y_diff);
414 }
415
416 input_report_abs(idev, ABS_X, x);
417 input_report_abs(idev, ABS_Y, y);
418 priv->abs_x = x;
419 priv->abs_y = y;
420
421 done:
422 input_sync(idev);
423 }
424
425 static void hgpk_process_simple_packet(struct psmouse *psmouse)
426 {
427 struct input_dev *dev = psmouse->dev;
428 unsigned char *packet = psmouse->packet;
429 int left = packet[0] & 1;
430 int right = (packet[0] >> 1) & 1;
431 int x = packet[1] - ((packet[0] << 4) & 0x100);
432 int y = ((packet[0] << 3) & 0x100) - packet[2];
433
434 if (packet[0] & 0xc0)
435 psmouse_dbg(psmouse,
436 "overflow -- 0x%02x 0x%02x 0x%02x\n",
437 packet[0], packet[1], packet[2]);
438
439 if (hgpk_discard_decay_hack(psmouse, x, y)) {
440 if (tpdebug)
441 psmouse_dbg(psmouse, "discarding\n");
442 return;
443 }
444
445 hgpk_spewing_hack(psmouse, left, right, x, y);
446
447 if (tpdebug)
448 psmouse_dbg(psmouse, "l=%d r=%d x=%d y=%d\n",
449 left, right, x, y);
450
451 input_report_key(dev, BTN_LEFT, left);
452 input_report_key(dev, BTN_RIGHT, right);
453
454 input_report_rel(dev, REL_X, x);
455 input_report_rel(dev, REL_Y, y);
456
457 input_sync(dev);
458 }
459
460 static psmouse_ret_t hgpk_process_byte(struct psmouse *psmouse)
461 {
462 struct hgpk_data *priv = psmouse->private;
463
464 if (!hgpk_is_byte_valid(psmouse, psmouse->packet))
465 return PSMOUSE_BAD_DATA;
466
467 if (psmouse->pktcnt >= psmouse->pktsize) {
468 if (priv->mode == HGPK_MODE_MOUSE)
469 hgpk_process_simple_packet(psmouse);
470 else
471 hgpk_process_advanced_packet(psmouse);
472 return PSMOUSE_FULL_PACKET;
473 }
474
475 if (priv->recalib_window) {
476 if (time_before(jiffies, priv->recalib_window)) {
477
478
479
480
481 psmouse_dbg(psmouse,
482 "packet inside calibration window, queueing another recalibration\n");
483 psmouse_queue_work(psmouse, &priv->recalib_wq,
484 msecs_to_jiffies(post_interrupt_delay));
485 }
486 priv->recalib_window = 0;
487 }
488
489 return PSMOUSE_GOOD_DATA;
490 }
491
492 static int hgpk_select_mode(struct psmouse *psmouse)
493 {
494 struct ps2dev *ps2dev = &psmouse->ps2dev;
495 struct hgpk_data *priv = psmouse->private;
496 int i;
497 int cmd;
498
499
500
501
502
503 const int advanced_init[] = {
504 PSMOUSE_CMD_DISABLE, PSMOUSE_CMD_DISABLE,
505 PSMOUSE_CMD_DISABLE, PSMOUSE_CMD_DISABLE,
506 0xf2, 0xf2, 0xf2,
507 };
508
509 switch (priv->mode) {
510 case HGPK_MODE_MOUSE:
511 psmouse->pktsize = 3;
512 break;
513
514 case HGPK_MODE_GLIDESENSOR:
515 case HGPK_MODE_PENTABLET:
516 psmouse->pktsize = 6;
517
518
519 for (i = 0; i < ARRAY_SIZE(advanced_init); i++)
520 if (ps2_command(ps2dev, NULL, advanced_init[i]))
521 return -EIO;
522
523
524 cmd = priv->mode == HGPK_MODE_GLIDESENSOR ?
525 PSMOUSE_CMD_SETSCALE11 : PSMOUSE_CMD_SETSCALE21;
526
527 if (ps2_command(ps2dev, NULL, cmd))
528 return -EIO;
529 break;
530
531 default:
532 return -EINVAL;
533 }
534
535 return 0;
536 }
537
538 static void hgpk_setup_input_device(struct input_dev *input,
539 struct input_dev *old_input,
540 enum hgpk_mode mode)
541 {
542 if (old_input) {
543 input->name = old_input->name;
544 input->phys = old_input->phys;
545 input->id = old_input->id;
546 input->dev.parent = old_input->dev.parent;
547 }
548
549 memset(input->evbit, 0, sizeof(input->evbit));
550 memset(input->relbit, 0, sizeof(input->relbit));
551 memset(input->keybit, 0, sizeof(input->keybit));
552
553
554 __set_bit(EV_KEY, input->evbit);
555 __set_bit(BTN_LEFT, input->keybit);
556 __set_bit(BTN_RIGHT, input->keybit);
557
558 switch (mode) {
559 case HGPK_MODE_MOUSE:
560 __set_bit(EV_REL, input->evbit);
561 __set_bit(REL_X, input->relbit);
562 __set_bit(REL_Y, input->relbit);
563 break;
564
565 case HGPK_MODE_GLIDESENSOR:
566 __set_bit(BTN_TOUCH, input->keybit);
567 __set_bit(BTN_TOOL_FINGER, input->keybit);
568
569 __set_bit(EV_ABS, input->evbit);
570
571
572 input_set_abs_params(input, ABS_PRESSURE, 0, 15, 0, 0);
573
574
575 input_set_abs_params(input, ABS_X, 0, 399, 0, 0);
576 input_set_abs_params(input, ABS_Y, 0, 290, 0, 0);
577
578
579 input_abs_set_res(input, ABS_X, 8);
580 input_abs_set_res(input, ABS_Y, 8);
581 break;
582
583 case HGPK_MODE_PENTABLET:
584 __set_bit(BTN_TOUCH, input->keybit);
585 __set_bit(BTN_TOOL_FINGER, input->keybit);
586
587 __set_bit(EV_ABS, input->evbit);
588
589
590 input_set_abs_params(input, ABS_X, 0, 999, 0, 0);
591 input_set_abs_params(input, ABS_Y, 5, 239, 0, 0);
592
593
594 input_abs_set_res(input, ABS_X, 6);
595 input_abs_set_res(input, ABS_Y, 8);
596 break;
597
598 default:
599 BUG();
600 }
601 }
602
603 static int hgpk_reset_device(struct psmouse *psmouse, bool recalibrate)
604 {
605 int err;
606
607 psmouse_reset(psmouse);
608
609 if (recalibrate) {
610 struct ps2dev *ps2dev = &psmouse->ps2dev;
611
612
613 if (ps2_command(ps2dev, NULL, 0xf5) ||
614 ps2_command(ps2dev, NULL, 0xf5) ||
615 ps2_command(ps2dev, NULL, 0xe6) ||
616 ps2_command(ps2dev, NULL, 0xf5)) {
617 return -1;
618 }
619
620
621 msleep(150);
622 }
623
624 err = hgpk_select_mode(psmouse);
625 if (err) {
626 psmouse_err(psmouse, "failed to select mode\n");
627 return err;
628 }
629
630 hgpk_reset_hack_state(psmouse);
631
632 return 0;
633 }
634
635 static int hgpk_force_recalibrate(struct psmouse *psmouse)
636 {
637 struct hgpk_data *priv = psmouse->private;
638 int err;
639
640
641 if (psmouse->model < HGPK_MODEL_C)
642 return 0;
643
644 if (!autorecal) {
645 psmouse_dbg(psmouse, "recalibration disabled, ignoring\n");
646 return 0;
647 }
648
649 psmouse_dbg(psmouse, "recalibrating touchpad..\n");
650
651
652 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
653
654
655 err = hgpk_reset_device(psmouse, true);
656 if (err)
657 return err;
658
659
660
661
662
663
664
665 if (psmouse_activate(psmouse))
666 return -1;
667
668 if (tpdebug)
669 psmouse_dbg(psmouse, "touchpad reactivated\n");
670
671
672
673
674
675
676 if (recal_guard_time)
677 priv->recalib_window = jiffies +
678 msecs_to_jiffies(recal_guard_time);
679
680 return 0;
681 }
682
683
684
685
686
687
688
689
690
691
692 static int hgpk_toggle_powersave(struct psmouse *psmouse, int enable)
693 {
694 struct ps2dev *ps2dev = &psmouse->ps2dev;
695 int timeo;
696 int err;
697
698
699 if (psmouse->model < HGPK_MODEL_D)
700 return 0;
701
702 if (enable) {
703 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
704
705
706
707
708
709
710
711
712 for (timeo = 20; timeo > 0; timeo--) {
713 if (!ps2_sendbyte(ps2dev, PSMOUSE_CMD_DISABLE, 20))
714 break;
715 msleep(25);
716 }
717
718 err = hgpk_reset_device(psmouse, false);
719 if (err) {
720 psmouse_err(psmouse, "Failed to reset device!\n");
721 return err;
722 }
723
724
725 psmouse_activate(psmouse);
726 psmouse_dbg(psmouse, "Touchpad powered up.\n");
727 } else {
728 psmouse_dbg(psmouse, "Powering off touchpad.\n");
729
730 if (ps2_command(ps2dev, NULL, 0xec) ||
731 ps2_command(ps2dev, NULL, 0xec) ||
732 ps2_command(ps2dev, NULL, 0xea)) {
733 return -1;
734 }
735
736 psmouse_set_state(psmouse, PSMOUSE_IGNORE);
737
738
739 ps2_sendbyte(ps2dev, 0xec, 20);
740 }
741
742 return 0;
743 }
744
745 static int hgpk_poll(struct psmouse *psmouse)
746 {
747
748 return -1;
749 }
750
751 static int hgpk_reconnect(struct psmouse *psmouse)
752 {
753 struct hgpk_data *priv = psmouse->private;
754
755
756
757
758
759
760 if (olpc_board_at_least(olpc_board(0xb2)))
761 if (psmouse->ps2dev.serio->dev.power.power_state.event !=
762 PM_EVENT_ON)
763 return 0;
764
765 priv->powered = 1;
766 return hgpk_reset_device(psmouse, false);
767 }
768
769 static ssize_t hgpk_show_powered(struct psmouse *psmouse, void *data, char *buf)
770 {
771 struct hgpk_data *priv = psmouse->private;
772
773 return sprintf(buf, "%d\n", priv->powered);
774 }
775
776 static ssize_t hgpk_set_powered(struct psmouse *psmouse, void *data,
777 const char *buf, size_t count)
778 {
779 struct hgpk_data *priv = psmouse->private;
780 unsigned int value;
781 int err;
782
783 err = kstrtouint(buf, 10, &value);
784 if (err)
785 return err;
786
787 if (value > 1)
788 return -EINVAL;
789
790 if (value != priv->powered) {
791
792
793
794
795 err = hgpk_toggle_powersave(psmouse, value);
796 if (!err)
797 priv->powered = value;
798 }
799
800 return err ? err : count;
801 }
802
803 __PSMOUSE_DEFINE_ATTR(powered, S_IWUSR | S_IRUGO, NULL,
804 hgpk_show_powered, hgpk_set_powered, false);
805
806 static ssize_t attr_show_mode(struct psmouse *psmouse, void *data, char *buf)
807 {
808 struct hgpk_data *priv = psmouse->private;
809
810 return sprintf(buf, "%s\n", hgpk_mode_names[priv->mode]);
811 }
812
813 static ssize_t attr_set_mode(struct psmouse *psmouse, void *data,
814 const char *buf, size_t len)
815 {
816 struct hgpk_data *priv = psmouse->private;
817 enum hgpk_mode old_mode = priv->mode;
818 enum hgpk_mode new_mode = hgpk_mode_from_name(buf, len);
819 struct input_dev *old_dev = psmouse->dev;
820 struct input_dev *new_dev;
821 int err;
822
823 if (new_mode == HGPK_MODE_INVALID)
824 return -EINVAL;
825
826 if (old_mode == new_mode)
827 return len;
828
829 new_dev = input_allocate_device();
830 if (!new_dev)
831 return -ENOMEM;
832
833 psmouse_set_state(psmouse, PSMOUSE_INITIALIZING);
834
835
836 priv->mode = new_mode;
837 err = hgpk_reset_device(psmouse, false);
838 if (err)
839 goto err_try_restore;
840
841 hgpk_setup_input_device(new_dev, old_dev, new_mode);
842
843 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
844
845 err = input_register_device(new_dev);
846 if (err)
847 goto err_try_restore;
848
849 psmouse->dev = new_dev;
850 input_unregister_device(old_dev);
851
852 return len;
853
854 err_try_restore:
855 input_free_device(new_dev);
856 priv->mode = old_mode;
857 hgpk_reset_device(psmouse, false);
858
859 return err;
860 }
861
862 PSMOUSE_DEFINE_ATTR(hgpk_mode, S_IWUSR | S_IRUGO, NULL,
863 attr_show_mode, attr_set_mode);
864
865 static ssize_t hgpk_trigger_recal_show(struct psmouse *psmouse,
866 void *data, char *buf)
867 {
868 return -EINVAL;
869 }
870
871 static ssize_t hgpk_trigger_recal(struct psmouse *psmouse, void *data,
872 const char *buf, size_t count)
873 {
874 struct hgpk_data *priv = psmouse->private;
875 unsigned int value;
876 int err;
877
878 err = kstrtouint(buf, 10, &value);
879 if (err)
880 return err;
881
882 if (value != 1)
883 return -EINVAL;
884
885
886
887
888
889
890 psmouse_queue_work(psmouse, &priv->recalib_wq, 0);
891 return count;
892 }
893
894 __PSMOUSE_DEFINE_ATTR(recalibrate, S_IWUSR | S_IRUGO, NULL,
895 hgpk_trigger_recal_show, hgpk_trigger_recal, false);
896
897 static void hgpk_disconnect(struct psmouse *psmouse)
898 {
899 struct hgpk_data *priv = psmouse->private;
900
901 device_remove_file(&psmouse->ps2dev.serio->dev,
902 &psmouse_attr_powered.dattr);
903 device_remove_file(&psmouse->ps2dev.serio->dev,
904 &psmouse_attr_hgpk_mode.dattr);
905
906 if (psmouse->model >= HGPK_MODEL_C)
907 device_remove_file(&psmouse->ps2dev.serio->dev,
908 &psmouse_attr_recalibrate.dattr);
909
910 psmouse_reset(psmouse);
911 kfree(priv);
912 }
913
914 static void hgpk_recalib_work(struct work_struct *work)
915 {
916 struct delayed_work *w = to_delayed_work(work);
917 struct hgpk_data *priv = container_of(w, struct hgpk_data, recalib_wq);
918 struct psmouse *psmouse = priv->psmouse;
919
920 if (hgpk_force_recalibrate(psmouse))
921 psmouse_err(psmouse, "recalibration failed!\n");
922 }
923
924 static int hgpk_register(struct psmouse *psmouse)
925 {
926 struct hgpk_data *priv = psmouse->private;
927 int err;
928
929
930 psmouse->protocol_handler = hgpk_process_byte;
931 psmouse->poll = hgpk_poll;
932 psmouse->disconnect = hgpk_disconnect;
933 psmouse->reconnect = hgpk_reconnect;
934
935
936 psmouse->resync_time = 0;
937
938 psmouse->resetafter = 1024;
939
940 hgpk_setup_input_device(psmouse->dev, NULL, priv->mode);
941
942 err = device_create_file(&psmouse->ps2dev.serio->dev,
943 &psmouse_attr_powered.dattr);
944 if (err) {
945 psmouse_err(psmouse, "Failed creating 'powered' sysfs node\n");
946 return err;
947 }
948
949 err = device_create_file(&psmouse->ps2dev.serio->dev,
950 &psmouse_attr_hgpk_mode.dattr);
951 if (err) {
952 psmouse_err(psmouse,
953 "Failed creating 'hgpk_mode' sysfs node\n");
954 goto err_remove_powered;
955 }
956
957
958 if (psmouse->model >= HGPK_MODEL_C) {
959 err = device_create_file(&psmouse->ps2dev.serio->dev,
960 &psmouse_attr_recalibrate.dattr);
961 if (err) {
962 psmouse_err(psmouse,
963 "Failed creating 'recalibrate' sysfs node\n");
964 goto err_remove_mode;
965 }
966 }
967
968 return 0;
969
970 err_remove_mode:
971 device_remove_file(&psmouse->ps2dev.serio->dev,
972 &psmouse_attr_hgpk_mode.dattr);
973 err_remove_powered:
974 device_remove_file(&psmouse->ps2dev.serio->dev,
975 &psmouse_attr_powered.dattr);
976 return err;
977 }
978
979 int hgpk_init(struct psmouse *psmouse)
980 {
981 struct hgpk_data *priv;
982 int err;
983
984 priv = kzalloc(sizeof(struct hgpk_data), GFP_KERNEL);
985 if (!priv) {
986 err = -ENOMEM;
987 goto alloc_fail;
988 }
989
990 psmouse->private = priv;
991
992 priv->psmouse = psmouse;
993 priv->powered = true;
994 priv->mode = hgpk_default_mode;
995 INIT_DELAYED_WORK(&priv->recalib_wq, hgpk_recalib_work);
996
997 err = hgpk_reset_device(psmouse, false);
998 if (err)
999 goto init_fail;
1000
1001 err = hgpk_register(psmouse);
1002 if (err)
1003 goto init_fail;
1004
1005 return 0;
1006
1007 init_fail:
1008 kfree(priv);
1009 alloc_fail:
1010 return err;
1011 }
1012
1013 static enum hgpk_model_t hgpk_get_model(struct psmouse *psmouse)
1014 {
1015 struct ps2dev *ps2dev = &psmouse->ps2dev;
1016 unsigned char param[3];
1017
1018
1019 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) ||
1020 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) ||
1021 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE21) ||
1022 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
1023 return -EIO;
1024 }
1025
1026 psmouse_dbg(psmouse, "ID: %*ph\n", 3, param);
1027
1028
1029 if (param[0] != 0x67 || param[1] != 0x00)
1030 return -ENODEV;
1031
1032 psmouse_info(psmouse, "OLPC touchpad revision 0x%x\n", param[2]);
1033
1034 return param[2];
1035 }
1036
1037 int hgpk_detect(struct psmouse *psmouse, bool set_properties)
1038 {
1039 int version;
1040
1041 version = hgpk_get_model(psmouse);
1042 if (version < 0)
1043 return version;
1044
1045 if (set_properties) {
1046 psmouse->vendor = "ALPS";
1047 psmouse->name = "HGPK";
1048 psmouse->model = version;
1049 }
1050
1051 return 0;
1052 }
1053
1054 void hgpk_module_init(void)
1055 {
1056 hgpk_default_mode = hgpk_mode_from_name(hgpk_mode_name,
1057 strlen(hgpk_mode_name));
1058 if (hgpk_default_mode == HGPK_MODE_INVALID) {
1059 hgpk_default_mode = HGPK_MODE_MOUSE;
1060 strlcpy(hgpk_mode_name, hgpk_mode_names[HGPK_MODE_MOUSE],
1061 sizeof(hgpk_mode_name));
1062 }
1063 }