2009-05-11 08:15:39 +07:00
|
|
|
/*-
|
|
|
|
* Finger Sensing Pad PS/2 mouse driver.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2005-2007 Asia Vital Components Co., Ltd.
|
2012-03-26 07:16:36 +07:00
|
|
|
* Copyright (C) 2005-2012 Tai-hwa Liang, Sentelic Corporation.
|
2009-05-11 08:15:39 +07:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/input.h>
|
2012-03-26 07:16:36 +07:00
|
|
|
#include <linux/input/mt.h>
|
2009-05-11 08:15:39 +07:00
|
|
|
#include <linux/ctype.h>
|
|
|
|
#include <linux/libps2.h>
|
|
|
|
#include <linux/serio.h>
|
|
|
|
#include <linux/jiffies.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2009-05-11 08:15:39 +07:00
|
|
|
|
|
|
|
#include "psmouse.h"
|
|
|
|
#include "sentelic.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Timeout for FSP PS/2 command only (in milliseconds).
|
|
|
|
*/
|
|
|
|
#define FSP_CMD_TIMEOUT 200
|
|
|
|
#define FSP_CMD_TIMEOUT2 30
|
|
|
|
|
2012-03-26 07:17:27 +07:00
|
|
|
#define GET_ABS_X(packet) ((packet[1] << 2) | ((packet[3] >> 2) & 0x03))
|
|
|
|
#define GET_ABS_Y(packet) ((packet[2] << 2) | (packet[3] & 0x03))
|
|
|
|
|
2009-05-11 08:15:39 +07:00
|
|
|
/** Driver version. */
|
2012-05-07 22:45:58 +07:00
|
|
|
static const char fsp_drv_ver[] = "1.1.0-K";
|
2009-05-11 08:15:39 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure that the value being sent to FSP will not conflict with
|
|
|
|
* possible sample rate values.
|
|
|
|
*/
|
|
|
|
static unsigned char fsp_test_swap_cmd(unsigned char reg_val)
|
|
|
|
{
|
|
|
|
switch (reg_val) {
|
|
|
|
case 10: case 20: case 40: case 60: case 80: case 100: case 200:
|
|
|
|
/*
|
|
|
|
* The requested value being sent to FSP matched to possible
|
|
|
|
* sample rates, swap the given value such that the hardware
|
|
|
|
* wouldn't get confused.
|
|
|
|
*/
|
|
|
|
return (reg_val >> 4) | (reg_val << 4);
|
|
|
|
default:
|
|
|
|
return reg_val; /* swap isn't necessary */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure that the value being sent to FSP will not conflict with certain
|
|
|
|
* commands.
|
|
|
|
*/
|
|
|
|
static unsigned char fsp_test_invert_cmd(unsigned char reg_val)
|
|
|
|
{
|
|
|
|
switch (reg_val) {
|
|
|
|
case 0xe9: case 0xee: case 0xf2: case 0xff:
|
|
|
|
/*
|
|
|
|
* The requested value being sent to FSP matched to certain
|
|
|
|
* commands, inverse the given value such that the hardware
|
|
|
|
* wouldn't get confused.
|
|
|
|
*/
|
|
|
|
return ~reg_val;
|
|
|
|
default:
|
|
|
|
return reg_val; /* inversion isn't necessary */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsp_reg_read(struct psmouse *psmouse, int reg_addr, int *reg_val)
|
|
|
|
{
|
|
|
|
struct ps2dev *ps2dev = &psmouse->ps2dev;
|
|
|
|
unsigned char param[3];
|
|
|
|
unsigned char addr;
|
|
|
|
int rc = -1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to shut off the device and switch it into command
|
|
|
|
* mode so we don't confuse our protocol handler. We don't need
|
|
|
|
* to do that for writes because sysfs set helper does this for
|
|
|
|
* us.
|
|
|
|
*/
|
2012-02-24 15:51:37 +07:00
|
|
|
psmouse_deactivate(psmouse);
|
2009-09-16 15:06:43 +07:00
|
|
|
|
|
|
|
ps2_begin_command(ps2dev);
|
2009-05-11 08:15:39 +07:00
|
|
|
|
|
|
|
if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* should return 0xfe(request for resending) */
|
|
|
|
ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
|
|
|
|
/* should return 0xfc(failed) */
|
|
|
|
ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
|
|
|
|
|
|
|
|
if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if ((addr = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
|
|
|
|
ps2_sendbyte(ps2dev, 0x68, FSP_CMD_TIMEOUT2);
|
|
|
|
} else if ((addr = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
|
|
|
|
/* swapping is required */
|
|
|
|
ps2_sendbyte(ps2dev, 0xcc, FSP_CMD_TIMEOUT2);
|
|
|
|
/* expect 0xfe */
|
|
|
|
} else {
|
|
|
|
/* swapping isn't necessary */
|
|
|
|
ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
|
|
|
|
/* expect 0xfe */
|
|
|
|
}
|
|
|
|
/* should return 0xfc(failed) */
|
|
|
|
ps2_sendbyte(ps2dev, addr, FSP_CMD_TIMEOUT);
|
|
|
|
|
|
|
|
if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO) < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
*reg_val = param[2];
|
|
|
|
rc = 0;
|
|
|
|
|
|
|
|
out:
|
2009-09-16 15:06:43 +07:00
|
|
|
ps2_end_command(ps2dev);
|
2012-02-24 15:51:37 +07:00
|
|
|
psmouse_activate(psmouse);
|
2012-03-26 07:15:03 +07:00
|
|
|
psmouse_dbg(psmouse,
|
|
|
|
"READ REG: 0x%02x is 0x%02x (rc = %d)\n",
|
|
|
|
reg_addr, *reg_val, rc);
|
2009-05-11 08:15:39 +07:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsp_reg_write(struct psmouse *psmouse, int reg_addr, int reg_val)
|
|
|
|
{
|
|
|
|
struct ps2dev *ps2dev = &psmouse->ps2dev;
|
|
|
|
unsigned char v;
|
|
|
|
int rc = -1;
|
|
|
|
|
2009-09-16 15:06:43 +07:00
|
|
|
ps2_begin_command(ps2dev);
|
2009-05-11 08:15:39 +07:00
|
|
|
|
|
|
|
if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if ((v = fsp_test_invert_cmd(reg_addr)) != reg_addr) {
|
|
|
|
/* inversion is required */
|
|
|
|
ps2_sendbyte(ps2dev, 0x74, FSP_CMD_TIMEOUT2);
|
|
|
|
} else {
|
|
|
|
if ((v = fsp_test_swap_cmd(reg_addr)) != reg_addr) {
|
|
|
|
/* swapping is required */
|
|
|
|
ps2_sendbyte(ps2dev, 0x77, FSP_CMD_TIMEOUT2);
|
|
|
|
} else {
|
|
|
|
/* swapping isn't necessary */
|
|
|
|
ps2_sendbyte(ps2dev, 0x55, FSP_CMD_TIMEOUT2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* write the register address in correct order */
|
|
|
|
ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
|
|
|
|
|
|
|
|
if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
|
2011-12-23 16:14:31 +07:00
|
|
|
goto out;
|
2009-05-11 08:15:39 +07:00
|
|
|
|
|
|
|
if ((v = fsp_test_invert_cmd(reg_val)) != reg_val) {
|
|
|
|
/* inversion is required */
|
|
|
|
ps2_sendbyte(ps2dev, 0x47, FSP_CMD_TIMEOUT2);
|
|
|
|
} else if ((v = fsp_test_swap_cmd(reg_val)) != reg_val) {
|
|
|
|
/* swapping is required */
|
|
|
|
ps2_sendbyte(ps2dev, 0x44, FSP_CMD_TIMEOUT2);
|
|
|
|
} else {
|
|
|
|
/* swapping isn't necessary */
|
|
|
|
ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* write the register value in correct order */
|
|
|
|
ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
|
|
|
|
rc = 0;
|
|
|
|
|
|
|
|
out:
|
2009-09-16 15:06:43 +07:00
|
|
|
ps2_end_command(ps2dev);
|
2012-03-26 07:15:03 +07:00
|
|
|
psmouse_dbg(psmouse,
|
|
|
|
"WRITE REG: 0x%02x to 0x%02x (rc = %d)\n",
|
|
|
|
reg_addr, reg_val, rc);
|
2009-05-11 08:15:39 +07:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Enable register clock gating for writing certain registers */
|
|
|
|
static int fsp_reg_write_enable(struct psmouse *psmouse, bool enable)
|
|
|
|
{
|
|
|
|
int v, nv;
|
|
|
|
|
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_SYSCTL1, &v) == -1)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (enable)
|
|
|
|
nv = v | FSP_BIT_EN_REG_CLK;
|
|
|
|
else
|
|
|
|
nv = v & ~FSP_BIT_EN_REG_CLK;
|
|
|
|
|
|
|
|
/* only write if necessary */
|
|
|
|
if (nv != v)
|
|
|
|
if (fsp_reg_write(psmouse, FSP_REG_SYSCTL1, nv) == -1)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsp_page_reg_read(struct psmouse *psmouse, int *reg_val)
|
|
|
|
{
|
|
|
|
struct ps2dev *ps2dev = &psmouse->ps2dev;
|
|
|
|
unsigned char param[3];
|
|
|
|
int rc = -1;
|
|
|
|
|
2012-02-24 15:51:37 +07:00
|
|
|
psmouse_deactivate(psmouse);
|
2009-09-16 15:06:43 +07:00
|
|
|
|
|
|
|
ps2_begin_command(ps2dev);
|
2009-05-11 08:15:39 +07:00
|
|
|
|
|
|
|
if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ps2_sendbyte(ps2dev, 0x66, FSP_CMD_TIMEOUT2);
|
|
|
|
ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
|
|
|
|
|
|
|
|
if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ps2_sendbyte(ps2dev, 0x83, FSP_CMD_TIMEOUT2);
|
|
|
|
ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
|
|
|
|
|
|
|
|
/* get the returned result */
|
|
|
|
if (__ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
*reg_val = param[2];
|
|
|
|
rc = 0;
|
|
|
|
|
|
|
|
out:
|
2009-09-16 15:06:43 +07:00
|
|
|
ps2_end_command(ps2dev);
|
2012-02-24 15:51:37 +07:00
|
|
|
psmouse_activate(psmouse);
|
2012-03-26 07:15:03 +07:00
|
|
|
psmouse_dbg(psmouse,
|
|
|
|
"READ PAGE REG: 0x%02x (rc = %d)\n",
|
|
|
|
*reg_val, rc);
|
2009-05-11 08:15:39 +07:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsp_page_reg_write(struct psmouse *psmouse, int reg_val)
|
|
|
|
{
|
|
|
|
struct ps2dev *ps2dev = &psmouse->ps2dev;
|
|
|
|
unsigned char v;
|
|
|
|
int rc = -1;
|
|
|
|
|
2009-09-16 15:06:43 +07:00
|
|
|
ps2_begin_command(ps2dev);
|
2009-05-11 08:15:39 +07:00
|
|
|
|
|
|
|
if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ps2_sendbyte(ps2dev, 0x38, FSP_CMD_TIMEOUT2);
|
|
|
|
ps2_sendbyte(ps2dev, 0x88, FSP_CMD_TIMEOUT2);
|
|
|
|
|
|
|
|
if (ps2_sendbyte(ps2dev, 0xf3, FSP_CMD_TIMEOUT) < 0)
|
2011-12-23 16:14:31 +07:00
|
|
|
goto out;
|
2009-05-11 08:15:39 +07:00
|
|
|
|
|
|
|
if ((v = fsp_test_invert_cmd(reg_val)) != reg_val) {
|
|
|
|
ps2_sendbyte(ps2dev, 0x47, FSP_CMD_TIMEOUT2);
|
|
|
|
} else if ((v = fsp_test_swap_cmd(reg_val)) != reg_val) {
|
|
|
|
/* swapping is required */
|
|
|
|
ps2_sendbyte(ps2dev, 0x44, FSP_CMD_TIMEOUT2);
|
|
|
|
} else {
|
|
|
|
/* swapping isn't necessary */
|
|
|
|
ps2_sendbyte(ps2dev, 0x33, FSP_CMD_TIMEOUT2);
|
|
|
|
}
|
|
|
|
|
|
|
|
ps2_sendbyte(ps2dev, v, FSP_CMD_TIMEOUT2);
|
|
|
|
rc = 0;
|
|
|
|
|
|
|
|
out:
|
2009-09-16 15:06:43 +07:00
|
|
|
ps2_end_command(ps2dev);
|
2012-03-26 07:15:03 +07:00
|
|
|
psmouse_dbg(psmouse,
|
|
|
|
"WRITE PAGE REG: to 0x%02x (rc = %d)\n",
|
|
|
|
reg_val, rc);
|
2009-05-11 08:15:39 +07:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsp_get_version(struct psmouse *psmouse, int *version)
|
|
|
|
{
|
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_VERSION, version))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsp_get_revision(struct psmouse *psmouse, int *rev)
|
|
|
|
{
|
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_REVISION, rev))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-07 22:45:58 +07:00
|
|
|
static int fsp_get_sn(struct psmouse *psmouse, int *sn)
|
|
|
|
{
|
|
|
|
int v0, v1, v2;
|
|
|
|
int rc = -EIO;
|
|
|
|
|
|
|
|
/* production number since Cx is available at: 0x0b40 ~ 0x0b42 */
|
|
|
|
if (fsp_page_reg_write(psmouse, FSP_PAGE_0B))
|
|
|
|
goto out;
|
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_SN0, &v0))
|
|
|
|
goto out;
|
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_SN1, &v1))
|
|
|
|
goto out;
|
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_SN2, &v2))
|
|
|
|
goto out;
|
|
|
|
*sn = (v0 << 16) | (v1 << 8) | v2;
|
|
|
|
rc = 0;
|
|
|
|
out:
|
|
|
|
fsp_page_reg_write(psmouse, FSP_PAGE_DEFAULT);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2009-05-11 08:15:39 +07:00
|
|
|
static int fsp_get_buttons(struct psmouse *psmouse, int *btn)
|
|
|
|
{
|
|
|
|
static const int buttons[] = {
|
|
|
|
0x16, /* Left/Middle/Right/Forward/Backward & Scroll Up/Down */
|
|
|
|
0x06, /* Left/Middle/Right & Scroll Up/Down/Right/Left */
|
|
|
|
0x04, /* Left/Middle/Right & Scroll Up/Down */
|
|
|
|
0x02, /* Left/Middle/Right */
|
|
|
|
};
|
|
|
|
int val;
|
|
|
|
|
2011-12-30 00:47:36 +07:00
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_TMOD_STATUS, &val) == -1)
|
2009-05-11 08:15:39 +07:00
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
*btn = buttons[(val & 0x30) >> 4];
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Enable on-pad command tag output */
|
|
|
|
static int fsp_opc_tag_enable(struct psmouse *psmouse, bool enable)
|
|
|
|
{
|
|
|
|
int v, nv;
|
|
|
|
int res = 0;
|
|
|
|
|
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_OPC_QDOWN, &v) == -1) {
|
2012-03-26 07:15:03 +07:00
|
|
|
psmouse_err(psmouse, "Unable get OPC state.\n");
|
2009-05-11 08:15:39 +07:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (enable)
|
|
|
|
nv = v | FSP_BIT_EN_OPC_TAG;
|
|
|
|
else
|
|
|
|
nv = v & ~FSP_BIT_EN_OPC_TAG;
|
|
|
|
|
|
|
|
/* only write if necessary */
|
|
|
|
if (nv != v) {
|
|
|
|
fsp_reg_write_enable(psmouse, true);
|
|
|
|
res = fsp_reg_write(psmouse, FSP_REG_OPC_QDOWN, nv);
|
|
|
|
fsp_reg_write_enable(psmouse, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (res != 0) {
|
2012-03-26 07:15:03 +07:00
|
|
|
psmouse_err(psmouse, "Unable to enable OPC tag.\n");
|
2009-05-11 08:15:39 +07:00
|
|
|
res = -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsp_onpad_vscr(struct psmouse *psmouse, bool enable)
|
|
|
|
{
|
|
|
|
struct fsp_data *pad = psmouse->private;
|
|
|
|
int val;
|
|
|
|
|
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
pad->vscroll = enable;
|
|
|
|
|
|
|
|
if (enable)
|
|
|
|
val |= (FSP_BIT_FIX_VSCR | FSP_BIT_ONPAD_ENABLE);
|
|
|
|
else
|
|
|
|
val &= ~FSP_BIT_FIX_VSCR;
|
|
|
|
|
|
|
|
if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsp_onpad_hscr(struct psmouse *psmouse, bool enable)
|
|
|
|
{
|
|
|
|
struct fsp_data *pad = psmouse->private;
|
|
|
|
int val, v2;
|
|
|
|
|
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_ONPAD_CTL, &val))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &v2))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
pad->hscroll = enable;
|
|
|
|
|
|
|
|
if (enable) {
|
|
|
|
val |= (FSP_BIT_FIX_HSCR | FSP_BIT_ONPAD_ENABLE);
|
|
|
|
v2 |= FSP_BIT_EN_MSID6;
|
|
|
|
} else {
|
|
|
|
val &= ~FSP_BIT_FIX_HSCR;
|
|
|
|
v2 &= ~(FSP_BIT_EN_MSID6 | FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fsp_reg_write(psmouse, FSP_REG_ONPAD_CTL, val))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
/* reconfigure horizontal scrolling packet output */
|
|
|
|
if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, v2))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write device specific initial parameters.
|
|
|
|
*
|
|
|
|
* ex: 0xab 0xcd - write oxcd into register 0xab
|
|
|
|
*/
|
|
|
|
static ssize_t fsp_attr_set_setreg(struct psmouse *psmouse, void *data,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2015-08-21 23:29:50 +07:00
|
|
|
unsigned int reg, val;
|
2009-05-11 08:15:39 +07:00
|
|
|
char *rest;
|
|
|
|
ssize_t retval;
|
|
|
|
|
|
|
|
reg = simple_strtoul(buf, &rest, 16);
|
|
|
|
if (rest == buf || *rest != ' ' || reg > 0xff)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-08-21 23:29:50 +07:00
|
|
|
retval = kstrtouint(rest + 1, 16, &val);
|
2011-11-10 01:20:14 +07:00
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
if (val > 0xff)
|
2009-05-11 08:15:39 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (fsp_reg_write_enable(psmouse, true))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
retval = fsp_reg_write(psmouse, reg, val) < 0 ? -EIO : count;
|
|
|
|
|
|
|
|
fsp_reg_write_enable(psmouse, false);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
PSMOUSE_DEFINE_WO_ATTR(setreg, S_IWUSR, NULL, fsp_attr_set_setreg);
|
|
|
|
|
|
|
|
static ssize_t fsp_attr_show_getreg(struct psmouse *psmouse,
|
|
|
|
void *data, char *buf)
|
|
|
|
{
|
|
|
|
struct fsp_data *pad = psmouse->private;
|
|
|
|
|
|
|
|
return sprintf(buf, "%02x%02x\n", pad->last_reg, pad->last_val);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read a register from device.
|
|
|
|
*
|
|
|
|
* ex: 0xab -- read content from register 0xab
|
|
|
|
*/
|
|
|
|
static ssize_t fsp_attr_set_getreg(struct psmouse *psmouse, void *data,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct fsp_data *pad = psmouse->private;
|
2015-08-21 23:29:50 +07:00
|
|
|
unsigned int reg, val;
|
|
|
|
int err;
|
2011-11-10 01:20:14 +07:00
|
|
|
|
2015-08-21 23:29:50 +07:00
|
|
|
err = kstrtouint(buf, 16, ®);
|
2011-11-10 01:20:14 +07:00
|
|
|
if (err)
|
|
|
|
return err;
|
2009-05-11 08:15:39 +07:00
|
|
|
|
2011-11-10 01:20:14 +07:00
|
|
|
if (reg > 0xff)
|
2009-05-11 08:15:39 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (fsp_reg_read(psmouse, reg, &val))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
pad->last_reg = reg;
|
|
|
|
pad->last_val = val;
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
PSMOUSE_DEFINE_ATTR(getreg, S_IWUSR | S_IRUGO, NULL,
|
|
|
|
fsp_attr_show_getreg, fsp_attr_set_getreg);
|
|
|
|
|
|
|
|
static ssize_t fsp_attr_show_pagereg(struct psmouse *psmouse,
|
|
|
|
void *data, char *buf)
|
|
|
|
{
|
|
|
|
int val = 0;
|
|
|
|
|
|
|
|
if (fsp_page_reg_read(psmouse, &val))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return sprintf(buf, "%02x\n", val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t fsp_attr_set_pagereg(struct psmouse *psmouse, void *data,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2015-08-21 23:29:50 +07:00
|
|
|
unsigned int val;
|
|
|
|
int err;
|
2009-05-11 08:15:39 +07:00
|
|
|
|
2015-08-21 23:29:50 +07:00
|
|
|
err = kstrtouint(buf, 16, &val);
|
2011-11-10 01:20:14 +07:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (val > 0xff)
|
2009-05-11 08:15:39 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (fsp_page_reg_write(psmouse, val))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
PSMOUSE_DEFINE_ATTR(page, S_IWUSR | S_IRUGO, NULL,
|
|
|
|
fsp_attr_show_pagereg, fsp_attr_set_pagereg);
|
|
|
|
|
|
|
|
static ssize_t fsp_attr_show_vscroll(struct psmouse *psmouse,
|
|
|
|
void *data, char *buf)
|
|
|
|
{
|
|
|
|
struct fsp_data *pad = psmouse->private;
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", pad->vscroll);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t fsp_attr_set_vscroll(struct psmouse *psmouse, void *data,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2011-11-10 01:20:14 +07:00
|
|
|
unsigned int val;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = kstrtouint(buf, 10, &val);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2009-05-11 08:15:39 +07:00
|
|
|
|
2011-11-10 01:20:14 +07:00
|
|
|
if (val > 1)
|
2009-05-11 08:15:39 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
fsp_onpad_vscr(psmouse, val);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
PSMOUSE_DEFINE_ATTR(vscroll, S_IWUSR | S_IRUGO, NULL,
|
|
|
|
fsp_attr_show_vscroll, fsp_attr_set_vscroll);
|
|
|
|
|
|
|
|
static ssize_t fsp_attr_show_hscroll(struct psmouse *psmouse,
|
|
|
|
void *data, char *buf)
|
|
|
|
{
|
|
|
|
struct fsp_data *pad = psmouse->private;
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", pad->hscroll);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t fsp_attr_set_hscroll(struct psmouse *psmouse, void *data,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2011-11-10 01:20:14 +07:00
|
|
|
unsigned int val;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = kstrtouint(buf, 10, &val);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2009-05-11 08:15:39 +07:00
|
|
|
|
2011-11-10 01:20:14 +07:00
|
|
|
if (val > 1)
|
2009-05-11 08:15:39 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
fsp_onpad_hscr(psmouse, val);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
PSMOUSE_DEFINE_ATTR(hscroll, S_IWUSR | S_IRUGO, NULL,
|
|
|
|
fsp_attr_show_hscroll, fsp_attr_set_hscroll);
|
|
|
|
|
|
|
|
static ssize_t fsp_attr_show_flags(struct psmouse *psmouse,
|
|
|
|
void *data, char *buf)
|
|
|
|
{
|
|
|
|
struct fsp_data *pad = psmouse->private;
|
|
|
|
|
|
|
|
return sprintf(buf, "%c\n",
|
|
|
|
pad->flags & FSPDRV_FLAG_EN_OPC ? 'C' : 'c');
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t fsp_attr_set_flags(struct psmouse *psmouse, void *data,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct fsp_data *pad = psmouse->private;
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
switch (buf[i]) {
|
|
|
|
case 'C':
|
|
|
|
pad->flags |= FSPDRV_FLAG_EN_OPC;
|
|
|
|
break;
|
|
|
|
case 'c':
|
|
|
|
pad->flags &= ~FSPDRV_FLAG_EN_OPC;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
PSMOUSE_DEFINE_ATTR(flags, S_IWUSR | S_IRUGO, NULL,
|
|
|
|
fsp_attr_show_flags, fsp_attr_set_flags);
|
|
|
|
|
|
|
|
static ssize_t fsp_attr_show_ver(struct psmouse *psmouse,
|
|
|
|
void *data, char *buf)
|
|
|
|
{
|
|
|
|
return sprintf(buf, "Sentelic FSP kernel module %s\n", fsp_drv_ver);
|
|
|
|
}
|
|
|
|
|
|
|
|
PSMOUSE_DEFINE_RO_ATTR(ver, S_IRUGO, NULL, fsp_attr_show_ver);
|
|
|
|
|
|
|
|
static struct attribute *fsp_attributes[] = {
|
|
|
|
&psmouse_attr_setreg.dattr.attr,
|
|
|
|
&psmouse_attr_getreg.dattr.attr,
|
|
|
|
&psmouse_attr_page.dattr.attr,
|
|
|
|
&psmouse_attr_vscroll.dattr.attr,
|
|
|
|
&psmouse_attr_hscroll.dattr.attr,
|
|
|
|
&psmouse_attr_flags.dattr.attr,
|
|
|
|
&psmouse_attr_ver.dattr.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group fsp_attribute_group = {
|
|
|
|
.attrs = fsp_attributes,
|
|
|
|
};
|
|
|
|
|
2012-03-26 07:17:27 +07:00
|
|
|
#ifdef FSP_DEBUG
|
|
|
|
static void fsp_packet_debug(struct psmouse *psmouse, unsigned char packet[])
|
2009-05-11 08:15:39 +07:00
|
|
|
{
|
|
|
|
static unsigned int ps2_packet_cnt;
|
|
|
|
static unsigned int ps2_last_second;
|
|
|
|
unsigned int jiffies_msec;
|
2012-03-26 07:17:27 +07:00
|
|
|
const char *packet_type = "UNKNOWN";
|
|
|
|
unsigned short abs_x = 0, abs_y = 0;
|
|
|
|
|
|
|
|
/* Interpret & dump the packet data. */
|
|
|
|
switch (packet[0] >> FSP_PKT_TYPE_SHIFT) {
|
|
|
|
case FSP_PKT_TYPE_ABS:
|
|
|
|
packet_type = "Absolute";
|
|
|
|
abs_x = GET_ABS_X(packet);
|
|
|
|
abs_y = GET_ABS_Y(packet);
|
|
|
|
break;
|
|
|
|
case FSP_PKT_TYPE_NORMAL:
|
|
|
|
packet_type = "Normal";
|
|
|
|
break;
|
|
|
|
case FSP_PKT_TYPE_NOTIFY:
|
|
|
|
packet_type = "Notify";
|
|
|
|
break;
|
|
|
|
case FSP_PKT_TYPE_NORMAL_OPC:
|
|
|
|
packet_type = "Normal-OPC";
|
|
|
|
break;
|
|
|
|
}
|
2009-05-11 08:15:39 +07:00
|
|
|
|
|
|
|
ps2_packet_cnt++;
|
|
|
|
jiffies_msec = jiffies_to_msecs(jiffies);
|
2011-10-11 08:27:03 +07:00
|
|
|
psmouse_dbg(psmouse,
|
2012-03-26 07:17:27 +07:00
|
|
|
"%08dms %s packets: %02x, %02x, %02x, %02x; "
|
|
|
|
"abs_x: %d, abs_y: %d\n",
|
|
|
|
jiffies_msec, packet_type,
|
|
|
|
packet[0], packet[1], packet[2], packet[3], abs_x, abs_y);
|
2009-05-11 08:15:39 +07:00
|
|
|
|
|
|
|
if (jiffies_msec - ps2_last_second > 1000) {
|
2011-10-11 08:27:03 +07:00
|
|
|
psmouse_dbg(psmouse, "PS/2 packets/sec = %d\n", ps2_packet_cnt);
|
2009-05-11 08:15:39 +07:00
|
|
|
ps2_packet_cnt = 0;
|
|
|
|
ps2_last_second = jiffies_msec;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
2012-03-26 07:17:27 +07:00
|
|
|
static void fsp_packet_debug(struct psmouse *psmouse, unsigned char packet[])
|
2009-05-11 08:15:39 +07:00
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-03-26 07:16:36 +07:00
|
|
|
static void fsp_set_slot(struct input_dev *dev, int slot, bool active,
|
|
|
|
unsigned int x, unsigned int y)
|
|
|
|
{
|
|
|
|
input_mt_slot(dev, slot);
|
|
|
|
input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
|
|
|
|
if (active) {
|
|
|
|
input_report_abs(dev, ABS_MT_POSITION_X, x);
|
|
|
|
input_report_abs(dev, ABS_MT_POSITION_Y, y);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-11 08:15:39 +07:00
|
|
|
static psmouse_ret_t fsp_process_byte(struct psmouse *psmouse)
|
|
|
|
{
|
|
|
|
struct input_dev *dev = psmouse->dev;
|
|
|
|
struct fsp_data *ad = psmouse->private;
|
|
|
|
unsigned char *packet = psmouse->packet;
|
|
|
|
unsigned char button_status = 0, lscroll = 0, rscroll = 0;
|
2012-03-26 07:16:36 +07:00
|
|
|
unsigned short abs_x, abs_y, fgrs = 0;
|
2009-05-11 08:15:39 +07:00
|
|
|
int rel_x, rel_y;
|
|
|
|
|
|
|
|
if (psmouse->pktcnt < 4)
|
|
|
|
return PSMOUSE_GOOD_DATA;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Full packet accumulated, process it
|
|
|
|
*/
|
|
|
|
|
2012-03-26 07:17:27 +07:00
|
|
|
fsp_packet_debug(psmouse, packet);
|
|
|
|
|
2009-05-11 08:15:39 +07:00
|
|
|
switch (psmouse->packet[0] >> FSP_PKT_TYPE_SHIFT) {
|
|
|
|
case FSP_PKT_TYPE_ABS:
|
2012-09-20 01:10:47 +07:00
|
|
|
|
|
|
|
if ((packet[0] == 0x48 || packet[0] == 0x49) &&
|
|
|
|
packet[1] == 0 && packet[2] == 0) {
|
|
|
|
/*
|
|
|
|
* Ignore coordinate noise when finger leaving the
|
|
|
|
* surface, otherwise cursor may jump to upper-left
|
|
|
|
* corner.
|
|
|
|
*/
|
|
|
|
packet[3] &= 0xf0;
|
|
|
|
}
|
|
|
|
|
2012-03-26 07:17:27 +07:00
|
|
|
abs_x = GET_ABS_X(packet);
|
|
|
|
abs_y = GET_ABS_Y(packet);
|
2012-03-26 07:16:36 +07:00
|
|
|
|
|
|
|
if (packet[0] & FSP_PB0_MFMC) {
|
|
|
|
/*
|
|
|
|
* MFMC packet: assume that there are two fingers on
|
|
|
|
* pad
|
|
|
|
*/
|
|
|
|
fgrs = 2;
|
|
|
|
|
|
|
|
/* MFMC packet */
|
|
|
|
if (packet[0] & FSP_PB0_MFMC_FGR2) {
|
|
|
|
/* 2nd finger */
|
|
|
|
if (ad->last_mt_fgr == 2) {
|
|
|
|
/*
|
|
|
|
* workaround for buggy firmware
|
|
|
|
* which doesn't clear MFMC bit if
|
|
|
|
* the 1st finger is up
|
|
|
|
*/
|
|
|
|
fgrs = 1;
|
|
|
|
fsp_set_slot(dev, 0, false, 0, 0);
|
|
|
|
}
|
|
|
|
ad->last_mt_fgr = 2;
|
|
|
|
|
|
|
|
fsp_set_slot(dev, 1, fgrs == 2, abs_x, abs_y);
|
|
|
|
} else {
|
|
|
|
/* 1st finger */
|
|
|
|
if (ad->last_mt_fgr == 1) {
|
|
|
|
/*
|
|
|
|
* workaround for buggy firmware
|
|
|
|
* which doesn't clear MFMC bit if
|
|
|
|
* the 2nd finger is up
|
|
|
|
*/
|
|
|
|
fgrs = 1;
|
|
|
|
fsp_set_slot(dev, 1, false, 0, 0);
|
|
|
|
}
|
|
|
|
ad->last_mt_fgr = 1;
|
|
|
|
fsp_set_slot(dev, 0, fgrs != 0, abs_x, abs_y);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* SFAC packet */
|
2012-04-03 23:46:32 +07:00
|
|
|
if ((packet[0] & (FSP_PB0_LBTN|FSP_PB0_PHY_BTN)) ==
|
|
|
|
FSP_PB0_LBTN) {
|
|
|
|
/* On-pad click in SFAC mode should be handled
|
|
|
|
* by userspace. On-pad clicks in MFMC mode
|
|
|
|
* are real clickpad clicks, and not ignored.
|
|
|
|
*/
|
|
|
|
packet[0] &= ~FSP_PB0_LBTN;
|
|
|
|
}
|
2012-03-26 07:16:36 +07:00
|
|
|
|
|
|
|
/* no multi-finger information */
|
|
|
|
ad->last_mt_fgr = 0;
|
|
|
|
|
|
|
|
if (abs_x != 0 && abs_y != 0)
|
|
|
|
fgrs = 1;
|
|
|
|
|
|
|
|
fsp_set_slot(dev, 0, fgrs > 0, abs_x, abs_y);
|
|
|
|
fsp_set_slot(dev, 1, false, 0, 0);
|
|
|
|
}
|
2012-12-25 00:20:40 +07:00
|
|
|
if (fgrs == 1 || (fgrs == 2 && !(packet[0] & FSP_PB0_MFMC_FGR2))) {
|
2012-03-26 07:16:36 +07:00
|
|
|
input_report_abs(dev, ABS_X, abs_x);
|
|
|
|
input_report_abs(dev, ABS_Y, abs_y);
|
|
|
|
}
|
|
|
|
input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
|
|
|
|
input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
|
|
|
|
input_report_key(dev, BTN_TOUCH, fgrs);
|
|
|
|
input_report_key(dev, BTN_TOOL_FINGER, fgrs == 1);
|
|
|
|
input_report_key(dev, BTN_TOOL_DOUBLETAP, fgrs == 2);
|
2009-05-11 08:15:39 +07:00
|
|
|
break;
|
|
|
|
|
|
|
|
case FSP_PKT_TYPE_NORMAL_OPC:
|
|
|
|
/* on-pad click, filter it if necessary */
|
|
|
|
if ((ad->flags & FSPDRV_FLAG_EN_OPC) != FSPDRV_FLAG_EN_OPC)
|
2012-03-26 07:17:00 +07:00
|
|
|
packet[0] &= ~FSP_PB0_LBTN;
|
2009-05-11 08:15:39 +07:00
|
|
|
/* fall through */
|
|
|
|
|
|
|
|
case FSP_PKT_TYPE_NORMAL:
|
|
|
|
/* normal packet */
|
|
|
|
/* special packet data translation from on-pad packets */
|
|
|
|
if (packet[3] != 0) {
|
|
|
|
if (packet[3] & BIT(0))
|
|
|
|
button_status |= 0x01; /* wheel down */
|
|
|
|
if (packet[3] & BIT(1))
|
|
|
|
button_status |= 0x0f; /* wheel up */
|
|
|
|
if (packet[3] & BIT(2))
|
2010-01-13 15:25:35 +07:00
|
|
|
button_status |= BIT(4);/* horizontal left */
|
2009-05-11 08:15:39 +07:00
|
|
|
if (packet[3] & BIT(3))
|
2010-01-13 15:25:35 +07:00
|
|
|
button_status |= BIT(5);/* horizontal right */
|
2009-05-11 08:15:39 +07:00
|
|
|
/* push back to packet queue */
|
|
|
|
if (button_status != 0)
|
|
|
|
packet[3] = button_status;
|
|
|
|
rscroll = (packet[3] >> 4) & 1;
|
|
|
|
lscroll = (packet[3] >> 5) & 1;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Processing wheel up/down and extra button events
|
|
|
|
*/
|
|
|
|
input_report_rel(dev, REL_WHEEL,
|
|
|
|
(int)(packet[3] & 8) - (int)(packet[3] & 7));
|
|
|
|
input_report_rel(dev, REL_HWHEEL, lscroll - rscroll);
|
|
|
|
input_report_key(dev, BTN_BACK, lscroll);
|
|
|
|
input_report_key(dev, BTN_FORWARD, rscroll);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Standard PS/2 Mouse
|
|
|
|
*/
|
|
|
|
input_report_key(dev, BTN_LEFT, packet[0] & 1);
|
|
|
|
input_report_key(dev, BTN_MIDDLE, (packet[0] >> 2) & 1);
|
|
|
|
input_report_key(dev, BTN_RIGHT, (packet[0] >> 1) & 1);
|
|
|
|
|
|
|
|
rel_x = packet[1] ? (int)packet[1] - (int)((packet[0] << 4) & 0x100) : 0;
|
|
|
|
rel_y = packet[2] ? (int)((packet[0] << 3) & 0x100) - (int)packet[2] : 0;
|
|
|
|
|
|
|
|
input_report_rel(dev, REL_X, rel_x);
|
|
|
|
input_report_rel(dev, REL_Y, rel_y);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
input_sync(dev);
|
|
|
|
|
|
|
|
return PSMOUSE_FULL_PACKET;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsp_activate_protocol(struct psmouse *psmouse)
|
|
|
|
{
|
|
|
|
struct fsp_data *pad = psmouse->private;
|
|
|
|
struct ps2dev *ps2dev = &psmouse->ps2dev;
|
|
|
|
unsigned char param[2];
|
|
|
|
int val;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Standard procedure to enter FSP Intellimouse mode
|
|
|
|
* (scrolling wheel, 4th and 5th buttons)
|
|
|
|
*/
|
|
|
|
param[0] = 200;
|
|
|
|
ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
|
|
|
|
param[0] = 200;
|
|
|
|
ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
|
|
|
|
param[0] = 80;
|
|
|
|
ps2_command(ps2dev, param, PSMOUSE_CMD_SETRATE);
|
|
|
|
|
|
|
|
ps2_command(ps2dev, param, PSMOUSE_CMD_GETID);
|
|
|
|
if (param[0] != 0x04) {
|
2012-03-26 07:15:03 +07:00
|
|
|
psmouse_err(psmouse,
|
|
|
|
"Unable to enable 4 bytes packet format.\n");
|
2009-05-11 08:15:39 +07:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2012-03-26 07:15:03 +07:00
|
|
|
if (pad->ver < FSP_VER_STL3888_C0) {
|
|
|
|
/* Preparing relative coordinates output for older hardware */
|
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_SYSCTL5, &val)) {
|
|
|
|
psmouse_err(psmouse,
|
|
|
|
"Unable to read SYSCTL5 register.\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
2009-05-11 08:15:39 +07:00
|
|
|
|
2012-03-26 07:15:03 +07:00
|
|
|
if (fsp_get_buttons(psmouse, &pad->buttons)) {
|
|
|
|
psmouse_err(psmouse,
|
|
|
|
"Unable to retrieve number of buttons.\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
2009-05-11 08:15:39 +07:00
|
|
|
|
2012-03-26 07:15:03 +07:00
|
|
|
val &= ~(FSP_BIT_EN_MSID7 | FSP_BIT_EN_MSID8 | FSP_BIT_EN_AUTO_MSID8);
|
|
|
|
/* Ensure we are not in absolute mode */
|
|
|
|
val &= ~FSP_BIT_EN_PKT_G0;
|
|
|
|
if (pad->buttons == 0x06) {
|
|
|
|
/* Left/Middle/Right & Scroll Up/Down/Right/Left */
|
|
|
|
val |= FSP_BIT_EN_MSID6;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fsp_reg_write(psmouse, FSP_REG_SYSCTL5, val)) {
|
|
|
|
psmouse_err(psmouse,
|
|
|
|
"Unable to set up required mode bits.\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Enable OPC tags such that driver can tell the difference
|
|
|
|
* between on-pad and real button click
|
|
|
|
*/
|
|
|
|
if (fsp_opc_tag_enable(psmouse, true))
|
|
|
|
psmouse_warn(psmouse,
|
|
|
|
"Failed to enable OPC tag mode.\n");
|
|
|
|
/* enable on-pad click by default */
|
|
|
|
pad->flags |= FSPDRV_FLAG_EN_OPC;
|
|
|
|
|
|
|
|
/* Enable on-pad vertical and horizontal scrolling */
|
|
|
|
fsp_onpad_vscr(psmouse, true);
|
|
|
|
fsp_onpad_hscr(psmouse, true);
|
2012-03-26 07:16:36 +07:00
|
|
|
} else {
|
|
|
|
/* Enable absolute coordinates output for Cx/Dx hardware */
|
|
|
|
if (fsp_reg_write(psmouse, FSP_REG_SWC1,
|
|
|
|
FSP_BIT_SWC1_EN_ABS_1F |
|
|
|
|
FSP_BIT_SWC1_EN_ABS_2F |
|
|
|
|
FSP_BIT_SWC1_EN_FUP_OUT |
|
|
|
|
FSP_BIT_SWC1_EN_ABS_CON)) {
|
|
|
|
psmouse_err(psmouse,
|
|
|
|
"Unable to enable absolute coordinates output.\n");
|
|
|
|
return -EIO;
|
|
|
|
}
|
2009-05-11 08:15:39 +07:00
|
|
|
}
|
|
|
|
|
2012-03-26 07:15:03 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsp_set_input_params(struct psmouse *psmouse)
|
|
|
|
{
|
|
|
|
struct input_dev *dev = psmouse->dev;
|
|
|
|
struct fsp_data *pad = psmouse->private;
|
2009-05-11 08:15:39 +07:00
|
|
|
|
2012-03-26 07:15:03 +07:00
|
|
|
if (pad->ver < FSP_VER_STL3888_C0) {
|
|
|
|
__set_bit(BTN_MIDDLE, dev->keybit);
|
|
|
|
__set_bit(BTN_BACK, dev->keybit);
|
|
|
|
__set_bit(BTN_FORWARD, dev->keybit);
|
|
|
|
__set_bit(REL_WHEEL, dev->relbit);
|
|
|
|
__set_bit(REL_HWHEEL, dev->relbit);
|
2012-03-26 07:16:36 +07:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Hardware prior to Cx performs much better in relative mode;
|
|
|
|
* hence, only enable absolute coordinates output as well as
|
|
|
|
* multi-touch output for the newer hardware.
|
|
|
|
*
|
|
|
|
* Maximum coordinates can be computed as:
|
|
|
|
*
|
|
|
|
* number of scanlines * 64 - 57
|
|
|
|
*
|
|
|
|
* where number of X/Y scanline lines are 16/12.
|
|
|
|
*/
|
|
|
|
int abs_x = 967, abs_y = 711;
|
|
|
|
|
|
|
|
__set_bit(EV_ABS, dev->evbit);
|
|
|
|
__clear_bit(EV_REL, dev->evbit);
|
|
|
|
__set_bit(BTN_TOUCH, dev->keybit);
|
|
|
|
__set_bit(BTN_TOOL_FINGER, dev->keybit);
|
|
|
|
__set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
|
|
|
|
__set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
|
|
|
|
|
|
|
|
input_set_abs_params(dev, ABS_X, 0, abs_x, 0, 0);
|
|
|
|
input_set_abs_params(dev, ABS_Y, 0, abs_y, 0, 0);
|
2012-08-12 03:07:55 +07:00
|
|
|
input_mt_init_slots(dev, 2, 0);
|
2012-03-26 07:16:36 +07:00
|
|
|
input_set_abs_params(dev, ABS_MT_POSITION_X, 0, abs_x, 0, 0);
|
|
|
|
input_set_abs_params(dev, ABS_MT_POSITION_Y, 0, abs_y, 0, 0);
|
2012-03-26 07:15:03 +07:00
|
|
|
}
|
2009-05-11 08:15:39 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-10 09:13:20 +07:00
|
|
|
int fsp_detect(struct psmouse *psmouse, bool set_properties)
|
2009-05-11 08:15:39 +07:00
|
|
|
{
|
|
|
|
int id;
|
|
|
|
|
|
|
|
if (fsp_reg_read(psmouse, FSP_REG_DEVICE_ID, &id))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
if (id != 0x01)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (set_properties) {
|
|
|
|
psmouse->vendor = "Sentelic";
|
|
|
|
psmouse->name = "FingerSensingPad";
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void fsp_reset(struct psmouse *psmouse)
|
|
|
|
{
|
|
|
|
fsp_opc_tag_enable(psmouse, false);
|
|
|
|
fsp_onpad_vscr(psmouse, false);
|
|
|
|
fsp_onpad_hscr(psmouse, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void fsp_disconnect(struct psmouse *psmouse)
|
|
|
|
{
|
|
|
|
sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
|
|
|
|
&fsp_attribute_group);
|
|
|
|
|
|
|
|
fsp_reset(psmouse);
|
|
|
|
kfree(psmouse->private);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsp_reconnect(struct psmouse *psmouse)
|
|
|
|
{
|
|
|
|
int version;
|
|
|
|
|
|
|
|
if (fsp_detect(psmouse, 0))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (fsp_get_version(psmouse, &version))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (fsp_activate_protocol(psmouse))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int fsp_init(struct psmouse *psmouse)
|
|
|
|
{
|
|
|
|
struct fsp_data *priv;
|
2012-05-07 22:45:58 +07:00
|
|
|
int ver, rev, sn = 0;
|
2009-05-11 08:15:39 +07:00
|
|
|
int error;
|
|
|
|
|
|
|
|
if (fsp_get_version(psmouse, &ver) ||
|
2012-03-26 07:15:03 +07:00
|
|
|
fsp_get_revision(psmouse, &rev)) {
|
2009-05-11 08:15:39 +07:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
2012-05-07 22:45:58 +07:00
|
|
|
if (ver >= FSP_VER_STL3888_C0) {
|
|
|
|
/* firmware information is only available since C0 */
|
|
|
|
fsp_get_sn(psmouse, &sn);
|
|
|
|
}
|
2009-05-11 08:15:39 +07:00
|
|
|
|
2012-05-07 22:45:58 +07:00
|
|
|
psmouse_info(psmouse,
|
|
|
|
"Finger Sensing Pad, hw: %d.%d.%d, sn: %x, sw: %s\n",
|
|
|
|
ver >> 4, ver & 0x0F, rev, sn, fsp_drv_ver);
|
2009-05-11 08:15:39 +07:00
|
|
|
|
|
|
|
psmouse->private = priv = kzalloc(sizeof(struct fsp_data), GFP_KERNEL);
|
|
|
|
if (!priv)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
priv->ver = ver;
|
|
|
|
priv->rev = rev;
|
|
|
|
|
|
|
|
psmouse->protocol_handler = fsp_process_byte;
|
|
|
|
psmouse->disconnect = fsp_disconnect;
|
|
|
|
psmouse->reconnect = fsp_reconnect;
|
|
|
|
psmouse->cleanup = fsp_reset;
|
|
|
|
psmouse->pktsize = 4;
|
|
|
|
|
|
|
|
error = fsp_activate_protocol(psmouse);
|
|
|
|
if (error)
|
|
|
|
goto err_out;
|
|
|
|
|
2012-03-26 07:15:03 +07:00
|
|
|
/* Set up various supported input event bits */
|
|
|
|
error = fsp_set_input_params(psmouse);
|
|
|
|
if (error)
|
|
|
|
goto err_out;
|
|
|
|
|
2009-05-11 08:15:39 +07:00
|
|
|
error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
|
|
|
|
&fsp_attribute_group);
|
|
|
|
if (error) {
|
2012-03-26 07:15:03 +07:00
|
|
|
psmouse_err(psmouse,
|
|
|
|
"Failed to create sysfs attributes (%d)", error);
|
2009-05-11 08:15:39 +07:00
|
|
|
goto err_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_out:
|
|
|
|
kfree(psmouse->private);
|
|
|
|
psmouse->private = NULL;
|
|
|
|
return error;
|
|
|
|
}
|