mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 19:29:37 +00:00
Input: synaptics - process finger (<=3) transitions
Synaptics image sensor touchpads track 5 fingers, but only report 2. This patch attempts to deal with some idiosyncrasies of these touchpads: * When there are 3 or more fingers, only two are reported. * The touchpad tracks the 5 fingers in slot[0] through slot[4]. * It always reports the lowest and highest valid slots in SGM and AGM packets, respectively. * The number of fingers is only reported in the SGM packet. However, the number of fingers can change either before or after an AGM packet. * Thus, if an SGM reports a different number of fingers than the last SGM, it is impossible to tell whether the intervening AGM corresponds to the old number of fingers or the new number of fingers. * For example, when going from 2->3 fingers, it is not possible to tell whether tell AGM contains slot[1] (old 2nd finger) or slot[2] (new 3rd finger). * When fingers are added one at at time, from 1->2->3, it is possible to track which slots are contained in the SGM and AGM packets: 1 finger: SGM = slot[0], no AGM 2 fingers: SGM = slot[0], AGM = slot[1] 3 fingers: SGM = slot[0], AGM = slot[2] * It is also possible to track which slot is contained in the SGM when 1 of 2 fingers is removed. This is because the touchpad sends a special (0,0,0) AGM packet whenever all fingers are removed except slot[0]: Last AGM == (0,0,0): SGM contains slot[1] Else: SGM contains slot[0] * However, once there are 3 fingers, if exactly 1 finger is removed, it is impossible to tell which 2 slots are contained in SGM and AGM. The (SGM,AGM) could be (0,1), (0,2), or (1,2). There is no way to know. * Similarly, if two fingers are simultaneously removed (3->1), then it is only possible to know if SGM still contains slot[0]. * Since it is not possible to reliably track which slot is being reported, we invalidate the tracking_id every time the number of fingers changes until this ambiguity is resolved when: a) All fingers are removed. b) 4 or 5 fingers are touched, generates an AGM-CONTACT packet. c) All fingers are removed except slot[0]. In this special case, the ambiguity is resolved since by the (0,0,0) AGM packet. Behavior of the driver: When 2 or more fingers are present on the touchpad, the kernel reports up to two MT-B slots containing the position data for two of the fingers reported by the touchpad. If the identity of a finger cannot be tracked when the number-of-fingers changes, the corresponding MT-B slot will be invalidated (track_id set to -1), and a new track_id will be assigned in a subsequent input event report. The driver always reports the total number of fingers using one of the EV_KEY/BTN_TOOL_*TAP events. This could differ from the number of valid MT-B slots for two reasons: a) There are more than 2 fingers on the pad. b) During ambiguous number-of-fingers transitions, the correct track_id for one or both of the slots cannot be determined, so the slots are invalidated. Thus, this is a hybrid singletouch/MT-B scheme. Userspace can detect this behavior by noting that the driver supports more EV_KEY/BTN_TOOL_*TAP events than its maximum EV_ABS/ABS_MT_SLOT. Signed-off-by: Daniel Kurtz <djkurtz@chromium.org> Acked-by: Chase Douglas <chase.douglas@canonical.com> Acked-by: Henrik Rydberg <rydberg@euromail.se> Signed-off-by: Dmitry Torokhov <dtor@mail.ru>
This commit is contained in:
parent
a93bd154d8
commit
4dc772d274
2 changed files with 278 additions and 16 deletions
|
@ -453,6 +453,9 @@ static void synaptics_parse_agm(const unsigned char buf[],
|
|||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
/* Record that at least one AGM has been received since last SGM */
|
||||
priv->agm_pending = true;
|
||||
}
|
||||
|
||||
static int synaptics_parse_hw_state(const unsigned char buf[],
|
||||
|
@ -606,26 +609,53 @@ static void synaptics_report_slot(struct input_dev *dev, int slot,
|
|||
}
|
||||
|
||||
static void synaptics_report_mt_data(struct psmouse *psmouse,
|
||||
int count,
|
||||
struct synaptics_mt_state *mt_state,
|
||||
const struct synaptics_hw_state *sgm)
|
||||
{
|
||||
struct input_dev *dev = psmouse->dev;
|
||||
struct synaptics_data *priv = psmouse->private;
|
||||
struct synaptics_hw_state *agm = &priv->agm;
|
||||
struct synaptics_mt_state *old = &priv->mt_state;
|
||||
|
||||
switch (count) {
|
||||
switch (mt_state->count) {
|
||||
case 0:
|
||||
synaptics_report_slot(dev, 0, NULL);
|
||||
synaptics_report_slot(dev, 1, NULL);
|
||||
break;
|
||||
case 1:
|
||||
synaptics_report_slot(dev, 0, sgm);
|
||||
synaptics_report_slot(dev, 1, NULL);
|
||||
if (mt_state->sgm == -1) {
|
||||
synaptics_report_slot(dev, 0, NULL);
|
||||
synaptics_report_slot(dev, 1, NULL);
|
||||
} else if (mt_state->sgm == 0) {
|
||||
synaptics_report_slot(dev, 0, sgm);
|
||||
synaptics_report_slot(dev, 1, NULL);
|
||||
} else {
|
||||
synaptics_report_slot(dev, 0, NULL);
|
||||
synaptics_report_slot(dev, 1, sgm);
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
case 3: /* Fall-through case */
|
||||
synaptics_report_slot(dev, 0, sgm);
|
||||
synaptics_report_slot(dev, 1, agm);
|
||||
default:
|
||||
/*
|
||||
* If the finger slot contained in SGM is valid, and either
|
||||
* hasn't changed, or is new, then report SGM in MTB slot 0.
|
||||
* Otherwise, empty MTB slot 0.
|
||||
*/
|
||||
if (mt_state->sgm != -1 &&
|
||||
(mt_state->sgm == old->sgm || old->sgm == -1))
|
||||
synaptics_report_slot(dev, 0, sgm);
|
||||
else
|
||||
synaptics_report_slot(dev, 0, NULL);
|
||||
|
||||
/*
|
||||
* If the finger slot contained in AGM is valid, and either
|
||||
* hasn't changed, or is new, then report AGM in MTB slot 1.
|
||||
* Otherwise, empty MTB slot 1.
|
||||
*/
|
||||
if (mt_state->agm != -1 &&
|
||||
(mt_state->agm == old->agm || old->agm == -1))
|
||||
synaptics_report_slot(dev, 1, agm);
|
||||
else
|
||||
synaptics_report_slot(dev, 1, NULL);
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -633,29 +663,257 @@ static void synaptics_report_mt_data(struct psmouse *psmouse,
|
|||
input_mt_report_pointer_emulation(dev, false);
|
||||
|
||||
/* Send the number of fingers reported by touchpad itself. */
|
||||
input_mt_report_finger_count(dev, count);
|
||||
input_mt_report_finger_count(dev, mt_state->count);
|
||||
|
||||
synaptics_report_buttons(psmouse, sgm);
|
||||
|
||||
input_sync(dev);
|
||||
}
|
||||
|
||||
/* Handle case where mt_state->count = 0 */
|
||||
static void synaptics_image_sensor_0f(struct synaptics_data *priv,
|
||||
struct synaptics_mt_state *mt_state)
|
||||
{
|
||||
synaptics_mt_state_set(mt_state, 0, -1, -1);
|
||||
priv->mt_state_lost = false;
|
||||
}
|
||||
|
||||
/* Handle case where mt_state->count = 1 */
|
||||
static void synaptics_image_sensor_1f(struct synaptics_data *priv,
|
||||
struct synaptics_mt_state *mt_state)
|
||||
{
|
||||
struct synaptics_hw_state *agm = &priv->agm;
|
||||
struct synaptics_mt_state *old = &priv->mt_state;
|
||||
|
||||
/*
|
||||
* If the last AGM was (0,0,0), and there is only one finger left,
|
||||
* then we absolutely know that SGM contains slot 0, and all other
|
||||
* fingers have been removed.
|
||||
*/
|
||||
if (priv->agm_pending && agm->z == 0) {
|
||||
synaptics_mt_state_set(mt_state, 1, 0, -1);
|
||||
priv->mt_state_lost = false;
|
||||
return;
|
||||
}
|
||||
|
||||
switch (old->count) {
|
||||
case 0:
|
||||
synaptics_mt_state_set(mt_state, 1, 0, -1);
|
||||
break;
|
||||
case 1:
|
||||
/*
|
||||
* If mt_state_lost, then the previous transition was 3->1,
|
||||
* and SGM now contains either slot 0 or 1, but we don't know
|
||||
* which. So, we just assume that the SGM now contains slot 1.
|
||||
*
|
||||
* If pending AGM and either:
|
||||
* (a) the previous SGM slot contains slot 0, or
|
||||
* (b) there was no SGM slot
|
||||
* then, the SGM now contains slot 1
|
||||
*
|
||||
* Case (a) happens with very rapid "drum roll" gestures, where
|
||||
* slot 0 finger is lifted and a new slot 1 finger touches
|
||||
* within one reporting interval.
|
||||
*
|
||||
* Case (b) happens if initially two or more fingers tap
|
||||
* briefly, and all but one lift before the end of the first
|
||||
* reporting interval.
|
||||
*
|
||||
* (In both these cases, slot 0 will becomes empty, so SGM
|
||||
* contains slot 1 with the new finger)
|
||||
*
|
||||
* Else, if there was no previous SGM, it now contains slot 0.
|
||||
*
|
||||
* Otherwise, SGM still contains the same slot.
|
||||
*/
|
||||
if (priv->mt_state_lost ||
|
||||
(priv->agm_pending && old->sgm <= 0))
|
||||
synaptics_mt_state_set(mt_state, 1, 1, -1);
|
||||
else if (old->sgm == -1)
|
||||
synaptics_mt_state_set(mt_state, 1, 0, -1);
|
||||
break;
|
||||
case 2:
|
||||
/*
|
||||
* If mt_state_lost, we don't know which finger SGM contains.
|
||||
*
|
||||
* So, report 1 finger, but with both slots empty.
|
||||
* We will use slot 1 on subsequent 1->1
|
||||
*/
|
||||
if (priv->mt_state_lost) {
|
||||
synaptics_mt_state_set(mt_state, 1, -1, -1);
|
||||
break;
|
||||
}
|
||||
/*
|
||||
* Since the last AGM was NOT (0,0,0), it was the finger in
|
||||
* slot 0 that has been removed.
|
||||
* So, SGM now contains previous AGM's slot, and AGM is now
|
||||
* empty.
|
||||
*/
|
||||
synaptics_mt_state_set(mt_state, 1, old->agm, -1);
|
||||
break;
|
||||
case 3:
|
||||
/*
|
||||
* Since last AGM was not (0,0,0), we don't know which finger
|
||||
* is left.
|
||||
*
|
||||
* So, report 1 finger, but with both slots empty.
|
||||
* We will use slot 1 on subsequent 1->1
|
||||
*/
|
||||
synaptics_mt_state_set(mt_state, 1, -1, -1);
|
||||
priv->mt_state_lost = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Handle case where mt_state->count = 2 */
|
||||
static void synaptics_image_sensor_2f(struct synaptics_data *priv,
|
||||
struct synaptics_mt_state *mt_state)
|
||||
{
|
||||
struct synaptics_mt_state *old = &priv->mt_state;
|
||||
|
||||
switch (old->count) {
|
||||
case 0:
|
||||
synaptics_mt_state_set(mt_state, 2, 0, 1);
|
||||
break;
|
||||
case 1:
|
||||
/*
|
||||
* If previous SGM contained slot 1 or higher, SGM now contains
|
||||
* slot 0 (the newly touching finger) and AGM contains SGM's
|
||||
* previous slot.
|
||||
*
|
||||
* Otherwise, SGM still contains slot 0 and AGM now contains
|
||||
* slot 1.
|
||||
*/
|
||||
if (old->sgm >= 1)
|
||||
synaptics_mt_state_set(mt_state, 2, 0, old->sgm);
|
||||
else
|
||||
synaptics_mt_state_set(mt_state, 2, 0, 1);
|
||||
break;
|
||||
case 2:
|
||||
/*
|
||||
* If mt_state_lost, SGM now contains either finger 1 or 2, but
|
||||
* we don't know which.
|
||||
* So, we just assume that the SGM contains slot 0 and AGM 1.
|
||||
*/
|
||||
if (priv->mt_state_lost)
|
||||
synaptics_mt_state_set(mt_state, 2, 0, 1);
|
||||
/*
|
||||
* Otherwise, use the same mt_state, since it either hasn't
|
||||
* changed, or was updated by a recently received AGM-CONTACT
|
||||
* packet.
|
||||
*/
|
||||
break;
|
||||
case 3:
|
||||
/*
|
||||
* 3->2 transitions have two unsolvable problems:
|
||||
* 1) no indication is given which finger was removed
|
||||
* 2) no way to tell if agm packet was for finger 3
|
||||
* before 3->2, or finger 2 after 3->2.
|
||||
*
|
||||
* So, report 2 fingers, but empty all slots.
|
||||
* We will guess slots [0,1] on subsequent 2->2.
|
||||
*/
|
||||
synaptics_mt_state_set(mt_state, 2, -1, -1);
|
||||
priv->mt_state_lost = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Handle case where mt_state->count = 3 */
|
||||
static void synaptics_image_sensor_3f(struct synaptics_data *priv,
|
||||
struct synaptics_mt_state *mt_state)
|
||||
{
|
||||
struct synaptics_mt_state *old = &priv->mt_state;
|
||||
|
||||
switch (old->count) {
|
||||
case 0:
|
||||
synaptics_mt_state_set(mt_state, 3, 0, 2);
|
||||
break;
|
||||
case 1:
|
||||
/*
|
||||
* If previous SGM contained slot 2 or higher, SGM now contains
|
||||
* slot 0 (one of the newly touching fingers) and AGM contains
|
||||
* SGM's previous slot.
|
||||
*
|
||||
* Otherwise, SGM now contains slot 0 and AGM contains slot 2.
|
||||
*/
|
||||
if (old->sgm >= 2)
|
||||
synaptics_mt_state_set(mt_state, 3, 0, old->sgm);
|
||||
else
|
||||
synaptics_mt_state_set(mt_state, 3, 0, 2);
|
||||
break;
|
||||
case 2:
|
||||
/*
|
||||
* After some 3->1 and all 3->2 transitions, we lose track
|
||||
* of which slot is reported by SGM and AGM.
|
||||
*
|
||||
* For 2->3 in this state, report 3 fingers, but empty all
|
||||
* slots, and we will guess (0,2) on a subsequent 0->3.
|
||||
*
|
||||
* To userspace, the resulting transition will look like:
|
||||
* 2:[0,1] -> 3:[-1,-1] -> 3:[0,2]
|
||||
*/
|
||||
if (priv->mt_state_lost) {
|
||||
synaptics_mt_state_set(mt_state, 3, -1, -1);
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* If the (SGM,AGM) really previously contained slots (0, 1),
|
||||
* then we cannot know what slot was just reported by the AGM,
|
||||
* because the 2->3 transition can occur either before or after
|
||||
* the AGM packet. Thus, this most recent AGM could contain
|
||||
* either the same old slot 1 or the new slot 2.
|
||||
* Subsequent AGMs will be reporting slot 2.
|
||||
*
|
||||
* To userspace, the resulting transition will look like:
|
||||
* 2:[0,1] -> 3:[0,-1] -> 3:[0,2]
|
||||
*/
|
||||
synaptics_mt_state_set(mt_state, 3, 0, -1);
|
||||
break;
|
||||
case 3:
|
||||
/*
|
||||
* If, for whatever reason, the previous agm was invalid,
|
||||
* Assume SGM now contains slot 0, AGM now contains slot 2.
|
||||
*/
|
||||
if (old->agm <= 2)
|
||||
synaptics_mt_state_set(mt_state, 3, 0, 2);
|
||||
/*
|
||||
* mt_state either hasn't changed, or was updated by a recently
|
||||
* received AGM-CONTACT packet.
|
||||
*/
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void synaptics_image_sensor_process(struct psmouse *psmouse,
|
||||
struct synaptics_hw_state *sgm)
|
||||
{
|
||||
int count;
|
||||
struct synaptics_data *priv = psmouse->private;
|
||||
struct synaptics_hw_state *agm = &priv->agm;
|
||||
struct synaptics_mt_state mt_state;
|
||||
|
||||
/* Initialize using current mt_state (as updated by last agm) */
|
||||
mt_state = agm->mt_state;
|
||||
|
||||
/*
|
||||
* Update mt_state using the new finger count and current mt_state.
|
||||
*/
|
||||
if (sgm->z == 0)
|
||||
count = 0;
|
||||
synaptics_image_sensor_0f(priv, &mt_state);
|
||||
else if (sgm->w >= 4)
|
||||
count = 1;
|
||||
synaptics_image_sensor_1f(priv, &mt_state);
|
||||
else if (sgm->w == 0)
|
||||
count = 2;
|
||||
else
|
||||
count = 3;
|
||||
synaptics_image_sensor_2f(priv, &mt_state);
|
||||
else if (sgm->w == 1)
|
||||
synaptics_image_sensor_3f(priv, &mt_state);
|
||||
|
||||
/* Send resulting input events to user space */
|
||||
synaptics_report_mt_data(psmouse, count, sgm);
|
||||
synaptics_report_mt_data(psmouse, &mt_state, sgm);
|
||||
|
||||
/* Store updated mt_state */
|
||||
priv->mt_state = agm->mt_state = mt_state;
|
||||
priv->agm_pending = false;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -161,11 +161,15 @@ struct synaptics_data {
|
|||
|
||||
struct serio *pt_port; /* Pass-through serio port */
|
||||
|
||||
struct synaptics_mt_state mt_state; /* Current mt finger state */
|
||||
bool mt_state_lost; /* mt_state may be incorrect */
|
||||
|
||||
/*
|
||||
* Last received Advanced Gesture Mode (AGM) packet. An AGM packet
|
||||
* contains position data for a second contact, at half resolution.
|
||||
*/
|
||||
struct synaptics_hw_state agm;
|
||||
bool agm_pending; /* new AGM packet received */
|
||||
};
|
||||
|
||||
void synaptics_module_init(void);
|
||||
|
|
Loading…
Reference in a new issue