![[BACK]](/icons/back.gif){kind=icon}
Return to hid.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb|
Return to hid.c CVS log | Up to [local] / sys / dev / usb |
1.1 nbrk 1: /* $OpenBSD: hid.c,v 1.18 2007/06/05 08:43:55 mbalmer Exp $ */
2: /* $NetBSD: hid.c,v 1.23 2002/07/11 21:14:25 augustss Exp $ */
3: /* $FreeBSD: src/sys/dev/usb/hid.c,v 1.11 1999/11/17 22:33:39 n_hibma Exp $ */
4:
5: /*
6: * Copyright (c) 1998 The NetBSD Foundation, Inc.
7: * All rights reserved.
8: *
9: * This code is derived from software contributed to The NetBSD Foundation
10: * by Lennart Augustsson (lennart@augustsson.net) at
11: * Carlstedt Research & Technology.
12: *
13: * Redistribution and use in source and binary forms, with or without
14: * modification, are permitted provided that the following conditions
15: * are met:
16: * 1. Redistributions of source code must retain the above copyright
17: * notice, this list of conditions and the following disclaimer.
18: * 2. Redistributions in binary form must reproduce the above copyright
19: * notice, this list of conditions and the following disclaimer in the
20: * documentation and/or other materials provided with the distribution.
21: * 3. All advertising materials mentioning features or use of this software
22: * must display the following acknowledgement:
23: * This product includes software developed by the NetBSD
24: * Foundation, Inc. and its contributors.
25: * 4. Neither the name of The NetBSD Foundation nor the names of its
26: * contributors may be used to endorse or promote products derived
27: * from this software without specific prior written permission.
28: *
29: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
30: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
31: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
32: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
33: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
34: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
35: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
36: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
37: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
38: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
39: * POSSIBILITY OF SUCH DAMAGE.
40: */
41:
42: #include <sys/param.h>
43: #include <sys/systm.h>
44: #include <sys/malloc.h>
45:
46: #include <dev/usb/usb.h>
47: #include <dev/usb/usbhid.h>
48:
49: #include <dev/usb/hid.h>
50:
51: #ifdef UHIDEV_DEBUG
52: #define DPRINTF(x) do { if (uhidevdebug) printf x; } while (0)
53: #define DPRINTFN(n,x) do { if (uhidevdebug>(n)) printf x; } while (0)
54: extern int uhidevdebug;
55: #else
56: #define DPRINTF(x)
57: #define DPRINTFN(n,x)
58: #endif
59:
60: void hid_clear_local(struct hid_item *);
61:
62: #define MAXUSAGE 256
63: struct hid_data {
64: u_char *start;
65: u_char *end;
66: u_char *p;
67: struct hid_item cur;
68: int32_t usages[MAXUSAGE];
69: int nu;
70: int minset;
71: int multi;
72: int multimax;
73: enum hid_kind kind;
74: };
75:
76: void
77: hid_clear_local(struct hid_item *c)
78: {
79:
80: DPRINTFN(5,("hid_clear_local\n"));
81: c->usage = 0;
82: c->usage_minimum = 0;
83: c->usage_maximum = 0;
84: c->designator_index = 0;
85: c->designator_minimum = 0;
86: c->designator_maximum = 0;
87: c->string_index = 0;
88: c->string_minimum = 0;
89: c->string_maximum = 0;
90: c->set_delimiter = 0;
91: }
92:
93: struct hid_data *
94: hid_start_parse(void *d, int len, enum hid_kind kind)
95: {
96: struct hid_data *s;
97:
98: s = malloc(sizeof *s, M_TEMP, M_WAITOK);
99: if (s == NULL)
100: panic("hid_start_parse");
101: memset(s, 0, sizeof *s);
102:
103: s->start = s->p = d;
104: s->end = (char *)d + len;
105: s->kind = kind;
106: return (s);
107: }
108:
109: void
110: hid_end_parse(struct hid_data *s)
111: {
112:
113: while (s->cur.next != NULL) {
114: struct hid_item *hi = s->cur.next->next;
115: free(s->cur.next, M_TEMP);
116: s->cur.next = hi;
117: }
118: free(s, M_TEMP);
119: }
120:
121: int
122: hid_get_item(struct hid_data *s, struct hid_item *h)
123: {
124: struct hid_item *c = &s->cur;
125: unsigned int bTag, bType, bSize;
126: u_int32_t oldpos;
127: u_char *data;
128: int32_t dval;
129: u_char *p;
130: struct hid_item *hi;
131: int i;
132: enum hid_kind retkind;
133:
134: top:
135: DPRINTFN(5,("hid_get_item: multi=%d multimax=%d\n",
136: s->multi, s->multimax));
137: if (s->multimax != 0) {
138: if (s->multi < s->multimax) {
139: c->usage = s->usages[min(s->multi, s->nu-1)];
140: s->multi++;
141: *h = *c;
142: c->loc.pos += c->loc.size;
143: h->next = NULL;
144: DPRINTFN(5,("return multi\n"));
145: return (1);
146: } else {
147: c->loc.count = s->multimax;
148: s->multimax = 0;
149: s->nu = 0;
150: hid_clear_local(c);
151: }
152: }
153: for (;;) {
154: p = s->p;
155: if (p >= s->end)
156: return (0);
157:
158: bSize = *p++;
159: if (bSize == 0xfe) {
160: /* long item */
161: bSize = *p++;
162: bSize |= *p++ << 8;
163: bTag = *p++;
164: data = p;
165: p += bSize;
166: bType = 0xff; /* XXX what should it be */
167: } else {
168: /* short item */
169: bTag = bSize >> 4;
170: bType = (bSize >> 2) & 3;
171: bSize &= 3;
172: if (bSize == 3) bSize = 4;
173: data = p;
174: p += bSize;
175: }
176: s->p = p;
177: switch(bSize) {
178: case 0:
179: dval = 0;
180: break;
181: case 1:
182: dval = /*(int8_t)*/ *data++;
183: break;
184: case 2:
185: dval = *data++;
186: dval |= *data++ << 8;
187: dval = /*(int16_t)*/ dval;
188: break;
189: case 4:
190: dval = *data++;
191: dval |= *data++ << 8;
192: dval |= *data++ << 16;
193: dval |= *data++ << 24;
194: break;
195: default:
196: printf("BAD LENGTH %d\n", bSize);
197: continue;
198: }
199:
200: DPRINTFN(5,("hid_get_item: bType=%d bTag=%d dval=%d\n",
201: bType, bTag, dval));
202: switch (bType) {
203: case 0: /* Main */
204: switch (bTag) {
205: case 8: /* Input */
206: retkind = hid_input;
207: ret:
208: if (s->kind != retkind) {
209: s->minset = 0;
210: s->nu = 0;
211: hid_clear_local(c);
212: continue;
213: }
214: c->kind = retkind;
215: c->flags = dval;
216: if (c->flags & HIO_VARIABLE) {
217: s->multimax = c->loc.count;
218: s->multi = 0;
219: c->loc.count = 1;
220: if (s->minset) {
221: for (i = c->usage_minimum;
222: i <= c->usage_maximum;
223: i++) {
224: s->usages[s->nu] = i;
225: if (s->nu < MAXUSAGE-1)
226: s->nu++;
227: }
228: s->minset = 0;
229: }
230: goto top;
231: } else {
232: c->usage = c->_usage_page; /* XXX */
233: *h = *c;
234: h->next = NULL;
235: c->loc.pos +=
236: c->loc.size * c->loc.count;
237: s->minset = 0;
238: s->nu = 0;
239: hid_clear_local(c);
240: return (1);
241: }
242: case 9: /* Output */
243: retkind = hid_output;
244: goto ret;
245: case 10: /* Collection */
246: c->kind = hid_collection;
247: c->collection = dval;
248: c->collevel++;
249: *h = *c;
250: hid_clear_local(c);
251: s->nu = 0;
252: return (1);
253: case 11: /* Feature */
254: retkind = hid_feature;
255: goto ret;
256: case 12: /* End collection */
257: c->kind = hid_endcollection;
258: c->collevel--;
259: *h = *c;
260: s->nu = 0;
261: return (1);
262: default:
263: printf("Main bTag=%d\n", bTag);
264: break;
265: }
266: break;
267: case 1: /* Global */
268: switch (bTag) {
269: case 0:
270: c->_usage_page = dval << 16;
271: break;
272: case 1:
273: c->logical_minimum = dval;
274: break;
275: case 2:
276: c->logical_maximum = dval;
277: break;
278: case 3:
279: c->physical_maximum = dval;
280: break;
281: case 4:
282: c->physical_maximum = dval;
283: break;
284: case 5:
285: c->unit_exponent = dval;
286: break;
287: case 6:
288: c->unit = dval;
289: break;
290: case 7:
291: c->loc.size = dval;
292: break;
293: case 8:
294: c->report_ID = dval;
295: c->loc.pos = 0;
296: break;
297: case 9:
298: c->loc.count = dval;
299: break;
300: case 10: /* Push */
301: hi = malloc(sizeof *hi, M_TEMP, M_WAITOK);
302: *hi = s->cur;
303: c->next = hi;
304: break;
305: case 11: /* Pop */
306: hi = c->next;
307: oldpos = c->loc.pos;
308: s->cur = *hi;
309: c->loc.pos = oldpos;
310: free(hi, M_TEMP);
311: break;
312: default:
313: printf("Global bTag=%d\n", bTag);
314: break;
315: }
316: break;
317: case 2: /* Local */
318: switch (bTag) {
319: case 0:
320: if (bSize == 1)
321: dval = c->_usage_page | (dval&0xff);
322: else if (bSize == 2)
323: dval = c->_usage_page | (dval&0xffff);
324: c->usage = dval;
325: if (s->nu < MAXUSAGE)
326: s->usages[s->nu++] = dval;
327: /* else XXX */
328: break;
329: case 1:
330: s->minset = 1;
331: if (bSize == 1)
332: dval = c->_usage_page | (dval&0xff);
333: else if (bSize == 2)
334: dval = c->_usage_page | (dval&0xffff);
335: c->usage_minimum = dval;
336: break;
337: case 2:
338: if (bSize == 1)
339: dval = c->_usage_page | (dval&0xff);
340: else if (bSize == 2)
341: dval = c->_usage_page | (dval&0xffff);
342: c->usage_maximum = dval;
343: break;
344: case 3:
345: c->designator_index = dval;
346: break;
347: case 4:
348: c->designator_minimum = dval;
349: break;
350: case 5:
351: c->designator_maximum = dval;
352: break;
353: case 7:
354: c->string_index = dval;
355: break;
356: case 8:
357: c->string_minimum = dval;
358: break;
359: case 9:
360: c->string_maximum = dval;
361: break;
362: case 10:
363: c->set_delimiter = dval;
364: break;
365: default:
366: printf("Local bTag=%d\n", bTag);
367: break;
368: }
369: break;
370: default:
371: printf("default bType=%d\n", bType);
372: break;
373: }
374: }
375: }
376:
377: int
378: hid_report_size(void *buf, int len, enum hid_kind k, u_int8_t id)
379: {
380: struct hid_data *d;
381: struct hid_item h;
382: int lo, hi;
383:
384: h.report_ID = 0;
385: lo = hi = -1;
386: DPRINTFN(2,("hid_report_size: kind=%d id=%d\n", k, id));
387: for (d = hid_start_parse(buf, len, k); hid_get_item(d, &h); ) {
388: DPRINTFN(2,("hid_report_size: item kind=%d id=%d pos=%d "
389: "size=%d count=%d\n",
390: h.kind, h.report_ID, h.loc.pos, h.loc.size,
391: h.loc.count));
392: if (h.report_ID == id && h.kind == k) {
393: if (lo < 0) {
394: lo = h.loc.pos;
395: #ifdef DIAGNOSTIC
396: if (lo != 0) {
397: printf("hid_report_size: lo != 0\n");
398: }
399: #endif
400: }
401: hi = h.loc.pos + h.loc.size * h.loc.count;
402: DPRINTFN(2,("hid_report_size: lo=%d hi=%d\n", lo, hi));
403: }
404: }
405: hid_end_parse(d);
406: return ((hi - lo + 7) / 8);
407: }
408:
409: int
410: hid_locate(void *desc, int size, u_int32_t u, u_int8_t id, enum hid_kind k,
411: struct hid_location *loc, u_int32_t *flags)
412: {
413: struct hid_data *d;
414: struct hid_item h;
415:
416: h.report_ID = 0;
417: DPRINTFN(5,("hid_locate: enter usage=0x%x kind=%d id=%d\n", u, k, id));
418: for (d = hid_start_parse(desc, size, k); hid_get_item(d, &h); ) {
419: DPRINTFN(5,("hid_locate: usage=0x%x kind=%d id=%d flags=0x%x\n",
420: h.usage, h.kind, h.report_ID, h.flags));
421: if (h.kind == k && !(h.flags & HIO_CONST) &&
422: h.usage == u && h.report_ID == id) {
423: if (loc != NULL)
424: *loc = h.loc;
425: if (flags != NULL)
426: *flags = h.flags;
427: hid_end_parse(d);
428: return (1);
429: }
430: }
431: hid_end_parse(d);
432: loc->size = 0;
433: return (0);
434: }
435:
436: u_long
437: hid_get_data(u_char *buf, struct hid_location *loc)
438: {
439: u_int hpos = loc->pos;
440: u_int hsize = loc->size;
441: u_int32_t data;
442: int i, s;
443:
444: DPRINTFN(10, ("hid_get_data: loc %d/%d\n", hpos, hsize));
445:
446: if (hsize == 0)
447: return (0);
448:
449: data = 0;
450: s = hpos / 8;
451: for (i = hpos; i < hpos+hsize; i += 8)
452: data |= buf[i / 8] << ((i / 8 - s) * 8);
453: data >>= hpos % 8;
454: data &= (1 << hsize) - 1;
455: hsize = 32 - hsize;
456: /* Sign extend */
457: data = ((int32_t)data << hsize) >> hsize;
458: DPRINTFN(10,("hid_get_data: loc %d/%d = %lu\n",
459: loc->pos, loc->size, (long)data));
460: return (data);
461: }
462:
463: int
464: hid_is_collection(void *desc, int size, u_int8_t id, u_int32_t usage)
465: {
466: struct hid_data *hd;
467: struct hid_item hi;
468: u_int32_t coll_usage = ~0;
469:
470: hd = hid_start_parse(desc, size, hid_none);
471: if (hd == NULL)
472: return (0);
473:
474: DPRINTFN(2,("hid_is_collection: id=%d usage=0x%x\n", id, usage));
475: while (hid_get_item(hd, &hi)) {
476: DPRINTFN(2,("hid_is_collection: kind=%d id=%d usage=0x%x"
477: "(0x%x)\n",
478: hi.kind, hi.report_ID, hi.usage, coll_usage));
479: if (hi.kind == hid_collection &&
480: hi.collection == HCOLL_APPLICATION)
481: coll_usage = hi.usage;
482: if (hi.kind == hid_endcollection &&
483: coll_usage == usage &&
484: hi.report_ID == id) {
485: DPRINTFN(2,("hid_is_collection: found\n"));
486: hid_end_parse(hd);
487: return (1);
488: }
489: }
490: DPRINTFN(2,("hid_is_collection: not found\n"));
491: hid_end_parse(hd);
492: return (0);
493: }