Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libusbhid/parse.c	Lines:	0	252	0.0 %
Date:	2017-11-13	Branches:	0	145	0.0 %


/*	$OpenBSD: parse.c,v 1.11 2015/02/04 00:43:45 mpi Exp $	*/
/*	$NetBSD: parse.c,v 1.2 2001/12/29 20:44:22 augustss Exp $	*/

/*
 * Copyright (c) 1999, 2001 Lennart Augustsson <augustss@netbsd.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 <stdlib.h>
#include <string.h>

#include <dev/usb/usb.h>
#include <dev/usb/usbhid.h>

#include "usbhid.h"
#include "usbvar.h"

#define	MAXUSAGE 100
#define	MAXPUSH 4
#define	MAXID 64
#define	ITEMTYPES 3

struct hid_pos_data {
	int32_t rid;
	uint32_t pos[ITEMTYPES];
};

struct hid_data {
	const uint8_t *start;
	const uint8_t *end;
	const uint8_t *p;
	struct hid_item cur[MAXPUSH];
	struct hid_pos_data last_pos[MAXID];
	uint32_t pos[ITEMTYPES];
	int32_t usages_min[MAXUSAGE];
	int32_t usages_max[MAXUSAGE];
	int32_t usage_last;	/* last seen usage */
	uint32_t loc_size;	/* last seen size */
	uint32_t loc_count;	/* last seen count */
	uint8_t	kindset;	/* we have 5 kinds so 8 bits are enough */
	uint8_t	pushlevel;	/* current pushlevel */
	uint8_t	ncount;		/* end usage item count */
	uint8_t icount;		/* current usage item count */
	uint8_t	nusage;		/* end "usages_min/max" index */
	uint8_t	iusage;		/* current "usages_min/max" index */
	uint8_t ousage;		/* current "usages_min/max" offset */
	uint8_t	susage;		/* usage set flags */
	int32_t	reportid;	/* requested report ID */
	struct hid_item savedcoll; /* save coll until we know the ID */
	uint8_t hassavedcoll;
};

static void
hid_clear_local(hid_item_t *c)
{

	c->usage = 0;
	c->usage_minimum = 0;
	c->usage_maximum = 0;
	c->designator_index = 0;
	c->designator_minimum = 0;
	c->designator_maximum = 0;
	c->string_index = 0;
	c->string_minimum = 0;
	c->string_maximum = 0;
	c->set_delimiter = 0;
}

static void
hid_switch_rid(struct hid_data *s, struct hid_item *c, int32_t next_rID)
{
	uint8_t i, j;

	/* check for same report ID - optimise */

	if (c->report_ID == next_rID)
		return;

	/* save current position for current rID */

	if (c->report_ID == 0) {
		i = 0;
	} else {
		for (i = 1; i != MAXID; i++) {
			if (s->last_pos[i].rid == c->report_ID)
				break;
			if (s->last_pos[i].rid == 0)
				break;
		}
	}
	if (i != MAXID) {
		s->last_pos[i].rid = c->report_ID;
		for (j = 0; j < ITEMTYPES; j++)
			s->last_pos[i].pos[j] = s->pos[j];
	}

	/* store next report ID */

	c->report_ID = next_rID;

	/* lookup last position for next rID */

	if (next_rID == 0) {
		i = 0;
	} else {
		for (i = 1; i != MAXID; i++) {
			if (s->last_pos[i].rid == next_rID)
				break;
			if (s->last_pos[i].rid == 0)
				break;
		}
	}
	if (i != MAXID) {
		s->last_pos[i].rid = next_rID;
		for (j = 0; j < ITEMTYPES; j++)
			s->pos[j] = s->last_pos[i].pos[j];
	} else {
		for (j = 0; j < ITEMTYPES; j++)
			s->pos[j] = 0;	/* Out of RID entries. */
	}
}

