1 /* $NetBSD: parse.c,v 1.11 2000/09/24 02:19:54 augustss Exp $ */
4 * Copyright (c) 1999, 2001 Lennart Augustsson <augustss@netbsd.org>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * $FreeBSD: src/lib/libusbhid/parse.c,v 1.10 2004/02/11 21:09:13 emax Exp $
29 * $DragonFly: src/lib/libusbhid/parse.c,v 1.4 2008/11/24 17:15:17 hasso Exp $
37 #include <bus/usb/usb.h>
38 #include <bus/usb/usbhid.h>
49 unsigned int usages[MAXUSAGE];
59 * The start of collection item has no report ID set, so save
60 * it until we know the ID.
65 * Absolute data position (bits) for input/output/feature.
66 * Assumes that hid_input, hid_output and hid_feature have
69 unsigned int kindpos[3];
72 static int min(int x, int y) { return x < y ? x : y; }
74 static int hid_get_item_raw(hid_data_t s, hid_item_t *h);
77 hid_clear_local(hid_item_t *c)
82 c->designator_index = 0;
83 c->designator_minimum = 0;
84 c->designator_maximum = 0;
86 c->string_minimum = 0;
87 c->string_maximum = 0;
92 hid_start_parse(report_desc_t d, int kindset, int id)
96 s = malloc(sizeof *s);
97 memset(s, 0, sizeof *s);
98 s->start = s->p = d->data;
99 s->end = d->data + d->size;
100 s->kindset = kindset;
107 hid_end_parse(hid_data_t s)
109 while (s->cur.next) {
110 hid_item_t *hi = s->cur.next->next;
118 hid_get_item(hid_data_t s, hid_item_t *h)
123 r = hid_get_item_raw(s, h);
126 if (h->report_ID == s->reportid || s->reportid == -1)
132 #define REPORT_SAVED_COLL \
134 if (s->hassavedcoll) { \
136 h->report_ID = c->report_ID; \
137 s->hassavedcoll = 0; \
140 } while(/*LINTED*/ 0)
143 hid_get_item_raw(hid_data_t s, hid_item_t *h)
146 unsigned int bTag = 0, bType = 0, bSize;
160 if (c->logical_minimum >= c->logical_maximum) {
161 if (s->logminsize == 1)
162 c->logical_minimum =(int8_t)c->logical_minimum;
163 else if (s->logminsize == 2)
164 c->logical_minimum =(int16_t)c->logical_minimum;
166 if (s->multi < s->multimax) {
167 c->usage = s->usages[min(s->multi, s->nusage-1)];
171 * 'multimax' is only non-zero if the current
172 * item kind is input/output/feature
174 h->pos = s->kindpos[c->kind];
175 s->kindpos[c->kind] += c->report_size;
179 c->report_count = s->multimax;
201 bType = (bSize >> 2) & 3;
203 if (bSize == 3) bSize = 4;
209 * The spec is unclear if the data is signed or unsigned.
220 dval |= *data++ << 8;
224 dval |= *data++ << 8;
225 dval |= *data++ << 16;
226 dval |= *data++ << 24;
238 if (!(s->kindset & (1 << retkind))) {
239 /* Drop the items of this kind */
245 if (c->flags & HIO_VARIABLE) {
246 s->multimax = c->report_count;
250 for (i = c->usage_minimum;
251 i <= c->usage_maximum;
253 s->usages[s->nusage] = i;
254 if (s->nusage < MAXUSAGE-1)
257 c->usage_minimum = 0;
258 c->usage_maximum = 0;
264 c->usage = c->usage_minimum;
267 h->pos = s->kindpos[c->kind];
268 s->kindpos[c->kind] +=
269 c->report_size * c->report_count;
275 retkind = hid_output;
277 case 10: /* Collection */
278 c->kind = hid_collection;
279 c->collection = dval;
283 /*c->report_ID = NO_REPORT_ID;*/
285 if (s->hassavedcoll) {
287 h->report_ID = nc.report_ID;
295 case 11: /* Feature */
296 retkind = hid_feature;
298 case 12: /* End collection */
300 c->kind = hid_endcollection;
303 /*hid_clear_local(c);*/
314 c->_usage_page = dval << 16;
317 c->logical_minimum = dval;
318 s->logminsize = bSize;
321 c->logical_maximum = dval;
324 c->physical_maximum = dval;
327 c->physical_maximum = dval;
330 c->unit_exponent = dval;
336 c->report_size = dval;
340 s->kindpos[hid_input] =
341 s->kindpos[hid_output] =
342 s->kindpos[hid_feature] = 0;
345 c->report_count = dval;
348 hi = malloc(sizeof *hi);
364 c->usage = c->_usage_page | dval;
365 if (s->nusage < MAXUSAGE)
366 s->usages[s->nusage++] = c->usage;
371 c->usage_minimum = c->_usage_page | dval;
374 c->usage_maximum = c->_usage_page | dval;
377 c->designator_index = dval;
380 c->designator_minimum = dval;
383 c->designator_maximum = dval;
386 c->string_index = dval;
389 c->string_minimum = dval;
392 c->string_maximum = dval;
395 c->set_delimiter = dval;
408 hid_report_size(report_desc_t r, enum hid_kind k, int id)
414 memset(&h, 0, sizeof h);
416 for (d = hid_start_parse(r, 1<<k, id); hid_get_item(d, &h); ) {
417 if (h.report_ID == id && h.kind == k) {
418 size = d->kindpos[k];
422 return ((size + 7) / 8);
426 hid_locate(report_desc_t desc, unsigned int u, enum hid_kind k,
427 hid_item_t *h, int id)
431 for (d = hid_start_parse(desc, 1<<k, id); hid_get_item(d, h); ) {
432 if (h->kind == k && !(h->flags & HIO_CONST) && h->usage == u) {