Attachment #223223 for bug #252236

Lines 621-627 evdev_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, Link Here

(-)b/sys/dev/evdev/cdev.c (-1 / +1 lines)
621	MIN(len / sizeof(int32_t) - 1, MAXIMAL_MT_SLOT(evdev) + 1);	621	MIN(len / sizeof(int32_t) - 1, MAXIMAL_MT_SLOT(evdev) + 1);
622	for (int i = 0; i < nvalues; i++)	622	for (int i = 0; i < nvalues; i++)
623	((int32_t *)data)[i + 1] =	623	((int32_t *)data)[i + 1] =
624	evdev_get_mt_value(evdev, i, code);	624	evdev_mt_get_value(evdev, i, code);
625	return (0);	625	return (0);
626		626
627	case EVIOCGKEY(0):	627	case EVIOCGKEY(0):




static void evdev_stop_repeat(struct evdev_dev *);
static int evdev_check_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);

static inline void
bit_change(bitstr_t *bitstr, int bit, int value)
{
	if (value)
		bit_set(bitstr, bit);
	else
		bit_clear(bitstr, bit);
}

struct evdev_dev *
evdev_alloc(void)
{

		}
	}

	/* Initialize multitouch protocol type B states or A to B convertor */
	if ((bit_test(evdev->ev_abs_flags, ABS_MT_SLOT) &&
	     evdev->ev_absinfo != NULL && MAXIMAL_MT_SLOT(evdev) > 0) ||
	    (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK) &&
	     bit_test(evdev->ev_abs_flags, ABS_MT_POSITION_X) &&
	     bit_test(evdev->ev_abs_flags, ABS_MT_POSITION_Y)))
		evdev_mt_init(evdev);

	/* Estimate maximum report size */

		break;

	case EV_ABS:
		if (code == ABS_MT_SLOT)
		if (fuzz == 0 || code == ABS_MT_SLOT)
			break;
		else if (!ABS_IS_MT(code))
			old_value = evdev->ev_absinfo[code].value;
		else if (!bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))
			/* Pass MT protocol type A events as is */
			break;
		else if (code == ABS_MT_TRACKING_ID) {
			*value = evdev_mt_reassign_id(evdev,
			    evdev_mt_get_last_slot(evdev), *value);
			break;
		} else
			old_value = evdev_mt_get_value(evdev,
			    evdev_mt_get_last_slot(evdev), code);

		fuzz = evdev->ev_absinfo[code].fuzz;
		if (fuzz == 0)
			break;

		abs_change = abs(*value - old_value);

		switch (code) {
		case ABS_MT_SLOT:
			/* Postpone ABS_MT_SLOT till next event */
			evdev_mt_set_last_slot(evdev, value);
			return (EV_SKIP_EVENT);

		case ABS_MT_FIRST ... ABS_MT_LAST:

			if (!bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))
				break;
			/* Don`t repeat MT protocol type B events */
			last_mt_slot = evdev_mt_get_last_slot(evdev);
			if (evdev_mt_get_value(evdev, last_mt_slot, code)
			     == value)
				return (EV_SKIP_EVENT);
			evdev_mt_set_value(evdev, last_mt_slot, code, value);
			if (last_mt_slot != CURRENT_MT_SLOT(evdev)) {
				CURRENT_MT_SLOT(evdev) = last_mt_slot;
				evdev->ev_report_opened = true;


	EVDEV_LOCK_ASSERT(evdev);

	evdev_modify_event(evdev, type, code, &value);
	sparse =  evdev_sparse_event(evdev, type, code, value);
	switch (sparse) {
	case EV_REPORT_MT_SLOT:

	EVDEV_LOCK_ASSERT(evdev);

	/* Report postponed leds */
	bit_foreach(evdev->ev_kdb_led_states, LED_CNT, code)
		evdev_send_event(evdev, EV_LED, code,
		    !bit_test(evdev->ev_led_states, code));
			    !bit_test(evdev->ev_led_states, code));
	bit_nclear(evdev->ev_kdb_led_states, 0, LED_MAX);

	/* Release stuck keys (CTRL + ALT + ESC) */
	evdev_stop_repeat(evdev);
	bit_foreach(evdev->ev_key_states, KEY_CNT, code)
		evdev_send_event(evdev, EV_KEY, code, KEY_EVENT_UP);
	evdev_send_event(evdev, EV_SYN, SYN_REPORT, 1);
			evdev_send_event(evdev, EV_SYN, SYN_REPORT, 1);
		}
	}
}

int

		evdev_restore_after_kdb(evdev);
	}

	evdev_modify_event(evdev, type, code, &value);
	if (type == EV_SYN && code == SYN_REPORT &&
	    bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))
		evdev_mt_sync_frame(evdev);
	else
		if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK) &&
		    evdev_mt_record_event(evdev, type, code, value))
			goto exit;

	evdev_send_event(evdev, type, code, value);
exit:
	EVDEV_EXIT(evdev);

	return (0);

Lines 90-95 extern int evdev_sysmouse_t_axis; Link Here

(-)b/sys/dev/evdev/evdev.h (-3 / +38 lines)
90	* current MT protocol type B report */	90	* current MT protocol type B report */
91	#define EVDEV_FLAG_EXT_EPOCH 0x03 /* evdev_push_* is allways called with	91	#define EVDEV_FLAG_EXT_EPOCH 0x03 /* evdev_push_* is allways called with
92	* input (global) epoch entered */	92	* input (global) epoch entered */
		93	#define EVDEV_FLAG_MT_TRACK 0x04 /* Assign touch to slot by evdev */
		94	#define EVDEV_FLAG_MT_KEEPID 0x05 /* Do not reassign tracking ID */
93	#define EVDEV_FLAG_MAX 0x1F	95	#define EVDEV_FLAG_MAX 0x1F
94	#define EVDEV_FLAG_CNT (EVDEV_FLAG_MAX + 1)	96	#define EVDEV_FLAG_CNT (EVDEV_FLAG_MAX + 1)
95		97
Lines 102-107 struct evdev_methods Link Here
102	evdev_keycode_t *ev_set_keycode;	104	evdev_keycode_t *ev_set_keycode;
103	};	105	};
104		106
		107	union evdev_mt_slot {
		108	int32_t val[MT_CNT];
		109	struct {
		110	int32_t maj; /* ABS_MT_TOUCH_MAJOR */
		111	int32_t min; /* ABS_MT_TOUCH_MINOR */
		112	int32_t w_maj; /* ABS_MT_WIDTH_MAJOR */
		113	int32_t w_min; /* ABS_MT_WIDTH_MINOR */
		114	int32_t ori; /* ABS_MT_ORIENTATION */
		115	int32_t x; /* ABS_MT_POSITION_X */
		116	int32_t y; /* ABS_MT_POSITION_Y */
		117	int32_t type; /* ABS_MT_TOOL_TYPE */
		118	int32_t blob_id; /* ABS_MT_BLOB_ID */
		119	int32_t id; /* ABS_MT_TRACKING_ID */
		120	int32_t p; /* ABS_MT_PRESSURE */
		121	int32_t dist; /* ABS_MT_DISTANCE */
		122	int32_t tool_x; /* ABS_MT_TOOL_X */
		123	int32_t tool_y; /* ABS_MT_TOOL_Y */
		124	};
		125	};
		126	_Static_assert(offsetof(union evdev_mt_slot, tool_y) ==
		127	offsetof(union evdev_mt_slot, val[ABS_MT_INDEX(ABS_MT_TOOL_Y)]),
		128	"evdev_mt_slot array members does not match their structure aliases");
		129
105	/* Input device interface: */	130	/* Input device interface: */
106	struct evdev_dev *evdev_alloc(void);	131	struct evdev_dev *evdev_alloc(void);
107	void evdev_free(struct evdev_dev *);	132	void evdev_free(struct evdev_dev *);
Lines 131-141 void evdev_set_flag(struct evdev_dev *, uint16_t); Link Here
131	void evdev_get_softc(struct evdev_dev );	156	void evdev_get_softc(struct evdev_dev );
132		157
133	/* Multitouch related functions: */	158	/* Multitouch related functions: */
134	int32_t evdev_get_mt_slot_by_tracking_id(struct evdev_dev *, int32_t);	159	int evdev_get_mt_slot_by_tracking_id(struct evdev_dev *, int32_t);
135	void evdev_support_nfingers(struct evdev_dev *, int32_t);
136	void evdev_support_mt_compat(struct evdev_dev *);	160	void evdev_support_mt_compat(struct evdev_dev *);
137	void evdev_push_nfingers(struct evdev_dev *, int32_t);
138	void evdev_push_mt_compat(struct evdev_dev *);	161	void evdev_push_mt_compat(struct evdev_dev *);
		162	int evdev_mt_push_slot(struct evdev_dev , int, union evdev_mt_slot );
		163	int evdev_mt_push_frame(struct evdev_dev , union evdev_mt_slot , int);
		164	void evdev_mt_match_frame(struct evdev_dev , union evdev_mt_slot , int);
		165	union evdev_mt_slot evdev_mt_get_match_slots(struct evdev_dev );
		166	void evdev_mt_push_autorel(struct evdev_dev *);
		167	static __inline int
		168	evdev_mt_id_to_slot(struct evdev_dev *evdev, int32_t id)
		169	{
		170	return (evdev_get_mt_slot_by_tracking_id(evdev, id));
		171	}
139		172
140	/* Utility functions: */	173	/* Utility functions: */
141	uint16_t evdev_hid2key(int);	174	uint16_t evdev_hid2key(int);
Lines 144-149 uint16_t evdev_scancode2key(int *, int); Link Here
144	void evdev_push_mouse_btn(struct evdev_dev *, int);	177	void evdev_push_mouse_btn(struct evdev_dev *, int);
145	void evdev_push_leds(struct evdev_dev *, int);	178	void evdev_push_leds(struct evdev_dev *, int);
146	void evdev_push_repeats(struct evdev_dev , keyboard_t );	179	void evdev_push_repeats(struct evdev_dev , keyboard_t );
		180	void evdev_support_nfingers(struct evdev_dev *, int);
		181	void evdev_push_nfingers(struct evdev_dev *, int);
