779d0b9341c0d966fa52604931ef388e9450e038
[releases.git] / sentelic.c
1 /*-
2  * Finger Sensing Pad PS/2 mouse driver.
3  *
4  * Copyright (C) 2005-2007 Asia Vital Components Co., Ltd.
5  * Copyright (C) 2005-2012 Tai-hwa Liang, Sentelic Corporation.
6  *
7  *   This program is free software; you can redistribute it and/or
8  *   modify it under the terms of the GNU General Public License
9  *   as published by the Free Software Foundation; either version 2
10  *   of the License, or (at your option) any later version.
11  *
12  *   This program is distributed in the hope that it will be useful,
13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *   GNU General Public License for more details.
16  *
17  *   You should have received a copy of the GNU General Public License
18  *   along with this program; if not, write to the Free Software
19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21
22 #include <linux/module.h>
23 #include <linux/input.h>
24 #include <linux/input/mt.h>
25 #include <linux/ctype.h>
26 #include <linux/libps2.h>
27 #include <linux/serio.h>
28 #include <linux/jiffies.h>
29 #include <linux/slab.h>
30
31 #include "psmouse.h"
32 #include "sentelic.h"
33
34 /*
35  * Timeout for FSP PS/2 command only (in milliseconds).
36  */
37 #define FSP_CMD_TIMEOUT         200
38 #define FSP_CMD_TIMEOUT2        30
39
40 #define GET_ABS_X(packet)       ((packet[1] << 2) | ((packet[3] >> 2) & 0x03))
41 #define GET_ABS_Y(packet)       ((packet[2] << 2) | (packet[3] & 0x03))
42
43 /** Driver version. */
44 static const char fsp_drv_ver[] = "1.1.0-K";
45
46 /*
47  * Make sure that the value being sent to FSP will not conflict with
48  * possible sample rate values.
49  */
50 static unsigned char fsp_test_swap_cmd(unsigned char reg_val)
51 {
52         switch (reg_val) {
53         case 10: case 20: case 40: case 60: case 80: case 100: case 200:
54                 /*
55                  * The requested value being sent to FSP matched to possible
56                  * sample rates, swap the given value such that the hardware
57                  * wouldn't get confused.
58                  */
59                 return (reg_val >> 4) | (reg_val << 4);
60         default:
61                 return reg_val; /* swap isn't necessary */
62         }
63 }
64
65 /*
66  * Make sure that the value being sent to FSP will not conflict with certain
67  * commands.
68  */
69 static unsigned char fsp_test_invert_cmd(unsigned char reg_val)
70 {
71         switch (reg_val) {
72         case 0xe9: case 0xee: case 0xf2: case 0xff:
73                 /*
74                  * The requested value being sent to FSP matched to certain
75                  * commands, inverse the given value such that the hardware
76                  * wouldn't get confused.
77                  */
78                 return ~reg_val;
79         default:
80                 return reg_val; /* inversion isn't necessary */
81         }
82 }
83
84 static int fsp_reg_read(struct psmouse *psmouse, int reg_addr, int *reg_val)
85 {
86         struct ps2dev *ps2dev = &psmouse->ps2dev;
87         unsigned char param[3];
88         unsigned char addr;
89         int rc = -1;
90
91         /*
92          * We need to shut off the device and switch it into command
93          * mode so we don't confuse our protocol handler. We don't need
94          * to do that for writes because sysfs set helper does this for
95          * us.
96          */
97         psmouse_deactivate(psmouse);
98
99         ps2_begin_command(ps2dev);
100
101         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
102                 goto out;
103
104         /* should return 0xfe(request for resending) */
105         ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
106         /* should return 0xfc(failed) */
107         ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
108
109         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
110                 goto out;
111
112         if ((addr = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
113                 ps2_sendbyte(ps2dev, 0x68, FSP_CMD_TIMEOUT2);
114         } else if ((addr = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
115                 /* swapping is required */
116                 ps2_sendbyte(ps2dev, 0xcc, FSP_CMD_TIMEOUT2);
117                 /* expect 0xfe */
118         } else {
119                 /* swapping isn't necessary */
120                 ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
121                 /* expect 0xfe */
122         }
123         /* should return 0xfc(failed) */
124         ps2_sendbyte(ps2dev, addr, FSP_CMD_TIMEOUT);
125
126         if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO) < 0)
127                 goto out;
128
129         *reg_val = param[2];
130         rc = 0;
131
132  out:
133         ps2_end_command(ps2dev);
134         psmouse_activate(psmouse);
135         psmouse_dbg(psmouse,
136                     "READ REG: 0x%02x is 0x%02x (rc = %d)\n",
137                     reg_addr, *reg_val, rc);
138         return rc;
139 }
140
141 static int fsp_reg_write(struct psmouse *psmouse, int reg_addr, int reg_val)
142 {
143         struct ps2dev *ps2dev = &psmouse->ps2dev;
144         unsigned char v;
145         int rc = -1;
146
147         ps2_begin_command(ps2dev);
148
149         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
150                 goto out;
151
152         if ((v = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
153                 /* inversion is required */
154                 ps2_sendbyte(ps2dev, 0x74, FSP_CMD_TIMEOUT2);
155         } else {
156                 if ((v = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
157                         /* swapping is required */
158                         ps2_sendbyte(ps2dev, 0x77, FSP_CMD_TIMEOUT2);
159                 } else {
160                         /* swapping isn't necessary */
161                         ps2_sendbyte(ps2dev, 0x55, FSP_CMD_TIMEOUT2);
162                 }
163         }
164         /* write the register address in correct order */
165         ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
166
167         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
168                 goto out;
169
170         if ((v = fsp_test_invert_cmd(reg_val)) != reg_val) {
171                 /* inversion is required */
172                 ps2_sendbyte(ps2dev, 0x47, FSP_CMD_TIMEOUT2);
173         } else if ((v = fsp_test_swap_cmd(reg_val)) != reg_val) {
174                 /* swapping is required */
175                 ps2_sendbyte(ps2dev, 0x44, FSP_CMD_TIMEOUT2);
176         } else {
177                 /* swapping isn't necessary */
178                 ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
179         }
180
181         /* write the register value in correct order */
182         ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
183         rc = 0;
184
185  out:
186         ps2_end_command(ps2dev);
187         psmouse_dbg(psmouse,
188                     "WRITE REG: 0x%02x to 0x%02x (rc = %d)\n",
189                     reg_addr, reg_val, rc);
190         return rc;
191 }
192
193 /* Enable register clock gating for writing certain registers */
194 static int fsp_reg_write_enable(struct psmouse *psmouse, bool enable)
195 {
196         int v, nv;
197
198         if (fsp_reg_read(psmouse, FSP_REG_SYSCTL1, &v) == -1)
199                 return -1;
200
201         if (enable)
202                 nv = v | FSP_BIT_EN_REG_CLK;
203         else
204                 nv = v & ~FSP_BIT_EN_REG_CLK;
205
206         /* only write if necessary */
207         if (nv != v)
208                 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL1, nv) == -1)
209                         return -1;
210
211         return 0;
212 }
213
214 static int fsp_page_reg_read(struct psmouse *psmouse, int *reg_val)
215 {
216         struct ps2dev *ps2dev = &psmouse->ps2dev;
217         unsigned char param[3];
218         int rc = -1;
219
220         psmouse_deactivate(psmouse);
221
222         ps2_begin_command(ps2dev);
223
224         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
225                 goto out;
226
227         ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
228         ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
229
230         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
231                 goto out;
232
233         ps2_sendbyte(ps2dev, 0x83, FSP_CMD_TIMEOUT2);
234         ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
235
236         /* get the returned result */
237         if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
238                 goto out;
239
240         *reg_val = param[2];
241         rc = 0;
242
243  out:
244         ps2_end_command(ps2dev);
245         psmouse_activate(psmouse);
246         psmouse_dbg(psmouse,
247                     "READ PAGE REG: 0x%02x (rc = %d)\n",
248                     *reg_val, rc);
249         return rc;
250 }
251
252 static int fsp_page_reg_write(struct psmouse *psmouse, int reg_val)
253 {
254         struct ps2dev *ps2dev = &psmouse->ps2dev;
255         unsigned char v;
256         int rc = -1;
257
258         ps2_begin_command(ps2dev);
259
260         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
261                 goto out;
262
263         ps2_sendbyte(ps2dev, 0x38, FSP_CMD_TIMEOUT2);
264         ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
265
266         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
267                 goto out;
268
269         if ((v = fsp_test_invert_cmd(reg_val)) != reg_val) {
270                 ps2_sendbyte(ps2dev, 0x47, FSP_CMD_TIMEOUT2);
271         } else if ((v = fsp_test_swap_cmd(reg_val)) != reg_val) {
272                 /* swapping is required */
273                 ps2_sendbyte(ps2dev, 0x44, FSP_CMD_TIMEOUT2);
274         } else {
275                 /* swapping isn't necessary */
276                 ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
277         }
278
279         ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
280         rc = 0;
281
282  out:
283         ps2_end_command(ps2dev);
284         psmouse_dbg(psmouse,
285                     "WRITE PAGE REG: to 0x%02x (rc = %d)\n",
286                     reg_val, rc);
287         return rc;
288 }
289
290 static int fsp_get_version(struct psmouse *psmouse, int *version)
291 {
292         if (fsp_reg_read(psmouse, FSP_REG_VERSION, version))
293                 return -EIO;
294
295         return 0;
296 }
297
298 static int fsp_get_revision(struct psmouse *psmouse, int *rev)
299 {
300         if (fsp_reg_read(psmouse, FSP_REG_REVISION, rev))
301                 return -EIO;
302
303         return 0;
304 }
305
306 static int fsp_get_sn(struct psmouse *psmouse, int *sn)
307 {
308         int v0, v1, v2;
309         int rc = -EIO;
310
311         /* production number since Cx is available at: 0x0b40 ~ 0x0b42 */
312         if (fsp_page_reg_write(psmouse, FSP_PAGE_0B))
313                 goto out;
314         if (fsp_reg_read(psmouse, FSP_REG_SN0, &v0))
315                 goto out;
316         if (fsp_reg_read(psmouse, FSP_REG_SN1, &v1))
317                 goto out;
318         if (fsp_reg_read(psmouse, FSP_REG_SN2, &v2))
319                 goto out;
320         *sn = (v0 << 16) | (v1 << 8) | v2;
321         rc = 0;
322 out:
323         fsp_page_reg_write(psmouse, FSP_PAGE_DEFAULT);
324         return rc;
325 }
326
327 static int fsp_get_buttons(struct psmouse *psmouse, int *btn)
328 {
329         static const int buttons[] = {
330                 0x16, /* Left/Middle/Right/Forward/Backward & Scroll Up/Down */
331                 0x06, /* Left/Middle/Right & Scroll Up/Down/Right/Left */
332                 0x04, /* Left/Middle/Right & Scroll Up/Down */
333                 0x02, /* Left/Middle/Right */
334         };
335         int val;
336
337         if (fsp_reg_read(psmouse, FSP_REG_TMOD_STATUS, &val) == -1)
338                 return -EIO;
339
340         *btn = buttons[(val & 0x30) >> 4];
341         return 0;
342 }
343
344 /* Enable on-pad command tag output */
345 static int fsp_opc_tag_enable(struct psmouse *psmouse, bool enable)
346 {
347         int v, nv;
348         int res = 0;
349
350         if (fsp_reg_read(psmouse, FSP_REG_OPC_QDOWN, &v) == -1) {
351                 psmouse_err(psmouse, "Unable get OPC state.\n");
352                 return -EIO;
353         }
354
355         if (enable)
356                 nv = v | FSP_BIT_EN_OPC_TAG;
357         else
358                 nv = v & ~FSP_BIT_EN_OPC_TAG;
359
360         /* only write if necessary */
361         if (nv != v) {
362                 fsp_reg_write_enable(psmouse, true);
363                 res = fsp_reg_write(psmouse, FSP_REG_OPC_QDOWN, nv);
364                 fsp_reg_write_enable(psmouse, false);
365         }
366
367         if (res != 0) {
368                 psmouse_err(psmouse, "Unable to enable OPC tag.\n");
369                 res = -EIO;
370         }
371
372         return res;
373 }
374
375 static int fsp_onpad_vscr(struct psmouse *psmouse, bool enable)
376 {
377         struct fsp_data *pad = psmouse->private;
378         int val;
379
380         if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
381                 return -EIO;
382
383         pad->vscroll = enable;
384
385         if (enable)
386                 val |= (FSP_BIT_FIX_VSCR | FSP_BIT_ONPAD_ENABLE);
387         else
388                 val &= ~FSP_BIT_FIX_VSCR;
389
390         if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
391                 return -EIO;
392
393         return 0;
394 }
395
396 static int fsp_onpad_hscr(struct psmouse *psmouse, bool enable)
397 {
398         struct fsp_data *pad = psmouse->private;
399         int val, v2;
400
401         if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
402                 return -EIO;
403
404         if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &v2))
405                 return -EIO;
406
407         pad->hscroll = enable;
408
409         if (enable) {
410                 val |= (FSP_BIT_FIX_HSCR | FSP_BIT_ONPAD_ENABLE);
411                 v2 |= FSP_BIT_EN_MSID6;
412         } else {
413                 val &= ~FSP_BIT_FIX_HSCR;
414                 v2 &= ~(FSP_BIT_EN_MSID6 | FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8);
415         }
416
417         if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
418                 return -EIO;
419
420         /* reconfigure horizontal scrolling packet output */
421         if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, v2))
422                 return -EIO;
423
424         return 0;
425 }
426
427 /*
428  * Write device specific initial parameters.
429  *
430  * ex: 0xab 0xcd - write oxcd into register 0xab
431  */
432 static ssize_t fsp_attr_set_setreg(struct psmouse *psmouse, void *data,
433                                    const char *buf, size_t count)
434 {
435         unsigned int reg, val;
436         char *rest;
437         ssize_t retval;
438
439         reg = simple_strtoul(buf, &rest, 16);
440         if (rest == buf || *rest != ' ' || reg > 0xff)
441                 return -EINVAL;
442
443         retval = kstrtouint(rest + 1, 16, &val);
444         if (retval)
445                 return retval;
446
447         if (val > 0xff)
448                 return -EINVAL;
449
450         if (fsp_reg_write_enable(psmouse, true))
451                 return -EIO;
452
453         retval = fsp_reg_write(psmouse, reg, val) < 0 ? -EIO : count;
454
455         fsp_reg_write_enable(psmouse, false);
456
457         return retval;
458 }
459
460 PSMOUSE_DEFINE_WO_ATTR(setreg, S_IWUSR, NULL, fsp_attr_set_setreg);
461
462 static ssize_t fsp_attr_show_getreg(struct psmouse *psmouse,
463                                         void *data, char *buf)
464 {
465         struct fsp_data *pad = psmouse->private;
466
467         return sprintf(buf, "%02x%02x\n", pad->last_reg, pad->last_val);
468 }
469
470 /*
471  * Read a register from device.
472  *
473  * ex: 0xab -- read content from register 0xab
474  */
475 static ssize_t fsp_attr_set_getreg(struct psmouse *psmouse, void *data,
476                                         const char *buf, size_t count)
477 {
478         struct fsp_data *pad = psmouse->private;
479         unsigned int reg, val;
480         int err;
481
482         err = kstrtouint(buf, 16, &reg);
483         if (err)
484                 return err;
485
486         if (reg > 0xff)
487                 return -EINVAL;
488
489         if (fsp_reg_read(psmouse, reg, &val))
490                 return -EIO;
491
492         pad->last_reg = reg;
493         pad->last_val = val;
494
495         return count;
496 }
497
498 PSMOUSE_DEFINE_ATTR(getreg, S_IWUSR | S_IRUGO, NULL,
499                         fsp_attr_show_getreg, fsp_attr_set_getreg);
500
501 static ssize_t fsp_attr_show_pagereg(struct psmouse *psmouse,
502                                         void *data, char *buf)
503 {
504         int val = 0;
505
506         if (fsp_page_reg_read(psmouse, &val))
507                 return -EIO;
508
509         return sprintf(buf, "%02x\n", val);
510 }
511
512 static ssize_t fsp_attr_set_pagereg(struct psmouse *psmouse, void *data,
513                                         const char *buf, size_t count)
514 {
515         unsigned int val;
516         int err;
517
518         err = kstrtouint(buf, 16, &val);
519         if (err)
520                 return err;
521
522         if (val > 0xff)
523                 return -EINVAL;
524
525         if (fsp_page_reg_write(psmouse, val))
526                 return -EIO;
527
528         return count;
529 }
530
531 PSMOUSE_DEFINE_ATTR(page, S_IWUSR | S_IRUGO, NULL,
532                         fsp_attr_show_pagereg, fsp_attr_set_pagereg);
533
534 static ssize_t fsp_attr_show_vscroll(struct psmouse *psmouse,
535                                         void *data, char *buf)
536 {
537         struct fsp_data *pad = psmouse->private;
538
539         return sprintf(buf, "%d\n", pad->vscroll);
540 }
541
542 static ssize_t fsp_attr_set_vscroll(struct psmouse *psmouse, void *data,
543                                         const char *buf, size_t count)
544 {
545         unsigned int val;
546         int err;
547
548         err = kstrtouint(buf, 10, &val);
549         if (err)
550                 return err;
551
552         if (val > 1)
553                 return -EINVAL;
554
555         fsp_onpad_vscr(psmouse, val);
556
557         return count;
558 }
559
560 PSMOUSE_DEFINE_ATTR(vscroll, S_IWUSR | S_IRUGO, NULL,
561                         fsp_attr_show_vscroll, fsp_attr_set_vscroll);
562
563 static ssize_t fsp_attr_show_hscroll(struct psmouse *psmouse,
564                                         void *data, char *buf)
565 {
566         struct fsp_data *pad = psmouse->private;
567
568         return sprintf(buf, "%d\n", pad->hscroll);
569 }
570
571 static ssize_t fsp_attr_set_hscroll(struct psmouse *psmouse, void *data,
572                                         const char *buf, size_t count)
573 {
574         unsigned int val;
575         int err;
576
577         err = kstrtouint(buf, 10, &val);
578         if (err)
579                 return err;
580
581         if (val > 1)
582                 return -EINVAL;
583
584         fsp_onpad_hscr(psmouse, val);
585
586         return count;
587 }
588
589 PSMOUSE_DEFINE_ATTR(hscroll, S_IWUSR | S_IRUGO, NULL,
590                         fsp_attr_show_hscroll, fsp_attr_set_hscroll);
591
592 static ssize_t fsp_attr_show_flags(struct psmouse *psmouse,
593                                         void *data, char *buf)
594 {
595         struct fsp_data *pad = psmouse->private;
596
597         return sprintf(buf, "%c\n",
598                         pad->flags & FSPDRV_FLAG_EN_OPC ? 'C' : 'c');
599 }
600
601 static ssize_t fsp_attr_set_flags(struct psmouse *psmouse, void *data,
602                                         const char *buf, size_t count)
603 {
604         struct fsp_data *pad = psmouse->private;
605         size_t i;
606
607         for (i = 0; i < count; i++) {
608                 switch (buf[i]) {
609                 case 'C':
610                         pad->flags |= FSPDRV_FLAG_EN_OPC;
611                         break;
612                 case 'c':
613                         pad->flags &= ~FSPDRV_FLAG_EN_OPC;
614                         break;
615                 default:
616                         return -EINVAL;
617                 }
618         }
619         return count;
620 }
621
622 PSMOUSE_DEFINE_ATTR(flags, S_IWUSR | S_IRUGO, NULL,
623                         fsp_attr_show_flags, fsp_attr_set_flags);
624
625 static ssize_t fsp_attr_show_ver(struct psmouse *psmouse,
626                                         void *data, char *buf)
627 {
628         return sprintf(buf, "Sentelic FSP kernel module %s\n", fsp_drv_ver);
629 }
630
631 PSMOUSE_DEFINE_RO_ATTR(ver, S_IRUGO, NULL, fsp_attr_show_ver);
632
633 static struct attribute *fsp_attributes[] = {
634         &psmouse_attr_setreg.dattr.attr,
635         &psmouse_attr_getreg.dattr.attr,
636         &psmouse_attr_page.dattr.attr,
637         &psmouse_attr_vscroll.dattr.attr,
638         &psmouse_attr_hscroll.dattr.attr,
639         &psmouse_attr_flags.dattr.attr,
640         &psmouse_attr_ver.dattr.attr,
641         NULL
642 };
643
644 static struct attribute_group fsp_attribute_group = {
645         .attrs = fsp_attributes,
646 };
647
648 #ifdef  FSP_DEBUG
649 static void fsp_packet_debug(struct psmouse *psmouse, unsigned char packet[])
650 {
651         static unsigned int ps2_packet_cnt;
652         static unsigned int ps2_last_second;
653         unsigned int jiffies_msec;
654         const char *packet_type = "UNKNOWN";
655         unsigned short abs_x = 0, abs_y = 0;
656
657         /* Interpret & dump the packet data. */
658         switch (packet[0] >> FSP_PKT_TYPE_SHIFT) {
659         case FSP_PKT_TYPE_ABS:
660                 packet_type = "Absolute";
661                 abs_x = GET_ABS_X(packet);
662                 abs_y = GET_ABS_Y(packet);
663                 break;
664         case FSP_PKT_TYPE_NORMAL:
665                 packet_type = "Normal";
666                 break;
667         case FSP_PKT_TYPE_NOTIFY:
668                 packet_type = "Notify";
669                 break;
670         case FSP_PKT_TYPE_NORMAL_OPC:
671                 packet_type = "Normal-OPC";
672                 break;
673         }
674
675         ps2_packet_cnt++;
676         jiffies_msec = jiffies_to_msecs(jiffies);
677         psmouse_dbg(psmouse,
678                     "%08dms %s packets: %02x, %02x, %02x, %02x; "
679                     "abs_x: %d, abs_y: %d\n",
680                     jiffies_msec, packet_type,
681                     packet[0], packet[1], packet[2], packet[3], abs_x, abs_y);
682
683         if (jiffies_msec - ps2_last_second > 1000) {
684                 psmouse_dbg(psmouse, "PS/2 packets/sec = %d\n", ps2_packet_cnt);
685                 ps2_packet_cnt = 0;
686                 ps2_last_second = jiffies_msec;
687         }
688 }
689 #else
690 static void fsp_packet_debug(struct psmouse *psmouse, unsigned char packet[])
691 {
692 }
693 #endif
694
695 static void fsp_set_slot(struct input_dev *dev, int slot, bool active,
696                          unsigned int x, unsigned int y)
697 {
698         input_mt_slot(dev, slot);
699         input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
700         if (active) {
701                 input_report_abs(dev, ABS_MT_POSITION_X, x);
702                 input_report_abs(dev, ABS_MT_POSITION_Y, y);
703         }
704 }
705
706 static psmouse_ret_t fsp_process_byte(struct psmouse *psmouse)
707 {
708         struct input_dev *dev = psmouse->dev;
709         struct fsp_data *ad = psmouse->private;
710         unsigned char *packet = psmouse->packet;
711         unsigned char button_status = 0, lscroll = 0, rscroll = 0;
712         unsigned short abs_x, abs_y, fgrs = 0;
713         int rel_x, rel_y;
714
715         if (psmouse->pktcnt < 4)
716                 return PSMOUSE_GOOD_DATA;
717
718         /*
719          * Full packet accumulated, process it
720          */
721
722         fsp_packet_debug(psmouse, packet);
723
724         switch (psmouse->packet[0] >> FSP_PKT_TYPE_SHIFT) {
725         case FSP_PKT_TYPE_ABS:
726
727                 if ((packet[0] == 0x48 || packet[0] == 0x49) &&
728                     packet[1] == 0 && packet[2] == 0) {
729                         /*
730                          * Ignore coordinate noise when finger leaving the
731                          * surface, otherwise cursor may jump to upper-left
732                          * corner.
733                          */
734                         packet[3] &= 0xf0;
735                 }
736
737                 abs_x = GET_ABS_X(packet);
738                 abs_y = GET_ABS_Y(packet);
739
740                 if (packet[0] & FSP_PB0_MFMC) {
741                         /*
742                          * MFMC packet: assume that there are two fingers on
743                          * pad
744                          */
745                         fgrs = 2;
746
747                         /* MFMC packet */
748                         if (packet[0] & FSP_PB0_MFMC_FGR2) {
749                                 /* 2nd finger */
750                                 if (ad->last_mt_fgr == 2) {
751                                         /*
752                                          * workaround for buggy firmware
753                                          * which doesn't clear MFMC bit if
754                                          * the 1st finger is up
755                                          */
756                                         fgrs = 1;
757                                         fsp_set_slot(dev, 0, false, 0, 0);
758                                 }
759                                 ad->last_mt_fgr = 2;
760
761                                 fsp_set_slot(dev, 1, fgrs == 2, abs_x, abs_y);
762                         } else {
763                                 /* 1st finger */
764                                 if (ad->last_mt_fgr == 1) {
765                                         /*
766                                          * workaround for buggy firmware
767                                          * which doesn't clear MFMC bit if
768                                          * the 2nd finger is up
769                                          */
770                                         fgrs = 1;
771                                         fsp_set_slot(dev, 1, false, 0, 0);
772                                 }
773                                 ad->last_mt_fgr = 1;
774                                 fsp_set_slot(dev, 0, fgrs != 0, abs_x, abs_y);
775                         }
776                 } else {
777                         /* SFAC packet */
778                         if ((packet[0] & (FSP_PB0_LBTN|FSP_PB0_PHY_BTN)) ==
779                                 FSP_PB0_LBTN) {
780                                 /* On-pad click in SFAC mode should be handled
781                                  * by userspace.  On-pad clicks in MFMC mode
782                                  * are real clickpad clicks, and not ignored.
783                                  */
784                                 packet[0] &= ~FSP_PB0_LBTN;
785                         }
786
787                         /* no multi-finger information */
788                         ad->last_mt_fgr = 0;
789
790                         if (abs_x != 0 && abs_y != 0)
791                                 fgrs = 1;
792
793                         fsp_set_slot(dev, 0, fgrs > 0, abs_x, abs_y);
794                         fsp_set_slot(dev, 1, false, 0, 0);
795                 }
796                 if (fgrs == 1 || (fgrs == 2 && !(packet[0] & FSP_PB0_MFMC_FGR2))) {
797                         input_report_abs(dev, ABS_X, abs_x);
798                         input_report_abs(dev, ABS_Y, abs_y);
799                 }
800                 input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
801                 input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
802                 input_report_key(dev, BTN_TOUCH, fgrs);
803                 input_report_key(dev, BTN_TOOL_FINGER, fgrs == 1);
804                 input_report_key(dev, BTN_TOOL_DOUBLETAP, fgrs == 2);
805                 break;
806
807         case FSP_PKT_TYPE_NORMAL_OPC:
808                 /* on-pad click, filter it if necessary */
809                 if ((ad->flags & FSPDRV_FLAG_EN_OPC) != FSPDRV_FLAG_EN_OPC)
810                         packet[0] &= ~FSP_PB0_LBTN;
811                 /* fall through */
812
813         case FSP_PKT_TYPE_NORMAL:
814                 /* normal packet */
815                 /* special packet data translation from on-pad packets */
816                 if (packet[3] != 0) {
817                         if (packet[3] & BIT(0))
818                                 button_status |= 0x01;  /* wheel down */
819                         if (packet[3] & BIT(1))
820                                 button_status |= 0x0f;  /* wheel up */
821                         if (packet[3] & BIT(2))
822                                 button_status |= BIT(4);/* horizontal left */
823                         if (packet[3] & BIT(3))
824                                 button_status |= BIT(5);/* horizontal right */
825                         /* push back to packet queue */
826                         if (button_status != 0)
827                                 packet[3] = button_status;
828                         rscroll = (packet[3] >> 4) & 1;
829                         lscroll = (packet[3] >> 5) & 1;
830                 }
831                 /*
832                  * Processing wheel up/down and extra button events
833                  */
834                 input_report_rel(dev, REL_WHEEL,
835                                  (int)(packet[3] & 8) - (int)(packet[3] & 7));
836                 input_report_rel(dev, REL_HWHEEL, lscroll - rscroll);
837                 input_report_key(dev, BTN_BACK, lscroll);
838                 input_report_key(dev, BTN_FORWARD, rscroll);
839
840                 /*
841                  * Standard PS/2 Mouse
842                  */
843                 input_report_key(dev, BTN_LEFT, packet[0] & 1);
844                 input_report_key(dev, BTN_MIDDLE, (packet[0] >> 2) & 1);
845                 input_report_key(dev, BTN_RIGHT, (packet[0] >> 1) & 1);
846
847                 rel_x = packet[1] ? (int)packet[1] - (int)((packet[0] << 4) & 0x100) : 0;
848                 rel_y = packet[2] ? (int)((packet[0] << 3) & 0x100) - (int)packet[2] : 0;
849
850                 input_report_rel(dev, REL_X, rel_x);
851                 input_report_rel(dev, REL_Y, rel_y);
852                 break;
853         }
854
855         input_sync(dev);
856
857         return PSMOUSE_FULL_PACKET;
858 }
859
860 static int fsp_activate_protocol(struct psmouse *psmouse)
861 {
862         struct fsp_data *pad = psmouse->private;
863         struct ps2dev *ps2dev = &psmouse->ps2dev;
864         unsigned char param[2];
865         int val;
866
867         /*
868          * Standard procedure to enter FSP Intellimouse mode
869          * (scrolling wheel, 4th and 5th buttons)
870          */
871         param[0] = 200;
872         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
873         param[0] = 200;
874         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
875         param[0] =  80;
876         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
877
878         ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
879         if (param[0] != 0x04) {
880                 psmouse_err(psmouse,
881                             "Unable to enable 4 bytes packet format.\n");
882                 return -EIO;
883         }
884
885         if (pad->ver < FSP_VER_STL3888_C0) {
886                 /* Preparing relative coordinates output for older hardware */
887                 if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &val)) {
888                         psmouse_err(psmouse,
889                                     "Unable to read SYSCTL5 register.\n");
890                         return -EIO;
891                 }
892
893                 if (fsp_get_buttons(psmouse, &pad->buttons)) {
894                         psmouse_err(psmouse,
895                                     "Unable to retrieve number of buttons.\n");
896                         return -EIO;
897                 }
898
899                 val &= ~(FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8 | FSP_BIT_EN_AUTO_MSID8);
900                 /* Ensure we are not in absolute mode */
901                 val &= ~FSP_BIT_EN_PKT_G0;
902                 if (pad->buttons == 0x06) {
903                         /* Left/Middle/Right & Scroll Up/Down/Right/Left */
904                         val |= FSP_BIT_EN_MSID6;
905                 }
906
907                 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, val)) {
908                         psmouse_err(psmouse,
909                                     "Unable to set up required mode bits.\n");
910                         return -EIO;
911                 }
912
913                 /*
914                  * Enable OPC tags such that driver can tell the difference
915                  * between on-pad and real button click
916                  */
917                 if (fsp_opc_tag_enable(psmouse, true))
918                         psmouse_warn(psmouse,
919                                      "Failed to enable OPC tag mode.\n");
920                 /* enable on-pad click by default */
921                 pad->flags |= FSPDRV_FLAG_EN_OPC;
922
923                 /* Enable on-pad vertical and horizontal scrolling */
924                 fsp_onpad_vscr(psmouse, true);
925                 fsp_onpad_hscr(psmouse, true);
926         } else {
927                 /* Enable absolute coordinates output for Cx/Dx hardware */
928                 if (fsp_reg_write(psmouse, FSP_REG_SWC1,
929                                   FSP_BIT_SWC1_EN_ABS_1F |
930                                   FSP_BIT_SWC1_EN_ABS_2F |
931                                   FSP_BIT_SWC1_EN_FUP_OUT |
932                                   FSP_BIT_SWC1_EN_ABS_CON)) {
933                         psmouse_err(psmouse,
934                                     "Unable to enable absolute coordinates output.\n");
935                         return -EIO;
936                 }
937         }
938
939         return 0;
940 }
941
942 static int fsp_set_input_params(struct psmouse *psmouse)
943 {
944         struct input_dev *dev = psmouse->dev;
945         struct fsp_data *pad = psmouse->private;
946
947         if (pad->ver < FSP_VER_STL3888_C0) {
948                 __set_bit(BTN_MIDDLE, dev->keybit);
949                 __set_bit(BTN_BACK, dev->keybit);
950                 __set_bit(BTN_FORWARD, dev->keybit);
951                 __set_bit(REL_WHEEL, dev->relbit);
952                 __set_bit(REL_HWHEEL, dev->relbit);
953         } else {
954                 /*
955                  * Hardware prior to Cx performs much better in relative mode;
956                  * hence, only enable absolute coordinates output as well as
957                  * multi-touch output for the newer hardware.
958                  *
959                  * Maximum coordinates can be computed as:
960                  *
961                  *      number of scanlines * 64 - 57
962                  *
963                  * where number of X/Y scanline lines are 16/12.
964                  */
965                 int abs_x = 967, abs_y = 711;
966
967                 __set_bit(EV_ABS, dev->evbit);
968                 __clear_bit(EV_REL, dev->evbit);
969                 __set_bit(BTN_TOUCH, dev->keybit);
970                 __set_bit(BTN_TOOL_FINGER, dev->keybit);
971                 __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
972                 __set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
973
974                 input_set_abs_params(dev, ABS_X, 0, abs_x, 0, 0);
975                 input_set_abs_params(dev, ABS_Y, 0, abs_y, 0, 0);
976                 input_mt_init_slots(dev, 2, 0);
977                 input_set_abs_params(dev, ABS_MT_POSITION_X, 0, abs_x, 0, 0);
978                 input_set_abs_params(dev, ABS_MT_POSITION_Y, 0, abs_y, 0, 0);
979         }
980
981         return 0;
982 }
983
984 int fsp_detect(struct psmouse *psmouse, bool set_properties)
985 {
986         int id;
987
988         if (fsp_reg_read(psmouse, FSP_REG_DEVICE_ID, &id))
989                 return -EIO;
990
991         if (id != 0x01)
992                 return -ENODEV;
993
994         if (set_properties) {
995                 psmouse->vendor = "Sentelic";
996                 psmouse->name = "FingerSensingPad";
997         }
998
999         return 0;
1000 }
1001
1002 static void fsp_reset(struct psmouse *psmouse)
1003 {
1004         fsp_opc_tag_enable(psmouse, false);
1005         fsp_onpad_vscr(psmouse, false);
1006         fsp_onpad_hscr(psmouse, false);
1007 }
1008
1009 static void fsp_disconnect(struct psmouse *psmouse)
1010 {
1011         sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
1012                            &fsp_attribute_group);
1013
1014         fsp_reset(psmouse);
1015         kfree(psmouse->private);
1016 }
1017
1018 static int fsp_reconnect(struct psmouse *psmouse)
1019 {
1020         int version;
1021
1022         if (fsp_detect(psmouse, 0))
1023                 return -ENODEV;
1024
1025         if (fsp_get_version(psmouse, &version))
1026                 return -ENODEV;
1027
1028         if (fsp_activate_protocol(psmouse))
1029                 return -EIO;
1030
1031         return 0;
1032 }
1033
1034 int fsp_init(struct psmouse *psmouse)
1035 {
1036         struct fsp_data *priv;
1037         int ver, rev, sn = 0;
1038         int error;
1039
1040         if (fsp_get_version(psmouse, &ver) ||
1041             fsp_get_revision(psmouse, &rev)) {
1042                 return -ENODEV;
1043         }
1044         if (ver >= FSP_VER_STL3888_C0) {
1045                 /* firmware information is only available since C0 */
1046                 fsp_get_sn(psmouse, &sn);
1047         }
1048
1049         psmouse_info(psmouse,
1050                      "Finger Sensing Pad, hw: %d.%d.%d, sn: %x, sw: %s\n",
1051                      ver >> 4, ver & 0x0F, rev, sn, fsp_drv_ver);
1052
1053         psmouse->private = priv = kzalloc(sizeof(struct fsp_data), GFP_KERNEL);
1054         if (!priv)
1055                 return -ENOMEM;
1056
1057         priv->ver = ver;
1058         priv->rev = rev;
1059
1060         psmouse->protocol_handler = fsp_process_byte;
1061         psmouse->disconnect = fsp_disconnect;
1062         psmouse->reconnect = fsp_reconnect;
1063         psmouse->cleanup = fsp_reset;
1064         psmouse->pktsize = 4;
1065
1066         error = fsp_activate_protocol(psmouse);
1067         if (error)
1068                 goto err_out;
1069
1070         /* Set up various supported input event bits */
1071         error = fsp_set_input_params(psmouse);
1072         if (error)
1073                 goto err_out;
1074
1075         error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
1076                                    &fsp_attribute_group);
1077         if (error) {
1078                 psmouse_err(psmouse,
1079                             "Failed to create sysfs attributes (%d)", error);
1080                 goto err_out;
1081         }
1082
1083         return 0;
1084
1085  err_out:
1086         kfree(psmouse->private);
1087         psmouse->private = NULL;
1088         return error;
1089 }