hid_data_t
hid_start_parse(report_desc_t d, int kindset, int id)
{
	struct hid_data *s;

	s = calloc(1, sizeof *s);
	if (s == NULL)
		return (NULL);
	s->start = s->p = d->data;
	s->end = d->data + d->size;
	s->kindset = kindset;
	s->reportid = id;
	s->hassavedcoll = 0;
	return (s);
}

void
hid_end_parse(hid_data_t s)
{

	if (s == NULL)
		return;

	free(s);
}

static uint8_t
hid_get_byte(struct hid_data *s, const uint16_t wSize)
{
	const uint8_t *ptr;
	uint8_t retval;

	ptr = s->p;

	/* check if end is reached */
	if (ptr == s->end)
		return (0);

	/* read out a byte */
	retval = *ptr;

	/* check if data pointer can be advanced by "wSize" bytes */
	if ((s->end - ptr) < wSize)
		ptr = s->end;
	else
		ptr += wSize;

	/* update pointer */
	s->p = ptr;

	return (retval);
}

#define REPORT_SAVED_COLL \
	do { \
		if (s->hassavedcoll) { \
			*h = s->savedcoll; \
			h->report_ID = c->report_ID; \
			s->hassavedcoll = 0; \
			return (1); \
		} \
	} while(0)