147		182
148	/* Event reporting shortcuts: */	183	/* Event reporting shortcuts: */
149	static __inline int	184	static __inline int




/*-
 * Copyright (c) 2016, 2020 Vladimir Kondratyev <wulf@FreeBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without

 *
 * $FreeBSD$
 */
/*-
 * Copyright (c) 2015, 2016 Ulf Brosziewski
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>
#include <sys/lock.h>

#define	debugf(fmt, args...)
#endif

typedef	u_int	slotset_t;
	BTN_TOOL_FINGER,
	BTN_TOOL_DOUBLETAP,
	BTN_TOOL_TRIPLETAP,
	BTN_TOOL_QUADTAP,
	BTN_TOOL_QUINTTAP,
};

_Static_assert(MAX_MT_SLOTS < sizeof(slotset_t) * 8, "MAX_MT_SLOTS too big");

#define FOREACHBIT(v, i) \
	for ((i) = ffs(v) - 1; (i) != -1; (i) = ffs((v) & (~1 << (i))) - 1)
	{ ABS_MT_TOUCH_MAJOR, ABS_TOOL_WIDTH },
};

struct {
	uint16_t	mt;
	uint16_t	st;
	int32_t		max;
} static evdev_mtstmap[] = {
	{ ABS_MT_POSITION_X,	ABS_X,		0 },
	{ ABS_MT_POSITION_Y,	ABS_Y,		0 },
	{ ABS_MT_PRESSURE,	ABS_PRESSURE,	255 },
	{ ABS_MT_TOUCH_MAJOR,	ABS_TOOL_WIDTH,	15 },
};

struct evdev_mt {
	int			last_reported_slot;
	uint16_t		tracking_id;
	int32_t			tracking_ids[MAX_MT_SLOTS];
	bool			type_a;
	u_int			mtst_events;
	/* the set of slots with active touches */
	slotset_t		touches;
	/* the set of slots with unsynchronized state */
	slotset_t		frame;
	/* the set of slots to match with active touches */
	slotset_t		match_frame;
	int			match_slot;
	union evdev_mt_slot	*match_slots;
	int			*matrix;
	union evdev_mt_slot	slots[];
};

static void	evdev_mt_send_st_compat(struct evdev_dev *);
static void	evdev_mt_send_autorel(struct evdev_dev *);
static void	evdev_mt_replay_events(struct evdev_dev *);

static inline int
ffc_slot(struct evdev_dev *evdev, slotset_t slots)
{
	return (ffs(~slots & (2U << MAXIMAL_MT_SLOT(evdev)) - 1) - 1);
}

void
evdev_mt_init(struct evdev_dev *evdev)
{
	struct evdev_mt *mt;
	size_t size = offsetof(struct evdev_mt, slots);
	int slot, slots;
	bool type_a;

	type_a = !bit_test(evdev->ev_abs_flags, ABS_MT_SLOT);
	if (type_a) {
		/* Add events produced by MT type A to type B convertor */
		evdev_support_abs(evdev,
		    ABS_MT_SLOT, 0, MAX_MT_SLOTS - 1, 0, 0, 0);
		if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_KEEPID))
			evdev_support_abs(evdev,
			    ABS_MT_TRACKING_ID, -1, MAX_MT_SLOTS - 1, 0, 0, 0);
	}

	slots = MAXIMAL_MT_SLOT(evdev) + 1;
	size += sizeof(mt->slots[0]) * slots;
	if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK)) {
		size += sizeof(mt->match_slots[0]) * slots;
		size += sizeof(mt->matrix[0]) * (slots + 6) * slots;
	}

	mt = malloc(size, M_EVDEV, M_WAITOK | M_ZERO);
	evdev->ev_mt = mt;
	mt->type_a = type_a;

	if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK)) {
		mt->match_slots = mt->slots + slots;
		mt->matrix = (int *)(mt->match_slots + slots);
		 * .ev_report should not be initialized to initial value of
		 * report counter (0) as it brokes free slot detection in
		 * evdev_get_mt_slot_by_tracking_id. So initialize it to -1
		 */
		evdev->ev_mt->ev_mt_slots[slot] = (struct evdev_mt_slot) {
			.ev_report = 0xFFFFFFFFFFFFFFFFULL,
			.ev_mt_states[ABS_MT_INDEX(ABS_MT_TRACKING_ID)] = -1,
		};
	}

	/* Initialize multitouch protocol type B states */
	for (slot = 0; slot < slots; slot++)
		mt->slots[slot].id = -1;

	if (!bit_test(evdev->ev_flags, EVDEV_FLAG_MT_KEEPID))
		evdev_support_abs(evdev,
		    ABS_MT_TRACKING_ID, -1, UINT16_MAX, 0, 0, 0);
	if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_STCOMPAT))
		evdev_support_mt_compat(evdev);
}

void
evdev_mt_free(struct evdev_dev *evdev)
{

	free(evdev->ev_mt, M_EVDEV);
}

void
evdev_mt_sync_frame(struct evdev_dev *evdev)
{
	if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK))
		evdev_mt_replay_events(evdev);
	if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_AUTOREL))
		evdev_mt_send_autorel(evdev);
	if (evdev->ev_report_opened &&
	    bit_test(evdev->ev_flags, EVDEV_FLAG_MT_STCOMPAT))
		evdev_mt_send_st_compat(evdev);
	evdev->ev_mt->frame = 0;
}

static void
evdev_mt_send_slot(struct evdev_dev *evdev, int slot,
    union evdev_mt_slot *state)
{
	int i;
	bool type_a = !bit_test(evdev->ev_abs_flags, ABS_MT_SLOT);

	EVDEV_LOCK_ASSERT(evdev);
	MPASS(type_a || (slot >= 0 && slot <= MAXIMAL_MT_SLOT(evdev)));
	MPASS(!type_a || state != NULL);

	if (!type_a) {
		evdev_send_event(evdev, EV_ABS, ABS_MT_SLOT, slot);
		if (state == NULL) {
			evdev_send_event(evdev, EV_ABS, ABS_MT_TRACKING_ID, -1);
			return;
		}
	}
	bit_foreach_at(evdev->ev_abs_flags, ABS_MT_FIRST, ABS_MT_LAST + 1, i)
		evdev_send_event(evdev, EV_ABS, i,
		    state->val[ABS_MT_INDEX(i)]);
	if (type_a)
		evdev_send_event(evdev, EV_SYN, SYN_MT_REPORT, 1);
}

int
evdev_mt_push_slot(struct evdev_dev *evdev, int slot,
    union evdev_mt_slot *state)
{
	struct evdev_mt *mt = evdev->ev_mt;
	bool type_a = !bit_test(evdev->ev_abs_flags, ABS_MT_SLOT);

	if ((type_a || (mt != NULL && mt->type_a)) && state == NULL)
		return (EINVAL);
	if (!type_a && (slot < 0 || slot > MAXIMAL_MT_SLOT(evdev)))
		return (EINVAL);

	EVDEV_ENTER(evdev);
	if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK) && mt->type_a) {
		mt->match_slots[mt->match_slot] = *state;
		evdev_mt_record_event(evdev, EV_SYN, SYN_MT_REPORT, 1);
	} else if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK)) {
		evdev_mt_record_event(evdev, EV_ABS, ABS_MT_SLOT, slot);
		if (state != NULL)
			mt->match_slots[mt->match_slot] = *state;
		else
			evdev_mt_record_event(evdev, EV_ABS,
			    ABS_MT_TRACKING_ID, -1);
	} else
		evdev_mt_send_slot(evdev, slot, state);
	EVDEV_EXIT(evdev);

	return (0);
}

/*
 * Find a minimum-weight matching for an m-by-n matrix.
 *
 * m must be greater than or equal to n. The size of the buffer must be
 * at least 3m + 3n.
 *
 * On return, the first m elements of the buffer contain the row-to-
 * column mappings, i.e., buffer[i] is the column index for row i, or -1
 * if there is no assignment for that row (which may happen if n < m).
 *
 * Wrong results because of overflows will not occur with input values
 * in the range of 0 to INT_MAX / 2 inclusive.
 *
 * The function applies the Dinic-Kronrod algorithm. It is not modern or
 * popular, but it seems to be a good choice for small matrices at least.
 * The original form of the algorithm is modified as follows: There is no
 * initial search for row minima, the initial assignments are in a
 * "virtual" column with the index -1 and zero values. This permits inputs
 * with n < m, and it simplifies the reassignments.
 */
static void
evdev_mt_matching(int *matrix, int m, int n, int *buffer)
{
	int i, j, k, d, e, row, col, delta;
	int *p;
	int *r2c = buffer;	/* row-to-column assignments */
	int *red = r2c + m;	/* reduced values of the assignments */
	int *mc = red + m;	/* row-wise minimal elements of cs */
	int *cs = mc + m;	/* the column set */
	int *c2r = cs + n;	/* column-to-row assignments in cs */
	int *cd = c2r + n;	/* column deltas (reduction) */

	for (p = r2c; p < red; *p++ = -1) {}
	for (; p < mc; *p++ = 0) {}
	for (col = 0; col < n; col++) {
		delta = INT_MAX;
		for (i = 0, p = matrix + col; i < m; i++, p += n) {
			d = *p - red[i];
			if (d < delta || (d == delta && r2c[i] < 0)) {
				delta = d;
				row = i;
			}
		}
		cd[col] = delta;
		if (r2c[row] < 0) {
			r2c[row] = col;
			continue;
		}
		for (p = mc; p < cs; *p++ = col) {}
		for (k = 0; (j = r2c[row]) >= 0;) {
			cs[k++] = j;
			c2r[j] = row;
			mc[row] -= n;
			delta = INT_MAX;
			for (i = 0, p = matrix; i < m; i++, p += n)
				if (mc[i] >= 0) {
					d = p[mc[i]] - cd[mc[i]];
					e = p[j] - cd[j];
					if (e < d) {
						d = e;
						mc[i] = j;
					}
					d -= red[i];
					if (d < delta || (d == delta
					    && r2c[i] < 0)) {
						delta = d;
						row = i;
					}
				}
			cd[col] += delta;
			for (i = 0; i < k; i++) {
				cd[cs[i]] += delta;
				red[c2r[cs[i]]] -= delta;
			}
		}
		for (j = mc[row]; (r2c[row] = j) != col;) {
			row = c2r[j];
			j = mc[row] + n;
		}
	}
}

