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