static int
hid_get_item_raw(hid_data_t s, hid_item_t *h)
{
	hid_item_t nc, *c;
	unsigned int bTag, bType, bSize;
	int32_t mask;
	int32_t dval;

	if (s == NULL)
		return (0);

	c = &s->cur[s->pushlevel];

 top:
	/* check if there is an array of items */
	if (s->icount < s->ncount) {
		REPORT_SAVED_COLL;
		/* get current usage */
		if (s->iusage < s->nusage) {
			dval = s->usages_min[s->iusage] + s->ousage;
			c->usage = dval;
			s->usage_last = dval;
			if (dval == s->usages_max[s->iusage]) {
				s->iusage ++;
				s->ousage = 0;
			} else {
				s->ousage ++;
			}
		} else {
			/* Using last usage */
			dval = s->usage_last;
		}
		s->icount ++;
		/*
		 * Only copy HID item, increment position and return
		 * if correct kindset!
		 */
		if (s->kindset & (1 << c->kind)) {
			*h = *c;
			h->pos = s->pos[c->kind];
			s->pos[c->kind] += c->report_size * c->report_count;
			return (1);
		}
	}

	/* reset state variables */
	s->icount = 0;
	s->ncount = 0;
	s->iusage = 0;
	s->nusage = 0;
	s->susage = 0;
	s->ousage = 0;
	hid_clear_local(c);

	/* get next item */
	while (s->p != s->end) {

		bSize = hid_get_byte(s, 1);
		if (bSize == 0xfe) {
			/* long item */
			bSize = hid_get_byte(s, 1);
			bSize |= hid_get_byte(s, 1) << 8;
			bTag = hid_get_byte(s, 1);
			bType = 0xff;	/* XXX what should it be */
		} else {
			/* short item */
			bTag = bSize >> 4;
			bType = (bSize >> 2) & 3;
			bSize &= 3;
			if (bSize == 3)
				bSize = 4;
		}

		switch(bSize) {
		case 0:
			dval = 0;
			mask = 0;
			break;
		case 1:
			dval = (int8_t)hid_get_byte(s, 1);
			mask = 0xFF;
			break;
		case 2:
			dval = hid_get_byte(s, 1);
			dval |= hid_get_byte(s, 1) << 8;
			dval = (int16_t)dval;
			mask = 0xFFFF;
			break;
		case 4:
			dval = hid_get_byte(s, 1);
			dval |= hid_get_byte(s, 1) << 8;
			dval |= hid_get_byte(s, 1) << 16;
			dval |= hid_get_byte(s, 1) << 24;
			mask = 0xFFFFFFFF;
			break;
		default:
			dval = hid_get_byte(s, bSize);
			continue;
		}

		switch (bType) {
		case 0:		/* Main */
			switch (bTag) {
			case 8:	/* Input */
				c->kind = hid_input;
				c->flags = dval;
		ret:
				c->report_count = s->loc_count;
				c->report_size = s->loc_size;

				if (c->flags & HIO_VARIABLE) {
					/* range check usage count */
					if (c->report_count > 255) {
						s->ncount = 255;
					} else
						s->ncount = c->report_count;

					/*
					 * The "top" loop will return
					 * one and one item:
					 */
					c->report_count = 1;
					c->usage_minimum = 0;
					c->usage_maximum = 0;
				} else {
					s->ncount = 1;
				}
				goto top;

			case 9:	/* Output */
				c->kind = hid_output;
				c->flags = dval;
				goto ret;
			case 10:	/* Collection */
				c->kind = hid_collection;
				c->collection = dval;
				c->collevel++;
				c->usage = s->usage_last;
				nc = *c;
				if (s->hassavedcoll) {
					*h = s->savedcoll;
					h->report_ID = nc.report_ID;
					s->savedcoll = nc;
					return (1);
				} else {
					s->hassavedcoll = 1;
					s->savedcoll = nc;
				}
				goto top;
			case 11:	/* Feature */
				c->kind = hid_feature;
				c->flags = dval;
				goto ret;
			case 12:	/* End collection */
				REPORT_SAVED_COLL;
				c->kind = hid_endcollection;
				if (c->collevel == 0) {
					/* Invalid end collection. */
					return (0);
				}
				c->collevel--;
				*h = *c;
				return (1);
			default:
				break;
			}
			break;

		case 1:		/* Global */
			switch (bTag) {
			case 0:
				c->_usage_page = dval << 16;
				break;
			case 1:
				c->logical_minimum = dval;
				break;
			case 2:
				c->logical_maximum = dval;
				break;
			case 3:
				c->physical_minimum = dval;
				break;
			case 4:
				c->physical_maximum = dval;
				break;
			case 5:
				c->unit_exponent = dval;
				break;
			case 6:
				c->unit = dval;
				break;
			case 7:
				/* mask because value is unsigned */
				s->loc_size = dval & mask;
				break;
			case 8:
				hid_switch_rid(s, c, dval & mask);
				break;
			case 9:
				/* mask because value is unsigned */
				s->loc_count = dval & mask;
				break;
			case 10:	/* Push */
				s->pushlevel ++;
				if (s->pushlevel < MAXPUSH) {
					s->cur[s->pushlevel] = *c;
					/* store size and count */
					c->report_size = s->loc_size;
					c->report_count = s->loc_count;
					/* update current item pointer */
					c = &s->cur[s->pushlevel];
				}
				break;
			case 11:	/* Pop */
				s->pushlevel --;
				if (s->pushlevel < MAXPUSH) {
					c = &s->cur[s->pushlevel];
					/* restore size and count */
					s->loc_size = c->report_size;
					s->loc_count = c->report_count;
					c->report_size = 0;
					c->report_count = 0;
				}
				break;
			default:
				break;
			}
			break;
		case 2:		/* Local */
			switch (bTag) {
			case 0:
				if (bSize != 4)
					dval = (dval & mask) | c->_usage_page;

				/* set last usage, in case of a collection */
				s->usage_last = dval;

				if (s->nusage < MAXUSAGE) {
					s->usages_min[s->nusage] = dval;
					s->usages_max[s->nusage] = dval;
					s->nusage ++;
				}
				/* else XXX */

				/* clear any pending usage sets */
				s->susage = 0;
				break;
			case 1:
				s->susage |= 1;

				if (bSize != 4)
					dval = (dval & mask) | c->_usage_page;
				c->usage_minimum = dval;

				goto check_set;
			case 2:
				s->susage |= 2;

				if (bSize != 4)
					dval = (dval & mask) | c->_usage_page;
				c->usage_maximum = dval;

			check_set:
				if (s->susage != 3)
					break;

				/* sanity check */
				if ((s->nusage < MAXUSAGE) &&
				    (c->usage_minimum <= c->usage_maximum)) {
					/* add usage range */
					s->usages_min[s->nusage] =
					    c->usage_minimum;
					s->usages_max[s->nusage] =
					    c->usage_maximum;
					s->nusage ++;
				}
				/* else XXX */

				s->susage = 0;
				break;
			case 3:
				c->designator_index = dval;
				break;
			case 4:
				c->designator_minimum = dval;
				break;
			case 5:
				c->designator_maximum = dval;
				break;
			case 7:
				c->string_index = dval;
				break;
			case 8:
				c->string_minimum = dval;
				break;
			case 9:
				c->string_maximum = dval;
				break;
			case 10:
				c->set_delimiter = dval;
				break;
			default:
				break;
			}
			break;
		default:
			break;
		}
	}
	return (0);
}

