2 * Finger Sensing Pad PS/2 mouse driver.
4 * Copyright (C) 2005-2007 Asia Vital Components Co., Ltd.
5 * Copyright (C) 2005-2010 Tai-hwa Liang, Sentelic Corporation.
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.
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.
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.
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>
35 * Timeout for FSP PS/2 command only (in milliseconds).
37 #define FSP_CMD_TIMEOUT 200
38 #define FSP_CMD_TIMEOUT2 30
40 /** Driver version. */
41 static const char fsp_drv_ver[] = "1.0.0-K";
44 * Make sure that the value being sent to FSP will not conflict with
45 * possible sample rate values.
47 static unsigned char fsp_test_swap_cmd(unsigned char reg_val)
50 case 10: case 20: case 40: case 60: case 80: case 100: case 200:
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.
56 return (reg_val >> 4) | (reg_val << 4);
58 return reg_val; /* swap isn't necessary */
63 * Make sure that the value being sent to FSP will not conflict with certain
66 static unsigned char fsp_test_invert_cmd(unsigned char reg_val)
69 case 0xe9: case 0xee: case 0xf2: case 0xff:
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.
77 return reg_val; /* inversion isn't necessary */
81 static int fsp_reg_read(struct psmouse *psmouse, int reg_addr, int *reg_val)
83 struct ps2dev *ps2dev = &psmouse->ps2dev;
84 unsigned char param[3];
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
94 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE);
95 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
97 ps2_begin_command(ps2dev);
99 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
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);
107 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
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);
117 /* swapping isn't necessary */
118 ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
121 /* should return 0xfc(failed) */
122 ps2_sendbyte(ps2dev, addr, FSP_CMD_TIMEOUT);
124 if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO) < 0)
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);
139 static int fsp_reg_write(struct psmouse *psmouse, int reg_addr, int reg_val)
141 struct ps2dev *ps2dev = &psmouse->ps2dev;
145 ps2_begin_command(ps2dev);
147 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
150 if ((v = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
151 /* inversion is required */
152 ps2_sendbyte(ps2dev, 0x74, FSP_CMD_TIMEOUT2);
154 if ((v = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
155 /* swapping is required */
156 ps2_sendbyte(ps2dev, 0x77, FSP_CMD_TIMEOUT2);
158 /* swapping isn't necessary */
159 ps2_sendbyte(ps2dev, 0x55, FSP_CMD_TIMEOUT2);
162 /* write the register address in correct order */
163 ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
165 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
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);
175 /* swapping isn't necessary */
176 ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
179 /* write the register value in correct order */
180 ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
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);
190 /* Enable register clock gating for writing certain registers */
191 static int fsp_reg_write_enable(struct psmouse *psmouse, bool enable)
195 if (fsp_reg_read(psmouse, FSP_REG_SYSCTL1, &v) == -1)
199 nv = v | FSP_BIT_EN_REG_CLK;
201 nv = v & ~FSP_BIT_EN_REG_CLK;
203 /* only write if necessary */
205 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL1, nv) == -1)
211 static int fsp_page_reg_read(struct psmouse *psmouse, int *reg_val)
213 struct ps2dev *ps2dev = &psmouse->ps2dev;
214 unsigned char param[3];
217 ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE);
218 psmouse_set_state(psmouse, PSMOUSE_CMD_MODE);
220 ps2_begin_command(ps2dev);
222 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
225 ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
226 ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
228 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
231 ps2_sendbyte(ps2dev, 0x83, FSP_CMD_TIMEOUT2);
232 ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
234 /* get the returned result */
235 if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
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",
250 static int fsp_page_reg_write(struct psmouse *psmouse, int reg_val)
252 struct ps2dev *ps2dev = &psmouse->ps2dev;
256 ps2_begin_command(ps2dev);
258 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
261 ps2_sendbyte(ps2dev, 0x38, FSP_CMD_TIMEOUT2);
262 ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
264 if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
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);
273 /* swapping isn't necessary */
274 ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
277 ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
281 ps2_end_command(ps2dev);
282 dev_dbg(&ps2dev->serio->dev, "WRITE PAGE REG: to 0x%02x (rc = %d)\n",
287 static int fsp_get_version(struct psmouse *psmouse, int *version)
289 if (fsp_reg_read(psmouse, FSP_REG_VERSION, version))
295 static int fsp_get_revision(struct psmouse *psmouse, int *rev)
297 if (fsp_reg_read(psmouse, FSP_REG_REVISION, rev))
303 static int fsp_get_buttons(struct psmouse *psmouse, int *btn)
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 */
313 if (fsp_reg_read(psmouse, FSP_REG_TMOD_STATUS1, &val) == -1)
316 *btn = buttons[(val & 0x30) >> 4];
320 /* Enable on-pad command tag output */
321 static int fsp_opc_tag_enable(struct psmouse *psmouse, bool enable)
326 if (fsp_reg_read(psmouse, FSP_REG_OPC_QDOWN, &v) == -1) {
327 dev_err(&psmouse->ps2dev.serio->dev, "Unable get OPC state.\n");
332 nv = v | FSP_BIT_EN_OPC_TAG;
334 nv = v & ~FSP_BIT_EN_OPC_TAG;
336 /* only write if necessary */
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);
344 dev_err(&psmouse->ps2dev.serio->dev,
345 "Unable to enable OPC tag.\n");
352 static int fsp_onpad_vscr(struct psmouse *psmouse, bool enable)
354 struct fsp_data *pad = psmouse->private;
357 if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
360 pad->vscroll = enable;
363 val |= (FSP_BIT_FIX_VSCR | FSP_BIT_ONPAD_ENABLE);
365 val &= ~FSP_BIT_FIX_VSCR;
367 if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
373 static int fsp_onpad_hscr(struct psmouse *psmouse, bool enable)
375 struct fsp_data *pad = psmouse->private;
378 if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
381 if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &v2))
384 pad->hscroll = enable;
387 val |= (FSP_BIT_FIX_HSCR | FSP_BIT_ONPAD_ENABLE);
388 v2 |= FSP_BIT_EN_MSID6;
390 val &= ~FSP_BIT_FIX_HSCR;
391 v2 &= ~(FSP_BIT_EN_MSID6 | FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8);
394 if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
397 /* reconfigure horizontal scrolling packet output */
398 if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, v2))
405 * Write device specific initial parameters.
407 * ex: 0xab 0xcd - write oxcd into register 0xab
409 static ssize_t fsp_attr_set_setreg(struct psmouse *psmouse, void *data,
410 const char *buf, size_t count)
412 unsigned long reg, val;
416 reg = simple_strtoul(buf, &rest, 16);
417 if (rest == buf || *rest != ' ' || reg > 0xff)
420 if (strict_strtoul(rest + 1, 16, &val) || val > 0xff)
423 if (fsp_reg_write_enable(psmouse, true))
426 retval = fsp_reg_write(psmouse, reg, val) < 0 ? -EIO : count;
428 fsp_reg_write_enable(psmouse, false);
433 PSMOUSE_DEFINE_WO_ATTR(setreg, S_IWUSR, NULL, fsp_attr_set_setreg);
435 static ssize_t fsp_attr_show_getreg(struct psmouse *psmouse,
436 void *data, char *buf)
438 struct fsp_data *pad = psmouse->private;
440 return sprintf(buf, "%02x%02x\n", pad->last_reg, pad->last_val);
444 * Read a register from device.
446 * ex: 0xab -- read content from register 0xab
448 static ssize_t fsp_attr_set_getreg(struct psmouse *psmouse, void *data,
449 const char *buf, size_t count)
451 struct fsp_data *pad = psmouse->private;
455 if (strict_strtoul(buf, 16, ®) || reg > 0xff)
458 if (fsp_reg_read(psmouse, reg, &val))
467 PSMOUSE_DEFINE_ATTR(getreg, S_IWUSR | S_IRUGO, NULL,
468 fsp_attr_show_getreg, fsp_attr_set_getreg);
470 static ssize_t fsp_attr_show_pagereg(struct psmouse *psmouse,
471 void *data, char *buf)
475 if (fsp_page_reg_read(psmouse, &val))
478 return sprintf(buf, "%02x\n", val);
481 static ssize_t fsp_attr_set_pagereg(struct psmouse *psmouse, void *data,
482 const char *buf, size_t count)
486 if (strict_strtoul(buf, 16, &val) || val > 0xff)
489 if (fsp_page_reg_write(psmouse, val))
495 PSMOUSE_DEFINE_ATTR(page, S_IWUSR | S_IRUGO, NULL,
496 fsp_attr_show_pagereg, fsp_attr_set_pagereg);
498 static ssize_t fsp_attr_show_vscroll(struct psmouse *psmouse,
499 void *data, char *buf)
501 struct fsp_data *pad = psmouse->private;
503 return sprintf(buf, "%d\n", pad->vscroll);
506 static ssize_t fsp_attr_set_vscroll(struct psmouse *psmouse, void *data,
507 const char *buf, size_t count)
511 if (strict_strtoul(buf, 10, &val) || val > 1)
514 fsp_onpad_vscr(psmouse, val);
519 PSMOUSE_DEFINE_ATTR(vscroll, S_IWUSR | S_IRUGO, NULL,
520 fsp_attr_show_vscroll, fsp_attr_set_vscroll);
522 static ssize_t fsp_attr_show_hscroll(struct psmouse *psmouse,
523 void *data, char *buf)
525 struct fsp_data *pad = psmouse->private;
527 return sprintf(buf, "%d\n", pad->hscroll);
530 static ssize_t fsp_attr_set_hscroll(struct psmouse *psmouse, void *data,
531 const char *buf, size_t count)
535 if (strict_strtoul(buf, 10, &val) || val > 1)
538 fsp_onpad_hscr(psmouse, val);
543 PSMOUSE_DEFINE_ATTR(hscroll, S_IWUSR | S_IRUGO, NULL,
544 fsp_attr_show_hscroll, fsp_attr_set_hscroll);
546 static ssize_t fsp_attr_show_flags(struct psmouse *psmouse,
547 void *data, char *buf)
549 struct fsp_data *pad = psmouse->private;
551 return sprintf(buf, "%c\n",
552 pad->flags & FSPDRV_FLAG_EN_OPC ? 'C' : 'c');
555 static ssize_t fsp_attr_set_flags(struct psmouse *psmouse, void *data,
556 const char *buf, size_t count)
558 struct fsp_data *pad = psmouse->private;
561 for (i = 0; i < count; i++) {
564 pad->flags |= FSPDRV_FLAG_EN_OPC;
567 pad->flags &= ~FSPDRV_FLAG_EN_OPC;
576 PSMOUSE_DEFINE_ATTR(flags, S_IWUSR | S_IRUGO, NULL,
577 fsp_attr_show_flags, fsp_attr_set_flags);
579 static ssize_t fsp_attr_show_ver(struct psmouse *psmouse,
580 void *data, char *buf)
582 return sprintf(buf, "Sentelic FSP kernel module %s\n", fsp_drv_ver);
585 PSMOUSE_DEFINE_RO_ATTR(ver, S_IRUGO, NULL, fsp_attr_show_ver);
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,
598 static struct attribute_group fsp_attribute_group = {
599 .attrs = fsp_attributes,
603 static void fsp_packet_debug(unsigned char packet[])
605 static unsigned int ps2_packet_cnt;
606 static unsigned int ps2_last_second;
607 unsigned int jiffies_msec;
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]);
614 if (jiffies_msec - ps2_last_second > 1000) {
615 printk(KERN_DEBUG "PS/2 packets/sec = %d\n", ps2_packet_cnt);
617 ps2_last_second = jiffies_msec;
621 static void fsp_packet_debug(unsigned char packet[])
626 static psmouse_ret_t fsp_process_byte(struct psmouse *psmouse)
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;
634 if (psmouse->pktcnt < 4)
635 return PSMOUSE_GOOD_DATA;
638 * Full packet accumulated, process it
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");
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);
653 case FSP_PKT_TYPE_NORMAL:
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;
672 * Processing wheel up/down and extra button events
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);
681 * Standard PS/2 Mouse
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);
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;
690 input_report_rel(dev, REL_X, rel_x);
691 input_report_rel(dev, REL_Y, rel_y);
697 fsp_packet_debug(packet);
699 return PSMOUSE_FULL_PACKET;
702 static int fsp_activate_protocol(struct psmouse *psmouse)
704 struct fsp_data *pad = psmouse->private;
705 struct ps2dev *ps2dev = &psmouse->ps2dev;
706 unsigned char param[2];
710 * Standard procedure to enter FSP Intellimouse mode
711 * (scrolling wheel, 4th and 5th buttons)
714 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
716 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
718 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
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");
727 if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &val)) {
728 dev_err(&psmouse->ps2dev.serio->dev,
729 "Unable to read SYSCTL5 register.\n");
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;
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");
748 * Enable OPC tags such that driver can tell the difference between
749 * on-pad and real button click
751 if (fsp_opc_tag_enable(psmouse, true))
752 dev_warn(&psmouse->ps2dev.serio->dev,
753 "Failed to enable OPC tag mode.\n");
755 /* Enable on-pad vertical and horizontal scrolling */
756 fsp_onpad_vscr(psmouse, true);
757 fsp_onpad_hscr(psmouse, true);
762 int fsp_detect(struct psmouse *psmouse, bool set_properties)
766 if (fsp_reg_read(psmouse, FSP_REG_DEVICE_ID, &id))
772 if (set_properties) {
773 psmouse->vendor = "Sentelic";
774 psmouse->name = "FingerSensingPad";
780 static void fsp_reset(struct psmouse *psmouse)
782 fsp_opc_tag_enable(psmouse, false);
783 fsp_onpad_vscr(psmouse, false);
784 fsp_onpad_hscr(psmouse, false);
787 static void fsp_disconnect(struct psmouse *psmouse)
789 sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
790 &fsp_attribute_group);
793 kfree(psmouse->private);
796 static int fsp_reconnect(struct psmouse *psmouse)
800 if (fsp_detect(psmouse, 0))
803 if (fsp_get_version(psmouse, &version))
806 if (fsp_activate_protocol(psmouse))
812 int fsp_init(struct psmouse *psmouse)
814 struct fsp_data *priv;
815 int ver, rev, buttons;
818 if (fsp_get_version(psmouse, &ver) ||
819 fsp_get_revision(psmouse, &rev) ||
820 fsp_get_buttons(psmouse, &buttons)) {
825 "Finger Sensing Pad, hw: %d.%d.%d, sw: %s, buttons: %d\n",
826 ver >> 4, ver & 0x0F, rev, fsp_drv_ver, buttons & 7);
828 psmouse->private = priv = kzalloc(sizeof(struct fsp_data), GFP_KERNEL);
834 priv->buttons = buttons;
836 /* enable on-pad click by default */
837 priv->flags |= FSPDRV_FLAG_EN_OPC;
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);
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;
852 /* set default packet output based on number of buttons we found */
853 error = fsp_activate_protocol(psmouse);
857 error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
858 &fsp_attribute_group);
860 dev_err(&psmouse->ps2dev.serio->dev,
861 "Failed to create sysfs attributes (%d)", error);
868 kfree(psmouse->private);
869 psmouse->private = NULL;