Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 01ce661f authored by Seth Forshee's avatar Seth Forshee Committed by Dmitry Torokhov
Browse files

Input: ALPS - add semi-MT support for v3 protocol

parent 25bded7c
Loading
Loading
Loading
Loading
+214 −19
Original line number Original line Diff line number Diff line
@@ -17,6 +17,7 @@


#include <linux/slab.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/serio.h>
#include <linux/serio.h>
#include <linux/libps2.h>
#include <linux/libps2.h>


@@ -26,6 +27,12 @@
/*
/*
 * Definitions for ALPS version 3 and 4 command mode protocol
 * Definitions for ALPS version 3 and 4 command mode protocol
 */
 */
#define ALPS_V3_X_MAX	2000
#define ALPS_V3_Y_MAX	1400

#define ALPS_BITMAP_X_BITS	15
#define ALPS_BITMAP_Y_BITS	11

#define ALPS_CMD_NIBBLE_10	0x01f2
#define ALPS_CMD_NIBBLE_10	0x01f2


static const struct alps_nibble_commands alps_v3_nibble_commands[] = {
static const struct alps_nibble_commands alps_v3_nibble_commands[] = {
@@ -250,6 +257,137 @@ static void alps_process_packet_v1_v2(struct psmouse *psmouse)
	input_sync(dev);
	input_sync(dev);
}
}


/*
 * Process bitmap data from v3 and v4 protocols. Returns the number of
 * fingers detected. A return value of 0 means at least one of the
 * bitmaps was empty.
 *
 * The bitmaps don't have enough data to track fingers, so this function
 * only generates points representing a bounding box of all contacts.
 * These points are returned in x1, y1, x2, and y2 when the return value
 * is greater than 0.
 */
static int alps_process_bitmap(unsigned int x_map, unsigned int y_map,
			       int *x1, int *y1, int *x2, int *y2)
{
	struct alps_bitmap_point {
		int start_bit;
		int num_bits;
	};

	int fingers_x = 0, fingers_y = 0, fingers;
	int i, bit, prev_bit;
	struct alps_bitmap_point x_low = {0,}, x_high = {0,};
	struct alps_bitmap_point y_low = {0,}, y_high = {0,};
	struct alps_bitmap_point *point;

	if (!x_map || !y_map)
		return 0;

	*x1 = *y1 = *x2 = *y2 = 0;

	prev_bit = 0;
	point = &x_low;
	for (i = 0; x_map != 0; i++, x_map >>= 1) {
		bit = x_map & 1;
		if (bit) {
			if (!prev_bit) {
				point->start_bit = i;
				fingers_x++;
			}
			point->num_bits++;
		} else {
			if (prev_bit)
				point = &x_high;
			else
				point->num_bits = 0;
		}
		prev_bit = bit;
	}

	/*
	 * y bitmap is reversed for what we need (lower positions are in
	 * higher bits), so we process from the top end.
	 */
	y_map = y_map << (sizeof(y_map) * BITS_PER_BYTE - ALPS_BITMAP_Y_BITS);
	prev_bit = 0;
	point = &y_low;
	for (i = 0; y_map != 0; i++, y_map <<= 1) {
		bit = y_map & (1 << (sizeof(y_map) * BITS_PER_BYTE - 1));
		if (bit) {
			if (!prev_bit) {
				point->start_bit = i;
				fingers_y++;
			}
			point->num_bits++;
		} else {
			if (prev_bit)
				point = &y_high;
			else
				point->num_bits = 0;
		}
		prev_bit = bit;
	}

	/*
	 * Fingers can overlap, so we use the maximum count of fingers
	 * on either axis as the finger count.
	 */
	fingers = max(fingers_x, fingers_y);

	/*
	 * If total fingers is > 1 but either axis reports only a single
	 * contact, we have overlapping or adjacent fingers. For the
	 * purposes of creating a bounding box, divide the single contact
	 * (roughly) equally between the two points.
	 */
	if (fingers > 1) {
		if (fingers_x == 1) {
			i = x_low.num_bits / 2;
			x_low.num_bits = x_low.num_bits - i;
			x_high.start_bit = x_low.start_bit + i;
			x_high.num_bits = max(i, 1);
		} else if (fingers_y == 1) {
			i = y_low.num_bits / 2;
			y_low.num_bits = y_low.num_bits - i;
			y_high.start_bit = y_low.start_bit + i;
			y_high.num_bits = max(i, 1);
		}
	}

	*x1 = (ALPS_V3_X_MAX * (2 * x_low.start_bit + x_low.num_bits - 1)) /
	      (2 * (ALPS_BITMAP_X_BITS - 1));
	*y1 = (ALPS_V3_Y_MAX * (2 * y_low.start_bit + y_low.num_bits - 1)) /
	      (2 * (ALPS_BITMAP_Y_BITS - 1));

	if (fingers > 1) {
		*x2 = (ALPS_V3_X_MAX * (2 * x_high.start_bit + x_high.num_bits - 1)) /
		      (2 * (ALPS_BITMAP_X_BITS - 1));
		*y2 = (ALPS_V3_Y_MAX * (2 * y_high.start_bit + y_high.num_bits - 1)) /
		      (2 * (ALPS_BITMAP_Y_BITS - 1));
	}

	return fingers;
}