/*
 * Assign slot numbers to the points in the pt array.  The slot numbers are
 * passed to the caller in the pt->id fields.
 *
 * The slot assignment pairs the points with points of the previous frame in
 * such a way that the sum of the squared distances is minimal.  Using
 * squares instead of simple distances favours assignments with more uniform
 * distances, and it is faster.
 */
void
evdev_mt_match_frame(struct evdev_dev *evdev, union evdev_mt_slot *pt,
    int size)
{
	struct evdev_mt *mt = evdev->ev_mt;
	int i, j, m, n, dx, dy, slot, num_touches;
	int *p, *r2c, *c2r;
	u_int touches;

	EVDEV_LOCK_ASSERT(evdev);
	MPASS(mt->matrix != NULL);
	MPASS(size >= 0 && size <= MAXIMAL_MT_SLOT(evdev) + 1);

	if (size == 0)
		return;

	p = mt->matrix;
	touches = mt->touches;
	num_touches = bitcount(touches);
	if (num_touches >= size) {
		FOREACHBIT(touches, slot)
			for (i = 0; i < size; i++) {
				dx = pt[i].x - mt->slots[slot].x;
				dy = pt[i].y - mt->slots[slot].y;
				*p++ = dx * dx + dy * dy;
			}
		m = num_touches;
		n = size;
	} else {
		for (i = 0; i < size; i++)
			FOREACHBIT(touches, slot) {
				dx = pt[i].x - mt->slots[slot].x;
				dy = pt[i].y - mt->slots[slot].y;
				*p++ = dx * dx + dy * dy;
			}
		m = size;
		n = num_touches;
	}
	evdev_mt_matching(mt->matrix, m, n, p);

	r2c = p;
	c2r = p + m;
	for (i = 0; i < m; i++)
		if ((j = r2c[i]) >= 0)
			c2r[j] = i;

	p = (n == size ? r2c : c2r);
	FOREACHBIT(touches, slot)
		if ((i = *p++) >= 0)
			pt[i].id = slot;

	p = (n == size ? c2r : r2c);
	for (i = 0; i < size; i++)
		if (*p++ < 0 && (pt[i].id = ffc_slot(evdev, touches)) >= 0)
			touches |= 1U << pt[i].id;
}

static void
evdev_mt_send_frame(struct evdev_dev *evdev, union evdev_mt_slot *pt, int size)
{
	union evdev_mt_slot *slot;

	EVDEV_LOCK_ASSERT(evdev);
	MPASS(size >= 0 && size <= MAXIMAL_MT_SLOT(evdev) + 1);

	for (slot = pt; slot < pt + size; slot++)
		if (slot->id >= 0)
			evdev_mt_send_slot(evdev, slot->id, slot);
}

int
evdev_mt_push_frame(struct evdev_dev *evdev, union evdev_mt_slot *pt, int size)
{
	if (size < 0 || size > MAXIMAL_MT_SLOT(evdev) + 1)
		return (EINVAL);

	EVDEV_ENTER(evdev);
	evdev_mt_send_frame(evdev, pt, size);
	EVDEV_EXIT(evdev);

	return (0);
}

bool
evdev_mt_record_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
    int32_t value)
{
	struct evdev_mt *mt = evdev->ev_mt;

	EVDEV_LOCK_ASSERT(evdev);

	switch (type) {
	case EV_SYN:
		if (code == SYN_MT_REPORT) {
			/* MT protocol type A support */
			KASSERT(mt->type_a, ("Not a MT type A protocol"));
			mt->match_frame |= 1U << mt->match_slot;
			mt->match_slot++;
			return (true);
		}
		break;
	case EV_ABS:
		if (code == ABS_MT_SLOT) {
			/* MT protocol type B support */
			KASSERT(!mt->type_a, ("Not a MT type B protocol"));
			KASSERT(value >= 0, ("Negative slot number"));
			mt->match_slot = value;
			mt->match_frame |= 1U << mt->match_slot;
			return (true);
		} else if (code == ABS_MT_TRACKING_ID) {
			KASSERT(!mt->type_a, ("Not a MT type B protocol"));
			if (value == -1)
				mt->match_frame &= ~(1U << mt->match_slot);
			return (true);
		} else if (ABS_IS_MT(code)) {
			KASSERT(mt->match_slot >= 0, ("Negative slot"));
			KASSERT(mt->match_slot <= MAXIMAL_MT_SLOT(evdev),
			    ("Slot number too big"));
			mt->match_slots[mt->match_slot].
			    val[ABS_MT_INDEX(code)] = value;
			return (true);
		}
		break;
	default:
		break;
	}

	return (false);
	    value;
}