int
hid_get_item(hid_data_t s, hid_item_t *h)
{
	int r;

	for (;;) {
		r = hid_get_item_raw(s, h);
		if (r <= 0 || s->reportid == -1 || h->report_ID == s->reportid)
			break;
	}
	return (r);
}

int
hid_report_size(report_desc_t r, enum hid_kind k, int id)
{
	struct hid_data *d;
	struct hid_item h;
	uint32_t temp;
	uint32_t hpos;
	uint32_t lpos;
	int report_id = 0;

	hpos = 0;
	lpos = 0xFFFFFFFF;

	memset(&h, 0, sizeof h);
	for (d = hid_start_parse(r, 1 << k, id); hid_get_item(d, &h); ) {
		if (h.kind == k) {
			/* compute minimum */
			if (lpos > h.pos)
				lpos = h.pos;
			/* compute end position */
			temp = h.pos + (h.report_size * h.report_count);
			/* compute maximum */
			if (hpos < temp)
				hpos = temp;
			if (h.report_ID != 0)
				report_id = 1;
		}
	}
	hid_end_parse(d);

	/* safety check - can happen in case of currupt descriptors */
	if (lpos > hpos)
		temp = 0;
	else
		temp = hpos - lpos;

	/* No extra byte for the reportID because the kernel skips it. */
	return ((temp + 7) / 8);
}

