Attachment #224968 for bug #252236

Lines 1820-1825 dev/gpio/gpio_if.m optional gpio Link Here

(-)b/sys/conf/files (+1 lines)
1820	dev/gpio/gpiobus_if.m optional gpio	1820	dev/gpio/gpiobus_if.m optional gpio
1821	dev/gpio/gpiopps.c optional gpiopps fdt	1821	dev/gpio/gpiopps.c optional gpiopps fdt
1822	dev/gpio/ofw_gpiobus.c optional fdt gpio	1822	dev/gpio/ofw_gpiobus.c optional fdt gpio
		1823	dev/hid/bcm5974.c optional bcm5974
1823	dev/hid/hconf.c optional hconf	1824	dev/hid/hconf.c optional hconf
1824	dev/hid/hcons.c optional hcons	1825	dev/hid/hcons.c optional hcons
1825	dev/hid/hgame.c optional hgame	1826	dev/hid/hgame.c optional hgame

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_KEEPID 0x04 /* Do not reassign tracking ID */
		94	#define EVDEV_FLAG_MT_TRACK 0x05 /* Assign touch to slot by evdev */
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);
		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 tracking IDs to the points in the pt array.  The tracking ID
 * 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.
 * Set tracking id to -1 for unassigned (new) points.
 */
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;

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

	if (size == 0)
		return;

	p = mt->matrix;
	num_touches = bitcount(mt->touches);
	if (num_touches >= size) {
		FOREACHBIT(mt->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(mt->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 ? c2r : r2c);
	for (i = 0; i < size; i++)
		if (*p++ < 0)
			pt[i].id = -1;

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

static void
evdev_mt_send_frame(struct evdev_dev *evdev, union evdev_mt_slot *pt, int size)
{
	struct evdev_mt *mt = evdev->ev_mt;
	union evdev_mt_slot *slot;

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

	/*
	 * While MT-matching assign tracking IDs of new contacts to be equal
	 * to a slot number to make things simpler.
	 */
	for (slot = pt; slot < pt + size; slot++) {
		if (slot->id < 0)
			slot->id = ffc_slot(evdev, mt->touches | mt->frame);
		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"));

	/*
	 * 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);
int32_t evdev_mt_reassign_id(struct evdev_dev *, int, int32_t);
bool evdev_mt_record_event(struct evdev_dev *, uint16_t, uint16_t, 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;




/*-
 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
 *
 * Copyright (c) 2012 Huang Wen Hui
 * Copyright (c) 2021 Vladimir Kondratyev <wulf@FreeBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/endian.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/sysctl.h>
#include <sys/systm.h>

#include <dev/evdev/input.h>
#include <dev/evdev/evdev.h>

#define HID_DEBUG_VAR   bcm5974_debug
#include <dev/hid/hid.h>
#include <dev/hid/hidbus.h>
#include <dev/hid/hidquirk.h>

/* Enable support for Type1 & Type2 trackpads */
#define	BCM5974_USB	1

#ifdef BCM5974_USB
#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdi_util.h>
#include <dev/usb/usbhid.h>
#include <dev/usb/input/usbhid.h>
#endif

#include "usbdevs.h"

#define	BCM5974_BUFFER_MAX	(248 * 4)	/* 4 Type4 SPI frames */
#define	BCM5974_TLC_PAGE	HUP_GENERIC_DESKTOP
#define	BCM5974_TLC_USAGE	HUG_MOUSE

/* magic to switch device from HID (default) mode into raw */
/* Type1 & Type2 trackpads */
#define	BCM5974_USB_IFACE_INDEX	0
#define	BCM5974_USB_REPORT_LEN	8
#define	BCM5974_USB_REPORT_ID	0
#define	BCM5974_USB_MODE_RAW	0x01
#define	BCM5974_USB_MODE_HID	0x08
/* Type4 trackpads */
#define	BCM5974_HID_REPORT_LEN	2
#define	BCM5974_HID_REPORT_ID	2
#define	BCM5974_HID_MODE_RAW	0x01
#define	BCM5974_HID_MODE_HID	0x00

/* Tunables */
static	SYSCTL_NODE(_hw_hid, OID_AUTO, bcm5974, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
    "HID wellspring touchpad");

#ifdef HID_DEBUG
enum wsp_log_level {
	BCM5974_LLEVEL_DISABLED = 0,
	BCM5974_LLEVEL_ERROR,
	BCM5974_LLEVEL_DEBUG,		/* for troubleshooting */
	BCM5974_LLEVEL_INFO,		/* for diagnostics */
};
/* the default is to only log errors */
static int bcm5974_debug = BCM5974_LLEVEL_ERROR;

SYSCTL_INT(_hw_hid_bcm5974, OID_AUTO, debug, CTLFLAG_RWTUN,
    &bcm5974_debug, BCM5974_LLEVEL_ERROR, "BCM5974 debug level");
#endif					/* HID_DEBUG */

/*
 * Some tables, structures, definitions and constant values for the
 * touchpad protocol has been copied from Linux's
 * "drivers/input/mouse/bcm5974.c" which has the following copyright
 * holders under GPLv2. All device specific code in this driver has
 * been written from scratch. The decoding algorithm is based on
 * output from FreeBSD's usbdump.
 *
 * Copyright (C) 2008      Henrik Rydberg (rydberg@euromail.se)
 * Copyright (C) 2008      Scott Shawcroft (scott.shawcroft@gmail.com)
 * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
 * Copyright (C) 2005      Johannes Berg (johannes@sipsolutions.net)
 * Copyright (C) 2005      Stelian Pop (stelian@popies.net)
 * Copyright (C) 2005      Frank Arnold (frank@scirocco-5v-turbo.de)
 * Copyright (C) 2005      Peter Osterlund (petero2@telia.com)
 * Copyright (C) 2005      Michael Hanselmann (linux-kernel@hansmi.ch)
 * Copyright (C) 2006      Nicolas Boichat (nicolas@boichat.ch)
 */

/* trackpad header types */
enum tp_type {
#ifdef BCM5974_USB
	TYPE1,			/* plain trackpad */
	TYPE2,			/* button integrated in trackpad */
#endif
	TYPE3,			/* additional header fields since June 2013 */
	TYPE4,                  /* additional header field for pressure data */
	TYPE_CNT
};

/* list of device capability bits */
#define	HAS_INTEGRATED_BUTTON	1

struct tp_type_params {
	uint8_t	caps;		/* device capability bitmask */
	uint8_t	button;		/* offset to button data */
	uint8_t	offset;		/* offset to trackpad finger data */
	uint8_t delta;		/* offset from header to finger struct */
} const static tp[TYPE_CNT] = {
#ifdef BCM5974_USB
	[TYPE1] = {
		.caps = 0,
		.button = 0,
		.offset = 13 * 2,
		.delta = 0,
	},
	[TYPE2] = {
		.caps = HAS_INTEGRATED_BUTTON,
		.button = 15,
		.offset = 15 * 2,
		.delta = 0,
	},
#endif
	[TYPE3] = {
		.caps = HAS_INTEGRATED_BUTTON,
		.button = 23,
		.offset = 19 * 2,
		.delta = 0,
	},
	[TYPE4] = {
		.caps = HAS_INTEGRATED_BUTTON,
		.button = 31,
		.offset = 23 * 2,
		.delta = 2,
	},
};

/* trackpad finger structure - little endian */
struct tp_finger {
	int16_t	origin;			/* zero when switching track finger */
	int16_t	abs_x;			/* absolute x coodinate */
	int16_t	abs_y;			/* absolute y coodinate */
	int16_t	rel_x;			/* relative x coodinate */
	int16_t	rel_y;			/* relative y coodinate */
	int16_t	tool_major;		/* tool area, major axis */
	int16_t	tool_minor;		/* tool area, minor axis */
	int16_t	orientation;		/* 16384 when point, else 15 bit angle */
	int16_t	touch_major;		/* touch area, major axis */
	int16_t	touch_minor;		/* touch area, minor axis */
	int16_t	unused[2];		/* zeros */
	int16_t pressure;		/* pressure on forcetouch touchpad */
	int16_t	multi;			/* one finger: varies, more fingers:
				 	 * constant */
} __packed;

/* trackpad finger data size, empirically at least ten fingers */
#define	MAX_FINGERS		MAX_MT_SLOTS

#define	MAX_FINGER_ORIENTATION	16384

enum {
#ifdef BCM5974_USB
	BCM5974_FLAG_WELLSPRING1,
	BCM5974_FLAG_WELLSPRING2,
	BCM5974_FLAG_WELLSPRING3,
	BCM5974_FLAG_WELLSPRING4,
	BCM5974_FLAG_WELLSPRING4A,
	BCM5974_FLAG_WELLSPRING5,
	BCM5974_FLAG_WELLSPRING6A,
	BCM5974_FLAG_WELLSPRING6,
	BCM5974_FLAG_WELLSPRING5A,
	BCM5974_FLAG_WELLSPRING7,
	BCM5974_FLAG_WELLSPRING7A,
#endif
	BCM5974_FLAG_WELLSPRING8,
	BCM5974_FLAG_WELLSPRING9,
	BCM5974_FLAG_MAX,
};

/* device-specific parameters */
struct bcm5974_axis {
	int snratio;			/* signal-to-noise ratio */
	int min;			/* device minimum reading */
	int max;			/* device maximum reading */
	int size;			/* physical size, mm */
};

/* device-specific configuration */
struct bcm5974_dev_params {
	const struct tp_type_params* tp;
	struct bcm5974_axis p;		/* finger pressure limits */
	struct bcm5974_axis w;		/* finger width limits */
	struct bcm5974_axis x;		/* horizontal limits */
	struct bcm5974_axis y;		/* vertical limits */
	struct bcm5974_axis o;		/* orientation limits */
};

/* logical signal quality */
#define	SN_PRESSURE	45		/* pressure signal-to-noise ratio */
#define	SN_WIDTH	25		/* width signal-to-noise ratio */
#define	SN_COORD	250		/* coordinate signal-to-noise ratio */
#define	SN_ORIENT	10		/* orientation signal-to-noise ratio */

static const struct bcm5974_dev_params bcm5974_dev_params[BCM5974_FLAG_MAX] = {
#ifdef BCM5974_USB
	[BCM5974_FLAG_WELLSPRING1] = {
		.tp = tp + TYPE1,
		.p = { SN_PRESSURE, 0, 256, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4824, 5342, 105 },
		.y = { SN_COORD, -172, 5820, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
	[BCM5974_FLAG_WELLSPRING2] = {
		.tp = tp + TYPE1,
		.p = { SN_PRESSURE, 0, 256, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4824, 4824, 105 },
		.y = { SN_COORD, -172, 4290, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
	[BCM5974_FLAG_WELLSPRING3] = {
		.tp = tp + TYPE2,
		.p = { SN_PRESSURE, 0, 300, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4460, 5166, 105 },
		.y = { SN_COORD, -75, 6700, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
	[BCM5974_FLAG_WELLSPRING4] = {
		.tp = tp + TYPE2,
		.p = { SN_PRESSURE, 0, 300, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4620, 5140, 105 },
		.y = { SN_COORD, -150, 6600, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
	[BCM5974_FLAG_WELLSPRING4A] = {
		.tp = tp + TYPE2,
		.p = { SN_PRESSURE, 0, 300, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4616, 5112, 105 },
		.y = { SN_COORD, -142, 5234, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
	[BCM5974_FLAG_WELLSPRING5] = {
		.tp = tp + TYPE2,
		.p = { SN_PRESSURE, 0, 300, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4415, 5050, 105 },
		.y = { SN_COORD, -55, 6680, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
	[BCM5974_FLAG_WELLSPRING6] = {
		.tp = tp + TYPE2,
		.p = { SN_PRESSURE, 0, 300, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4620, 5140, 105 },
		.y = { SN_COORD, -150, 6600, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
	[BCM5974_FLAG_WELLSPRING5A] = {
		.tp = tp + TYPE2,
		.p = { SN_PRESSURE, 0, 300, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4750, 5280, 105 },
		.y = { SN_COORD, -150, 6730, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
	[BCM5974_FLAG_WELLSPRING6A] = {
		.tp = tp + TYPE2,
		.p = { SN_PRESSURE, 0, 300, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4620, 5140, 105 },
		.y = { SN_COORD, -150, 6600, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
	[BCM5974_FLAG_WELLSPRING7] = {
		.tp = tp + TYPE2,
		.p = { SN_PRESSURE, 0, 300, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4750, 5280, 105 },
		.y = { SN_COORD, -150, 6730, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
	[BCM5974_FLAG_WELLSPRING7A] = {
		.tp = tp + TYPE2,
		.p = { SN_PRESSURE, 0, 300, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4750, 5280, 105 },
		.y = { SN_COORD, -150, 6730, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
#endif
	[BCM5974_FLAG_WELLSPRING8] = {
		.tp = tp + TYPE3,
		.p = { SN_PRESSURE, 0, 300, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4620, 5140, 105 },
		.y = { SN_COORD, -150, 6600, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
	[BCM5974_FLAG_WELLSPRING9] = {
		.tp = tp + TYPE4,
		.p = { SN_PRESSURE, 0, 300, 0 },
		.w = { SN_WIDTH, 0, 2048, 0 },
		.x = { SN_COORD, -4828, 5345, 105 },
		.y = { SN_COORD, -203, 6803, 75 },
		.o = { SN_ORIENT,
		    -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
	},
};

#define	BCM5974_DEV(v,p,i)	{					\
	HID_BVPI(BUS_USB, USB_VENDOR_##v, USB_PRODUCT_##v##_##p, i),	\
	HID_TLC(BCM5974_TLC_PAGE, BCM5974_TLC_USAGE),			\
}

static const struct hid_device_id bcm5974_devs[] = {
#ifdef BCM5974_USB
	/* MacbookAir1.1 */
	BCM5974_DEV(APPLE, WELLSPRING_ANSI, BCM5974_FLAG_WELLSPRING1),
	BCM5974_DEV(APPLE, WELLSPRING_ISO, BCM5974_FLAG_WELLSPRING1),
	BCM5974_DEV(APPLE, WELLSPRING_JIS, BCM5974_FLAG_WELLSPRING1),

	/* MacbookProPenryn, aka wellspring2 */
	BCM5974_DEV(APPLE, WELLSPRING2_ANSI, BCM5974_FLAG_WELLSPRING2),
	BCM5974_DEV(APPLE, WELLSPRING2_ISO, BCM5974_FLAG_WELLSPRING2),
	BCM5974_DEV(APPLE, WELLSPRING2_JIS, BCM5974_FLAG_WELLSPRING2),

	/* Macbook5,1 (unibody), aka wellspring3 */
	BCM5974_DEV(APPLE, WELLSPRING3_ANSI, BCM5974_FLAG_WELLSPRING3),
        BCM5974_DEV(APPLE, WELLSPRING3_ISO, BCM5974_FLAG_WELLSPRING3),
	BCM5974_DEV(APPLE, WELLSPRING3_JIS, BCM5974_FLAG_WELLSPRING3),

	/* MacbookAir3,2 (unibody), aka wellspring4 */
	BCM5974_DEV(APPLE, WELLSPRING4_ANSI, BCM5974_FLAG_WELLSPRING4),
	BCM5974_DEV(APPLE, WELLSPRING4_ISO, BCM5974_FLAG_WELLSPRING4),
	BCM5974_DEV(APPLE, WELLSPRING4_JIS, BCM5974_FLAG_WELLSPRING4),

	/* MacbookAir3,1 (unibody), aka wellspring4 */
	BCM5974_DEV(APPLE, WELLSPRING4A_ANSI, BCM5974_FLAG_WELLSPRING4A),
	BCM5974_DEV(APPLE, WELLSPRING4A_ISO, BCM5974_FLAG_WELLSPRING4A),
	BCM5974_DEV(APPLE, WELLSPRING4A_JIS, BCM5974_FLAG_WELLSPRING4A),

	/* Macbook8 (unibody, March 2011) */
	BCM5974_DEV(APPLE, WELLSPRING5_ANSI, BCM5974_FLAG_WELLSPRING5),
	BCM5974_DEV(APPLE, WELLSPRING5_ISO, BCM5974_FLAG_WELLSPRING5),
	BCM5974_DEV(APPLE, WELLSPRING5_JIS, BCM5974_FLAG_WELLSPRING5),

	/* MacbookAir4,1 (unibody, July 2011) */
	BCM5974_DEV(APPLE, WELLSPRING6A_ANSI, BCM5974_FLAG_WELLSPRING6A),
	BCM5974_DEV(APPLE, WELLSPRING6A_ISO, BCM5974_FLAG_WELLSPRING6A),
	BCM5974_DEV(APPLE, WELLSPRING6A_JIS, BCM5974_FLAG_WELLSPRING6A),

	/* MacbookAir4,2 (unibody, July 2011) */
	BCM5974_DEV(APPLE, WELLSPRING6_ANSI, BCM5974_FLAG_WELLSPRING6),
	BCM5974_DEV(APPLE, WELLSPRING6_ISO, BCM5974_FLAG_WELLSPRING6),
	BCM5974_DEV(APPLE, WELLSPRING6_JIS, BCM5974_FLAG_WELLSPRING6),

	/* Macbook8,2 (unibody) */
	BCM5974_DEV(APPLE, WELLSPRING5A_ANSI, BCM5974_FLAG_WELLSPRING5A),
	BCM5974_DEV(APPLE, WELLSPRING5A_ISO, BCM5974_FLAG_WELLSPRING5A),
	BCM5974_DEV(APPLE, WELLSPRING5A_JIS, BCM5974_FLAG_WELLSPRING5A),

	/* MacbookPro10,1 (unibody, June 2012) */
	/* MacbookPro11,1-3 (unibody, June 2013) */
	BCM5974_DEV(APPLE, WELLSPRING7_ANSI, BCM5974_FLAG_WELLSPRING7),
	BCM5974_DEV(APPLE, WELLSPRING7_ISO, BCM5974_FLAG_WELLSPRING7),
        BCM5974_DEV(APPLE, WELLSPRING7_JIS, BCM5974_FLAG_WELLSPRING7),

        /* MacbookPro10,2 (unibody, October 2012) */
        BCM5974_DEV(APPLE, WELLSPRING7A_ANSI, BCM5974_FLAG_WELLSPRING7A),
        BCM5974_DEV(APPLE, WELLSPRING7A_ISO, BCM5974_FLAG_WELLSPRING7A),
        BCM5974_DEV(APPLE, WELLSPRING7A_JIS, BCM5974_FLAG_WELLSPRING7A),
#endif
	/* MacbookAir6,2 (unibody, June 2013) */
	BCM5974_DEV(APPLE, WELLSPRING8_ANSI, BCM5974_FLAG_WELLSPRING8),
	BCM5974_DEV(APPLE, WELLSPRING8_ISO, BCM5974_FLAG_WELLSPRING8),
	BCM5974_DEV(APPLE, WELLSPRING8_JIS, BCM5974_FLAG_WELLSPRING8),

	/* MacbookPro12,1 MacbookPro11,4 */
	BCM5974_DEV(APPLE, WELLSPRING9_ANSI, BCM5974_FLAG_WELLSPRING9),
	BCM5974_DEV(APPLE, WELLSPRING9_ISO, BCM5974_FLAG_WELLSPRING9),
	BCM5974_DEV(APPLE, WELLSPRING9_JIS, BCM5974_FLAG_WELLSPRING9),
};

struct bcm5974_softc {
	device_t sc_dev;
	struct evdev_dev *sc_evdev;
	/* device configuration */
	const struct bcm5974_dev_params *sc_params;
};

static const uint8_t bcm5974_rdesc[] = {
	0x05, BCM5974_TLC_PAGE,	/* Usage Page (BCM5974_TLC_PAGE)	*/
	0x09, BCM5974_TLC_USAGE,/* Usage (BCM5974_TLC_USAGE)		*/
	0xA1, 0x01,		/* Collection (Application)		*/
	0x06, 0x00, 0xFF,	/*   Usage Page (Vendor Defined 0xFF00)	*/
	0x09, 0x01,		/*   Usage (0x01)			*/
	0x15, 0x00,		/*   Logical Minimum (0)		*/
	0x26, 0xFF, 0x00,	/*   Logical Maximum (255)		*/
	0x75, 0x08,		/*   Report Size (8)			*/
	0x96,			/*   Report Count (BCM5974_BUFFER_MAX)	*/
	BCM5974_BUFFER_MAX & 0xFF,
	BCM5974_BUFFER_MAX >> 8 & 0xFF,
	0x81, 0x02,		/*   Input (Data,Var,Abs)		*/
	0xC0,			/* End Collection			*/
};

/*
 * function prototypes
 */
static evdev_open_t	bcm5974_ev_open;
static evdev_close_t	bcm5974_ev_close;
static const struct evdev_methods bcm5974_evdev_methods = {
	.ev_open =	&bcm5974_ev_open,
	.ev_close =	&bcm5974_ev_close,
};
static hid_intr_t	bcm5974_intr;

/* Device methods. */
static device_identify_t bcm5974_identify;
static device_probe_t	bcm5974_probe;
static device_attach_t	bcm5974_attach;
static device_detach_t	bcm5974_detach;

#ifdef BCM5974_USB
/*
 * Type1 and Type2 touchpads use keyboard USB interface to switch from HID to
 * RAW mode. Although it is possible to extend hkbd driver to support such a
 * mode change requests, it's not wanted due to cross device tree dependencies.
 * So, find lowest common denominator (struct usb_device of grandparent usbhid
 * driver) of touchpad and keyboard drivers and issue direct USB requests.
 */
static int
bcm5974_set_device_mode_usb(struct bcm5974_softc *sc, bool on)
{
	uint8_t mode_bytes[BCM5974_USB_REPORT_LEN];
	struct usb_device *udev;
	device_t usbhid;
	usb_error_t err;

	usbhid = device_get_parent(device_get_parent(sc->sc_dev));
	if (device_get_devclass(usbhid) != devclass_find("usbhid"))
		return (ENXIO);
	udev = usbhid_get_usb_device(usbhid);

	err = usbd_req_get_report(udev, NULL, mode_bytes,
	    BCM5974_USB_REPORT_LEN, BCM5974_USB_IFACE_INDEX,
	    UHID_FEATURE_REPORT, BCM5974_USB_REPORT_ID);
	if (err != USB_ERR_NORMAL_COMPLETION) {
		DPRINTF("Failed to read device mode (%d)\n", err);
		return (EIO);
	}
#if 0
	/*
	 * XXX Need to wait at least 250ms for hardware to get
	 * ready. The device mode handling appears to be handled
	 * asynchronously and we should not issue these commands too
	 * quickly.
	 */
	pause("WHW", hz / 4);
#endif
	mode_bytes[0] = on ? BCM5974_USB_MODE_RAW : BCM5974_USB_MODE_HID;

	err = usbd_req_set_report(udev, NULL, mode_bytes,
	    BCM5974_USB_REPORT_LEN, BCM5974_USB_IFACE_INDEX,
	    UHID_FEATURE_REPORT, BCM5974_USB_REPORT_ID);
	if (err != USB_ERR_NORMAL_COMPLETION) {
		DPRINTF("Failed to write device mode (%d)\n", err);
		return (EIO);
	}

	return (0);
}
#endif

static int
bcm5974_set_device_mode_hid(struct bcm5974_softc *sc, bool on)
{
	uint8_t	mode_bytes[BCM5974_HID_REPORT_LEN] = {
		BCM5974_HID_REPORT_ID,
		on ? BCM5974_HID_MODE_RAW : BCM5974_HID_MODE_HID,
	};
#if 0
	int err;

	err = hid_get_report(sc->sc_dev, mode_bytes, BCM5974_HID_REPORT_LEN,
	    NULL, HID_FEATURE_REPORT, BCM5974_HID_REPORT_ID);
	if (err != 0) {
		DPRINTF("Failed to read device mode (%d)\n", err);
		return (err);
	}
	/*
	 * XXX Need to wait at least 250ms for hardware to get
	 * ready. The device mode handling appears to be handled
	 * asynchronously and we should not issue these commands too
	 * quickly.
	 */
	pause("WHW", hz / 4);
	mode_bytes[1] = on ? BCM5974_HID_MODE_RAW : BCM5974_HID_MODE_HID;
#endif
	return (hid_set_report(sc->sc_dev, mode_bytes, BCM5974_HID_REPORT_LEN,
	    HID_FEATURE_REPORT, BCM5974_HID_REPORT_ID));
}

static int
bcm5974_set_device_mode(struct bcm5974_softc *sc, bool on)
{
	int err = 0;

	switch (sc->sc_params->tp - tp) {
#ifdef BCM5974_USB
	case TYPE1:
	case TYPE2:
		err = bcm5974_set_device_mode_usb(sc, on);
		break;
#endif
	case TYPE3:	/* Type 3 does not require a mode switch */
		break;
	case TYPE4:
		err = bcm5974_set_device_mode_hid(sc, on);
		break;
	default:
		KASSERT(0 == 1, ("Unknown trackpad type"));
	}

	return (err);
}

static void
bcm5974_identify(driver_t *driver, device_t parent)
{
	void *d_ptr;
	hid_size_t d_len;

	/*
	 * The bcm5974 touchpad has no stable RAW mode TLC in its report
	 * descriptor.  So replace existing HID mode mouse TLC with dummy one
	 * to set proper transport layer buffer sizes, make driver probe
	 * simpler and prevent unwanted hms driver attachment.
	 */
	if (HIDBUS_LOOKUP_ID(parent, bcm5974_devs) != NULL &&
	    hid_get_report_descr(parent, &d_ptr, &d_len) == 0 &&
	    hid_is_mouse(d_ptr, d_len))
		hid_set_report_descr(parent, bcm5974_rdesc,
		    sizeof(bcm5974_rdesc));
}

static int
bcm5974_probe(device_t dev)
{
	int err;

	err = HIDBUS_LOOKUP_DRIVER_INFO(dev, bcm5974_devs);
	if (err != 0)
		return (err);

	hidbus_set_desc(dev, "Touchpad");

	return (BUS_PROBE_DEFAULT);
}

static int
bcm5974_attach(device_t dev)
{
	struct bcm5974_softc *sc = device_get_softc(dev);
	const struct hid_device_info *hw = hid_get_device_info(dev);
	int err;

	DPRINTFN(BCM5974_LLEVEL_INFO, "sc=%p\n", sc);

	sc->sc_dev = dev;

	/* get device specific configuration */
	sc->sc_params = bcm5974_dev_params + hidbus_get_driver_info(dev);

	sc->sc_evdev = evdev_alloc();
	evdev_set_name(sc->sc_evdev, device_get_desc(dev));
	evdev_set_phys(sc->sc_evdev, device_get_nameunit(dev));
	evdev_set_id(sc->sc_evdev, hw->idBus, hw->idVendor, hw->idProduct,
	    hw->idVersion);
	evdev_set_serial(sc->sc_evdev, hw->serial);
	evdev_set_methods(sc->sc_evdev, sc, &bcm5974_evdev_methods);
	evdev_support_prop(sc->sc_evdev, INPUT_PROP_POINTER);
	evdev_support_event(sc->sc_evdev, EV_SYN);
	evdev_support_event(sc->sc_evdev, EV_ABS);
	evdev_support_event(sc->sc_evdev, EV_KEY);
	evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_EXT_EPOCH); /* hidbus child */

#define BCM5974_ABS(evdev, code, param)					\
	evdev_support_abs((evdev), (code), (param).min, (param).max,	\
	((param).max - (param).min) / (param).snratio, 0,		\
	(param).size != 0 ? ((param).max - (param).min) / (param).size : 0);

	/* finger position */
	BCM5974_ABS(sc->sc_evdev, ABS_MT_POSITION_X, sc->sc_params->x);
	BCM5974_ABS(sc->sc_evdev, ABS_MT_POSITION_Y, sc->sc_params->y);
	/* finger pressure */
	BCM5974_ABS(sc->sc_evdev, ABS_MT_PRESSURE, sc->sc_params->p);
	/* finger touch area */
	BCM5974_ABS(sc->sc_evdev, ABS_MT_TOUCH_MAJOR, sc->sc_params->w);
	BCM5974_ABS(sc->sc_evdev, ABS_MT_TOUCH_MINOR, sc->sc_params->w);
	/* finger approach area */
	BCM5974_ABS(sc->sc_evdev, ABS_MT_WIDTH_MAJOR, sc->sc_params->w);
	BCM5974_ABS(sc->sc_evdev, ABS_MT_WIDTH_MINOR, sc->sc_params->w);
	/* finger orientation */
	BCM5974_ABS(sc->sc_evdev, ABS_MT_ORIENTATION, sc->sc_params->o);
	/* button properties */
	evdev_support_key(sc->sc_evdev, BTN_LEFT);
	if ((sc->sc_params->tp->caps & HAS_INTEGRATED_BUTTON) != 0)
		evdev_support_prop(sc->sc_evdev, INPUT_PROP_BUTTONPAD);
	/* Enable automatic touch assignment for type B MT protocol */
	evdev_support_abs(sc->sc_evdev, ABS_MT_SLOT,
	    0, MAX_FINGERS - 1, 0, 0, 0);
	evdev_support_abs(sc->sc_evdev, ABS_MT_TRACKING_ID,
	    -1, MAX_FINGERS - 1, 0, 0, 0);
	evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_MT_TRACK);
	evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_MT_AUTOREL);
	/* Synaptics compatibility events */
	evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_MT_STCOMPAT);

	err = evdev_register(sc->sc_evdev);
	if (err)
		goto detach;

	hidbus_set_intr(dev, bcm5974_intr, sc);

	return (0);

detach:
	bcm5974_detach(dev);
	return (ENOMEM);
}

static int
bcm5974_detach(device_t dev)
{
	struct bcm5974_softc *sc = device_get_softc(dev);

	evdev_free(sc->sc_evdev);

	return (0);
}

static void
bcm5974_intr(void *context, void *data, hid_size_t len)
{
	struct bcm5974_softc *sc = context;
	const struct bcm5974_dev_params *params = sc->sc_params;
	union evdev_mt_slot slot_data;
	struct tp_finger *f;
	int ntouch;			/* the finger number in touch */
	int ibt;			/* button status */
	int i;
	int slot;
	uint8_t fsize = sizeof(struct tp_finger) + params->tp->delta;

	if ((len < params->tp->offset + fsize) ||
	    ((len - params->tp->offset) % fsize) != 0) {
		DPRINTFN(BCM5974_LLEVEL_INFO, "Invalid length: %d, %x, %x\n",
		    len, sc->tp_data[0], sc->tp_data[1]);
		return;
	}

	ibt = ((uint8_t *)data)[params->tp->button];
	ntouch = (len - params->tp->offset) / fsize;

	for (i = 0, slot = 0; i != ntouch; i++) {
		f = (struct tp_finger *)(((uint8_t *)data) +
		    params->tp->offset + params->tp->delta + i * fsize);
		DPRINTFN(BCM5974_LLEVEL_INFO,
		    "[%d]ibt=%d, taps=%d, o=%4d, ax=%5d, ay=%5d, "
		    "rx=%5d, ry=%5d, tlmaj=%4d, tlmin=%4d, ot=%4x, "
		    "tchmaj=%4d, tchmin=%4d, presure=%4d, m=%4x\n",
		    i, ibt, ntouch, le16toh(f->origin), le16toh(f->abs_x),
		    le16toh(f->abs_y), le16toh(f->rel_x), le16toh(f->rel_y),
		    le16toh(f->tool_major), le16toh(f->tool_minor),
		    le16toh(f->orientation), le16toh(f->touch_major),
		    le16toh(f->touch_minor), le16toh(f->pressure),
		    le16toh(f->multi));

		if (f->touch_major == 0)
			continue;
		slot_data = (union evdev_mt_slot) {
			.id = slot,
			.x = le16toh(f->abs_x),
			.y = params->y.min + params->y.max - le16toh(f->abs_y),
			.p = le16toh(f->pressure),
			.maj = le16toh(f->touch_major) << 1,
			.min = le16toh(f->touch_minor) << 1,
			.w_maj = le16toh(f->tool_major) << 1,
			.w_min = le16toh(f->tool_minor) << 1,
			.ori = params->o.max - le16toh(f->orientation),
		};
		evdev_mt_push_slot(sc->sc_evdev, slot, &slot_data);
		slot++;
	}

	evdev_push_key(sc->sc_evdev, BTN_LEFT, ibt);
	evdev_sync(sc->sc_evdev);
}

static int
bcm5974_ev_open(struct evdev_dev *evdev)
{
	struct bcm5974_softc *sc = evdev_get_softc(evdev);
	int err;

	/*
	 * By default the touchpad behaves like a HID device, sending
	 * packets with reportID = 8. Such reports contain only
	 * limited information. They encode movement deltas and button
	 * events, but do not include data from the pressure
	 * sensors. The device input mode can be switched from HID
	 * reports to raw sensor data using vendor-specific USB
	 * control commands:
	 */
	err = bcm5974_set_device_mode(sc, true);
	if (err != 0) {
		DPRINTF("failed to set mode to RAW MODE (%d)\n", err);
		return (err);
	}

	return (hidbus_intr_start(sc->sc_dev));
}

static int
bcm5974_ev_close(struct evdev_dev *evdev)
{
	struct bcm5974_softc *sc = evdev_get_softc(evdev);
	int err;

	err = hidbus_intr_stop(sc->sc_dev);
	if (err != 0)
		return (err);

	/*
	 * During re-enumeration of the device we need to force the
	 * device back into HID mode before switching it to RAW
	 * mode. Else the device does not work like expected.
	 */
	err = bcm5974_set_device_mode(sc, false);
	if (err != 0)
		DPRINTF("Failed to set mode to HID MODE (%d)\n", err);

	return (err);
}

static device_method_t bcm5974_methods[] = {
	/* Device interface */
	DEVMETHOD(device_identify,	bcm5974_identify),
	DEVMETHOD(device_probe,		bcm5974_probe),
	DEVMETHOD(device_attach,	bcm5974_attach),
	DEVMETHOD(device_detach,	bcm5974_detach),
	DEVMETHOD_END
};

static driver_t bcm5974_driver = {
	.name = "bcm5974",
	.methods = bcm5974_methods,
	.size = sizeof(struct bcm5974_softc)
};

static devclass_t bcm5974_devclass;

DRIVER_MODULE(bcm5974, hidbus, bcm5974_driver, bcm5974_devclass, NULL, 0);
MODULE_DEPEND(bcm5974, hidbus, 1, 1, 1);
MODULE_DEPEND(bcm5974, hid, 1, 1, 1);
#ifdef BCM5974_USB
MODULE_DEPEND(bcm5974, usb, 1, 1, 1);
MODULE_DEPEND(bcm5974, usbhid, 1, 1, 1);
#endif
MODULE_DEPEND(bcm5974, evdev, 1, 1, 1);
MODULE_VERSION(bcm5974, 1);
HID_PNP_INFO(bcm5974_devs);

Lines 2175-2185 atp_probe(device_t self) Link Here

(-)b/sys/dev/usb/input/atp.c (-2 / +2 lines)
2175		2175
2176	if ((usbd_lookup_id_by_uaa(fg_devs, sizeof(fg_devs), uaa)) == 0)	2176	if ((usbd_lookup_id_by_uaa(fg_devs, sizeof(fg_devs), uaa)) == 0)
2177	return ((uaa->info.bInterfaceProtocol == UIPROTO_MOUSE) ?	2177	return ((uaa->info.bInterfaceProtocol == UIPROTO_MOUSE) ?
2178	0 : ENXIO);	2178	BUS_PROBE_DEFAULT : ENXIO);
2179		2179
2180	if ((usbd_lookup_id_by_uaa(wsp_devs, sizeof(wsp_devs), uaa)) == 0)	2180	if ((usbd_lookup_id_by_uaa(wsp_devs, sizeof(wsp_devs), uaa)) == 0)
2181	if (uaa->info.bIfaceIndex == WELLSPRING_INTERFACE_INDEX)	2181	if (uaa->info.bIfaceIndex == WELLSPRING_INTERFACE_INDEX)
2182	return (0);	2182	return (BUS_PROBE_DEFAULT);
2183		2183
2184	return (ENXIO);	2184	return (ENXIO);
2185	}	2185	}




#include <dev/usb/usbdi.h>
#include <dev/usb/usbdi_util.h>
#include <dev/usb/usbhid.h>
#include <dev/usb/input/usbhid.h>

#define	USB_DEBUG_VAR usbhid_debug
#include <dev/usb/usb_debug.h>

    &usbhid_debug, 0, "Debug level");
#endif

/* Second set of USB transfers for polling mode */
#define	POLL_XFER(xfer)	((xfer) + USBHID_N_TRANSFER)
	USBHID_INTR_IN_DT,
	USBHID_CTRL_DT,
	USBHID_N_TRANSFER,
};

struct usbhid_xfer_ctx;
typedef int usbhid_callback_t(struct usbhid_xfer_ctx *xfer_ctx);

union usbhid_device_request {
	struct {			/* INTR xfers */
		uint16_t maxlen;
		uint16_t actlen;
	} intr;
	struct usb_device_request ctrl;	/* CTRL xfers */
};

/* Syncronous USB transfer context */
struct usbhid_xfer_ctx {
	union usbhid_device_request req;


	struct mtx sc_mtx;
	struct usb_config sc_config[USBHID_N_TRANSFER];
	struct usb_xfer *sc_xfer[POLL_XFER(USBHID_N_TRANSFER)];
	struct usbhid_xfer_ctx sc_xfer_ctx[POLL_XFER(USBHID_N_TRANSFER)];

	struct usb_device *sc_udev;
	uint8_t	sc_iface_no;

static usbhid_callback_t usbhid_intr_handler_cb;
static usbhid_callback_t usbhid_sync_wakeup_cb;

struct usb_device *
usbhid_get_usb_device(device_t dev)
{
	struct usbhid_softc *sc = device_get_softc(dev);

	return (sc->sc_udev);
}

static void
usbhid_intr_out_callback(struct usb_xfer *xfer, usb_error_t error)
{

	},
};

static inline usb_frlength_t
usbhid_xfer_max_len(struct usb_xfer *xfer)
{
	return (xfer == NULL ? 0 : usbd_xfer_max_len(xfer));
}

static inline int
usbhid_xfer_check_len(struct usb_xfer *xfer, hid_size_t len)
{
	if (xfer == NULL)
		return (ENODEV);
	if (len > usbd_xfer_max_len(xfer))
		return (ENOBUFS);
	return (0);
}

static void
usbhid_intr_setup(device_t dev, hid_intr_t intr, void *context,
    struct hid_rdesc_info *rdesc)

	 * itself, typically by hkbd via CTRL+ALT+ESC sequences. Or if the HID
	 * keyboard driver was processing a key at the moment of panic.
	 */
	for (n = 0; n != POLL_XFER(USBHID_N_TRANSFER); n++) {
		sc->sc_xfer[n] = NULL;
		if (nowrite && n == USBHID_INTR_OUT_DT)
			continue;
		error = usbd_transfer_setup(sc->sc_udev, &sc->sc_iface_index,
		    sc->sc_xfer + n, sc->sc_config + n % USBHID_N_TRANSFER, 1,
		    (void *)(sc->sc_xfer_ctx + n), &sc->sc_mtx);
		if (error)
			DPRINTF("xfer %d setup error=%s\n", n,
			    usbd_errstr(error));
	}

	rdesc->rdsize = usbhid_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]);
	rdesc->grsize = usbhid_xfer_max_len(sc->sc_xfer[USBHID_CTRL_DT]);

	rdesc->rdsize = usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]);
	rdesc->grsize = usbd_xfer_max_len(sc->sc_xfer[USBHID_CTRL_DT]);
	rdesc->srsize = rdesc->grsize;
	rdesc->wrsize = nowrite ? rdesc->srsize :
	    usbhid_xfer_max_len(sc->sc_xfer[USBHID_INTR_OUT_DT]);

	sc->sc_intr_buf = malloc(rdesc->rdsize, M_USBDEV, M_ZERO | M_WAITOK);
}

	struct usbhid_softc* sc = device_get_softc(dev);

	usbd_transfer_unsetup(sc->sc_xfer, USBHID_N_TRANSFER);
	usbd_transfer_unsetup(
	    sc->sc_xfer, POLL_XFER(USBHID_N_TRANSFER));
	free(sc->sc_intr_buf, M_USBDEV);
}


{
	struct usbhid_softc* sc = device_get_softc(dev);

	if (sc->sc_xfer[USBHID_INTR_IN_DT] == NULL)
		return (ENODEV);

	mtx_lock(&sc->sc_mtx);
	sc->sc_xfer_ctx[USBHID_INTR_IN_DT] = (struct usbhid_xfer_ctx) {
		.req.intr.maxlen =

		.cb_ctx = sc,
		.buf = sc->sc_intr_buf,
	};
	sc->sc_xfer_ctx[POLL_XFER(USBHID_INTR_IN_DT)] = (struct usbhid_xfer_ctx) {
		.req.intr.maxlen =
		    usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]),
		.cb = usbhid_intr_handler_cb,
		.cb_ctx = sc,
		.buf = sc->sc_intr_buf,
	};
	usbd_transfer_start(sc->sc_xfer[USBHID_INTR_IN_DT]);
	usbd_transfer_start(sc->sc_xfer[POLL_XFER(USBHID_INTR_IN_DT)]);
	mtx_unlock(&sc->sc_mtx);

	return (0);


	usbd_transfer_drain(sc->sc_xfer[USBHID_INTR_IN_DT]);
	usbd_transfer_drain(sc->sc_xfer[USBHID_INTR_OUT_DT]);
	usbd_transfer_drain(sc->sc_xfer[POLL_XFER(USBHID_INTR_IN_DT)]);

	return (0);
}

	struct usbhid_softc* sc = device_get_softc(dev);

	usbd_transfer_poll(sc->sc_xfer + USBHID_INTR_IN_DT, 1);
	usbd_transfer_poll(sc->sc_xfer + POLL_XFER(USBHID_INTR_IN_DT), 1);
}

/*
 * HID interface
 */
static int
usbhid_sync_xfer(struct usbhid_softc* sc, enum usbhid_xfer xfer_idx,
    union usbhid_device_request *req, void *buf)
{
	int error, timeout;
	struct usbhid_xfer_ctx *xfer_ctx;

	xfer_ctx = sc->sc_xfer_ctx + xfer_idx;

	if (USB_IN_POLLING_MODE_FUNC()) {
		xfer_ctx = POLL_XFER(xfer_ctx);
		xfer_idx = POLL_XFER(xfer_idx);
	} else {
		mtx_lock(&sc->sc_mtx);
		++xfer_ctx->waiters;

	if (error == 0)
		*req = xfer_ctx->req;

	if (!USB_IN_POLLING_MODE_FUNC()) {
		*xfer_ctx = save;
	} else {
		xfer_ctx->influx = false;
		if (xfer_ctx->waiters != 0)
			wakeup_one(&xfer_ctx->waiters);

	return (error);
}

int
usbhid_do_request(device_t dev, enum usbhid_xfer xfer_idx,
    union usbhid_device_request *req, void *buf)
{
	struct usbhid_softc* sc = device_get_softc(dev);
	int error;

	error = usbhid_xfer_check_len(sc->sc_xfer[USBHID_CTRL_DT], 0);
	if (error)
		return (error);

	return (usbhid_sync_xfer(sc, xfer_idx, req, buf));
}

static int
usbhid_get_rdesc(device_t dev, void *buf, hid_size_t len)
{

	union usbhid_device_request req;
	int error;

	error = usbhid_xfer_check_len(sc->sc_xfer[USBHID_CTRL_DT], maxlen);
	if (error)
		return (error);

	req.ctrl.bmRequestType = UT_READ_CLASS_INTERFACE;
	req.ctrl.bRequest = UR_GET_REPORT;

{
	struct usbhid_softc* sc = device_get_softc(dev);
	union usbhid_device_request req;
	int error;

	error = usbhid_xfer_check_len(sc->sc_xfer[USBHID_CTRL_DT], len);
	if (error)
		return (error);

	req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;
	req.ctrl.bRequest = UR_SET_REPORT;

	union usbhid_device_request req;
	int error;

	error = usbhid_xfer_check_len(sc->sc_xfer[USBHID_INTR_IN_DT], maxlen);
	if (error)
		return (error);

	req.intr.maxlen = maxlen;
	error = usbhid_sync_xfer(sc, USBHID_INTR_IN_DT, &req, buf);

{
	struct usbhid_softc* sc = device_get_softc(dev);
	union usbhid_device_request req;
	int error;

	error = usbhid_xfer_check_len(sc->sc_xfer[USBHID_INTR_OUT_DT], len);
	if (error)
		return (error);

	req.intr.maxlen = len;
	return (usbhid_sync_xfer(sc, USBHID_INTR_OUT_DT, &req,

	struct usbhid_softc* sc = device_get_softc(dev);
	union usbhid_device_request req;

	if (sc->sc_xfer[USBHID_CTRL_DT] == NULL)
		return (ENODEV);

	/* Duration is measured in 4 milliseconds per unit. */
	req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;
	req.ctrl.bRequest = UR_SET_IDLE;

	struct usbhid_softc* sc = device_get_softc(dev);
	union usbhid_device_request req;

	if (sc->sc_xfer[USBHID_CTRL_DT] == NULL)
		return (ENODEV);

	req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;
	req.ctrl.bRequest = UR_SET_PROTOCOL;
	USETW(req.ctrl.wValue, protocol);




/*-
 * SPDX-License-Identifier: BSD-2-Clause-NetBSD
 *
 * Copyright (c) 2021 Vladimir Kondratyev <wulf@FreeBSD.org>
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Lennart Augustsson (lennart@augustsson.net) at
 * Carlstedt Research & Technology.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _USB_INPUT_USBHID_H_
#define _USB_INPUT_USBHID_H_

enum usbhid_xfer {
	USBHID_INTR_OUT_DT,
	USBHID_INTR_IN_DT,
	USBHID_CTRL_DT,
	USBHID_N_TRANSFER,
};

union usbhid_device_request {
	struct {                        /* INTR xfers */
		uint16_t maxlen;
		uint16_t actlen;
	} intr;
	struct usb_device_request ctrl; /* CTRL xfers */
};

struct usb_device *usbhid_get_usb_device(device_t);
int usbhid_do_request(device_t, enum usbhid_xfer,
    union usbhid_device_request *, void *);

#endif	/* _USB_INPUT_USBHID_H_ */

Lines 29-34 Link Here

(-)b/sys/dev/usb/input/wsp.c (-220 / +385 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 169-175 enum tp_type { Link Here
169	TYPE1, /* plain trackpad */	176	TYPE1, /* plain trackpad */
170	TYPE2, /* button integrated in trackpad */	177	TYPE2, /* button integrated in trackpad */
171	TYPE3, /* additional header fields since June 2013 */	178	TYPE3, /* additional header fields since June 2013 */
172	TYPE4 /* additional header field for pressure data */	179	TYPE4, /* additional header field for pressure data */
		180	TYPE_CNT
173	};	181	};
174		182
175	/* trackpad finger data offsets, le16-aligned */	183	/* trackpad finger data offsets, le16-aligned */
Lines 192-197 enum tp_type { Link Here
192	#define FSIZE_TYPE3 (14 * 2)	200	#define FSIZE_TYPE3 (14 * 2)
193	#define FSIZE_TYPE4 (15 * 2)	201	#define FSIZE_TYPE4 (15 * 2)
194		202
		203	struct tp {
		204	uint8_t caps; /* device capability bitmask */
		205	uint8_t button; /* offset to button data */
		206	uint8_t offset; /* offset to trackpad finger data */
		207	uint8_t fsize; /* bytes in single finger block */
		208	uint8_t delta; /* offset from header to finger struct */
		209	uint8_t iface_index;
		210	uint8_t um_size; /* usb control message length */
		211	uint8_t um_req_idx; /* usb control message index */
		212	uint8_t um_switch_idx; /* usb control message mode switch index */
		213	uint8_t um_switch_on; /* usb control message mode switch on */
		214	uint8_t um_switch_off; /* usb control message mode switch off */
		215	} const static tp[TYPE_CNT] = {
		216	[TYPE1] = {
		217	.caps = 0,
		218	.button = 0,
		219	.offset = FINGER_TYPE1,
		220	.fsize = FSIZE_TYPE1,
		221	.delta = 0,
		222	.iface_index = 0,
		223	.um_size = 8,
		224	.um_req_idx = 0x00,
		225	.um_switch_idx = 0,
		226	.um_switch_on = 0x01,
		227	.um_switch_off = 0x08,
		228	},
		229	[TYPE2] = {
		230	.caps = HAS_INTEGRATED_BUTTON,
		231	.button = BUTTON_TYPE2,
		232	.offset = FINGER_TYPE2,
		233	.fsize = FSIZE_TYPE2,
		234	.delta = 0,
		235	.iface_index = 0,
		236	.um_size = 8,
		237	.um_req_idx = 0x00,
		238	.um_switch_idx = 0,
		239	.um_switch_on = 0x01,
		240	.um_switch_off = 0x08,
		241	},
		242	[TYPE3] = {
		243	.caps = HAS_INTEGRATED_BUTTON,
		244	.button = BUTTON_TYPE3,
		245	.offset = FINGER_TYPE3,
		246	.fsize = FSIZE_TYPE3,
		247	.delta = 0,
		248	},
		249	[TYPE4] = {
		250	.caps = HAS_INTEGRATED_BUTTON,
		251	.button = BUTTON_TYPE4,
		252	.offset = FINGER_TYPE4,
		253	.fsize = FSIZE_TYPE4,
		254	.delta = 2,
		255	.iface_index = 2,
		256	.um_size = 2,
		257	.um_req_idx = 0x02,
		258	.um_switch_idx = 1,
		259	.um_switch_on = 0x01,
		260	.um_switch_off = 0x00,
		261	},
		262	};
		263
195	/* trackpad finger header - little endian */	264	/* trackpad finger header - little endian */
196	struct tp_header {	265	struct tp_header {
197	uint8_t flag;	266	uint8_t flag;
Lines 226-234 struct tp_finger { Link Here
226	} __packed;	295	} __packed;
227		296
228	/* trackpad finger data size, empirically at least ten fingers */	297	/* trackpad finger data size, empirically at least ten fingers */
		298	#ifdef EVDEV_SUPPORT
		299	#define MAX_FINGERS MAX_MT_SLOTS
		300	#else
229	#define MAX_FINGERS 16	301	#define MAX_FINGERS 16
		302	#endif
230	#define SIZEOF_FINGER sizeof(struct tp_finger)	303	#define SIZEOF_FINGER sizeof(struct tp_finger)
231	#define SIZEOF_ALL_FINGERS (MAX_FINGERS * SIZEOF_FINGER)	304	#define SIZEOF_ALL_FINGERS (MAX_FINGERS * SIZEOF_FINGER)
		305	#define MAX_FINGER_ORIENTATION 16384
232		306
233	#if (WSP_BUFFER_MAX < ((MAX_FINGERS * FSIZE_TYPE4) + FINGER_TYPE4))	307	#if (WSP_BUFFER_MAX < ((MAX_FINGERS * FSIZE_TYPE4) + FINGER_TYPE4))
234	#error "WSP_BUFFER_MAX is too small"	308	#error "WSP_BUFFER_MAX is too small"
Lines 251-467 enum { Link Here
251	WSP_FLAG_MAX,	325	WSP_FLAG_MAX,
252	};	326	};
253		327
		328	/* device-specific parameters */
		329	struct wsp_param {
		330	int snratio; /* signal-to-noise ratio */
		331	int min; /* device minimum reading */
		332	int max; /* device maximum reading */
		333	int size; /* physical size, mm */
		334	};
		335
254	/* device-specific configuration */	336	/* device-specific configuration */
255	struct wsp_dev_params {	337	struct wsp_dev_params {
256	uint8_t caps; /* device capability bitmask */	338	const struct tp* tp;
257	uint8_t tp_type; /* type of trackpad interface */	339	struct wsp_param p; /* finger pressure limits */
258	uint8_t tp_button; /* offset to button data */	340	struct wsp_param w; /* finger width limits */
259	uint8_t tp_offset; /* offset to trackpad finger data */	341	struct wsp_param x; /* horizontal limits */
260	uint8_t tp_fsize; /* bytes in single finger block */	342	struct wsp_param y; /* vertical limits */
261	uint8_t tp_delta; /* offset from header to finger struct */	343	struct wsp_param o; /* orientation limits */
262	uint8_t iface_index;
263	uint8_t um_size; /* usb control message length */
264	uint8_t um_req_val; /* usb control message value */
265	uint8_t um_req_idx; /* usb control message index */
266	uint8_t um_switch_idx; /* usb control message mode switch index */
267	uint8_t um_switch_on; /* usb control message mode switch on */
268	uint8_t um_switch_off; /* usb control message mode switch off */
269	};	344	};
270		345
		346	/* logical signal quality */
		347	#define SN_PRESSURE 45 /* pressure signal-to-noise ratio */
		348	#define SN_WIDTH 25 /* width signal-to-noise ratio */
		349	#define SN_COORD 250 /* coordinate signal-to-noise ratio */
		350	#define SN_ORIENT 10 /* orientation signal-to-noise ratio */
		351
271	static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = {	352	static const struct wsp_dev_params wsp_dev_params[WSP_FLAG_MAX] = {
272	[WSP_FLAG_WELLSPRING1] = {	353	[WSP_FLAG_WELLSPRING1] = {
273	.caps = 0,	354	.tp = tp + TYPE1,
274	.tp_type = TYPE1,	355	.p = { SN_PRESSURE, 0, 256, 0 },
275	.tp_button = 0,	356	.w = { SN_WIDTH, 0, 2048, 0 },
276	.tp_offset = FINGER_TYPE1,	357	.x = { SN_COORD, -4824, 5342, 105 },
277	.tp_fsize = FSIZE_TYPE1,	358	.y = { SN_COORD, -172, 5820, 75 },
278	.tp_delta = 0,	359	.o = { SN_ORIENT,
279	.iface_index = 0,	360	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
280	.um_size = 8,
281	.um_req_val = 0x03,
282	.um_req_idx = 0x00,
283	.um_switch_idx = 0,
284	.um_switch_on = 0x01,
285	.um_switch_off = 0x08,
286	},	361	},
287	[WSP_FLAG_WELLSPRING2] = {	362	[WSP_FLAG_WELLSPRING2] = {
288	.caps = 0,	363	.tp = tp + TYPE1,
289	.tp_type = TYPE1,	364	.p = { SN_PRESSURE, 0, 256, 0 },
290	.tp_button = 0,	365	.w = { SN_WIDTH, 0, 2048, 0 },
291	.tp_offset = FINGER_TYPE1,	366	.x = { SN_COORD, -4824, 4824, 105 },
292	.tp_fsize = FSIZE_TYPE1,	367	.y = { SN_COORD, -172, 4290, 75 },
293	.tp_delta = 0,	368	.o = { SN_ORIENT,
294	.iface_index = 0,	369	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
295	.um_size = 8,
296	.um_req_val = 0x03,
297	.um_req_idx = 0x00,
298	.um_switch_idx = 0,
299	.um_switch_on = 0x01,
300	.um_switch_off = 0x08,
301	},	370	},
302	[WSP_FLAG_WELLSPRING3] = {	371	[WSP_FLAG_WELLSPRING3] = {
303	.caps = HAS_INTEGRATED_BUTTON,	372	.tp = tp + TYPE2,
304	.tp_type = TYPE2,	373	.p = { SN_PRESSURE, 0, 300, 0 },
305	.tp_button = BUTTON_TYPE2,	374	.w = { SN_WIDTH, 0, 2048, 0 },
306	.tp_offset = FINGER_TYPE2,	375	.x = { SN_COORD, -4460, 5166, 105 },
307	.tp_fsize = FSIZE_TYPE2,	376	.y = { SN_COORD, -75, 6700, 75 },
308	.tp_delta = 0,	377	.o = { SN_ORIENT,
309	.iface_index = 0,	378	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
310	.um_size = 8,
311	.um_req_val = 0x03,
312	.um_req_idx = 0x00,
313	.um_switch_idx = 0,
314	.um_switch_on = 0x01,
315	.um_switch_off = 0x08,
316	},	379	},
317	[WSP_FLAG_WELLSPRING4] = {	380	[WSP_FLAG_WELLSPRING4] = {
318	.caps = HAS_INTEGRATED_BUTTON,	381	.tp = tp + TYPE2,
319	.tp_type = TYPE2,	382	.p = { SN_PRESSURE, 0, 300, 0 },
320	.tp_button = BUTTON_TYPE2,	383	.w = { SN_WIDTH, 0, 2048, 0 },
321	.tp_offset = FINGER_TYPE2,	384	.x = { SN_COORD, -4620, 5140, 105 },
322	.tp_fsize = FSIZE_TYPE2,	385	.y = { SN_COORD, -150, 6600, 75 },
323	.tp_delta = 0,	386	.o = { SN_ORIENT,
324	.iface_index = 0,	387	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
325	.um_size = 8,
326	.um_req_val = 0x03,
327	.um_req_idx = 0x00,
328	.um_switch_idx = 0,
329	.um_switch_on = 0x01,
330	.um_switch_off = 0x08,
331	},	388	},
332	[WSP_FLAG_WELLSPRING4A] = {	389	[WSP_FLAG_WELLSPRING4A] = {
333	.caps = HAS_INTEGRATED_BUTTON,	390	.tp = tp + TYPE2,
334	.tp_type = TYPE2,	391	.p = { SN_PRESSURE, 0, 300, 0 },
335	.tp_button = BUTTON_TYPE2,	392	.w = { SN_WIDTH, 0, 2048, 0 },
336	.tp_offset = FINGER_TYPE2,	393	.x = { SN_COORD, -4616, 5112, 105 },
337	.tp_fsize = FSIZE_TYPE2,	394	.y = { SN_COORD, -142, 5234, 75 },
338	.tp_delta = 0,	395	.o = { SN_ORIENT,
339	.iface_index = 0,	396	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
340	.um_size = 8,
341	.um_req_val = 0x03,
342	.um_req_idx = 0x00,
343	.um_switch_idx = 0,
344	.um_switch_on = 0x01,
345	.um_switch_off = 0x08,
346	},	397	},
347	[WSP_FLAG_WELLSPRING5] = {	398	[WSP_FLAG_WELLSPRING5] = {
348	.caps = HAS_INTEGRATED_BUTTON,	399	.tp = tp + TYPE2,
349	.tp_type = TYPE2,	400	.p = { SN_PRESSURE, 0, 300, 0 },
350	.tp_button = BUTTON_TYPE2,	401	.w = { SN_WIDTH, 0, 2048, 0 },
351	.tp_offset = FINGER_TYPE2,	402	.x = { SN_COORD, -4415, 5050, 105 },
352	.tp_fsize = FSIZE_TYPE2,	403	.y = { SN_COORD, -55, 6680, 75 },
353	.tp_delta = 0,	404	.o = { SN_ORIENT,
354	.iface_index = 0,	405	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
355	.um_size = 8,
356	.um_req_val = 0x03,
357	.um_req_idx = 0x00,
358	.um_switch_idx = 0,
359	.um_switch_on = 0x01,
360	.um_switch_off = 0x08,
361	},	406	},
362	[WSP_FLAG_WELLSPRING6] = {	407	[WSP_FLAG_WELLSPRING6] = {
363	.caps = HAS_INTEGRATED_BUTTON,	408	.tp = tp + TYPE2,
364	.tp_type = TYPE2,	409	.p = { SN_PRESSURE, 0, 300, 0 },
365	.tp_button = BUTTON_TYPE2,	410	.w = { SN_WIDTH, 0, 2048, 0 },
366	.tp_offset = FINGER_TYPE2,	411	.x = { SN_COORD, -4620, 5140, 105 },
367	.tp_fsize = FSIZE_TYPE2,	412	.y = { SN_COORD, -150, 6600, 75 },
368	.tp_delta = 0,	413	.o = { SN_ORIENT,
369	.iface_index = 0,	414	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
370	.um_size = 8,
371	.um_req_val = 0x03,
372	.um_req_idx = 0x00,
373	.um_switch_idx = 0,
374	.um_switch_on = 0x01,
375	.um_switch_off = 0x08,
376	},	415	},
377	[WSP_FLAG_WELLSPRING5A] = {	416	[WSP_FLAG_WELLSPRING5A] = {
378	.caps = HAS_INTEGRATED_BUTTON,	417	.tp = tp + TYPE2,
379	.tp_type = TYPE2,	418	.p = { SN_PRESSURE, 0, 300, 0 },
380	.tp_button = BUTTON_TYPE2,	419	.w = { SN_WIDTH, 0, 2048, 0 },
381	.tp_offset = FINGER_TYPE2,	420	.x = { SN_COORD, -4750, 5280, 105 },
382	.tp_fsize = FSIZE_TYPE2,	421	.y = { SN_COORD, -150, 6730, 75 },
383	.tp_delta = 0,	422	.o = { SN_ORIENT,
384	.iface_index = 0,	423	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
385	.um_size = 8,
386	.um_req_val = 0x03,
387	.um_req_idx = 0x00,
388	.um_switch_idx = 0,
389	.um_switch_on = 0x01,
390	.um_switch_off = 0x08,
391	},	424	},
392	[WSP_FLAG_WELLSPRING6A] = {	425	[WSP_FLAG_WELLSPRING6A] = {
393	.caps = HAS_INTEGRATED_BUTTON,	426	.tp = tp + TYPE2,
394	.tp_type = TYPE2,	427	.p = { SN_PRESSURE, 0, 300, 0 },
395	.tp_button = BUTTON_TYPE2,	428	.w = { SN_WIDTH, 0, 2048, 0 },
396	.tp_offset = FINGER_TYPE2,	429	.x = { SN_COORD, -4620, 5140, 105 },
397	.tp_fsize = FSIZE_TYPE2,	430	.y = { SN_COORD, -150, 6600, 75 },
398	.tp_delta = 0,	431	.o = { SN_ORIENT,
399	.um_size = 8,	432	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
400	.um_req_val = 0x03,
401	.um_req_idx = 0x00,
402	.um_switch_idx = 0,
403	.um_switch_on = 0x01,
404	.um_switch_off = 0x08,
405	},	433	},
406	[WSP_FLAG_WELLSPRING7] = {	434	[WSP_FLAG_WELLSPRING7] = {
407	.caps = HAS_INTEGRATED_BUTTON,	435	.tp = tp + TYPE2,
408	.tp_type = TYPE2,	436	.p = { SN_PRESSURE, 0, 300, 0 },
409	.tp_button = BUTTON_TYPE2,	437	.w = { SN_WIDTH, 0, 2048, 0 },
410	.tp_offset = FINGER_TYPE2,	438	.x = { SN_COORD, -4750, 5280, 105 },
411	.tp_fsize = FSIZE_TYPE2,	439	.y = { SN_COORD, -150, 6730, 75 },
412	.tp_delta = 0,	440	.o = { SN_ORIENT,
413	.iface_index = 0,	441	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
414	.um_size = 8,
415	.um_req_val = 0x03,
416	.um_req_idx = 0x00,
417	.um_switch_idx = 0,
418	.um_switch_on = 0x01,
419	.um_switch_off = 0x08,
420	},	442	},
421	[WSP_FLAG_WELLSPRING7A] = {	443	[WSP_FLAG_WELLSPRING7A] = {
422	.caps = HAS_INTEGRATED_BUTTON,	444	.tp = tp + TYPE2,
423	.tp_type = TYPE2,	445	.p = { SN_PRESSURE, 0, 300, 0 },
424	.tp_button = BUTTON_TYPE2,	446	.w = { SN_WIDTH, 0, 2048, 0 },
425	.tp_offset = FINGER_TYPE2,	447	.x = { SN_COORD, -4750, 5280, 105 },
426	.tp_fsize = FSIZE_TYPE2,	448	.y = { SN_COORD, -150, 6730, 75 },
427	.tp_delta = 0,	449	.o = { SN_ORIENT,
428	.iface_index = 0,	450	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
429	.um_size = 8,
430	.um_req_val = 0x03,
431	.um_req_idx = 0x00,
432	.um_switch_idx = 0,
433	.um_switch_on = 0x01,
434	.um_switch_off = 0x08,
435	},	451	},
436	[WSP_FLAG_WELLSPRING8] = {	452	[WSP_FLAG_WELLSPRING8] = {
437	.caps = HAS_INTEGRATED_BUTTON,	453	.tp = tp + TYPE3,
438	.tp_type = TYPE3,	454	.p = { SN_PRESSURE, 0, 300, 0 },
439	.tp_button = BUTTON_TYPE3,	455	.w = { SN_WIDTH, 0, 2048, 0 },
440	.tp_offset = FINGER_TYPE3,	456	.x = { SN_COORD, -4620, 5140, 105 },
441	.tp_fsize = FSIZE_TYPE3,	457	.y = { SN_COORD, -150, 6600, 75 },
442	.tp_delta = 0,	458	.o = { SN_ORIENT,
443	.iface_index = 0,	459	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
444	.um_size = 8,
445	.um_req_val = 0x03,
446	.um_req_idx = 0x00,
447	.um_switch_idx = 0,
448	.um_switch_on = 0x01,
449	.um_switch_off = 0x08,
450	},	460	},
451	[WSP_FLAG_WELLSPRING9] = {	461	[WSP_FLAG_WELLSPRING9] = {
452	.caps = HAS_INTEGRATED_BUTTON,	462	.tp = tp + TYPE4,
453	.tp_type = TYPE4,	463	.p = { SN_PRESSURE, 0, 300, 0 },
454	.tp_button = BUTTON_TYPE4,	464	.w = { SN_WIDTH, 0, 2048, 0 },
455	.tp_offset = FINGER_TYPE4,	465	.x = { SN_COORD, -4828, 5345, 105 },
456	.tp_fsize = FSIZE_TYPE4,	466	.y = { SN_COORD, -203, 6803, 75 },
457	.tp_delta = 2,	467	.o = { SN_ORIENT,
458	.iface_index = 2,	468	-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION, 0 },
459	.um_size = 2,
460	.um_req_val = 0x03,
461	.um_req_idx = 0x02,
462	.um_switch_idx = 1,
463	.um_switch_on = 0x01,
464	.um_switch_off = 0x00,
465	},	469	},
466	};	470	};
467	#define WSP_DEV(v,p,i) { USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, i) }	471	#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		554
551	const struct wsp_dev_params sc_params; / device configuration */	555	const struct wsp_dev_params sc_params; / device configuration */
552		556
		557	#ifdef EVDEV_SUPPORT
		558	struct evdev_dev *sc_evdev;
		559	#endif
553	mousehw_t sc_hw;	560	mousehw_t sc_hw;
554	mousemode_t sc_mode;	561	mousemode_t sc_mode;
555	u_int sc_pollrate;	562	u_int sc_pollrate;
556	mousestatus_t sc_status;	563	mousestatus_t sc_status;
		564	int sc_fflags;
557	u_int sc_state;	565	u_int sc_state;
558	#define WSP_ENABLED 0x01	566	#define WSP_ENABLED 0x01
		567	#define WSP_EVDEV_OPENED 0x02
559		568
560	struct tp_finger index[MAX_FINGERS]; / finger index data */	569	struct tp_finger index[MAX_FINGERS]; / finger index data */
561	int16_t pos_x[MAX_FINGERS]; /* position array */	570	int16_t pos_x[MAX_FINGERS]; /* position array */
Lines 596-603 struct wsp_softc { Link Here
596	/*	605	/*
597	* function prototypes	606	* function prototypes
598	*/	607	*/
599	static usb_fifo_cmd_t wsp_start_read;	608	static usb_fifo_cmd_t wsp_fifo_start_read;
600	static usb_fifo_cmd_t wsp_stop_read;	609	static usb_fifo_cmd_t wsp_fifo_stop_read;
601	static usb_fifo_open_t wsp_open;	610	static usb_fifo_open_t wsp_open;
602	static usb_fifo_close_t wsp_close;	611	static usb_fifo_close_t wsp_close;
603	static usb_fifo_ioctl_t wsp_ioctl;	612	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,	615	.f_open = &wsp_open,
607	.f_close = &wsp_close,	616	.f_close = &wsp_close,
608	.f_ioctl = &wsp_ioctl,	617	.f_ioctl = &wsp_ioctl,
609	.f_start_read = &wsp_start_read,	618	.f_start_read = &wsp_fifo_start_read,
610	.f_stop_read = &wsp_stop_read,	619	.f_stop_read = &wsp_fifo_stop_read,
611	.basename[0] = WSP_DRIVER_NAME,	620	.basename[0] = WSP_DRIVER_NAME,
612	};	621	};
613		622
		623	#ifdef EVDEV_SUPPORT
		624	static evdev_open_t wsp_ev_open;
		625	static evdev_close_t wsp_ev_close;
		626	static const struct evdev_methods wsp_evdev_methods = {
		627	.ev_open = &wsp_ev_open,
		628	.ev_close = &wsp_ev_close,
		629	};
		630	#endif
		631
614	/* device initialization and shutdown */	632	/* device initialization and shutdown */
615	static int wsp_enable(struct wsp_softc *sc);	633	static int wsp_enable(struct wsp_softc *sc);
616	static void wsp_disable(struct wsp_softc *sc);	634	static void wsp_disable(struct wsp_softc *sc);
Lines 647-658 wsp_set_device_mode(struct wsp_softc *sc, uint8_t on) Link Here
647	usb_error_t err;	665	usb_error_t err;
648		666
649	/* Type 3 does not require a mode switch */	667	/* Type 3 does not require a mode switch */
650	if (params->tp_type == TYPE3)	668	if (params->tp == tp + TYPE3)
651	return 0;	669	return 0;
652		670
653	err = usbd_req_get_report(sc->sc_usb_device, NULL,	671	err = usbd_req_get_report(sc->sc_usb_device, NULL,
654	mode_bytes, params->um_size, params->iface_index,	672	mode_bytes, params->tp->um_size, params->tp->iface_index,
655	params->um_req_val, params->um_req_idx);	673	UHID_FEATURE_REPORT, params->tp->um_req_idx);
656		674
657	if (err != USB_ERR_NORMAL_COMPLETION) {	675	if (err != USB_ERR_NORMAL_COMPLETION) {
658	DPRINTF("Failed to read device mode (%d)\n", err);	676	DPRINTF("Failed to read device mode (%d)\n", err);
Lines 667-678 wsp_set_device_mode(struct wsp_softc *sc, uint8_t on) Link Here
667	*/	685	*/
668	pause("WHW", hz / 4);	686	pause("WHW", hz / 4);
669		687
670	mode_bytes[params->um_switch_idx] =	688	mode_bytes[params->tp->um_switch_idx] =
671	on ? params->um_switch_on : params->um_switch_off;	689	on ? params->tp->um_switch_on : params->tp->um_switch_off;
672		690
673	return (usbd_req_set_report(sc->sc_usb_device, NULL,	691	return (usbd_req_set_report(sc->sc_usb_device, NULL,
674	mode_bytes, params->um_size, params->iface_index,	692	mode_bytes, params->tp->um_size, params->tp->iface_index,
675	params->um_req_val, params->um_req_idx));	693	UHID_FEATURE_REPORT, params->tp->um_req_idx));
676	}	694	}
677		695
678	static int	696	static int
Lines 720-726 wsp_probe(device_t self) Link Here
720	/* check if we are attaching to the first match */	738	/* check if we are attaching to the first match */
721	if (uaa->info.bIfaceIndex != i)	739	if (uaa->info.bIfaceIndex != i)
722	return (ENXIO);	740	return (ENXIO);
723	return (usbd_lookup_id_by_uaa(wsp_devs, sizeof(wsp_devs), uaa));	741	if (usbd_lookup_id_by_uaa(wsp_devs, sizeof(wsp_devs), uaa) != 0)
		742	return (ENXIO);
		743
		744	return (BUS_PROBE_DEFAULT);
724	}	745	}
725		746
726	static int	747	static int
Lines 816-821 wsp_attach(device_t dev) Link Here
816	sc->sc_touch = WSP_UNTOUCH;	837	sc->sc_touch = WSP_UNTOUCH;
817	sc->scr_mode = WSP_SCR_NONE;	838	sc->scr_mode = WSP_SCR_NONE;
818		839
		840	#ifdef EVDEV_SUPPORT
		841	sc->sc_evdev = evdev_alloc();
		842	evdev_set_name(sc->sc_evdev, device_get_desc(dev));
		843	evdev_set_phys(sc->sc_evdev, device_get_nameunit(dev));
		844	evdev_set_id(sc->sc_evdev, BUS_USB, uaa->info.idVendor,
		845	uaa->info.idProduct, 0);
		846	evdev_set_serial(sc->sc_evdev, usb_get_serial(uaa->device));
		847	evdev_set_methods(sc->sc_evdev, sc, &wsp_evdev_methods);
		848	evdev_support_prop(sc->sc_evdev, INPUT_PROP_POINTER);
		849	evdev_support_event(sc->sc_evdev, EV_SYN);
		850	evdev_support_event(sc->sc_evdev, EV_ABS);
		851	evdev_support_event(sc->sc_evdev, EV_KEY);
		852
		853	#define WSP_SUPPORT_ABS(evdev, code, param) \
		854	evdev_support_abs((evdev), (code), (param).min, (param).max, \
		855	((param).max - (param).min) / (param).snratio, 0, \
		856	(param).size != 0 ? ((param).max - (param).min) / (param).size : 0);
		857
		858	/* finger position */
		859	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_POSITION_X, sc->sc_params->x);
		860	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_POSITION_Y, sc->sc_params->y);
		861	/* finger pressure */
		862	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_PRESSURE, sc->sc_params->p);
		863	/* finger touch area */
		864	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_TOUCH_MAJOR, sc->sc_params->w);
		865	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_TOUCH_MINOR, sc->sc_params->w);
		866	/* finger approach area */
		867	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_WIDTH_MAJOR, sc->sc_params->w);
		868	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_WIDTH_MINOR, sc->sc_params->w);
		869	/* finger orientation */
		870	WSP_SUPPORT_ABS(sc->sc_evdev, ABS_MT_ORIENTATION, sc->sc_params->o);
		871	/* button properties */
		872	evdev_support_key(sc->sc_evdev, BTN_LEFT);
		873	if ((sc->sc_params->tp->caps & HAS_INTEGRATED_BUTTON) != 0)
		874	evdev_support_prop(sc->sc_evdev, INPUT_PROP_BUTTONPAD);
		875	/* Enable automatic touch assignment for type B MT protocol */
		876	evdev_support_abs(sc->sc_evdev, ABS_MT_SLOT,
		877	0, MAX_FINGERS - 1, 0, 0, 0);
		878	evdev_support_abs(sc->sc_evdev, ABS_MT_TRACKING_ID,
		879	-1, MAX_FINGERS - 1, 0, 0, 0);
		880	evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_MT_TRACK);
		881	evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_MT_AUTOREL);
		882	/* Synaptics compatibility events */
		883	evdev_set_flag(sc->sc_evdev, EVDEV_FLAG_MT_STCOMPAT);
		884
		885	err = evdev_register(sc->sc_evdev);
		886	if (err)
		887	goto detach;
		888	#endif
		889
819	return (0);	890	return (0);
820		891
821	detach:	892	detach:
Lines 837-842 wsp_detach(device_t dev) Link Here
837		908
838	usb_fifo_detach(&sc->sc_fifo);	909	usb_fifo_detach(&sc->sc_fifo);
839		910
		911	#ifdef EVDEV_SUPPORT
		912	evdev_free(sc->sc_evdev);
		913	#endif
		914
840	usbd_transfer_unsetup(sc->sc_xfer, WSP_N_TRANSFER);	915	usbd_transfer_unsetup(sc->sc_xfer, WSP_N_TRANSFER);
841		916
842	mtx_destroy(&sc->sc_mutex);	917	mtx_destroy(&sc->sc_mutex);
Lines 863-868 wsp_intr_callback(struct usb_xfer *xfer, usb_error_t error) Link Here
863	int rdz = 0;	938	int rdz = 0;
864	int len;	939	int len;
865	int i;	940	int i;
		941	#ifdef EVDEV_SUPPORT
		942	int slot = 0;
		943	#endif
866		944
867	wsp_runing_rangecheck(&tun);	945	wsp_runing_rangecheck(&tun);
868		946
Lines 878-885 wsp_intr_callback(struct usb_xfer *xfer, usb_error_t error) Link Here
878	pc = usbd_xfer_get_frame(xfer, 0);	956	pc = usbd_xfer_get_frame(xfer, 0);
879	usbd_copy_out(pc, 0, sc->tp_data, len);	957	usbd_copy_out(pc, 0, sc->tp_data, len);
880		958
881	if ((len < params->tp_offset + params->tp_fsize) \|\|	959	if ((len < params->tp->offset + params->tp->fsize) \|\|
882	((len - params->tp_offset) % params->tp_fsize) != 0) {	960	((len - params->tp->offset) % params->tp->fsize) != 0) {
883	DPRINTFN(WSP_LLEVEL_INFO, "Invalid length: %d, %x, %x\n",	961	DPRINTFN(WSP_LLEVEL_INFO, "Invalid length: %d, %x, %x\n",
884	len, sc->tp_data[0], sc->tp_data[1]);	962	len, sc->tp_data[0], sc->tp_data[1]);
885	goto tr_setup;	963	goto tr_setup;
Lines 892-901 wsp_intr_callback(struct usb_xfer *xfer, usb_error_t error) Link Here
892		970
893	h = (struct tp_header *)(sc->tp_data);	971	h = (struct tp_header *)(sc->tp_data);
894		972
895	if (params->tp_type >= TYPE2) {	973	if (params->tp != tp + TYPE1) {
896	ibt = sc->tp_data[params->tp_button];	974	ibt = sc->tp_data[params->tp->button];
897	ntouch = sc->tp_data[params->tp_button - 1];	975	ntouch = sc->tp_data[params->tp->button - 1];
898	}	976	} else
		977	ntouch = (len - params->tp->offset) / params->tp->fsize;
		978
899	/* range check */	979	/* range check */
900	if (ntouch < 0)	980	if (ntouch < 0)
901	ntouch = 0;	981	ntouch = 0;
Lines 903-909 wsp_intr_callback(struct usb_xfer *xfer, usb_error_t error) Link Here
903	ntouch = MAX_FINGERS;	983	ntouch = MAX_FINGERS;
904		984
905	for (i = 0; i != ntouch; i++) {	985	for (i = 0; i != ntouch; i++) {
906	f = (struct tp_finger )(sc->tp_data + params->tp_offset + params->tp_delta + i params->tp_fsize);	986	f = (struct tp_finger )(sc->tp_data + params->tp->offset + params->tp->delta + i params->tp->fsize);
907	/* swap endianness, if any */	987	/* swap endianness, if any */
908	if (le16toh(0x1234) != 0x1234) {	988	if (le16toh(0x1234) != 0x1234) {
909	f->origin = le16toh((uint16_t)f->origin);	989	f->origin = le16toh((uint16_t)f->origin);
Lines 929-945 wsp_intr_callback(struct usb_xfer *xfer, usb_error_t error) Link Here
929	sc->pos_x[i] = f->abs_x;	1009	sc->pos_x[i] = f->abs_x;
930	sc->pos_y[i] = -f->abs_y;	1010	sc->pos_y[i] = -f->abs_y;
931	sc->index[i] = f;	1011	sc->index[i] = f;
		1012	#ifdef EVDEV_SUPPORT
		1013	if (evdev_rcpt_mask & EVDEV_RCPT_HW_MOUSE && f->touch_major != 0) {
		1014	union evdev_mt_slot slot_data = {
		1015	.id = slot,
		1016	.x = f->abs_x,
		1017	.y = params->y.min + params->y.max - f->abs_y,
		1018	.p = f->pressure,
		1019	.maj = f->touch_major << 1,
		1020	.min = f->touch_minor << 1,
		1021	.w_maj = f->tool_major << 1,
		1022	.w_min = f->tool_minor << 1,
		1023	.ori = params->o.max - f->orientation,
		1024	};
		1025	evdev_mt_push_slot(sc->sc_evdev, slot, &slot_data);
		1026	slot++;
		1027	}
		1028	#endif
932	}	1029	}
933		1030
		1031	#ifdef EVDEV_SUPPORT
		1032	if (evdev_rcpt_mask & EVDEV_RCPT_HW_MOUSE) {
		1033	evdev_push_key(sc->sc_evdev, BTN_LEFT, ibt);
		1034	evdev_sync(sc->sc_evdev);
		1035	}
		1036	#endif
934	sc->sc_status.flags &= ~MOUSE_POSCHANGED;	1037	sc->sc_status.flags &= ~MOUSE_POSCHANGED;
935	sc->sc_status.flags &= ~MOUSE_STDBUTTONSCHANGED;	1038	sc->sc_status.flags &= ~MOUSE_STDBUTTONSCHANGED;
936	sc->sc_status.obutton = sc->sc_status.button;	1039	sc->sc_status.obutton = sc->sc_status.button;
937	sc->sc_status.button = 0;	1040	sc->sc_status.button = 0;
938		1041
939	if (ibt != 0) {	1042	if (ibt != 0) {
940	if ((params->caps & HAS_INTEGRATED_BUTTON) && ntouch == 2)	1043	if ((params->tp->caps & HAS_INTEGRATED_BUTTON) && ntouch == 2)
941	sc->sc_status.button \|= MOUSE_BUTTON3DOWN;	1044	sc->sc_status.button \|= MOUSE_BUTTON3DOWN;
942	else if ((params->caps & HAS_INTEGRATED_BUTTON) && ntouch == 3)	1045	else if ((params->tp->caps & HAS_INTEGRATED_BUTTON) && ntouch == 3)
943	sc->sc_status.button \|= MOUSE_BUTTON2DOWN;	1046	sc->sc_status.button \|= MOUSE_BUTTON2DOWN;
944	else	1047	else
945	sc->sc_status.button \|= MOUSE_BUTTON1DOWN;	1048	sc->sc_status.button \|= MOUSE_BUTTON1DOWN;
Lines 986-992 wsp_intr_callback(struct usb_xfer *xfer, usb_error_t error) Link Here
986	*/	1089	*/
987	switch (sc->ntaps) {	1090	switch (sc->ntaps) {
988	case 1:	1091	case 1:
989	if (!(params->caps & HAS_INTEGRATED_BUTTON) \|\| tun.enable_single_tap_clicks) {	1092	if (!(params->tp->caps & HAS_INTEGRATED_BUTTON) \|\| tun.enable_single_tap_clicks) {
990	wsp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON1DOWN);	1093	wsp_add_to_queue(sc, 0, 0, 0, MOUSE_BUTTON1DOWN);
991	DPRINTFN(WSP_LLEVEL_INFO, "LEFT CLICK!\n");	1094	DPRINTFN(WSP_LLEVEL_INFO, "LEFT CLICK!\n");
992	}	1095	}
Lines 1235-1243 wsp_reset_buf(struct wsp_softc *sc) Link Here
1235	}	1338	}
1236		1339
1237	static void	1340	static void
1238	wsp_start_read(struct usb_fifo *fifo)	1341	wsp_start_read(struct wsp_softc *sc)
1239	{	1342	{
1240	struct wsp_softc *sc = usb_fifo_softc(fifo);
1241	int rate;	1343	int rate;
1242		1344
1243	/* Check if we should override the default polling interval */	1345	/* Check if we should override the default polling interval */
Lines 1258-1306 wsp_start_read(struct usb_fifo *fifo) Link Here
1258	}	1360	}
1259		1361
1260	static void	1362	static void
1261	wsp_stop_read(struct usb_fifo *fifo)	1363	wsp_stop_read(struct wsp_softc *sc)
1262	{	1364	{
1263	struct wsp_softc *sc = usb_fifo_softc(fifo);
1264
1265	usbd_transfer_stop(sc->sc_xfer[WSP_INTR_DT]);	1365	usbd_transfer_stop(sc->sc_xfer[WSP_INTR_DT]);
1266	}	1366	}
1267		1367
1268	static int	1368	static int
1269	wsp_open(struct usb_fifo *fifo, int fflags)	1369	wsp_open(struct usb_fifo *fifo, int fflags)
1270	{	1370	{
1271	DPRINTFN(WSP_LLEVEL_INFO, "\n");	1371	struct wsp_softc *sc = usb_fifo_softc(fifo);
		1372	int rc = 0;
1272		1373
1273	if (fflags & FREAD) {	1374	DPRINTFN(WSP_LLEVEL_INFO, "\n");
1274	struct wsp_softc *sc = usb_fifo_softc(fifo);
1275	int rc;
1276		1375
1277	if (sc->sc_state & WSP_ENABLED)	1376	if (sc->sc_fflags & fflags)
1278	return (EBUSY);	1377	return (EBUSY);
1279		1378
		1379	if (fflags & FREAD) {
1280	if (usb_fifo_alloc_buffer(fifo,	1380	if (usb_fifo_alloc_buffer(fifo,
1281	WSP_FIFO_BUF_SIZE, WSP_FIFO_QUEUE_MAXLEN)) {	1381	WSP_FIFO_BUF_SIZE, WSP_FIFO_QUEUE_MAXLEN)) {
1282	return (ENOMEM);	1382	return (ENOMEM);
1283	}	1383	}
1284	rc = wsp_enable(sc);	1384	#ifdef EVDEV_SUPPORT
		1385	if ((sc->sc_state & WSP_EVDEV_OPENED) == 0)
		1386	#endif
		1387	rc = wsp_enable(sc);
1285	if (rc != 0) {	1388	if (rc != 0) {
1286	usb_fifo_free_buffer(fifo);	1389	usb_fifo_free_buffer(fifo);
1287	return (rc);	1390	return (rc);
1288	}	1391	}
1289	}	1392	}
		1393	sc->sc_fflags \|= fflags & (FREAD \| FWRITE);
1290	return (0);	1394	return (0);
1291	}	1395	}
1292		1396
1293	static void	1397	static void
1294	wsp_close(struct usb_fifo *fifo, int fflags)	1398	wsp_close(struct usb_fifo *fifo, int fflags)
1295	{	1399	{
1296	if (fflags & FREAD) {	1400	struct wsp_softc *sc = usb_fifo_softc(fifo);
1297	struct wsp_softc *sc = usb_fifo_softc(fifo);
1298		1401
1299	wsp_disable(sc);	1402	if (fflags & FREAD) {
		1403	#ifdef EVDEV_SUPPORT
		1404	if ((sc->sc_state & WSP_EVDEV_OPENED) == 0)
		1405	#endif
		1406	wsp_disable(sc);
1300	usb_fifo_free_buffer(fifo);	1407	usb_fifo_free_buffer(fifo);
1301	}	1408	}
		1409
		1410	sc->sc_fflags &= ~(fflags & (FREAD \| FWRITE));
1302	}	1411	}
1303		1412
		1413	static void
		1414	wsp_fifo_start_read(struct usb_fifo *fifo)
		1415	{
		1416	struct wsp_softc *sc = usb_fifo_softc(fifo);
		1417
		1418	wsp_start_read(sc);
		1419	}
		1420
		1421	static void
		1422	wsp_fifo_stop_read(struct usb_fifo *fifo)
		1423	{
		1424	struct wsp_softc *sc = usb_fifo_softc(fifo);
		1425
		1426	#ifdef EVDEV_SUPPORT
		1427	if ((sc->sc_state & WSP_EVDEV_OPENED) == 0)
		1428	#endif
		1429	wsp_stop_read(sc);
		1430	}
		1431
		1432	#ifdef EVDEV_SUPPORT
		1433	static int
		1434	wsp_ev_open(struct evdev_dev *evdev)
		1435	{
		1436	struct wsp_softc *sc = evdev_get_softc(evdev);
		1437	int rc = 0;
		1438
		1439	mtx_lock(&sc->sc_mutex);
		1440	if (sc->sc_fflags == 0)
		1441	rc = wsp_enable(sc);
		1442	if (rc == 0) {
		1443	wsp_start_read(sc);
		1444	sc->sc_state \|= WSP_EVDEV_OPENED;
		1445	}
		1446	mtx_unlock(&sc->sc_mutex);
		1447
		1448	return (rc);
		1449	}
		1450
		1451	static int
		1452	wsp_ev_close(struct evdev_dev *evdev)
		1453	{
		1454	struct wsp_softc *sc = evdev_get_softc(evdev);
		1455
		1456	mtx_lock(&sc->sc_mutex);
		1457	sc->sc_state &= ~WSP_EVDEV_OPENED;
		1458	if (sc->sc_fflags == 0)
		1459	wsp_stop_read(sc);
		1460	mtx_unlock(&sc->sc_mutex);
		1461
		1462	return (0);
		1463	}
		1464	#endif
		1465
1304	int	1466	int
1305	wsp_ioctl(struct usb_fifo fifo, u_long cmd, void addr, int fflags)	1467	wsp_ioctl(struct usb_fifo fifo, u_long cmd, void addr, int fflags)
1306	{	1468	{
Lines 1412-1416 static devclass_t wsp_devclass; Link Here
1412	DRIVER_MODULE(wsp, uhub, wsp_driver, wsp_devclass, NULL, 0);	1574	DRIVER_MODULE(wsp, uhub, wsp_driver, wsp_devclass, NULL, 0);
1413	MODULE_DEPEND(wsp, usb, 1, 1, 1);	1575	MODULE_DEPEND(wsp, usb, 1, 1, 1);
1414	MODULE_DEPEND(wsp, hid, 1, 1, 1);	1576	MODULE_DEPEND(wsp, hid, 1, 1, 1);
		1577	#ifdef EVDEV_SUPPORT
		1578	MODULE_DEPEND(wsp, evdev, 1, 1, 1);
		1579	#endif
1415	MODULE_VERSION(wsp, 1);	1580	MODULE_VERSION(wsp, 1);
1416	USB_PNP_HOST_INFO(wsp_devs);	1581	USB_PNP_HOST_INFO(wsp_devs);

Lines 8-13 SUBDIR = \ Link Here

(-)b/sys/modules/hid/Makefile (+1 lines)
8	hidraw	8	hidraw
9		9
10	SUBDIR += \	10	SUBDIR += \
		11	bcm5974 \
11	hconf \	12	hconf \
12	hcons \	13	hcons \
13	hgame \	14	hgame \

Added Link Here

(-)b/sys/modules/hid/bcm5974/Makefile (+10 lines)
1	# $FreeBSD$
2
3	.PATH: ${SRCTOP}/sys/dev/hid
4
5	KMOD= bcm5974
6	SRCS= bcm5974.c
7	SRCS+= opt_hid.h
8	SRCS+= bus_if.h device_if.h usbdevs.h
9
10	.include <bsd.kmod.mk>

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	int32_t evdev_mt_reassign_id(struct evdev_dev *, int, int32_t);
		294	bool evdev_mt_record_event(struct evdev_dev *, uint16_t, uint16_t, 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 */

Lines 67-72 __FBSDID("$FreeBSD$"); Link Here

(-)b/sys/dev/usb/input/usbhid.c (-39 / +91 lines)
67	#include <dev/usb/usbdi.h>	67	#include <dev/usb/usbdi.h>
68	#include <dev/usb/usbdi_util.h>	68	#include <dev/usb/usbdi_util.h>
69	#include <dev/usb/usbhid.h>	69	#include <dev/usb/usbhid.h>
		70	#include <dev/usb/input/usbhid.h>
70		71
71	#define USB_DEBUG_VAR usbhid_debug	72	#define USB_DEBUG_VAR usbhid_debug
72	#include <dev/usb/usb_debug.h>	73	#include <dev/usb/usb_debug.h>
Lines 85-108 SYSCTL_INT(_hw_usb_usbhid, OID_AUTO, debug, CTLFLAG_RWTUN, Link Here
85	&usbhid_debug, 0, "Debug level");	86	&usbhid_debug, 0, "Debug level");
86	#endif	87	#endif
87		88
88	enum {	89	/* Second set of USB transfers for polling mode */
89	USBHID_INTR_OUT_DT,	90	#define POLL_XFER(xfer) ((xfer) + USBHID_N_TRANSFER)
90	USBHID_INTR_IN_DT,
91	USBHID_CTRL_DT,
92	USBHID_N_TRANSFER,
93	};
94		91
95	struct usbhid_xfer_ctx;	92	struct usbhid_xfer_ctx;
96	typedef int usbhid_callback_t(struct usbhid_xfer_ctx *xfer_ctx);	93	typedef int usbhid_callback_t(struct usbhid_xfer_ctx *xfer_ctx);
97		94
98	union usbhid_device_request {
99	struct { /* INTR xfers */
100	uint16_t maxlen;
101	uint16_t actlen;
102	} intr;
103	struct usb_device_request ctrl; /* CTRL xfers */
104	};
105
106	/* Syncronous USB transfer context */	95	/* Syncronous USB transfer context */
107	struct usbhid_xfer_ctx {	96	struct usbhid_xfer_ctx {
108	union usbhid_device_request req;	97	union usbhid_device_request req;
Lines 123-130 struct usbhid_softc { Link Here
123		112
124	struct mtx sc_mtx;	113	struct mtx sc_mtx;
125	struct usb_config sc_config[USBHID_N_TRANSFER];	114	struct usb_config sc_config[USBHID_N_TRANSFER];
126	struct usb_xfer *sc_xfer[USBHID_N_TRANSFER];	115	struct usb_xfer *sc_xfer[POLL_XFER(USBHID_N_TRANSFER)];
127	struct usbhid_xfer_ctx sc_xfer_ctx[USBHID_N_TRANSFER];	116	struct usbhid_xfer_ctx sc_xfer_ctx[POLL_XFER(USBHID_N_TRANSFER)];
128		117
129	struct usb_device *sc_udev;	118	struct usb_device *sc_udev;
130	uint8_t sc_iface_no;	119	uint8_t sc_iface_no;
Lines 144-149 static usb_callback_t usbhid_ctrl_callback; Link Here
144	static usbhid_callback_t usbhid_intr_handler_cb;	133	static usbhid_callback_t usbhid_intr_handler_cb;
145	static usbhid_callback_t usbhid_sync_wakeup_cb;	134	static usbhid_callback_t usbhid_sync_wakeup_cb;
146		135
		136	struct usb_device *
		137	usbhid_get_usb_device(device_t dev)
		138	{
		139	struct usbhid_softc *sc = device_get_softc(dev);
		140
		141	return (sc->sc_udev);
		142	}
		143
147	static void	144	static void
148	usbhid_intr_out_callback(struct usb_xfer *xfer, usb_error_t error)	145	usbhid_intr_out_callback(struct usb_xfer *xfer, usb_error_t error)
149	{	146	{
Lines 308-313 static const struct usb_config usbhid_config[USBHID_N_TRANSFER] = { Link Here
308	},	305	},
309	};	306	};
310		307
		308	static inline usb_frlength_t
		309	usbhid_xfer_max_len(struct usb_xfer *xfer)
		310	{
		311	return (xfer == NULL ? 0 : usbd_xfer_max_len(xfer));
		312	}
		313
		314	static inline int
		315	usbhid_xfer_check_len(struct usb_xfer *xfer, hid_size_t len)
		316	{
		317	if (xfer == NULL)
		318	return (ENODEV);
		319	if (len > usbd_xfer_max_len(xfer))
		320	return (ENOBUFS);
		321	return (0);
		322	}
		323
311	static void	324	static void
312	usbhid_intr_setup(device_t dev, hid_intr_t intr, void *context,	325	usbhid_intr_setup(device_t dev, hid_intr_t intr, void *context,
313	struct hid_rdesc_info *rdesc)	326	struct hid_rdesc_info *rdesc)
Lines 335-358 usbhid_intr_setup(device_t dev, hid_intr_t intr, void *context, Link Here
335	* itself, typically by hkbd via CTRL+ALT+ESC sequences. Or if the HID	348	* itself, typically by hkbd via CTRL+ALT+ESC sequences. Or if the HID
336	* keyboard driver was processing a key at the moment of panic.	349	* keyboard driver was processing a key at the moment of panic.
337	*/	350	*/
338	for (n = 0; n != USBHID_N_TRANSFER; n++) {	351	for (n = 0; n != POLL_XFER(USBHID_N_TRANSFER); n++) {
		352	sc->sc_xfer[n] = NULL;
339	if (nowrite && n == USBHID_INTR_OUT_DT)	353	if (nowrite && n == USBHID_INTR_OUT_DT)
340	continue;	354	continue;
341	error = usbd_transfer_setup(sc->sc_udev, &sc->sc_iface_index,	355	error = usbd_transfer_setup(sc->sc_udev, &sc->sc_iface_index,
342	sc->sc_xfer + n, sc->sc_config + n, 1,	356	sc->sc_xfer + n, sc->sc_config + n % USBHID_N_TRANSFER, 1,
343	(void *)(sc->sc_xfer_ctx + n), &sc->sc_mtx);	357	(void *)(sc->sc_xfer_ctx + n), &sc->sc_mtx);
344	if (error)	358	if (error)
345	break;	359	DPRINTF("xfer %d setup error=%s\n", n,
		360	usbd_errstr(error));
346	}	361	}
347		362
348	if (error)	363	rdesc->rdsize = usbhid_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]);
349	DPRINTF("error=%s\n", usbd_errstr(error));	364	rdesc->grsize = usbhid_xfer_max_len(sc->sc_xfer[USBHID_CTRL_DT]);
350
351	rdesc->rdsize = usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]);
352	rdesc->grsize = usbd_xfer_max_len(sc->sc_xfer[USBHID_CTRL_DT]);
353	rdesc->srsize = rdesc->grsize;	365	rdesc->srsize = rdesc->grsize;
354	rdesc->wrsize = nowrite ? rdesc->srsize :	366	rdesc->wrsize = nowrite ? rdesc->srsize :
355	usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_OUT_DT]);	367	usbhid_xfer_max_len(sc->sc_xfer[USBHID_INTR_OUT_DT]);
356		368
357	sc->sc_intr_buf = malloc(rdesc->rdsize, M_USBDEV, M_ZERO \| M_WAITOK);	369	sc->sc_intr_buf = malloc(rdesc->rdsize, M_USBDEV, M_ZERO \| M_WAITOK);
358	}	370	}
Lines 363-368 usbhid_intr_unsetup(device_t dev) Link Here
363	struct usbhid_softc* sc = device_get_softc(dev);	375	struct usbhid_softc* sc = device_get_softc(dev);
364		376
365	usbd_transfer_unsetup(sc->sc_xfer, USBHID_N_TRANSFER);	377	usbd_transfer_unsetup(sc->sc_xfer, USBHID_N_TRANSFER);
		378	usbd_transfer_unsetup(
		379	sc->sc_xfer, POLL_XFER(USBHID_N_TRANSFER));
366	free(sc->sc_intr_buf, M_USBDEV);	380	free(sc->sc_intr_buf, M_USBDEV);
367	}	381	}
368		382
Lines 371-376 usbhid_intr_start(device_t dev) Link Here
371	{	385	{
372	struct usbhid_softc* sc = device_get_softc(dev);	386	struct usbhid_softc* sc = device_get_softc(dev);
373		387
		388	if (sc->sc_xfer[USBHID_INTR_IN_DT] == NULL)
		389	return (ENODEV);
		390
374	mtx_lock(&sc->sc_mtx);	391	mtx_lock(&sc->sc_mtx);
375	sc->sc_xfer_ctx[USBHID_INTR_IN_DT] = (struct usbhid_xfer_ctx) {	392	sc->sc_xfer_ctx[USBHID_INTR_IN_DT] = (struct usbhid_xfer_ctx) {
376	.req.intr.maxlen =	393	.req.intr.maxlen =
Lines 379-385 usbhid_intr_start(device_t dev) Link Here
379	.cb_ctx = sc,	396	.cb_ctx = sc,
380	.buf = sc->sc_intr_buf,	397	.buf = sc->sc_intr_buf,
381	};	398	};
		399	sc->sc_xfer_ctx[POLL_XFER(USBHID_INTR_IN_DT)] = (struct usbhid_xfer_ctx) {
		400	.req.intr.maxlen =
		401	usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]),
		402	.cb = usbhid_intr_handler_cb,
		403	.cb_ctx = sc,
		404	.buf = sc->sc_intr_buf,
		405	};
382	usbd_transfer_start(sc->sc_xfer[USBHID_INTR_IN_DT]);	406	usbd_transfer_start(sc->sc_xfer[USBHID_INTR_IN_DT]);
		407	usbd_transfer_start(sc->sc_xfer[POLL_XFER(USBHID_INTR_IN_DT)]);
383	mtx_unlock(&sc->sc_mtx);	408	mtx_unlock(&sc->sc_mtx);
384		409
385	return (0);	410	return (0);
Lines 392-397 usbhid_intr_stop(device_t dev) Link Here
392		417
393	usbd_transfer_drain(sc->sc_xfer[USBHID_INTR_IN_DT]);	418	usbd_transfer_drain(sc->sc_xfer[USBHID_INTR_IN_DT]);
394	usbd_transfer_drain(sc->sc_xfer[USBHID_INTR_OUT_DT]);	419	usbd_transfer_drain(sc->sc_xfer[USBHID_INTR_OUT_DT]);
		420	usbd_transfer_drain(sc->sc_xfer[POLL_XFER(USBHID_INTR_IN_DT)]);
395		421
396	return (0);	422	return (0);
397	}	423	}
Lines 402-423 usbhid_intr_poll(device_t dev) Link Here
402	struct usbhid_softc* sc = device_get_softc(dev);	428	struct usbhid_softc* sc = device_get_softc(dev);
403		429
404	usbd_transfer_poll(sc->sc_xfer + USBHID_INTR_IN_DT, 1);	430	usbd_transfer_poll(sc->sc_xfer + USBHID_INTR_IN_DT, 1);
		431	usbd_transfer_poll(sc->sc_xfer + POLL_XFER(USBHID_INTR_IN_DT), 1);
405	}	432	}
406		433
407	/*	434	/*
408	* HID interface	435	* HID interface
409	*/	436	*/
410	static int	437	static int
411	usbhid_sync_xfer(struct usbhid_softc* sc, int xfer_idx,	438	usbhid_sync_xfer(struct usbhid_softc* sc, enum usbhid_xfer xfer_idx,
412	union usbhid_device_request req, void buf)	439	union usbhid_device_request req, void buf)
413	{	440	{
414	int error, timeout;	441	int error, timeout;
415	struct usbhid_xfer_ctx *xfer_ctx, save;	442	struct usbhid_xfer_ctx *xfer_ctx;
416		443
417	xfer_ctx = sc->sc_xfer_ctx + xfer_idx;	444	xfer_ctx = sc->sc_xfer_ctx + xfer_idx;
418		445
419	if (USB_IN_POLLING_MODE_FUNC()) {	446	if (USB_IN_POLLING_MODE_FUNC()) {
420	save = *xfer_ctx;	447	xfer_ctx = POLL_XFER(xfer_ctx);
		448	xfer_idx = POLL_XFER(xfer_idx);
421	} else {	449	} else {
422	mtx_lock(&sc->sc_mtx);	450	mtx_lock(&sc->sc_mtx);
423	++xfer_ctx->waiters;	451	++xfer_ctx->waiters;
Lines 455-463 usbhid_sync_xfer(struct usbhid_softc* sc, int xfer_idx, Link Here
455	if (error == 0)	483	if (error == 0)
456	*req = xfer_ctx->req;	484	*req = xfer_ctx->req;
457		485
458	if (USB_IN_POLLING_MODE_FUNC()) {	486	if (!USB_IN_POLLING_MODE_FUNC()) {
459	*xfer_ctx = save;
460	} else {
461	xfer_ctx->influx = false;	487	xfer_ctx->influx = false;
462	if (xfer_ctx->waiters != 0)	488	if (xfer_ctx->waiters != 0)
463	wakeup_one(&xfer_ctx->waiters);	489	wakeup_one(&xfer_ctx->waiters);
Lines 470-475 usbhid_sync_xfer(struct usbhid_softc* sc, int xfer_idx, Link Here
470	return (error);	496	return (error);
471	}	497	}
472		498
		499	int
		500	usbhid_do_request(device_t dev, enum usbhid_xfer xfer_idx,
		501	union usbhid_device_request req, void buf)
		502	{
		503	struct usbhid_softc* sc = device_get_softc(dev);
		504	int error;
		505
		506	error = usbhid_xfer_check_len(sc->sc_xfer[USBHID_CTRL_DT], 0);
		507	if (error)
		508	return (error);
		509
		510	return (usbhid_sync_xfer(sc, xfer_idx, req, buf));
		511	}
		512
473	static int	513	static int
474	usbhid_get_rdesc(device_t dev, void *buf, hid_size_t len)	514	usbhid_get_rdesc(device_t dev, void *buf, hid_size_t len)
475	{	515	{
Lines 493-500 usbhid_get_report(device_t dev, void *buf, hid_size_t maxlen, Link Here
493	union usbhid_device_request req;	533	union usbhid_device_request req;
494	int error;	534	int error;
495		535
496	if (maxlen > usbd_xfer_max_len(sc->sc_xfer[USBHID_CTRL_DT]))	536	error = usbhid_xfer_check_len(sc->sc_xfer[USBHID_CTRL_DT], maxlen);
497	return (ENOBUFS);	537	if (error)
		538	return (error);
498		539
499	req.ctrl.bmRequestType = UT_READ_CLASS_INTERFACE;	540	req.ctrl.bmRequestType = UT_READ_CLASS_INTERFACE;
500	req.ctrl.bRequest = UR_GET_REPORT;	541	req.ctrl.bRequest = UR_GET_REPORT;
Lines 516-524 usbhid_set_report(device_t dev, const void *buf, hid_size_t len, uint8_t type, Link Here
516	{	557	{
517	struct usbhid_softc* sc = device_get_softc(dev);	558	struct usbhid_softc* sc = device_get_softc(dev);
518	union usbhid_device_request req;	559	union usbhid_device_request req;
		560	int error;
519		561
520	if (len > usbd_xfer_max_len(sc->sc_xfer[USBHID_CTRL_DT]))	562	error = usbhid_xfer_check_len(sc->sc_xfer[USBHID_CTRL_DT], len);
521	return (ENOBUFS);	563	if (error)
		564	return (error);
522		565
523	req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;	566	req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;
524	req.ctrl.bRequest = UR_SET_REPORT;	567	req.ctrl.bRequest = UR_SET_REPORT;
Lines 538-545 usbhid_read(device_t dev, void buf, hid_size_t maxlen, hid_size_t actlen) Link Here
538	union usbhid_device_request req;	581	union usbhid_device_request req;
539	int error;	582	int error;
540		583
541	if (maxlen > usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]))	584	error = usbhid_xfer_check_len(sc->sc_xfer[USBHID_INTR_IN_DT], maxlen);
542	return (ENOBUFS);	585	if (error)
		586	return (error);
543		587
544	req.intr.maxlen = maxlen;	588	req.intr.maxlen = maxlen;
545	error = usbhid_sync_xfer(sc, USBHID_INTR_IN_DT, &req, buf);	589	error = usbhid_sync_xfer(sc, USBHID_INTR_IN_DT, &req, buf);
Lines 554-562 usbhid_write(device_t dev, const void *buf, hid_size_t len) Link Here
554	{	598	{
555	struct usbhid_softc* sc = device_get_softc(dev);	599	struct usbhid_softc* sc = device_get_softc(dev);
556	union usbhid_device_request req;	600	union usbhid_device_request req;
		601	int error;
557		602
558	if (len > usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_OUT_DT]))	603	error = usbhid_xfer_check_len(sc->sc_xfer[USBHID_INTR_OUT_DT], len);
559	return (ENOBUFS);	604	if (error)
		605	return (error);
560		606
561	req.intr.maxlen = len;	607	req.intr.maxlen = len;
562	return (usbhid_sync_xfer(sc, USBHID_INTR_OUT_DT, &req,	608	return (usbhid_sync_xfer(sc, USBHID_INTR_OUT_DT, &req,
Lines 569-574 usbhid_set_idle(device_t dev, uint16_t duration, uint8_t id) Link Here
569	struct usbhid_softc* sc = device_get_softc(dev);	615	struct usbhid_softc* sc = device_get_softc(dev);
570	union usbhid_device_request req;	616	union usbhid_device_request req;
571		617
		618	if (sc->sc_xfer[USBHID_CTRL_DT] == NULL)
		619	return (ENODEV);
		620
572	/* Duration is measured in 4 milliseconds per unit. */	621	/* Duration is measured in 4 milliseconds per unit. */
573	req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;	622	req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;
574	req.ctrl.bRequest = UR_SET_IDLE;	623	req.ctrl.bRequest = UR_SET_IDLE;
Lines 586-591 usbhid_set_protocol(device_t dev, uint16_t protocol) Link Here
586	struct usbhid_softc* sc = device_get_softc(dev);	635	struct usbhid_softc* sc = device_get_softc(dev);
587	union usbhid_device_request req;	636	union usbhid_device_request req;
588		637
		638	if (sc->sc_xfer[USBHID_CTRL_DT] == NULL)
		639	return (ENODEV);
		640
589	req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;	641	req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;
590	req.ctrl.bRequest = UR_SET_PROTOCOL;	642	req.ctrl.bRequest = UR_SET_PROTOCOL;
591	USETW(req.ctrl.wValue, protocol);	643	USETW(req.ctrl.wValue, protocol);

Added Link Here

(-)b/sys/dev/usb/input/usbhid.h (+54 lines)
1	/*-
2	* SPDX-License-Identifier: BSD-2-Clause-NetBSD
3	*
4	* Copyright (c) 2021 Vladimir Kondratyev <wulf@FreeBSD.org>
5	*
6	* This code is derived from software contributed to The NetBSD Foundation
7	* by Lennart Augustsson (lennart@augustsson.net) at
8	* Carlstedt Research & Technology.
9	*
10	* Redistribution and use in source and binary forms, with or without
11	* modification, are permitted provided that the following conditions
12	* are met:
13	* 1. Redistributions of source code must retain the above copyright
14	* notice, this list of conditions and the following disclaimer.
15	* 2. Redistributions in binary form must reproduce the above copyright
16	* notice, this list of conditions and the following disclaimer in the
17	* documentation and/or other materials provided with the distribution.
18	*
19	* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29	* POSSIBILITY OF SUCH DAMAGE.
30	*/
31
32	#ifndef _USB_INPUT_USBHID_H_
33	#define _USB_INPUT_USBHID_H_
34
35	enum usbhid_xfer {
36	USBHID_INTR_OUT_DT,
37	USBHID_INTR_IN_DT,
38	USBHID_CTRL_DT,
39	USBHID_N_TRANSFER,
40	};
41
42	union usbhid_device_request {
43	struct { /* INTR xfers */
44	uint16_t maxlen;
45	uint16_t actlen;
46	} intr;
47	struct usb_device_request ctrl; /* CTRL xfers */
48	};
49
50	struct usb_device *usbhid_get_usb_device(device_t);
51	int usbhid_do_request(device_t, enum usbhid_xfer,
52	union usbhid_device_request , void );
53
54	#endif /* _USB_INPUT_USBHID_H_ */