static void alps_set_slot(struct input_dev *dev, int slot, bool active,
			  int x, 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);
	}
}

static void alps_report_semi_mt_data(struct input_dev *dev, int num_fingers,
				     int x1, int y1, int x2, int y2)
{
	alps_set_slot(dev, 0, num_fingers != 0, x1, y1);
	alps_set_slot(dev, 1, num_fingers == 2, x2, y2);
}

static void alps_process_trackstick_packet_v3(struct psmouse *psmouse)
static void alps_process_trackstick_packet_v3(struct psmouse *psmouse)
{
{
	struct alps_data *priv = psmouse->private;
	struct alps_data *priv = psmouse->private;
@@ -318,16 +456,17 @@ static void alps_process_touchpad_packet_v3(struct psmouse *psmouse)
	struct input_dev *dev2 = priv->dev2;
	struct input_dev *dev2 = priv->dev2;
	int x, y, z;
	int x, y, z;
	int left, right, middle;
	int left, right, middle;
	int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
	int fingers = 0, bmap_fingers;
	unsigned int x_bitmap, y_bitmap;


	/*
	/*
	 * There's no single feature of touchpad position and bitmap
	 * There's no single feature of touchpad position and bitmap packets
	 * packets that can be used to distinguish between them. We
	 * that can be used to distinguish between them. We rely on the fact
	 * rely on the fact that a bitmap packet should always follow
	 * that a bitmap packet should always follow a position packet with
	 * a position packet with bit 6 of packet[4] set.
	 * bit 6 of packet[4] set.
	 */
	 */
	if (priv->multi_packet) {
	if (priv->multi_packet) {
		priv->multi_packet = 0;

		/*
		/*
		 * Sometimes a position packet will indicate a multi-packet
		 * Sometimes a position packet will indicate a multi-packet
		 * sequence, but then what follows is another position
		 * sequence, but then what follows is another position
@@ -335,17 +474,48 @@ static void alps_process_touchpad_packet_v3(struct psmouse *psmouse)
		 * position packet as usual.
		 * position packet as usual.
		 */
		 */
		if (packet[0] & 0x40) {
		if (packet[0] & 0x40) {
			fingers = (packet[5] & 0x3) + 1;
			x_bitmap = ((packet[4] & 0x7e) << 8) |
				   ((packet[1] & 0x7f) << 2) |
				   ((packet[0] & 0x30) >> 4);
			y_bitmap = ((packet[3] & 0x70) << 4) |
				   ((packet[2] & 0x7f) << 1) |
				   (packet[4] & 0x01);

			bmap_fingers = alps_process_bitmap(x_bitmap, y_bitmap,
							   &x1, &y1, &x2, &y2);

			/*
			/*
			 * Bitmap packets are not yet supported, so for now
			 * We shouldn't report more than one finger if
			 * just ignore them.
			 * we don't have two coordinates.
			 */
			 */
			return;
			if (fingers > 1 && bmap_fingers < 2)
				fingers = bmap_fingers;

			/* Now process position packet */
			packet = priv->multi_data;
		} else {
			priv->multi_packet = 0;
		}
		}
	}
	}


	if (!priv->multi_packet && (packet[4] & 0x40))
	/*
	 * Bit 6 of byte 0 is not usually set in position packets. The only
	 * times it seems to be set is in situations where the data is
	 * suspect anyway, e.g. a palm resting flat on the touchpad. Given
	 * this combined with the fact that this bit is useful for filtering
	 * out misidentified bitmap packets, we reject anything with this
	 * bit set.
	 */
	if (packet[0] & 0x40)
		return;

	if (!priv->multi_packet && (packet[4] & 0x40)) {
		priv->multi_packet = 1;
		priv->multi_packet = 1;
	else
		memcpy(priv->multi_data, packet, sizeof(priv->multi_data));
		return;
	}

	priv->multi_packet = 0;
	priv->multi_packet = 0;


	left = packet[3] & 0x01;
	left = packet[3] & 0x01;
@@ -366,22 +536,38 @@ static void alps_process_touchpad_packet_v3(struct psmouse *psmouse)
	if (x && y && !z)
	if (x && y && !z)
		return;
		return;


	/*
	 * If we don't have MT data or the bitmaps were empty, we have
	 * to rely on ST data.
	 */
	if (!fingers) {
		x1 = x;
		y1 = y;
		fingers = z > 0 ? 1 : 0;
	}

	if (z >= 64)
	if (z >= 64)
		input_report_key(dev, BTN_TOUCH, 1);
		input_report_key(dev, BTN_TOUCH, 1);
	else
	else
		input_report_key(dev, BTN_TOUCH, 0);
		input_report_key(dev, BTN_TOUCH, 0);


	alps_report_semi_mt_data(dev, fingers, x1, y1, x2, y2);

	input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
	input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
	input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
	input_report_key(dev, BTN_TOOL_QUADTAP, fingers == 4);

	input_report_key(dev, BTN_LEFT, left);
	input_report_key(dev, BTN_RIGHT, right);
	input_report_key(dev, BTN_MIDDLE, middle);

	if (z > 0) {
	if (z > 0) {
		input_report_abs(dev, ABS_X, x);
		input_report_abs(dev, ABS_X, x);
		input_report_abs(dev, ABS_Y, y);
		input_report_abs(dev, ABS_Y, y);
	}
	}
	input_report_abs(dev, ABS_PRESSURE, z);
	input_report_abs(dev, ABS_PRESSURE, z);


	input_report_key(dev, BTN_TOOL_FINGER, z > 0);
	input_report_key(dev, BTN_LEFT, left);
	input_report_key(dev, BTN_RIGHT, right);
	input_report_key(dev, BTN_MIDDLE, middle);

	input_sync(dev);
	input_sync(dev);


	if (!(priv->quirks & ALPS_QUIRK_TRACKSTICK_BUTTONS)) {
	if (!(priv->quirks & ALPS_QUIRK_TRACKSTICK_BUTTONS)) {
@@ -1368,9 +1554,18 @@ int alps_init(struct psmouse *psmouse)
		input_set_abs_params(dev1, ABS_Y, 0, 767, 0, 0);
		input_set_abs_params(dev1, ABS_Y, 0, 767, 0, 0);
		break;
		break;
	case ALPS_PROTO_V3:
	case ALPS_PROTO_V3:
		set_bit(INPUT_PROP_SEMI_MT, dev1->propbit);
		input_mt_init_slots(dev1, 2);
		input_set_abs_params(dev1, ABS_MT_POSITION_X, 0, ALPS_V3_X_MAX, 0, 0);
		input_set_abs_params(dev1, ABS_MT_POSITION_Y, 0, ALPS_V3_Y_MAX, 0, 0);

		set_bit(BTN_TOOL_DOUBLETAP, dev1->keybit);
		set_bit(BTN_TOOL_TRIPLETAP, dev1->keybit);
		set_bit(BTN_TOOL_QUADTAP, dev1->keybit);
		/* fall through */
	case ALPS_PROTO_V4:
	case ALPS_PROTO_V4:
		input_set_abs_params(dev1, ABS_X, 0, 2000, 0, 0);
		input_set_abs_params(dev1, ABS_X, 0, ALPS_V3_X_MAX, 0, 0);
		input_set_abs_params(dev1, ABS_Y, 0, 1400, 0, 0);
		input_set_abs_params(dev1, ABS_Y, 0, ALPS_V3_Y_MAX, 0, 0);
		break;
		break;
	}
	}


+1 −0
Original line number Original line Diff line number Diff line
@@ -38,6 +38,7 @@ struct alps_data {
	int addr_command;		/* Command to set register address */
	int addr_command;		/* Command to set register address */
	int prev_fin;			/* Finger bit from previous packet */
	int prev_fin;			/* Finger bit from previous packet */
	int multi_packet;		/* Multi-packet data in progress */
	int multi_packet;		/* Multi-packet data in progress */
	unsigned char multi_data[6];	/* Saved multi-packet data */
	u8 quirks;
	u8 quirks;
	struct timer_list timer;
	struct timer_list timer;
};
};