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