static void
evdev_mt_replay_events(struct evdev_dev *evdev)
{
	struct evdev_mt *mt = evdev->ev_mt;
	int slot, size = 0;

	EVDEV_LOCK_ASSERT(evdev);

	FOREACHBIT(mt->match_frame, slot) {
		if (slot != size)
			mt->match_slots[size] = mt->match_slots[slot];
		size++;
		 * released one within the same report. To avoid this compare
		 * report counter with slot`s report number updated with each
		 * ABS_MT_TRACKING_ID change.
		 */
		if (free_slot == -1 && tr_id == -1 &&
		    evdev->ev_mt->ev_mt_slots[slot].ev_report !=
		    evdev->ev_report_count)
			free_slot = slot;
	}
	evdev_mt_match_frame(evdev, mt->match_slots, size);
	evdev_mt_send_frame(evdev, mt->match_slots, size);
	mt->match_slot = 0;
	mt->match_frame = 0;
}

union evdev_mt_slot *
evdev_mt_get_match_slots(struct evdev_dev *evdev)
{
	return (evdev->ev_mt->match_slots);
}

int
evdev_mt_get_last_slot(struct evdev_dev *evdev)
{
	return (evdev->ev_mt->last_reported_slot);
}

void
evdev_mt_set_last_slot(struct evdev_dev *evdev, int slot)
{
	struct evdev_mt *mt = evdev->ev_mt;

	MPASS(slot >= 0 && slot <= MAXIMAL_MT_SLOT(evdev));

	mt->frame |= 1U << slot;
	mt->last_reported_slot = slot;
}

int32_t
evdev_mt_get_value(struct evdev_dev *evdev, int slot, int16_t code)
{
	struct evdev_mt *mt = evdev->ev_mt;

	MPASS(slot >= 0 && slot <= MAXIMAL_MT_SLOT(evdev));
		return;

	return (mt->slots[slot].val[ABS_MT_INDEX(code)]);
}

void
evdev_mt_set_value(struct evdev_dev *evdev, int slot, int16_t code,
    int32_t value)
{
	struct evdev_mt *mt = evdev->ev_mt;

	MPASS(slot >= 0 && slot <= MAXIMAL_MT_SLOT(evdev));

	if (code == ABS_MT_TRACKING_ID) {
		if (value != -1)
			mt->touches |= 1U << slot;
		else
			mt->touches &= ~(1U << slot);
	}
	mt->slots[slot].val[ABS_MT_INDEX(code)] = value;
}

int
evdev_get_mt_slot_by_tracking_id(struct evdev_dev *evdev, int32_t tracking_id)
{
	struct evdev_mt *mt = evdev->ev_mt;
	int slot;

	KASSERT(!mt->type_a, ("Not a MT type B protocol"));
		if (evdev_get_mt_value(evdev, i, ABS_MT_TRACKING_ID) != -1)
			nfingers++;

	/*
	 * Ignore tracking_id if slot assignment is performed by evdev.
	 * Events are written sequentially to temporary matching buffer.
	 */
	if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK))
		return (ffc_slot(evdev, mt->match_frame));

	FOREACHBIT(mt->touches, slot)
		if (mt->tracking_ids[slot] == tracking_id)
			return (slot);
	/*
	 * Do not allow allocation of new slot in a place of just
	 * released one within the same report.
	 */
	return (ffc_slot(evdev, mt->touches | mt->frame));
}

int32_t
evdev_mt_reassign_id(struct evdev_dev *evdev, int slot, int32_t id)
{
	struct evdev_mt *mt = evdev->ev_mt;
	int32_t nid;

	if (id == -1 || bit_test(evdev->ev_flags, EVDEV_FLAG_MT_KEEPID)) {
		mt->tracking_ids[slot] = id;
		return (id);
	}

	nid = evdev_mt_get_value(evdev, slot, ABS_MT_TRACKING_ID);
	if (nid != -1) {
		KASSERT(id == mt->tracking_ids[slot],
		    ("MT-slot tracking id has changed"));
		return (nid);
	}

	mt->tracking_ids[slot] = id;
again:
	nid = mt->tracking_id++;
	FOREACHBIT(mt->touches, slot)
		if (evdev_mt_get_value(evdev, slot, ABS_MT_TRACKING_ID) == nid)
			goto again;

	return (nid);
}

static inline int32_t
evdev_mt_normalize(int32_t value, int32_t mtmin, int32_t mtmax, int32_t stmax)
{
	if (stmax != 0 && mtmax != mtmin) {
		value = (value - mtmin) * stmax / (mtmax - mtmin);
		value = MAX(MIN(value, stmax), 0);
	}
	return (value);
}

void
evdev_support_mt_compat(struct evdev_dev *evdev)
{
	struct input_absinfo *ai;
	int i;

	if (evdev->ev_absinfo == NULL)
		return;

	evdev_support_event(evdev, EV_KEY);
	evdev_support_key(evdev, BTN_TOUCH);

	/* Touchscreens should not advertise tap tool capabilities */
	if (!bit_test(evdev->ev_prop_flags, INPUT_PROP_DIRECT))
		evdev_support_nfingers(evdev, MAXIMAL_MT_SLOT(evdev) + 1);

	/* Echo 0-th MT-slot as ST-slot */
	for (i = 0; i < nitems(evdev_mtstmap); i++) {
		if (!bit_test(evdev->ev_abs_flags, evdev_mtstmap[i].mt) ||
		     bit_test(evdev->ev_abs_flags, evdev_mtstmap[i].st))
			continue;
		ai = evdev->ev_absinfo + evdev_mtstmap[i].mt;
		evdev->ev_mt->mtst_events |= 1U << i;
		if (evdev_mtstmap[i].max != 0)
			evdev_support_abs(evdev, evdev_mtstmap[i].st,
			    0,
			    evdev_mtstmap[i].max,
			    0,
			    evdev_mt_normalize(
			      ai->flat, 0, ai->maximum, evdev_mtstmap[i].max),
			    0);
		else
			evdev_support_abs(evdev, evdev_mtstmap[i].st,
			    ai->minimum,
			    ai->maximum,
			    0,
			    ai->flat,
			    ai->resolution);
	}
}

static void
evdev_mt_send_st_compat(struct evdev_dev *evdev)
{
	struct evdev_mt *mt = evdev->ev_mt;
	int nfingers, i, st_slot;

	EVDEV_LOCK_ASSERT(evdev);

	nfingers = bitcount(mt->touches);
	evdev_send_event(evdev, EV_KEY, BTN_TOUCH, nfingers > 0);

	/* Send first active MT-slot state as single touch report */
	st_slot = ffs(mt->touches) - 1;
	if (st_slot != -1)
		FOREACHBIT(mt->mtst_events, i)
			evdev_send_event(evdev, EV_ABS, evdev_mtstmap[i].st,
			    evdev_mt_normalize(evdev_mt_get_value(evdev,
			      st_slot, evdev_mtstmap[i].mt),
			      evdev->ev_absinfo[evdev_mtstmap[i].mt].minimum,
			      evdev->ev_absinfo[evdev_mtstmap[i].mt].maximum,
			      evdev_mtstmap[i].max));

	/* Touchscreens should not report tool taps */
	if (!bit_test(evdev->ev_prop_flags, INPUT_PROP_DIRECT))

{

	EVDEV_ENTER(evdev);
	evdev_mt_send_st_compat(evdev);
	EVDEV_EXIT(evdev);
}

static void
evdev_mt_send_autorel(struct evdev_dev *evdev)
{
	struct evdev_mt *mt = evdev->ev_mt;
	int slot;

	EVDEV_LOCK_ASSERT(evdev);
	KASSERT(mt->match_frame == 0, ("Unmatched events exist"));

	FOREACHBIT(mt->touches & ~mt->frame, slot)
		evdev_mt_send_slot(evdev, slot, NULL);
}

void
evdev_mt_push_autorel(struct evdev_dev *evdev)
{
	EVDEV_ENTER(evdev);
	evdev_mt_send_autorel(evdev);
	EVDEV_EXIT(evdev);
}




    (((client)->ec_buffer_ready + (client)->ec_buffer_size - \
      (client)->ec_buffer_head) % (client)->ec_buffer_size)

/* bitstring(3) helpers */
static inline void
bit_change(bitstr_t *bitstr, int bit, int value)
{
	if (value)
		bit_set(bitstr, bit);
	else
		bit_clear(bitstr, bit);
}
#define	bit_foreach_at(_bitstr, _start, _nbits, _iter)			\
	for (bit_ffs_at((_bitstr), (_start), (_nbits), &(_iter));	\
	     (_iter) != -1;						\
	     bit_ffs_at((_bitstr), (_iter) + 1, (_nbits), &(_iter)))
#define	bit_foreach(_bitstr, _nbits, _iter)				\
	bit_foreach_at(_bitstr, /*start*/0, _nbits, _iter)

/* Input device interface: */
void evdev_send_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);
int evdev_inject_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);

/* Multitouch related functions: */
void evdev_mt_init(struct evdev_dev *);
void evdev_mt_free(struct evdev_dev *);
void evdev_mt_sync_frame(struct evdev_dev *);
int evdev_mt_get_last_slot(struct evdev_dev *);
void evdev_mt_set_last_slot(struct evdev_dev *, int);
int32_t evdev_mt_get_value(struct evdev_dev *, int, int16_t);
void evdev_mt_set_value(struct evdev_dev *, int, int16_t, int32_t);
bool evdev_mt_record_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);
int32_t evdev_mt_reassign_id(struct evdev_dev *, int, int32_t);

/* Utility functions: */
void evdev_client_dumpqueue(struct evdev_client *);
void evdev_send_nfingers(struct evdev_dev *, int);

#endif	/* _DEV_EVDEV_EVDEV_PRIVATE_H */

Lines 38-43 Link Here

(-)b/sys/dev/evdev/evdev_utils.c (+41 lines)
38	#include <sys/systm.h>	38	#include <sys/systm.h>
39		39
40	#include <dev/evdev/evdev.h>	40	#include <dev/evdev/evdev.h>
		41	#include <dev/evdev/evdev_private.h>
41	#include <dev/evdev/input.h>	42	#include <dev/evdev/input.h>
42		43
43	#define NONE KEY_RESERVED	44	#define NONE KEY_RESERVED
Lines 205-210 static uint16_t evdev_led_codes[] = { Link Here
205	LED_SCROLLL, /* SLKED */	206	LED_SCROLLL, /* SLKED */
206	};	207	};
207		208
		209	static uint16_t evdev_nfinger_codes[] = {
		210	BTN_TOOL_FINGER,
		211	BTN_TOOL_DOUBLETAP,
		212	BTN_TOOL_TRIPLETAP,
		213	BTN_TOOL_QUADTAP,
		214	BTN_TOOL_QUINTTAP,
		215	};
		216
208	uint16_t	217	uint16_t
209	evdev_hid2key(int scancode)	218	evdev_hid2key(int scancode)
210	{	219	{
Lines 300-302 evdev_push_repeats(struct evdev_dev evdev, keyboard_t kbd) Link Here
300	evdev_push_event(evdev, EV_REP, REP_DELAY, kbd->kb_delay1);	309	evdev_push_event(evdev, EV_REP, REP_DELAY, kbd->kb_delay1);
301	evdev_push_event(evdev, EV_REP, REP_PERIOD, kbd->kb_delay2);	310	evdev_push_event(evdev, EV_REP, REP_PERIOD, kbd->kb_delay2);
302	}	311	}
		312
		313	void
		314	evdev_support_nfingers(struct evdev_dev *evdev, int nfingers)
		315	{
		316	int i;
		317
		318	for (i = 0; i < MIN(nitems(evdev_nfinger_codes), nfingers); i++)
		319	evdev_support_key(evdev, evdev_nfinger_codes[i]);
		320	}
		321
		322	void
		323	evdev_send_nfingers(struct evdev_dev *evdev, int nfingers)
		324	{
		325	int i;
		326
		327	EVDEV_LOCK_ASSERT(evdev);
		328
		329	if (nfingers > nitems(evdev_nfinger_codes))
		330	nfingers = nitems(evdev_nfinger_codes);
		331
		332	for (i = 0; i < nitems(evdev_nfinger_codes); i++)
		333	evdev_send_event(evdev, EV_KEY, evdev_nfinger_codes[i],
		334	nfingers == i + 1);
		335	}
		336
		337	void
		338	evdev_push_nfingers(struct evdev_dev *evdev, int nfingers)
		339	{
		340	EVDEV_ENTER(evdev);
		341	evdev_send_nfingers(evdev, nfingers);
		342	EVDEV_EXIT(evdev);
		343	}

Lines 495-500 uinput_ioctl_sub(struct uinput_cdev_state *state, u_long cmd, caddr_t data) Link Here

(-)b/sys/dev/evdev/uinput.c (+1 lines)
495		495
496	evdev_set_methods(state->ucs_evdev, state, &uinput_ev_methods);	496	evdev_set_methods(state->ucs_evdev, state, &uinput_ev_methods);
497	evdev_set_flag(state->ucs_evdev, EVDEV_FLAG_SOFTREPEAT);	497	evdev_set_flag(state->ucs_evdev, EVDEV_FLAG_SOFTREPEAT);
		498	evdev_set_flag(state->ucs_evdev, EVDEV_FLAG_MT_KEEPID);
498	ret = evdev_register(state->ucs_evdev);	499	ret = evdev_register(state->ucs_evdev);
499	if (ret == 0)	500	if (ret == 0)
500	state->ucs_state = UINPUT_RUNNING;	501	state->ucs_state = UINPUT_RUNNING;

Lines 29-34 Link Here

(-)b/sys/dev/usb/input/wsp.c (-10 / +252 lines)
29	#include <sys/cdefs.h>	29	#include <sys/cdefs.h>
30	__FBSDID("$FreeBSD$");	30	__FBSDID("$FreeBSD$");
31		31
		32	#include "opt_evdev.h"
		33
32	#include <sys/param.h>	34	#include <sys/param.h>
33	#include <sys/systm.h>	35	#include <sys/systm.h>
34	#include <sys/kernel.h>	36	#include <sys/kernel.h>
Lines 56-61 __FBSDID("$FreeBSD$"); Link Here
56	#define USB_DEBUG_VAR wsp_debug	58	#define USB_DEBUG_VAR wsp_debug
57	#include <dev/usb/usb_debug.h>	59	#include <dev/usb/usb_debug.h>
58		60
		61	#ifdef EVDEV_SUPPORT
		62	#include <dev/evdev/input.h>
		63	#include <dev/evdev/evdev.h>
		64	#endif
		65
59	#include <sys/mouse.h>	66	#include <sys/mouse.h>
60		67
61	#define WSP_DRIVER_NAME "wsp"	68	#define WSP_DRIVER_NAME "wsp"
Lines 226-234 struct tp_finger { Link Here
226	} __packed;	233	} __packed;
227		234
228	/* trackpad finger data size, empirically at least ten fingers */	235	/* trackpad finger data size, empirically at least ten fingers */
		236	#ifdef EVDEV_SUPPORT
		237	#define MAX_FINGERS MAX_MT_SLOTS
		238	#else
229	#define MAX_FINGERS 16	239	#define MAX_FINGERS 16
		240	#endif
230	#define SIZEOF_FINGER sizeof(struct tp_finger)	241	#define SIZEOF_FINGER sizeof(struct tp_finger)
231	#define SIZEOF_ALL_FINGERS (MAX_FINGERS * SIZEOF_FINGER)	242	#define SIZEOF_ALL_FINGERS (MAX_FINGERS * SIZEOF_FINGER)
		243	#define MAX_FINGER_ORIENTATION 16384
232		244
233	#if (WSP_BUFFER_MAX < ((MAX_FINGERS * FSIZE_TYPE4) + FINGER_TYPE4))	245	#if (WSP_BUFFER_MAX < ((MAX_FINGERS * FSIZE_TYPE4) + FINGER_TYPE4))
234	#error "WSP_BUFFER_MAX is too small"	246	#error "WSP_BUFFER_MAX is too small"
Lines 251-256 enum { Link Here
251	WSP_FLAG_MAX,	263	WSP_FLAG_MAX,
252	};	264	};
253		265
		266	/* device-specific parameters */
		267	struct wsp_param {
		268	int snratio; /* signal-to-noise ratio */
		269	int min; /* device minimum reading */
		270	int max; /* device maximum reading */
		271	};
		272
254	/* device-specific configuration */	273	/* device-specific configuration */
255	struct wsp_dev_params {	274	struct wsp_dev_params {
256	uint8_t caps; /* device capability bitmask */	275	uint8_t caps; /* device capability bitmask */
Lines 266-273 struct wsp_dev_params { Link Here
266	uint8_t um_switch_idx; /* usb control message mode switch index */	285	uint8_t um_switch_idx; /* usb control message mode switch index */
267	uint8_t um_switch_on; /* usb control message mode switch on */	286	uint8_t um_switch_on; /* usb control message mode switch on */
268	uint8_t um_switch_off; /* usb control message mode switch off */	287	uint8_t um_switch_off; /* usb control message mode switch off */
		288	struct wsp_param p; /* finger pressure limits */
		289	struct wsp_param w; /* finger width limits */
		290	struct wsp_param x; /* horizontal limits */
		291	struct wsp_param y; /* vertical limits */
		292	struct wsp_param o; /* orientation limits */
269	};	293	};
270		294
		295	/* logical signal quality */
		296	#define SN_PRESSURE 45 /* pressure signal-to-noise ratio */
		297	#define SN_WIDTH 25 /* width signal-to-noise ratio */
		298	#define SN_COORD 250 /* coordinate signal-to-noise ratio */
		299	#define SN_ORIENT 10 /* orientation signal-to-noise ratio */
		300
271	static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = {	301	static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = {
272	[WSP_FLAG_WELLSPRING1] = {	302	[WSP_FLAG_WELLSPRING1] = {
273	.caps = 0,	303	.caps = 0,
Lines 283-288 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
283	.um_switch_idx = 0,	313	.um_switch_idx = 0,
284	.um_switch_on = 0x01,	314	.um_switch_on = 0x01,
285	.um_switch_off = 0x08,	315	.um_switch_off = 0x08,
		316	.p = { SN_PRESSURE, 0, 256 },
		317	.w = { SN_WIDTH, 0, 2048 },
		318	.x = { SN_COORD, -4824, 5342 },
		319	.y = { SN_COORD, -172, 5820 },
		320	.o = { SN_ORIENT,
		321	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
286	},	322	},
287	[WSP_FLAG_WELLSPRING2] = {	323	[WSP_FLAG_WELLSPRING2] = {
288	.caps = 0,	324	.caps = 0,
Lines 298-303 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
298	.um_switch_idx = 0,	334	.um_switch_idx = 0,
299	.um_switch_on = 0x01,	335	.um_switch_on = 0x01,
300	.um_switch_off = 0x08,	336	.um_switch_off = 0x08,
		337	.p = { SN_PRESSURE, 0, 256 },
		338	.w = { SN_WIDTH, 0, 2048 },
		339	.x = { SN_COORD, -4824, 4824 },
		340	.y = { SN_COORD, -172, 4290 },
		341	.o = { SN_ORIENT,
		342	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
301	},	343	},
302	[WSP_FLAG_WELLSPRING3] = {	344	[WSP_FLAG_WELLSPRING3] = {
303	.caps = HAS_INTEGRATED_BUTTON,	345	.caps = HAS_INTEGRATED_BUTTON,
Lines 313-318 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
313	.um_switch_idx = 0,	355	.um_switch_idx = 0,
314	.um_switch_on = 0x01,	356	.um_switch_on = 0x01,
315	.um_switch_off = 0x08,	357	.um_switch_off = 0x08,
		358	.p = { SN_PRESSURE, 0, 300 },
		359	.w = { SN_WIDTH, 0, 2048 },
		360	.x = { SN_COORD, -4460, 5166 },
		361	.y = { SN_COORD, -75, 6700 },
		362	.o = { SN_ORIENT,
		363	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
316	},	364	},
317	[WSP_FLAG_WELLSPRING4] = {	365	[WSP_FLAG_WELLSPRING4] = {
318	.caps = HAS_INTEGRATED_BUTTON,	366	.caps = HAS_INTEGRATED_BUTTON,
Lines 328-333 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
328	.um_switch_idx = 0,	376	.um_switch_idx = 0,
329	.um_switch_on = 0x01,	377	.um_switch_on = 0x01,
330	.um_switch_off = 0x08,	378	.um_switch_off = 0x08,
		379	.p = { SN_PRESSURE, 0, 300 },
		380	.w = { SN_WIDTH, 0, 2048 },
		381	.x = { SN_COORD, -4620, 5140 },
		382	.y = { SN_COORD, -150, 6600 },
		383	.o = { SN_ORIENT,
		384	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
331	},	385	},
332	[WSP_FLAG_WELLSPRING4A] = {	386	[WSP_FLAG_WELLSPRING4A] = {
333	.caps = HAS_INTEGRATED_BUTTON,	387	.caps = HAS_INTEGRATED_BUTTON,
Lines 343-348 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
343	.um_switch_idx = 0,	397	.um_switch_idx = 0,
344	.um_switch_on = 0x01,	398	.um_switch_on = 0x01,
345	.um_switch_off = 0x08,	399	.um_switch_off = 0x08,
		400	.p = { SN_PRESSURE, 0, 300 },
		401	.w = { SN_WIDTH, 0, 2048 },
		402	.x = { SN_COORD, -4616, 5112 },
		403	.y = { SN_COORD, -142, 5234 },
		404	.o = { SN_ORIENT,
		405	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
346	},	406	},
347	[WSP_FLAG_WELLSPRING5] = {	407	[WSP_FLAG_WELLSPRING5] = {
348	.caps = HAS_INTEGRATED_BUTTON,	408	.caps = HAS_INTEGRATED_BUTTON,
Lines 358-363 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
358	.um_switch_idx = 0,	418	.um_switch_idx = 0,
359	.um_switch_on = 0x01,	419	.um_switch_on = 0x01,
360	.um_switch_off = 0x08,	420	.um_switch_off = 0x08,
		421	.p = { SN_PRESSURE, 0, 300 },
		422	.w = { SN_WIDTH, 0, 2048 },
		423	.x = { SN_COORD, -4415, 5050 },
		424	.y = { SN_COORD, -55, 6680 },
		425	.o = { SN_ORIENT,
		426	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
361	},	427	},
362	[WSP_FLAG_WELLSPRING6] = {	428	[WSP_FLAG_WELLSPRING6] = {
363	.caps = HAS_INTEGRATED_BUTTON,	429	.caps = HAS_INTEGRATED_BUTTON,
Lines 373-378 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
373	.um_switch_idx = 0,	439	.um_switch_idx = 0,
374	.um_switch_on = 0x01,	440	.um_switch_on = 0x01,
375	.um_switch_off = 0x08,	441	.um_switch_off = 0x08,
		442	.p = { SN_PRESSURE, 0, 300 },
		443	.w = { SN_WIDTH, 0, 2048 },
		444	.x = { SN_COORD, -4620, 5140 },
		445	.y = { SN_COORD, -150, 6600 },
		446	.o = { SN_ORIENT,
		447	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
376	},	448	},
377	[WSP_FLAG_WELLSPRING5A] = {	449	[WSP_FLAG_WELLSPRING5A] = {
378	.caps = HAS_INTEGRATED_BUTTON,	450	.caps = HAS_INTEGRATED_BUTTON,
Lines 388-393 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
388	.um_switch_idx = 0,	460	.um_switch_idx = 0,
389	.um_switch_on = 0x01,	461	.um_switch_on = 0x01,
390	.um_switch_off = 0x08,	462	.um_switch_off = 0x08,
		463	.p = { SN_PRESSURE, 0, 300 },
		464	.w = { SN_WIDTH, 0, 2048 },
		465	.x = { SN_COORD, -4750, 5280 },
		466	.y = { SN_COORD, -150, 6730 },
		467	.o = { SN_ORIENT,
		468	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
391	},	469	},
392	[WSP_FLAG_WELLSPRING6A] = {	470	[WSP_FLAG_WELLSPRING6A] = {
393	.caps = HAS_INTEGRATED_BUTTON,	471	.caps = HAS_INTEGRATED_BUTTON,
Lines 402-407 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
402	.um_switch_idx = 0,	480	.um_switch_idx = 0,
403	.um_switch_on = 0x01,	481	.um_switch_on = 0x01,
404	.um_switch_off = 0x08,	482	.um_switch_off = 0x08,
		483	.p = { SN_PRESSURE, 0, 300 },
		484	.w = { SN_WIDTH, 0, 2048 },
		485	.x = { SN_COORD, -4620, 5140 },
		486	.y = { SN_COORD, -150, 6600 },
		487	.o = { SN_ORIENT,
		488	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
405	},	489	},
406	[WSP_FLAG_WELLSPRING7] = {	490	[WSP_FLAG_WELLSPRING7] = {
407	.caps = HAS_INTEGRATED_BUTTON,	491	.caps = HAS_INTEGRATED_BUTTON,
Lines 417-422 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
417	.um_switch_idx = 0,	501	.um_switch_idx = 0,
418	.um_switch_on = 0x01,	502	.um_switch_on = 0x01,
419	.um_switch_off = 0x08,	503	.um_switch_off = 0x08,
		504	.p = { SN_PRESSURE, 0, 300 },
		505	.w = { SN_WIDTH, 0, 2048 },
		506	.x = { SN_COORD, -4750, 5280 },
		507	.y = { SN_COORD, -150, 6730 },
		508	.o = { SN_ORIENT,
		509	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
420	},	510	},
421	[WSP_FLAG_WELLSPRING7A] = {	511	[WSP_FLAG_WELLSPRING7A] = {
422	.caps = HAS_INTEGRATED_BUTTON,	512	.caps = HAS_INTEGRATED_BUTTON,
Lines 432-437 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
432	.um_switch_idx = 0,	522	.um_switch_idx = 0,
433	.um_switch_on = 0x01,	523	.um_switch_on = 0x01,
434	.um_switch_off = 0x08,	524	.um_switch_off = 0x08,
		525	.p = { SN_PRESSURE, 0, 300 },
		526	.w = { SN_WIDTH, 0, 2048 },
		527	.x = { SN_COORD, -4750, 5280 },
		528	.y = { SN_COORD, -150, 6730 },
		529	.o = { SN_ORIENT,
		530	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
435	},	531	},
436	[WSP_FLAG_WELLSPRING8] = {	532	[WSP_FLAG_WELLSPRING8] = {
437	.caps = HAS_INTEGRATED_BUTTON,	533	.caps = HAS_INTEGRATED_BUTTON,
Lines 447-452 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
447	.um_switch_idx = 0,	543	.um_switch_idx = 0,
448	.um_switch_on = 0x01,	544	.um_switch_on = 0x01,
449	.um_switch_off = 0x08,	545	.um_switch_off = 0x08,
		546	.p = { SN_PRESSURE, 0, 300 },
		547	.w = { SN_WIDTH, 0, 2048 },
		548	.x = { SN_COORD, -4620, 5140 },
		549	.y = { SN_COORD, -150, 6600 },
		550	.o = { SN_ORIENT,
		551	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
450	},	552	},
451	[WSP_FLAG_WELLSPRING9] = {	553	[WSP_FLAG_WELLSPRING9] = {
452	.caps = HAS_INTEGRATED_BUTTON,	554	.caps = HAS_INTEGRATED_BUTTON,
Lines 462-467 static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = { Link Here
462	.um_switch_idx = 1,	564	.um_switch_idx = 1,
463	.um_switch_on = 0x01,	565	.um_switch_on = 0x01,
464	.um_switch_off = 0x00,	566	.um_switch_off = 0x00,
		567	.p = { SN_PRESSURE, 0, 300 },
		568	.w = { SN_WIDTH, 0, 2048 },
		569	.x = { SN_COORD, -4828, 5345 },
		570	.y = { SN_COORD, -203, 6803 },
		571	.o = { SN_ORIENT,
		572	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION },
465	},	573	},
466	};	574	};
467	#define WSP_DEV(v,p,i) { USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, i) }	575	#define WSP_DEV(v,p,i) { USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, i) }
Lines 550-561 struct wsp_softc { Link Here
550		658
551	const struct wsp_dev_params sc_params; / device configuration */	659	const struct wsp_dev_params sc_params; / device configuration */
552		660
		661	#ifdef EVDEV_SUPPORT
		662	struct evdev_dev *sc_evdev;
		663	#endif
553	mousehw_t sc_hw;	664	mousehw_t sc_hw;
554	mousemode_t sc_mode;	665	mousemode_t sc_mode;
555	u_int sc_pollrate;	666	u_int sc_pollrate;
556	mousestatus_t sc_status;	667	mousestatus_t sc_status;
557	u_int sc_state;	668	u_int sc_state;
558	#define WSP_ENABLED 0x01	669	#define WSP_ENABLED 0x01
		670	#define WSP_EVDEV_OPENED 0x02
559		671
560	struct tp_finger index[MAX_FINGERS]; / finger index data */	672	struct tp_finger index[MAX_FINGERS]; / finger index data */
561	int16_t pos_x[MAX_FINGERS]; /* position array */	673	int16_t pos_x[MAX_FINGERS]; /* position array */
Lines 596-603 struct wsp_softc { Link Here
596	/*	708	/*
597	* function prototypes	709	* function prototypes
598	*/	710	*/
599	static usb_fifo_cmd_t wsp_start_read;	711	static usb_fifo_cmd_t wsp_fifo_start_read;
600	static usb_fifo_cmd_t wsp_stop_read;	712	static usb_fifo_cmd_t wsp_fifo_stop_read;
601	static usb_fifo_open_t wsp_open;	713	static usb_fifo_open_t wsp_open;
602	static usb_fifo_close_t wsp_close;	714	static usb_fifo_close_t wsp_close;
603	static usb_fifo_ioctl_t wsp_ioctl;	715	static usb_fifo_ioctl_t wsp_ioctl;
Lines 606-616 static struct usb_fifo_methods wsp_fifo_methods = { Link Here
606	.f_open = &wsp_open,	718	.f_open = &wsp_open,
607	.f_close = &wsp_close,	719	.f_close = &wsp_close,
608	.f_ioctl = &wsp_ioctl,	720	.f_ioctl = &wsp_ioctl,
609	.f_start_read = &wsp_start_read,	721	.f_start_read = &wsp_fifo_start_read,
610	.f_stop_read = &wsp_stop_read,	722	.f_stop_read = &wsp_fifo_stop_read,
611	.basename[0] = WSP_DRIVER_NAME,	723	.basename[0] = WSP_DRIVER_NAME,
612	};	724	};
613		725
		726	#ifdef EVDEV_SUPPORT
		727	static evdev_open_t wsp_ev_open;
		728	static evdev_close_t wsp_ev_close;
		729	static const struct evdev_methods wsp_evdev_methods = {
		730	.ev_open = &wsp_ev_open,
		731	.ev_close = &wsp_ev_close,
		732	};
		733	#endif
		734
614	/* device initialization and shutdown */	735	/* device initialization and shutdown */
615	static int wsp_enable(struct wsp_softc *sc);	736	static int wsp_enable(struct wsp_softc *sc);
616	static void wsp_disable(struct wsp_softc *sc);	737	static void wsp_disable(struct wsp_softc *sc);
Lines 816-821 wsp_attach(device_t dev) Link Here
816	sc->sc_touch = WSP_UNTOUCH;	937	sc->sc_touch = WSP_UNTOUCH;
817	sc->scr_mode = WSP_SCR_NONE;	938	sc->scr_mode = WSP_SCR_NONE;
818		939
		940	#ifdef EVDEV_SUPPORT
		941	sc->sc_evdev = evdev_alloc();
		942	evdev_set_name(sc->sc_evdev, device_get_desc(dev));
		943	evdev_set_phys(sc->sc_evdev, device_get_nameunit(dev));
		944	evdev_set_id(sc->sc_evdev, BUS_USB, uaa->info.idVendor,
		945	uaa->info.idProduct, 0);
		946	evdev_set_serial(sc->sc_evdev, usb_get_serial(uaa->device));
		947	evdev_set_methods(sc->sc_evdev, sc, &wsp_evdev_methods);
		948	evdev_support_prop(sc->sc_evdev, INPUT_PROP_POINTER);
		949	evdev_support_event(sc->sc_evdev, EV_SYN);
		950	evdev_support_event(sc->sc_evdev, EV_ABS);
		951	evdev_support_event(sc->sc_evdev, EV_KEY);
		952
		953	#define WSP_SUPPORT_ABS(evdev, code, param) \
		954	evdev_support_abs((evdev), (code), (param).min, (param).max, \
		955	((param).max - (param).min) / (param).snratio, 0, 0);
		956
		957	/* finger position */
		958	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_POSITION_X, sc->sc_params->x);
		959	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_POSITION_Y, sc->sc_params->y);
		960	/* finger pressure */
		961	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_PRESSURE, sc->sc_params->p);
		962	/* finger touch area */
		963	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_TOUCH_MAJOR, sc->sc_params->w);
		964	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_TOUCH_MINOR, sc->sc_params->w);
		965	/* finger approach area */
		966	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_WIDTH_MAJOR, sc->sc_params->w);
		967	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_WIDTH_MINOR, sc->sc_params->w);
		968	/* finger orientation */
		969	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_ORIENTATION, sc->sc_params->o);
		970	/* button properties */
		971	evdev_support_key(sc->sc_evdev, BTN_LEFT);
		972	if ((sc->sc_params->caps & HAS_INTEGRATED_BUTTON) != 0)
		973	evdev_support_prop(sc->sc_evdev, INPUT_PROP_BUTTONPAD);
		974	/* Enable automatic touch assignment for type B MT protocol */
		975	evdev_support_abs(sc->sc_evdev, ABS_MT_SLOT,
		976	0, MAX_FINGERS - 1, 0, 0, 0);
		977	evdev_support_abs(sc->sc_evdev, ABS_MT_TRACKING_ID,
		978	-1, MAX_FINGERS - 1, 0, 0, 0);
		979	evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_MT_TRACK);
		980	evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_MT_AUTOREL);
		981	/* Synaptics compatibility events */
		982	evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_MT_STCOMPAT);
		983
		984	err = evdev_register(sc->sc_evdev);
		985	if (err)
		986	goto detach;
		987	#endif
		988
819	return (0);	989	return (0);
820		990
821	detach:	991	detach:
Lines 837-842 wsp_detach(device_t dev) Link Here
837		1007
838	usb_fifo_detach(&sc->sc_fifo);	1008	usb_fifo_detach(&sc->sc_fifo);
839		1009
		1010	#ifdef EVDEV_SUPPORT
		1011	evdev_free(sc->sc_evdev);
		1012	#endif
		1013
840	usbd_transfer_unsetup(sc->sc_xfer, WSP_N_TRANSFER);	1014	usbd_transfer_unsetup(sc->sc_xfer, WSP_N_TRANSFER);
841		1015
842	mtx_destroy(&sc->sc_mutex);	1016	mtx_destroy(&sc->sc_mutex);
Lines 929-936 wsp_intr_callback(struct usb_xfer *xfer, usb_error_t error) Link Here
929	sc->pos_x[i] = f->abs_x;	1103	sc->pos_x[i] = f->abs_x;
930	sc->pos_y[i] = -f->abs_y;	1104	sc->pos_y[i] = -f->abs_y;
931	sc->index[i] = f;	1105	sc->index[i] = f;
		1106	#ifdef EVDEV_SUPPORT
		1107	if (evdev_rcpt_mask & EVDEV_RCPT_HW_MOUSE) {
		1108	union evdev_mt_slot slot_data = {
		1109	.id = i,
		1110	.x = f->abs_x,
		1111	.y = params->y.max + params->y.min - f->abs_y,
		1112	.p = f->pressure,
		1113	.maj = f->touch_major << 1,
		1114	.min = f->touch_minor << 1,
		1115	.w_maj = f->tool_major << 1,
		1116	.w_min = f->tool_minor << 1,
		1117	.ori = params->o.max - f->orientation,
		1118	};
		1119	evdev_mt_push_slot(sc->sc_evdev, i, &slot_data);
		1120	}
		1121	#endif
932	}	1122	}
933		1123
		1124	#ifdef EVDEV_SUPPORT
		1125	if (evdev_rcpt_mask & EVDEV_RCPT_HW_MOUSE) {
		1126	evdev_push_key(sc->sc_evdev, BTN_LEFT, ibt);
		1127	evdev_sync(sc->sc_evdev);
		1128	}
		1129	#endif
934	sc->sc_status.flags &= ~MOUSE_POSCHANGED;	1130	sc->sc_status.flags &= ~MOUSE_POSCHANGED;
935	sc->sc_status.flags &= ~MOUSE_STDBUTTONSCHANGED;	1131	sc->sc_status.flags &= ~MOUSE_STDBUTTONSCHANGED;
936	sc->sc_status.obutton = sc->sc_status.button;	1132	sc->sc_status.obutton = sc->sc_status.button;
Lines 1235-1243 wsp_reset_buf(struct wsp_softc *sc) Link Here
1235	}	1431	}
1236		1432
1237	static void	1433	static void
1238	wsp_start_read(struct usb_fifo *fifo)	1434	wsp_start_read(struct wsp_softc *sc)
1239	{	1435	{
1240	struct wsp_softc *sc = usb_fifo_softc(fifo);
1241	int rate;	1436	int rate;
1242		1437
1243	/* Check if we should override the default polling interval */	1438	/* Check if we should override the default polling interval */
Lines 1258-1267 wsp_start_read(struct usb_fifo *fifo) Link Here
1258	}	1453	}
1259		1454
1260	static void	1455	static void
1261	wsp_stop_read(struct usb_fifo *fifo)	1456	wsp_stop_read(struct wsp_softc *sc)
1262	{	1457	{
1263	struct wsp_softc *sc = usb_fifo_softc(fifo);
1264
1265	usbd_transfer_stop(sc->sc_xfer[WSP_INTR_DT]);	1458	usbd_transfer_stop(sc->sc_xfer[WSP_INTR_DT]);
1266	}	1459	}
1267		1460
Lines 1301-1306 wsp_close(struct usb_fifo *fifo, int fflags) Link Here
1301	}	1494	}
1302	}	1495	}
1303		1496
		1497	static void
		1498	wsp_fifo_start_read(struct usb_fifo *fifo)
		1499	{
		1500	struct wsp_softc *sc = usb_fifo_softc(fifo);
		1501
		1502	wsp_start_read(sc);
		1503	}
		1504
		1505	static void
		1506	wsp_fifo_stop_read(struct usb_fifo *fifo)
		1507	{
		1508	struct wsp_softc *sc = usb_fifo_softc(fifo);
		1509
		1510	wsp_stop_read(sc);
		1511	}
		1512
		1513	#ifdef EVDEV_SUPPORT
		1514	static int
		1515	wsp_ev_open(struct evdev_dev *evdev)
		1516	{
		1517	struct wsp_softc *sc = evdev_get_softc(evdev);
		1518
		1519	mtx_lock(&sc->sc_mutex);
		1520	if ((sc->sc_state & WSP_ENABLED) == 0)
		1521	wsp_start_read(sc);
		1522	sc->sc_state \|= WSP_EVDEV_OPENED;
		1523	mtx_unlock(&sc->sc_mutex);
		1524
		1525	return (0);
		1526	}
		1527
		1528	static int
		1529	wsp_ev_close(struct evdev_dev *evdev)
		1530	{
		1531	struct wsp_softc *sc = evdev_get_softc(evdev);
		1532
		1533	mtx_lock(&sc->sc_mutex);
		1534	sc->sc_state &= ~WSP_EVDEV_OPENED;
		1535	if ((sc->sc_state & WSP_ENABLED) == 0)
		1536	wsp_stop_read(sc);
		1537	mtx_unlock(&sc->sc_mutex);
		1538
		1539	return (0);
		1540	}
		1541	#endif
		1542
1304	int	1543	int
1305	wsp_ioctl(struct usb_fifo fifo, u_long cmd, void addr, int fflags)	1544	wsp_ioctl(struct usb_fifo fifo, u_long cmd, void addr, int fflags)
1306	{	1545	{
Lines 1412-1416 static devclass_t wsp_devclass; Link Here
1412	DRIVER_MODULE(wsp, uhub, wsp_driver, wsp_devclass, NULL, 0);	1651	DRIVER_MODULE(wsp, uhub, wsp_driver, wsp_devclass, NULL, 0);
1413	MODULE_DEPEND(wsp, usb, 1, 1, 1);	1652	MODULE_DEPEND(wsp, usb, 1, 1, 1);
1414	MODULE_DEPEND(wsp, hid, 1, 1, 1);	1653	MODULE_DEPEND(wsp, hid, 1, 1, 1);
		1654	#ifdef EVDEV_SUPPORT
		1655	MODULE_DEPEND(wsp, evdev, 1, 1, 1);
		1656	#endif
1415	MODULE_VERSION(wsp, 1);	1657	MODULE_VERSION(wsp, 1);
1416	USB_PNP_HOST_INFO(wsp_devs);	1658	USB_PNP_HOST_INFO(wsp_devs);

Lines 30-36 S= ${SRCTOP}/sys Link Here

(-)b/sys/modules/usb/wsp/Makefile (-2 / +2 lines)
30	.PATH: $S/dev/usb/input	30	.PATH: $S/dev/usb/input
31		31
32	KMOD= wsp	32	KMOD= wsp
33	SRCS= opt_bus.h opt_usb.h device_if.h bus_if.h usb_if.h vnode_if.h usbdevs.h \	33	SRCS= opt_bus.h opt_evdev.h opt_usb.h device_if.h bus_if.h usb_if.h \
34	wsp.c	34	vnode_if.h usbdevs.h wsp.c
35		35
36	.include <bsd.kmod.mk>	36	.include <bsd.kmod.mk>

Return to bug 252236

Lines 93-107 static void evdev_start_repeat(struct evdev_dev *, uint16_t); Link Here

(-)b/sys/dev/evdev/evdev.c (-39 / +39 lines)
93	static void evdev_stop_repeat(struct evdev_dev *);	93	static void evdev_stop_repeat(struct evdev_dev *);
94	static int evdev_check_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);	94	static int evdev_check_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);
95		95
96	static inline void
97	bit_change(bitstr_t *bitstr, int bit, int value)
98	{
99	if (value)
100	bit_set(bitstr, bit);
101	else
102	bit_clear(bitstr, bit);
103	}
104
105	struct evdev_dev *	96	struct evdev_dev *
106	evdev_alloc(void)	97	evdev_alloc(void)
107	{	98	{
Lines 315-323 evdev_register_common(struct evdev_dev *evdev) Link Here
315	}	306	}
316	}	307	}
317		308
318	/* Initialize multitouch protocol type B states */	309	/* Initialize multitouch protocol type B states or A to B convertor */
319	if (bit_test(evdev->ev_abs_flags, ABS_MT_SLOT) &&	310	if ((bit_test(evdev->ev_abs_flags, ABS_MT_SLOT) &&
320	evdev->ev_absinfo != NULL && MAXIMAL_MT_SLOT(evdev) > 0)	311	evdev->ev_absinfo != NULL && MAXIMAL_MT_SLOT(evdev) > 0) \|\|
		312	(bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK) &&
		313	bit_test(evdev->ev_abs_flags, ABS_MT_POSITION_X) &&
		314	bit_test(evdev->ev_abs_flags, ABS_MT_POSITION_Y)))
321	evdev_mt_init(evdev);	315	evdev_mt_init(evdev);
322		316
323	/* Estimate maximum report size */	317	/* Estimate maximum report size */
Lines 720-734 evdev_modify_event(struct evdev_dev *evdev, uint16_t type, uint16_t code, Link Here
720	break;	714	break;
721		715
722	case EV_ABS:	716	case EV_ABS:
723	fuzz = evdev->ev_absinfo[code].fuzz;	717	if (code == ABS_MT_SLOT)
724	if (fuzz == 0 \|\| code == ABS_MT_SLOT)
725	break;	718	break;
726	else if (!ABS_IS_MT(code))	719	else if (!ABS_IS_MT(code))
727	old_value = evdev->ev_absinfo[code].value;	720	old_value = evdev->ev_absinfo[code].value;
728	else if (bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))	721	else if (!bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))
729	old_value = evdev_get_mt_value(evdev,	722	/* Pass MT protocol type A events as is */
730	evdev_get_last_mt_slot(evdev), code);	723	break;
731	else /* Pass MT protocol type A events as is */	724	else if (code == ABS_MT_TRACKING_ID) {
		725	*value = evdev_mt_reassign_id(evdev,
		726	evdev_mt_get_last_slot(evdev), *value);
		727	break;
		728	} else
		729	old_value = evdev_mt_get_value(evdev,
		730	evdev_mt_get_last_slot(evdev), code);
		731
		732	fuzz = evdev->ev_absinfo[code].fuzz;
		733	if (fuzz == 0)
732	break;	734	break;
733		735
734	abs_change = abs(*value - old_value);	736	abs_change = abs(*value - old_value);
Lines 807-813 evdev_sparse_event(struct evdev_dev *evdev, uint16_t type, uint16_t code, Link Here
807	switch (code) {	809	switch (code) {
808	case ABS_MT_SLOT:	810	case ABS_MT_SLOT:
809	/* Postpone ABS_MT_SLOT till next event */	811	/* Postpone ABS_MT_SLOT till next event */
810	evdev_set_last_mt_slot(evdev, value);	812	evdev_mt_set_last_slot(evdev, value);
811	return (EV_SKIP_EVENT);	813	return (EV_SKIP_EVENT);
812		814
813	case ABS_MT_FIRST ... ABS_MT_LAST:	815	case ABS_MT_FIRST ... ABS_MT_LAST:
Lines 815-825 evdev_sparse_event(struct evdev_dev *evdev, uint16_t type, uint16_t code, Link Here
815	if (!bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))	817	if (!bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))
816	break;	818	break;
817	/* Don`t repeat MT protocol type B events */	819	/* Don`t repeat MT protocol type B events */
818	last_mt_slot = evdev_get_last_mt_slot(evdev);	820	last_mt_slot = evdev_mt_get_last_slot(evdev);
819	if (evdev_get_mt_value(evdev, last_mt_slot, code)	821	if (evdev_mt_get_value(evdev, last_mt_slot, code)
820	== value)	822	== value)
821	return (EV_SKIP_EVENT);	823	return (EV_SKIP_EVENT);
822	evdev_set_mt_value(evdev, last_mt_slot, code, value);	824	evdev_mt_set_value(evdev, last_mt_slot, code, value);
823	if (last_mt_slot != CURRENT_MT_SLOT(evdev)) {	825	if (last_mt_slot != CURRENT_MT_SLOT(evdev)) {
824	CURRENT_MT_SLOT(evdev) = last_mt_slot;	826	CURRENT_MT_SLOT(evdev) = last_mt_slot;
825	evdev->ev_report_opened = true;	827	evdev->ev_report_opened = true;
Lines 895-900 evdev_send_event(struct evdev_dev *evdev, uint16_t type, uint16_t code, Link Here
895		897
896	EVDEV_LOCK_ASSERT(evdev);	898	EVDEV_LOCK_ASSERT(evdev);
897		899
		900	evdev_modify_event(evdev, type, code, &value);
898	sparse = evdev_sparse_event(evdev, type, code, value);	901	sparse = evdev_sparse_event(evdev, type, code, value);
899	switch (sparse) {	902	switch (sparse) {
900	case EV_REPORT_MT_SLOT:	903	case EV_REPORT_MT_SLOT:
Lines 918-937 evdev_restore_after_kdb(struct evdev_dev *evdev) Link Here
918	EVDEV_LOCK_ASSERT(evdev);	921	EVDEV_LOCK_ASSERT(evdev);
919		922
920	/* Report postponed leds */	923	/* Report postponed leds */
921	for (code = 0; code < LED_CNT; code++)	924	bit_foreach(evdev->ev_kdb_led_states, LED_CNT, code)
922	if (bit_test(evdev->ev_kdb_led_states, code))	925	evdev_send_event(evdev, EV_LED, code,
923	evdev_send_event(evdev, EV_LED, code,	926	!bit_test(evdev->ev_led_states, code));
924	!bit_test(evdev->ev_led_states, code));
925	bit_nclear(evdev->ev_kdb_led_states, 0, LED_MAX);	927	bit_nclear(evdev->ev_kdb_led_states, 0, LED_MAX);
926		928
927	/* Release stuck keys (CTRL + ALT + ESC) */	929	/* Release stuck keys (CTRL + ALT + ESC) */
928	evdev_stop_repeat(evdev);	930	evdev_stop_repeat(evdev);
929	for (code = 0; code < KEY_CNT; code++) {	931	bit_foreach(evdev->ev_key_states, KEY_CNT, code)
930	if (bit_test(evdev->ev_key_states, code)) {	932	evdev_send_event(evdev, EV_KEY, code, KEY_EVENT_UP);
931	evdev_send_event(evdev, EV_KEY, code, KEY_EVENT_UP);	933	evdev_send_event(evdev, EV_SYN, SYN_REPORT, 1);
932	evdev_send_event(evdev, EV_SYN, SYN_REPORT, 1);
933	}
934	}
935	}	934	}
936		935
937	int	936	int
Lines 962-976 evdev_push_event(struct evdev_dev *evdev, uint16_t type, uint16_t code, Link Here
962	evdev_restore_after_kdb(evdev);	961	evdev_restore_after_kdb(evdev);
963	}	962	}
964		963
965	evdev_modify_event(evdev, type, code, &value);
966	if (type == EV_SYN && code == SYN_REPORT &&	964	if (type == EV_SYN && code == SYN_REPORT &&
967	bit_test(evdev->ev_flags, EVDEV_FLAG_MT_AUTOREL))	965	bit_test(evdev->ev_abs_flags, ABS_MT_SLOT))
968	evdev_send_mt_autorel(evdev);	966	evdev_mt_sync_frame(evdev);
969	if (type == EV_SYN && code == SYN_REPORT && evdev->ev_report_opened &&	967	else
970	bit_test(evdev->ev_flags, EVDEV_FLAG_MT_STCOMPAT))	968	if (bit_test(evdev->ev_flags, EVDEV_FLAG_MT_TRACK) &&
971	evdev_send_mt_compat(evdev);	969	evdev_mt_record_event(evdev, type, code, value))
972	evdev_send_event(evdev, type, code, value);	970	goto exit;
973		971
		972	evdev_send_event(evdev, type, code, value);
		973	exit:
974	EVDEV_EXIT(evdev);	974	EVDEV_EXIT(evdev);
975		975
976	return (0);	976	return (0);

Lines 247-252 struct evdev_client Link Here

(-)b/sys/dev/evdev/evdev_private.h (-6 / +24 lines)
247	(((client)->ec_buffer_ready + (client)->ec_buffer_size - \	247	(((client)->ec_buffer_ready + (client)->ec_buffer_size - \
248	(client)->ec_buffer_head) % (client)->ec_buffer_size)	248	(client)->ec_buffer_head) % (client)->ec_buffer_size)
249		249
		250	/* bitstring(3) helpers */
		251	static inline void
		252	bit_change(bitstr_t *bitstr, int bit, int value)
		253	{
		254	if (value)
		255	bit_set(bitstr, bit);
		256	else
		257	bit_clear(bitstr, bit);
		258	}
		259	#define bit_foreach_at(_bitstr, _start, _nbits, _iter) \
		260	for (bit_ffs_at((_bitstr), (_start), (_nbits), &(_iter)); \
		261	(_iter) != -1; \
		262	bit_ffs_at((_bitstr), (_iter) + 1, (_nbits), &(_iter)))
		263	#define bit_foreach(_bitstr, _nbits, _iter) \
		264	bit_foreach_at(_bitstr, /start/0, _nbits, _iter)
		265
250	/* Input device interface: */	266	/* Input device interface: */
251	void evdev_send_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);	267	void evdev_send_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);
252	int evdev_inject_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);	268	int evdev_inject_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);
Lines 269-282 void evdev_revoke_client(struct evdev_client *); Link Here
269	/* Multitouch related functions: */	285	/* Multitouch related functions: */
270	void evdev_mt_init(struct evdev_dev *);	286	void evdev_mt_init(struct evdev_dev *);
271	void evdev_mt_free(struct evdev_dev *);	287	void evdev_mt_free(struct evdev_dev *);
272	int32_t evdev_get_last_mt_slot(struct evdev_dev *);	288	void evdev_mt_sync_frame(struct evdev_dev *);
273	void evdev_set_last_mt_slot(struct evdev_dev *, int32_t);	289	int evdev_mt_get_last_slot(struct evdev_dev *);
274	int32_t evdev_get_mt_value(struct evdev_dev *, int32_t, int16_t);	290	void evdev_mt_set_last_slot(struct evdev_dev *, int);
275	void evdev_set_mt_value(struct evdev_dev *, int32_t, int16_t, int32_t);	291	int32_t evdev_mt_get_value(struct evdev_dev *, int, int16_t);
276	void evdev_send_mt_compat(struct evdev_dev *);	292	void evdev_mt_set_value(struct evdev_dev *, int, int16_t, int32_t);
277	void evdev_send_mt_autorel(struct evdev_dev *);	293	bool evdev_mt_record_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);
		294	int32_t evdev_mt_reassign_id(struct evdev_dev *, int, int32_t);
278		295
279	/* Utility functions: */	296	/* Utility functions: */
280	void evdev_client_dumpqueue(struct evdev_client *);	297	void evdev_client_dumpqueue(struct evdev_client *);
		298	void evdev_send_nfingers(struct evdev_dev *, int);
281		299
282	#endif /* _DEV_EVDEV_EVDEV_PRIVATE_H */	300	#endif /* _DEV_EVDEV_EVDEV_PRIVATE_H */