int
hid_locate(report_desc_t desc, unsigned int u, enum hid_kind k,
    hid_item_t *h, int id)
{
	struct hid_data *d;

	for (d = hid_start_parse(desc, 1 << k, id); hid_get_item(d, h); ) {
		if (h->kind == k && !(h->flags & HIO_CONST) && h->usage == u) {
			hid_end_parse(d);
			return (1);
		}
	}
	hid_end_parse(d);
	h->report_size = 0;
	return (0);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: parse.c,v 1.11 2015/02/04 00:43:45 mpi Exp $ */
2			/* $NetBSD: parse.c,v 1.2 2001/12/29 20:44:22 augustss Exp $ */
3
4			/*
5			* Copyright (c) 1999, 2001 Lennart Augustsson <augustss@netbsd.org>
6			* All rights reserved.
7			*
8			* Redistribution and use in source and binary forms, with or without
9			* modification, are permitted provided that the following conditions
10			* are met:
11			* 1. Redistributions of source code must retain the above copyright
12			* notice, this list of conditions and the following disclaimer.
13			* 2. Redistributions in binary form must reproduce the above copyright
14			* notice, this list of conditions and the following disclaimer in the
15			* documentation and/or other materials provided with the distribution.
16			*
17			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27			* SUCH DAMAGE.
28			*/
29
30			#include <stdlib.h>
31			#include <string.h>
32
33			#include <dev/usb/usb.h>
34			#include <dev/usb/usbhid.h>
35
36			#include "usbhid.h"
37			#include "usbvar.h"
38
39			#define MAXUSAGE 100
40			#define MAXPUSH 4
41			#define MAXID 64
42			#define ITEMTYPES 3
43
44			struct hid_pos_data {
45			int32_t rid;
46			uint32_t pos[ITEMTYPES];
47			};
48
49			struct hid_data {
50			const uint8_t *start;
51			const uint8_t *end;
52			const uint8_t *p;
53			struct hid_item cur[MAXPUSH];
54			struct hid_pos_data last_pos[MAXID];
55			uint32_t pos[ITEMTYPES];
56			int32_t usages_min[MAXUSAGE];
57			int32_t usages_max[MAXUSAGE];
58			int32_t usage_last; /* last seen usage */
59			uint32_t loc_size; /* last seen size */
60			uint32_t loc_count; /* last seen count */
61			uint8_t kindset; /* we have 5 kinds so 8 bits are enough */
62			uint8_t pushlevel; /* current pushlevel */
63			uint8_t ncount; /* end usage item count */
64			uint8_t icount; /* current usage item count */
65			uint8_t nusage; /* end "usages_min/max" index */
66			uint8_t iusage; /* current "usages_min/max" index */
67			uint8_t ousage; /* current "usages_min/max" offset */
68			uint8_t susage; /* usage set flags */
69			int32_t reportid; /* requested report ID */
70			struct hid_item savedcoll; /* save coll until we know the ID */
71			uint8_t hassavedcoll;
72			};
73
74			static void
75			hid_clear_local(hid_item_t *c)
76			{
77
78			c->usage = 0;
79			c->usage_minimum = 0;
80			c->usage_maximum = 0;
81			c->designator_index = 0;
82			c->designator_minimum = 0;
83			c->designator_maximum = 0;
84			c->string_index = 0;
85			c->string_minimum = 0;
86			c->string_maximum = 0;
87			c->set_delimiter = 0;
88			}
89
90			static void
91			hid_switch_rid(struct hid_data s, struct hid_item c, int32_t next_rID)
92			{
93			uint8_t i, j;
94
95			/* check for same report ID - optimise */
96
97			if (c->report_ID == next_rID)
98			return;
99
100			/* save current position for current rID */
101
102			if (c->report_ID == 0) {
103			i = 0;
104			} else {
105			for (i = 1; i != MAXID; i++) {
106			if (s->last_pos[i].rid == c->report_ID)
107			break;
108			if (s->last_pos[i].rid == 0)
109			break;
110			}
111			}
112			if (i != MAXID) {
113			s->last_pos[i].rid = c->report_ID;
114			for (j = 0; j < ITEMTYPES; j++)
115			s->last_pos[i].pos[j] = s->pos[j];
116			}
117
118			/* store next report ID */
119
120			c->report_ID = next_rID;
121
122			/* lookup last position for next rID */
123
124			if (next_rID == 0) {
125			i = 0;
126			} else {
127			for (i = 1; i != MAXID; i++) {
128			if (s->last_pos[i].rid == next_rID)
129			break;
130			if (s->last_pos[i].rid == 0)
131			break;
132			}
133			}
134			if (i != MAXID) {
135			s->last_pos[i].rid = next_rID;
136			for (j = 0; j < ITEMTYPES; j++)
137			s->pos[j] = s->last_pos[i].pos[j];
138			} else {
139			for (j = 0; j < ITEMTYPES; j++)
140			s->pos[j] = 0; /* Out of RID entries. */
141			}
142			}
143
144			hid_data_t
145			hid_start_parse(report_desc_t d, int kindset, int id)
146			{
147			struct hid_data *s;
148
149			s = calloc(1, sizeof *s);
150			if (s == NULL)
151			return (NULL);
152			s->start = s->p = d->data;
153			s->end = d->data + d->size;
154			s->kindset = kindset;
155			s->reportid = id;
156			s->hassavedcoll = 0;
157			return (s);
158			}
159
160			void
161			hid_end_parse(hid_data_t s)
162			{
163
164			if (s == NULL)
165			return;
166
167			free(s);
168			}
169
170			static uint8_t
171			hid_get_byte(struct hid_data *s, const uint16_t wSize)
172			{
173			const uint8_t *ptr;
174			uint8_t retval;
175
176			ptr = s->p;
177
178			/* check if end is reached */
179			if (ptr == s->end)
180			return (0);
181
182			/* read out a byte */
183			retval = *ptr;
184
185			/* check if data pointer can be advanced by "wSize" bytes */
186			if ((s->end - ptr) < wSize)
187			ptr = s->end;
188			else
189			ptr += wSize;
190
191			/* update pointer */
192			s->p = ptr;
193
194			return (retval);
195			}
196
197			#define REPORT_SAVED_COLL \
198			do { \
199			if (s->hassavedcoll) { \
200			*h = s->savedcoll; \
201			h->report_ID = c->report_ID; \
202			s->hassavedcoll = 0; \
203			return (1); \
204			} \
205			} while(0)
206
207			static int
208			hid_get_item_raw(hid_data_t s, hid_item_t *h)
209			{
210			hid_item_t nc, *c;
211			unsigned int bTag, bType, bSize;
212			int32_t mask;
213			int32_t dval;
214
215			if (s == NULL)
216			return (0);
217
218			c = &s->cur[s->pushlevel];
219
220			top:
221			/* check if there is an array of items */
222			if (s->icount < s->ncount) {
223			REPORT_SAVED_COLL;
224			/* get current usage */
225			if (s->iusage < s->nusage) {
226			dval = s->usages_min[s->iusage] + s->ousage;
227			c->usage = dval;
228			s->usage_last = dval;
229			if (dval == s->usages_max[s->iusage]) {
230			s->iusage ++;
231			s->ousage = 0;
232			} else {
233			s->ousage ++;
234			}
235			} else {
236			/* Using last usage */
237			dval = s->usage_last;
238			}
239			s->icount ++;
240			/*
241			* Only copy HID item, increment position and return
242			* if correct kindset!
243			*/
244			if (s->kindset & (1 << c->kind)) {
245			h = c;
246			h->pos = s->pos[c->kind];
247			s->pos[c->kind] += c->report_size * c->report_count;
248			return (1);
249			}
250			}
251
252			/* reset state variables */
253			s->icount = 0;
254			s->ncount = 0;
255			s->iusage = 0;
256			s->nusage = 0;
257			s->susage = 0;
258			s->ousage = 0;
259			hid_clear_local(c);
260
261			/* get next item */
262			while (s->p != s->end) {
263
264			bSize = hid_get_byte(s, 1);
265			if (bSize == 0xfe) {
266			/* long item */
267			bSize = hid_get_byte(s, 1);
268			bSize \|= hid_get_byte(s, 1) << 8;
269			bTag = hid_get_byte(s, 1);
270			bType = 0xff; /* XXX what should it be */
271			} else {
272			/* short item */
273			bTag = bSize >> 4;
274			bType = (bSize >> 2) & 3;
275			bSize &= 3;
276			if (bSize == 3)
277			bSize = 4;
278			}
279
280			switch(bSize) {
281			case 0:
282			dval = 0;
283			mask = 0;
284			break;
285			case 1:
286			dval = (int8_t)hid_get_byte(s, 1);
287			mask = 0xFF;
288			break;
289			case 2:
290			dval = hid_get_byte(s, 1);
291			dval \|= hid_get_byte(s, 1) << 8;
292			dval = (int16_t)dval;
293			mask = 0xFFFF;
294			break;
295			case 4:
296			dval = hid_get_byte(s, 1);
297			dval \|= hid_get_byte(s, 1) << 8;
298			dval \|= hid_get_byte(s, 1) << 16;
299			dval \|= hid_get_byte(s, 1) << 24;
300			mask = 0xFFFFFFFF;
301			break;
302			default:
303			dval = hid_get_byte(s, bSize);
304			continue;
305			}
306
307			switch (bType) {
308			case 0: /* Main */
309			switch (bTag) {
310			case 8: /* Input */
311			c->kind = hid_input;
312			c->flags = dval;
313			ret:
314			c->report_count = s->loc_count;
315			c->report_size = s->loc_size;
316
317			if (c->flags & HIO_VARIABLE) {
318			/* range check usage count */
319			if (c->report_count > 255) {
320			s->ncount = 255;
321			} else
322			s->ncount = c->report_count;
323
324			/*
325			* The "top" loop will return
326			* one and one item:
327			*/
328			c->report_count = 1;
329			c->usage_minimum = 0;
330			c->usage_maximum = 0;
331			} else {
332			s->ncount = 1;
333			}
334			goto top;
335
336			case 9: /* Output */
337			c->kind = hid_output;
338			c->flags = dval;
339			goto ret;
340			case 10: /* Collection */
341			c->kind = hid_collection;
342			c->collection = dval;
343			c->collevel++;
344			c->usage = s->usage_last;
345			nc = *c;
346			if (s->hassavedcoll) {
347			*h = s->savedcoll;
348			h->report_ID = nc.report_ID;
349			s->savedcoll = nc;
350			return (1);
351			} else {
352			s->hassavedcoll = 1;
353			s->savedcoll = nc;
354			}
355			goto top;
356			case 11: /* Feature */
357			c->kind = hid_feature;
358			c->flags = dval;
359			goto ret;
360			case 12: /* End collection */
361			REPORT_SAVED_COLL;
362			c->kind = hid_endcollection;
363			if (c->collevel == 0) {
364			/* Invalid end collection. */
365			return (0);
366			}
367			c->collevel--;
368			h = c;
369			return (1);
370			default:
371			break;
372			}
373			break;
374
375			case 1: /* Global */
376			switch (bTag) {
377			case 0:
378			c->_usage_page = dval << 16;
379			break;
380			case 1:
381			c->logical_minimum = dval;
382			break;
383			case 2:
384			c->logical_maximum = dval;
385			break;
386			case 3:
387			c->physical_minimum = dval;
388			break;
389			case 4:
390			c->physical_maximum = dval;
391			break;
392			case 5:
393			c->unit_exponent = dval;
394			break;
395			case 6:
396			c->unit = dval;
397			break;
398			case 7:
399			/* mask because value is unsigned */
400			s->loc_size = dval & mask;
401			break;
402			case 8:
403			hid_switch_rid(s, c, dval & mask);
404			break;
405			case 9:
406			/* mask because value is unsigned */
407			s->loc_count = dval & mask;
408			break;
409			case 10: /* Push */
410			s->pushlevel ++;
411			if (s->pushlevel < MAXPUSH) {
412			s->cur[s->pushlevel] = *c;
413			/* store size and count */
414			c->report_size = s->loc_size;
415			c->report_count = s->loc_count;
416			/* update current item pointer */
417			c = &s->cur[s->pushlevel];
418			}
419			break;
420			case 11: /* Pop */
421			s->pushlevel --;
422			if (s->pushlevel < MAXPUSH) {
423			c = &s->cur[s->pushlevel];
424			/* restore size and count */
425			s->loc_size = c->report_size;
426			s->loc_count = c->report_count;
427			c->report_size = 0;
428			c->report_count = 0;
429			}
430			break;
431			default:
432			break;
433			}
434			break;
435			case 2: /* Local */
436			switch (bTag) {
437			case 0:
438			if (bSize != 4)
439			dval = (dval & mask) \| c->_usage_page;
440
441			/* set last usage, in case of a collection */
442			s->usage_last = dval;
443
444			if (s->nusage < MAXUSAGE) {
445			s->usages_min[s->nusage] = dval;
446			s->usages_max[s->nusage] = dval;
447			s->nusage ++;
448			}
449			/* else XXX */
450
451			/* clear any pending usage sets */
452			s->susage = 0;
453			break;
454			case 1:
455			s->susage \|= 1;
456
457			if (bSize != 4)
458			dval = (dval & mask) \| c->_usage_page;
459			c->usage_minimum = dval;
460
461			goto check_set;
462			case 2:
463			s->susage \|= 2;
464
465			if (bSize != 4)
466			dval = (dval & mask) \| c->_usage_page;
467			c->usage_maximum = dval;
468
469			check_set:
470			if (s->susage != 3)
471			break;
472
473			/* sanity check */
474			if ((s->nusage < MAXUSAGE) &&
475			(c->usage_minimum <= c->usage_maximum)) {
476			/* add usage range */
477			s->usages_min[s->nusage] =
478			c->usage_minimum;
479			s->usages_max[s->nusage] =
480			c->usage_maximum;
481			s->nusage ++;
482			}
483			/* else XXX */
484
485			s->susage = 0;
486			break;
487			case 3:
488			c->designator_index = dval;
489			break;
490			case 4:
491			c->designator_minimum = dval;
492			break;
493			case 5:
494			c->designator_maximum = dval;
495			break;
496			case 7:
497			c->string_index = dval;
498			break;
499			case 8:
500			c->string_minimum = dval;
501			break;
502			case 9:
503			c->string_maximum = dval;
504			break;
505			case 10:
506			c->set_delimiter = dval;
507			break;
508			default:
509			break;
510			}
511			break;
512			default:
513			break;
514			}
515			}
516			return (0);
517			}
518
519			int
520			hid_get_item(hid_data_t s, hid_item_t *h)
521			{
522			int r;
523
524			for (;;) {
525			r = hid_get_item_raw(s, h);
526			if (r <= 0 \|\| s->reportid == -1 \|\| h->report_ID == s->reportid)
527			break;
528			}
529			return (r);
530			}
531
532			int
533			hid_report_size(report_desc_t r, enum hid_kind k, int id)
534			{
535			struct hid_data *d;
536			struct hid_item h;
537			uint32_t temp;
538			uint32_t hpos;
539			uint32_t lpos;
540			int report_id = 0;
541
542			hpos = 0;
543			lpos = 0xFFFFFFFF;
544
545			memset(&h, 0, sizeof h);
546			for (d = hid_start_parse(r, 1 << k, id); hid_get_item(d, &h); ) {
547			if (h.kind == k) {
548			/* compute minimum */
549			if (lpos > h.pos)
550			lpos = h.pos;
551			/* compute end position */
552			temp = h.pos + (h.report_size * h.report_count);
553			/* compute maximum */
554			if (hpos < temp)
555			hpos = temp;
556			if (h.report_ID != 0)
557			report_id = 1;
558			}
559			}
560			hid_end_parse(d);
561
562			/* safety check - can happen in case of currupt descriptors */
563			if (lpos > hpos)
564			temp = 0;
565			else
566			temp = hpos - lpos;
567
568			/* No extra byte for the reportID because the kernel skips it. */
569			return ((temp + 7) / 8);
570			}
571
572			int
573			hid_locate(report_desc_t desc, unsigned int u, enum hid_kind k,
574			hid_item_t *h, int id)
575			{
576			struct hid_data *d;
577
578			for (d = hid_start_parse(desc, 1 << k, id); hid_get_item(d, h); ) {
579			if (h->kind == k && !(h->flags & HIO_CONST) && h->usage == u) {
580			hid_end_parse(d);
581			return (1);
582			}
583			}
584			hid_end_parse(d);
585			h->report_size = 0;
586			return (0);
587			}