84e2fc04d11bbda7f68d93cf7f3f64c98da2e0c6
[linux-2.6.git] / drivers / input / mouse / 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-2009 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/version.h>
24 #include <linux/input.h>
25 #include <linux/ctype.h>
26 #include <linux/libps2.h>
27 #include <linux/serio.h>
28 #include <linux/jiffies.h>
29
30 #include "psmouse.h"
31 #include "sentelic.h"
32
33 /*
34  * Timeout for FSP PS/2 command only (in milliseconds).
35  */
36 #define FSP_CMD_TIMEOUT         200
37 #define FSP_CMD_TIMEOUT2        30
38
39 /** Driver version. */
40 static const char fsp_drv_ver[] = "1.0.0-K";
41
42 /*
43  * Make sure that the value being sent to FSP will not conflict with
44  * possible sample rate values.
45  */
46 static unsigned char fsp_test_swap_cmd(unsigned char reg_val)
47 {
48         switch (reg_val) {
49         case 10: case 20: case 40: case 60: case 80: case 100: case 200:
50                 /*
51                  * The requested value being sent to FSP matched to possible
52                  * sample rates, swap the given value such that the hardware
53                  * wouldn't get confused.
54                  */
55                 return (reg_val >> 4) | (reg_val << 4);
56         default:
57                 return reg_val; /* swap isn't necessary */
58         }
59 }
60
61 /*
62  * Make sure that the value being sent to FSP will not conflict with certain
63  * commands.
64  */
65 static unsigned char fsp_test_invert_cmd(unsigned char reg_val)
66 {
67         switch (reg_val) {
68         case 0xe9: case 0xee: case 0xf2: case 0xff:
69                 /*
70                  * The requested value being sent to FSP matched to certain
71                  * commands, inverse the given value such that the hardware
72                  * wouldn't get confused.
73                  */
74                 return ~reg_val;
75         default:
76                 return reg_val; /* inversion isn't necessary */
77         }
78 }
79
80 static int fsp_reg_read(struct psmouse *psmouse, int reg_addr, int *reg_val)
81 {
82         struct ps2dev *ps2dev = &psmouse->ps2dev;
83         unsigned char param[3];
84         unsigned char addr;
85         int rc = -1;
86
87         /*
88          * We need to shut off the device and switch it into command
89          * mode so we don't confuse our protocol handler. We don't need
90          * to do that for writes because sysfs set helper does this for
91          * us.
92          */
93         ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE);
94         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
95         mutex_lock(&ps2dev->cmd_mutex);
96
97         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
98                 goto out;
99
100         /* should return 0xfe(request for resending) */
101         ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
102         /* should return 0xfc(failed) */
103         ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
104
105         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
106                 goto out;
107
108         if ((addr = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
109                 ps2_sendbyte(ps2dev, 0x68, FSP_CMD_TIMEOUT2);
110         } else if ((addr = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
111                 /* swapping is required */
112                 ps2_sendbyte(ps2dev, 0xcc, FSP_CMD_TIMEOUT2);
113                 /* expect 0xfe */
114         } else {
115                 /* swapping isn't necessary */
116                 ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
117                 /* expect 0xfe */
118         }
119         /* should return 0xfc(failed) */
120         ps2_sendbyte(ps2dev, addr, FSP_CMD_TIMEOUT);
121
122         if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO) < 0)
123                 goto out;
124
125         *reg_val = param[2];
126         rc = 0;
127
128  out:
129         mutex_unlock(&ps2dev->cmd_mutex);
130         ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE);
131         psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
132         dev_dbg(&ps2dev->serio->dev, "READ REG: 0x%02x is 0x%02x (rc = %d)\n",
133                 reg_addr, *reg_val, rc);
134         return rc;
135 }
136
137 static int fsp_reg_write(struct psmouse *psmouse, int reg_addr, int reg_val)
138 {
139         struct ps2dev *ps2dev = &psmouse->ps2dev;
140         unsigned char v;
141         int rc = -1;
142
143         mutex_lock(&ps2dev->cmd_mutex);
144
145         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
146                 goto out;
147
148         if ((v = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
149                 /* inversion is required */
150                 ps2_sendbyte(ps2dev, 0x74, FSP_CMD_TIMEOUT2);
151         } else {
152                 if ((v = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
153                         /* swapping is required */
154                         ps2_sendbyte(ps2dev, 0x77, FSP_CMD_TIMEOUT2);
155                 } else {
156                         /* swapping isn't necessary */
157                         ps2_sendbyte(ps2dev, 0x55, FSP_CMD_TIMEOUT2);
158                 }
159         }
160         /* write the register address in correct order */
161         ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
162
163         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
164                 return -1;
165
166         if ((v = fsp_test_invert_cmd(reg_val)) != reg_val) {
167                 /* inversion is required */
168                 ps2_sendbyte(ps2dev, 0x47, FSP_CMD_TIMEOUT2);
169         } else if ((v = fsp_test_swap_cmd(reg_val)) != reg_val) {
170                 /* swapping is required */
171                 ps2_sendbyte(ps2dev, 0x44, FSP_CMD_TIMEOUT2);
172         } else {
173                 /* swapping isn't necessary */
174                 ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
175         }
176
177         /* write the register value in correct order */
178         ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
179         rc = 0;
180
181  out:
182         mutex_unlock(&ps2dev->cmd_mutex);
183         dev_dbg(&ps2dev->serio->dev, "WRITE REG: 0x%02x to 0x%02x (rc = %d)\n",
184                 reg_addr, reg_val, rc);
185         return rc;
186 }
187
188 /* Enable register clock gating for writing certain registers */
189 static int fsp_reg_write_enable(struct psmouse *psmouse, bool enable)
190 {
191         int v, nv;
192
193         if (fsp_reg_read(psmouse, FSP_REG_SYSCTL1, &v) == -1)
194                 return -1;
195
196         if (enable)
197                 nv = v | FSP_BIT_EN_REG_CLK;
198         else
199                 nv = v & ~FSP_BIT_EN_REG_CLK;
200
201         /* only write if necessary */
202         if (nv != v)
203                 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL1, nv) == -1)
204                         return -1;
205
206         return 0;
207 }
208
209 static int fsp_page_reg_read(struct psmouse *psmouse, int *reg_val)
210 {
211         struct ps2dev *ps2dev = &psmouse->ps2dev;
212         unsigned char param[3];
213         int rc = -1;
214
215         ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE);
216         psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
217         mutex_lock(&ps2dev->cmd_mutex);
218
219         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
220                 goto out;
221
222         ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
223         ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
224
225         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
226                 goto out;
227
228         ps2_sendbyte(ps2dev, 0x83, FSP_CMD_TIMEOUT2);
229         ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
230
231         /* get the returned result */
232         if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
233                 goto out;
234
235         *reg_val = param[2];
236         rc = 0;
237
238  out:
239         mutex_unlock(&ps2dev->cmd_mutex);
240         ps2_command(ps2dev, NULL, PSMOUSE_CMD_ENABLE);
241         psmouse_set_state(psmouse, PSMOUSE_ACTIVATED);
242         dev_dbg(&ps2dev->serio->dev, "READ PAGE REG: 0x%02x (rc = %d)\n",
243                 *reg_val, rc);
244         return rc;
245 }
246
247 static int fsp_page_reg_write(struct psmouse *psmouse, int reg_val)
248 {
249         struct ps2dev *ps2dev = &psmouse->ps2dev;
250         unsigned char v;
251         int rc = -1;
252
253         mutex_lock(&ps2dev->cmd_mutex);
254
255         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
256                 goto out;
257
258         ps2_sendbyte(ps2dev, 0x38, FSP_CMD_TIMEOUT2);
259         ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
260
261         if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
262                 return -1;
263
264         if ((v = fsp_test_invert_cmd(reg_val)) != reg_val) {
265                 ps2_sendbyte(ps2dev, 0x47, FSP_CMD_TIMEOUT2);
266         } else if ((v = fsp_test_swap_cmd(reg_val)) != reg_val) {
267                 /* swapping is required */
268                 ps2_sendbyte(ps2dev, 0x44, FSP_CMD_TIMEOUT2);
269         } else {
270                 /* swapping isn't necessary */
271                 ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
272         }
273
274         ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
275         rc = 0;
276
277  out:
278         mutex_unlock(&ps2dev->cmd_mutex);
279         dev_dbg(&ps2dev->serio->dev, "WRITE PAGE REG: to 0x%02x (rc = %d)\n",
280                 reg_val, rc);
281         return rc;
282 }
283
284 static int fsp_get_version(struct psmouse *psmouse, int *version)
285 {
286         if (fsp_reg_read(psmouse, FSP_REG_VERSION, version))
287                 return -EIO;
288
289         return 0;
290 }
291
292 static int fsp_get_revision(struct psmouse *psmouse, int *rev)
293 {
294         if (fsp_reg_read(psmouse, FSP_REG_REVISION, rev))
295                 return -EIO;
296
297         return 0;
298 }
299
300 static int fsp_get_buttons(struct psmouse *psmouse, int *btn)
301 {
302         static const int buttons[] = {
303                 0x16, /* Left/Middle/Right/Forward/Backward & Scroll Up/Down */
304                 0x06, /* Left/Middle/Right & Scroll Up/Down/Right/Left */
305                 0x04, /* Left/Middle/Right & Scroll Up/Down */
306                 0x02, /* Left/Middle/Right */
307         };
308         int val;
309
310         if (fsp_reg_read(psmouse, FSP_REG_TMOD_STATUS1, &val) == -1)
311                 return -EIO;
312
313         *btn = buttons[(val & 0x30) >> 4];
314         return 0;
315 }
316
317 /* Enable on-pad command tag output */
318 static int fsp_opc_tag_enable(struct psmouse *psmouse, bool enable)
319 {
320         int v, nv;
321         int res = 0;
322
323         if (fsp_reg_read(psmouse, FSP_REG_OPC_QDOWN, &v) == -1) {
324                 dev_err(&psmouse->ps2dev.serio->dev, "Unable get OPC state.\n");
325                 return -EIO;
326         }
327
328         if (enable)
329                 nv = v | FSP_BIT_EN_OPC_TAG;
330         else
331                 nv = v & ~FSP_BIT_EN_OPC_TAG;
332
333         /* only write if necessary */
334         if (nv != v) {
335                 fsp_reg_write_enable(psmouse, true);
336                 res = fsp_reg_write(psmouse, FSP_REG_OPC_QDOWN, nv);
337                 fsp_reg_write_enable(psmouse, false);
338         }
339
340         if (res != 0) {
341                 dev_err(&psmouse->ps2dev.serio->dev,
342                         "Unable to enable OPC tag.\n");
343                 res = -EIO;
344         }
345
346         return res;
347 }
348
349 static int fsp_onpad_vscr(struct psmouse *psmouse, bool enable)
350 {
351         struct fsp_data *pad = psmouse->private;
352         int val;
353
354         if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
355                 return -EIO;
356
357         pad->vscroll = enable;
358
359         if (enable)
360                 val |= (FSP_BIT_FIX_VSCR | FSP_BIT_ONPAD_ENABLE);
361         else
362                 val &= ~FSP_BIT_FIX_VSCR;
363
364         if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
365                 return -EIO;
366
367         return 0;
368 }
369
370 static int fsp_onpad_hscr(struct psmouse *psmouse, bool enable)
371 {
372         struct fsp_data *pad = psmouse->private;
373         int val, v2;
374
375         if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
376                 return -EIO;
377
378         if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &v2))
379                 return -EIO;
380
381         pad->hscroll = enable;
382
383         if (enable) {
384                 val |= (FSP_BIT_FIX_HSCR | FSP_BIT_ONPAD_ENABLE);
385                 v2 |= FSP_BIT_EN_MSID6;
386         } else {
387                 val &= ~FSP_BIT_FIX_HSCR;
388                 v2 &= ~(FSP_BIT_EN_MSID6 | FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8);
389         }
390
391         if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
392                 return -EIO;
393
394         /* reconfigure horizontal scrolling packet output */
395         if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, v2))
396                 return -EIO;
397
398         return 0;
399 }
400
401 /*
402  * Write device specific initial parameters.
403  *
404  * ex: 0xab 0xcd - write oxcd into register 0xab
405  */
406 static ssize_t fsp_attr_set_setreg(struct psmouse *psmouse, void *data,
407                                    const char *buf, size_t count)
408 {
409         unsigned long reg, val;
410         char *rest;
411         ssize_t retval;
412
413         reg = simple_strtoul(buf, &rest, 16);
414         if (rest == buf || *rest != ' ' || reg > 0xff)
415                 return -EINVAL;
416
417         if (strict_strtoul(rest + 1, 16, &val) || val > 0xff)
418                 return -EINVAL;
419
420         if (fsp_reg_write_enable(psmouse, true))
421                 return -EIO;
422
423         retval = fsp_reg_write(psmouse, reg, val) < 0 ? -EIO : count;
424
425         fsp_reg_write_enable(psmouse, false);
426
427         return count;
428 }
429
430 PSMOUSE_DEFINE_WO_ATTR(setreg, S_IWUSR, NULL, fsp_attr_set_setreg);
431
432 static ssize_t fsp_attr_show_getreg(struct psmouse *psmouse,
433                                         void *data, char *buf)
434 {
435         struct fsp_data *pad = psmouse->private;
436
437         return sprintf(buf, "%02x%02x\n", pad->last_reg, pad->last_val);
438 }
439
440 /*
441  * Read a register from device.
442  *
443  * ex: 0xab -- read content from register 0xab
444  */
445 static ssize_t fsp_attr_set_getreg(struct psmouse *psmouse, void *data,
446                                         const char *buf, size_t count)
447 {
448         struct fsp_data *pad = psmouse->private;
449         unsigned long reg;
450         int val;
451
452         if (strict_strtoul(buf, 16, &reg) || reg > 0xff)
453                 return -EINVAL;
454
455         if (fsp_reg_read(psmouse, reg, &val))
456                 return -EIO;
457
458         pad->last_reg = reg;
459         pad->last_val = val;
460
461         return count;
462 }
463
464 PSMOUSE_DEFINE_ATTR(getreg, S_IWUSR | S_IRUGO, NULL,
465                         fsp_attr_show_getreg, fsp_attr_set_getreg);
466
467 static ssize_t fsp_attr_show_pagereg(struct psmouse *psmouse,
468                                         void *data, char *buf)
469 {
470         int val = 0;
471
472         if (fsp_page_reg_read(psmouse, &val))
473                 return -EIO;
474
475         return sprintf(buf, "%02x\n", val);
476 }
477
478 static ssize_t fsp_attr_set_pagereg(struct psmouse *psmouse, void *data,
479                                         const char *buf, size_t count)
480 {
481         unsigned long val;
482
483         if (strict_strtoul(buf, 16, &val) || val > 0xff)
484                 return -EINVAL;
485
486         if (fsp_page_reg_write(psmouse, val))
487                 return -EIO;
488
489         return count;
490 }
491
492 PSMOUSE_DEFINE_ATTR(page, S_IWUSR | S_IRUGO, NULL,
493                         fsp_attr_show_pagereg, fsp_attr_set_pagereg);
494
495 static ssize_t fsp_attr_show_vscroll(struct psmouse *psmouse,
496                                         void *data, char *buf)
497 {
498         struct fsp_data *pad = psmouse->private;
499
500         return sprintf(buf, "%d\n", pad->vscroll);
501 }
502
503 static ssize_t fsp_attr_set_vscroll(struct psmouse *psmouse, void *data,
504                                         const char *buf, size_t count)
505 {
506         unsigned long val;
507
508         if (strict_strtoul(buf, 10, &val) || val > 1)
509                 return -EINVAL;
510
511         fsp_onpad_vscr(psmouse, val);
512
513         return count;
514 }
515
516 PSMOUSE_DEFINE_ATTR(vscroll, S_IWUSR | S_IRUGO, NULL,
517                         fsp_attr_show_vscroll, fsp_attr_set_vscroll);
518
519 static ssize_t fsp_attr_show_hscroll(struct psmouse *psmouse,
520                                         void *data, char *buf)
521 {
522         struct fsp_data *pad = psmouse->private;
523
524         return sprintf(buf, "%d\n", pad->hscroll);
525 }
526
527 static ssize_t fsp_attr_set_hscroll(struct psmouse *psmouse, void *data,
528                                         const char *buf, size_t count)
529 {
530         unsigned long val;
531
532         if (strict_strtoul(buf, 10, &val) || val > 1)
533                 return -EINVAL;
534
535         fsp_onpad_hscr(psmouse, val);
536
537         return count;
538 }
539
540 PSMOUSE_DEFINE_ATTR(hscroll, S_IWUSR | S_IRUGO, NULL,
541                         fsp_attr_show_hscroll, fsp_attr_set_hscroll);
542
543 static ssize_t fsp_attr_show_flags(struct psmouse *psmouse,
544                                         void *data, char *buf)
545 {
546         struct fsp_data *pad = psmouse->private;
547
548         return sprintf(buf, "%c\n",
549                         pad->flags & FSPDRV_FLAG_EN_OPC ? 'C' : 'c');
550 }
551
552 static ssize_t fsp_attr_set_flags(struct psmouse *psmouse, void *data,
553                                         const char *buf, size_t count)
554 {
555         struct fsp_data *pad = psmouse->private;
556         size_t i;
557
558         for (i = 0; i < count; i++) {
559                 switch (buf[i]) {
560                 case 'C':
561                         pad->flags |= FSPDRV_FLAG_EN_OPC;
562                         break;
563                 case 'c':
564                         pad->flags &= ~FSPDRV_FLAG_EN_OPC;
565                         break;
566                 default:
567                         return -EINVAL;
568                 }
569         }
570         return count;
571 }
572
573 PSMOUSE_DEFINE_ATTR(flags, S_IWUSR | S_IRUGO, NULL,
574                         fsp_attr_show_flags, fsp_attr_set_flags);
575
576 static ssize_t fsp_attr_show_ver(struct psmouse *psmouse,
577                                         void *data, char *buf)
578 {
579         return sprintf(buf, "Sentelic FSP kernel module %s\n", fsp_drv_ver);
580 }
581
582 PSMOUSE_DEFINE_RO_ATTR(ver, S_IRUGO, NULL, fsp_attr_show_ver);
583
584 static struct attribute *fsp_attributes[] = {
585         &psmouse_attr_setreg.dattr.attr,
586         &psmouse_attr_getreg.dattr.attr,
587         &psmouse_attr_page.dattr.attr,
588         &psmouse_attr_vscroll.dattr.attr,
589         &psmouse_attr_hscroll.dattr.attr,
590         &psmouse_attr_flags.dattr.attr,
591         &psmouse_attr_ver.dattr.attr,
592         NULL
593 };
594
595 static struct attribute_group fsp_attribute_group = {
596         .attrs = fsp_attributes,
597 };
598
599 #ifdef FSP_DEBUG
600 static void fsp_packet_debug(unsigned char packet[])
601 {
602         static unsigned int ps2_packet_cnt;
603         static unsigned int ps2_last_second;
604         unsigned int jiffies_msec;
605
606         ps2_packet_cnt++;
607         jiffies_msec = jiffies_to_msecs(jiffies);
608         printk(KERN_DEBUG "%08dms PS/2 packets: %02x, %02x, %02x, %02x\n",
609                 jiffies_msec, packet[0], packet[1], packet[2], packet[3]);
610
611         if (jiffies_msec - ps2_last_second > 1000) {
612                 printk(KERN_DEBUG "PS/2 packets/sec = %d\n", ps2_packet_cnt);
613                 ps2_packet_cnt = 0;
614                 ps2_last_second = jiffies_msec;
615         }
616 }
617 #else
618 static void fsp_packet_debug(unsigned char packet[])
619 {
620 }
621 #endif
622
623 static psmouse_ret_t fsp_process_byte(struct psmouse *psmouse)
624 {
625         struct input_dev *dev = psmouse->dev;
626         struct fsp_data *ad = psmouse->private;
627         unsigned char *packet = psmouse->packet;
628         unsigned char button_status = 0, lscroll = 0, rscroll = 0;
629         int rel_x, rel_y;
630
631         if (psmouse->pktcnt < 4)
632                 return PSMOUSE_GOOD_DATA;
633
634         /*
635          * Full packet accumulated, process it
636          */
637
638         switch (psmouse->packet[0] >> FSP_PKT_TYPE_SHIFT) {
639         case FSP_PKT_TYPE_ABS:
640                 dev_warn(&psmouse->ps2dev.serio->dev,
641                          "Unexpected absolute mode packet, ignored.\n");
642                 break;
643
644         case FSP_PKT_TYPE_NORMAL_OPC:
645                 /* on-pad click, filter it if necessary */
646                 if ((ad->flags & FSPDRV_FLAG_EN_OPC) != FSPDRV_FLAG_EN_OPC)
647                         packet[0] &= ~BIT(0);
648                 /* fall through */
649
650         case FSP_PKT_TYPE_NORMAL:
651                 /* normal packet */
652                 /* special packet data translation from on-pad packets */
653                 if (packet[3] != 0) {
654                         if (packet[3] & BIT(0))
655                                 button_status |= 0x01;  /* wheel down */
656                         if (packet[3] & BIT(1))
657                                 button_status |= 0x0f;  /* wheel up */
658                         if (packet[3] & BIT(2))
659                                 button_status |= BIT(5);/* horizontal left */
660                         if (packet[3] & BIT(3))
661                                 button_status |= BIT(4);/* horizontal right */
662                         /* push back to packet queue */
663                         if (button_status != 0)
664                                 packet[3] = button_status;
665                         rscroll = (packet[3] >> 4) & 1;
666                         lscroll = (packet[3] >> 5) & 1;
667                 }
668                 /*
669                  * Processing wheel up/down and extra button events
670                  */
671                 input_report_rel(dev, REL_WHEEL,
672                                  (int)(packet[3] & 8) - (int)(packet[3] & 7));
673                 input_report_rel(dev, REL_HWHEEL, lscroll - rscroll);
674                 input_report_key(dev, BTN_BACK, lscroll);
675                 input_report_key(dev, BTN_FORWARD, rscroll);
676
677                 /*
678                  * Standard PS/2 Mouse
679                  */
680                 input_report_key(dev, BTN_LEFT, packet[0] & 1);
681                 input_report_key(dev, BTN_MIDDLE, (packet[0] >> 2) & 1);
682                 input_report_key(dev, BTN_RIGHT, (packet[0] >> 1) & 1);
683
684                 rel_x = packet[1] ? (int)packet[1] - (int)((packet[0] << 4) & 0x100) : 0;
685                 rel_y = packet[2] ? (int)((packet[0] << 3) & 0x100) - (int)packet[2] : 0;
686
687                 input_report_rel(dev, REL_X, rel_x);
688                 input_report_rel(dev, REL_Y, rel_y);
689                 break;
690         }
691
692         input_sync(dev);
693
694         fsp_packet_debug(packet);
695
696         return PSMOUSE_FULL_PACKET;
697 }
698
699 static int fsp_activate_protocol(struct psmouse *psmouse)
700 {
701         struct fsp_data *pad = psmouse->private;
702         struct ps2dev *ps2dev = &psmouse->ps2dev;
703         unsigned char param[2];
704         int val;
705
706         /*
707          * Standard procedure to enter FSP Intellimouse mode
708          * (scrolling wheel, 4th and 5th buttons)
709          */
710         param[0] = 200;
711         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
712         param[0] = 200;
713         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
714         param[0] =  80;
715         ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
716
717         ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
718         if (param[0] != 0x04) {
719                 dev_err(&psmouse->ps2dev.serio->dev,
720                         "Unable to enable 4 bytes packet format.\n");
721                 return -EIO;
722         }
723
724         if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &val)) {
725                 dev_err(&psmouse->ps2dev.serio->dev,
726                         "Unable to read SYSCTL5 register.\n");
727                 return -EIO;
728         }
729
730         val &= ~(FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8 | FSP_BIT_EN_AUTO_MSID8);
731         /* Ensure we are not in absolute mode */
732         val &= ~FSP_BIT_EN_PKT_G0;
733         if (pad->buttons == 0x06) {
734                 /* Left/Middle/Right & Scroll Up/Down/Right/Left */
735                 val |= FSP_BIT_EN_MSID6;
736         }
737
738         if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, val)) {
739                 dev_err(&psmouse->ps2dev.serio->dev,
740                         "Unable to set up required mode bits.\n");
741                 return -EIO;
742         }
743
744         /*
745          * Enable OPC tags such that driver can tell the difference between
746          * on-pad and real button click
747          */
748         if (fsp_opc_tag_enable(psmouse, true))
749                 dev_warn(&psmouse->ps2dev.serio->dev,
750                          "Failed to enable OPC tag mode.\n");
751
752         /* Enable on-pad vertical and horizontal scrolling */
753         fsp_onpad_vscr(psmouse, true);
754         fsp_onpad_hscr(psmouse, true);
755
756         return 0;
757 }
758
759 int fsp_detect(struct psmouse *psmouse, bool set_properties)
760 {
761         int id;
762
763         if (fsp_reg_read(psmouse, FSP_REG_DEVICE_ID, &id))
764                 return -EIO;
765
766         if (id != 0x01)
767                 return -ENODEV;
768
769         if (set_properties) {
770                 psmouse->vendor = "Sentelic";
771                 psmouse->name = "FingerSensingPad";
772         }
773
774         return 0;
775 }
776
777 static void fsp_reset(struct psmouse *psmouse)
778 {
779         fsp_opc_tag_enable(psmouse, false);
780         fsp_onpad_vscr(psmouse, false);
781         fsp_onpad_hscr(psmouse, false);
782 }
783
784 static void fsp_disconnect(struct psmouse *psmouse)
785 {
786         sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
787                            &fsp_attribute_group);
788
789         fsp_reset(psmouse);
790         kfree(psmouse->private);
791 }
792
793 static int fsp_reconnect(struct psmouse *psmouse)
794 {
795         int version;
796
797         if (fsp_detect(psmouse, 0))
798                 return -ENODEV;
799
800         if (fsp_get_version(psmouse, &version))
801                 return -ENODEV;
802
803         if (fsp_activate_protocol(psmouse))
804                 return -EIO;
805
806         return 0;
807 }
808
809 int fsp_init(struct psmouse *psmouse)
810 {
811         struct fsp_data *priv;
812         int ver, rev, buttons;
813         int error;
814
815         if (fsp_get_version(psmouse, &ver) ||
816             fsp_get_revision(psmouse, &rev) ||
817             fsp_get_buttons(psmouse, &buttons)) {
818                 return -ENODEV;
819         }
820
821         printk(KERN_INFO
822                 "Finger Sensing Pad, hw: %d.%d.%d, sw: %s, buttons: %d\n",
823                 ver >> 4, ver & 0x0F, rev, fsp_drv_ver, buttons & 7);
824
825         psmouse->private = priv = kzalloc(sizeof(struct fsp_data), GFP_KERNEL);
826         if (!priv)
827                 return -ENOMEM;
828
829         priv->ver = ver;
830         priv->rev = rev;
831         priv->buttons = buttons;
832
833         /* enable on-pad click by default */
834         priv->flags |= FSPDRV_FLAG_EN_OPC;
835
836         /* Set up various supported input event bits */
837         __set_bit(BTN_BACK, psmouse->dev->keybit);
838         __set_bit(BTN_FORWARD, psmouse->dev->keybit);
839         __set_bit(REL_WHEEL, psmouse->dev->relbit);
840         __set_bit(REL_HWHEEL, psmouse->dev->relbit);
841
842         psmouse->protocol_handler = fsp_process_byte;
843         psmouse->disconnect = fsp_disconnect;
844         psmouse->reconnect = fsp_reconnect;
845         psmouse->cleanup = fsp_reset;
846         psmouse->pktsize = 4;
847
848         /* set default packet output based on number of buttons we found */
849         error = fsp_activate_protocol(psmouse);
850         if (error)
851                 goto err_out;
852
853         error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
854                                    &fsp_attribute_group);
855         if (error) {
856                 dev_err(&psmouse->ps2dev.serio->dev,
857                         "Failed to create sysfs attributes (%d)", error);
858                 goto err_out;
859         }
860
861         return 0;
862
863  err_out:
864         kfree(psmouse->private);
865         psmouse->private = NULL;
866         return error;
867 }