Merge branch 'vendor/BYACC'
[dragonfly.git] / lib / libusb / libusb20_desc.h
1 /* $FreeBSD: src/lib/libusb/libusb20_desc.h,v 1.2 2011/11/09 19:03:26 hselasky Exp $ */
2 /*-
3  * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
4  * Copyright (c) 2007-2008 Daniel Drake.  All rights reserved.
5  * Copyright (c) 2001 Johannes Erdfelt.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
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.
15  *
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
26  * SUCH DAMAGE.
27  */
28
29 /*
30  * NOTE: This file contains the definition of some standard USB
31  * structures. All structures which name ends by *DECODED use host byte
32  * order.
33  */
34
35 /*
36  * NOTE: This file uses a lot of macros. If you want to see what the
37  * macros become when they are expanded then run the following
38  * commands from your shell:
39  *
40  * cpp libusb20_desc.h > temp.h
41  * indent temp.h
42  * less temp.h
43  */
44
45 #ifndef _LIBUSB20_DESC_H_
46 #define _LIBUSB20_DESC_H_
47
48 #ifdef __cplusplus
49 extern  "C" {
50 #endif
51 #if 0
52 };                                      /* style */
53
54 #endif
55 /* basic macros */
56
57 #define LIBUSB20__NOT(...) __VA_ARGS__
58 #define LIBUSB20_NOT(arg) LIBUSB20__NOT(LIBUSB20_YES arg(() LIBUSB20_NO))
59 #define LIBUSB20_YES(...) __VA_ARGS__
60 #define LIBUSB20_NO(...)
61 #define LIBUSB20_END(...) __VA_ARGS__
62 #define LIBUSB20_MAX(a,b) (((a) > (b)) ? (a) : (b))
63 #define LIBUSB20_MIN(a,b) (((a) < (b)) ? (a) : (b))
64
65 #define LIBUSB20_ADD_BYTES(ptr,off) \
66   ((void *)(((const uint8_t *)(ptr)) + (off) - ((const uint8_t *)0)))
67
68 /* basic message elements */
69 enum {
70         LIBUSB20_ME_INT8,
71         LIBUSB20_ME_INT16,
72         LIBUSB20_ME_INT32,
73         LIBUSB20_ME_INT64,
74         LIBUSB20_ME_STRUCT,
75         LIBUSB20_ME_MAX,                /* used to indicate end */
76 };
77
78 /* basic message element modifiers */
79 enum {
80         LIBUSB20_ME_IS_UNSIGNED = 0x00,
81         LIBUSB20_ME_IS_SIGNED = 0x80,
82         LIBUSB20_ME_MASK = 0x7F,
83 };
84
85 enum {
86         LIBUSB20_ME_IS_RAW,             /* structure excludes length field
87                                          * (hardcoded value) */
88         LIBUSB20_ME_IS_ENCODED,         /* structure includes length field */
89         LIBUSB20_ME_IS_EMPTY,           /* no structure */
90         LIBUSB20_ME_IS_DECODED,         /* structure is recursive */
91 };
92
93 /* basic helper structures and macros */
94
95 #define LIBUSB20_ME_STRUCT_ALIGN sizeof(void *)
96
97 struct libusb20_me_struct {
98         void   *ptr;                    /* data pointer */
99         uint16_t len;                   /* defaults to zero */
100         uint16_t type;                  /* defaults to LIBUSB20_ME_IS_EMPTY */
101 } __aligned(LIBUSB20_ME_STRUCT_ALIGN);
102
103 struct libusb20_me_format {
104         const uint8_t *format;          /* always set */
105         const char *desc;               /* optionally set */
106         const char *fields;             /* optionally set */
107 };
108
109 #define LIBUSB20_ME_STRUCT(n, field, arg, ismeta)               \
110   ismeta ( LIBUSB20_ME_STRUCT, 1, 0, )                  \
111   LIBUSB20_NOT(ismeta) ( struct libusb20_me_struct field; )
112
113 #define LIBUSB20_ME_STRUCT_ARRAY(n, field, arg, ismeta) \
114   ismeta ( LIBUSB20_ME_STRUCT , (arg) & 0xFF,           \
115            ((arg) / 0x100) & 0xFF, )                    \
116   LIBUSB20_NOT(ismeta) ( struct libusb20_me_struct field [arg]; )
117
118 #define LIBUSB20_ME_INTEGER(n, field, ismeta, un, u, bits, a, size)     \
119   ismeta ( LIBUSB20_ME_INT##bits |                                      \
120            LIBUSB20_ME_IS_##un##SIGNED ,                                \
121            (size) & 0xFF, ((size) / 0x100) & 0xFF, )            \
122   LIBUSB20_NOT(ismeta) ( u##int##bits##_t                               \
123                     __aligned((bits) / 8) field a; )
124
125 #define LIBUSB20_ME_UINT8_T(n, field, arg, ismeta) \
126   LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 8, , 1)
127
128 #define LIBUSB20_ME_UINT8_ARRAY_T(n, field, arg, ismeta) \
129   LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 8, [arg], arg)
130
131 #define LIBUSB20_ME_SINT8_T(n, field, arg, ismeta) \
132   LIBUSB20_ME_INTEGER(n, field, ismeta,,, 8, , 1)
133
134 #define LIBUSB20_ME_SINT8_ARRAY_T(n, field, arg, ismeta) \
135   LIBUSB20_ME_INTEGER(n, field, ismeta,,, 8, [arg], arg)
136
137 #define LIBUSB20_ME_UINT16_T(n, field, arg, ismeta) \
138   LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 16, , 1)
139
140 #define LIBUSB20_ME_UINT16_ARRAY_T(n, field, arg, ismeta) \
141   LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 16, [arg], arg)
142
143 #define LIBUSB20_ME_SINT16_T(n, field, arg, ismeta) \
144   LIBUSB20_ME_INTEGER(n, field, ismeta,,, 16, , 1)
145
146 #define LIBUSB20_ME_SINT16_ARRAY_T(n, field, arg, ismeta) \
147   LIBUSB20_ME_INTEGER(n, field, ismeta,,, 16, [arg], arg)
148
149 #define LIBUSB20_ME_UINT32_T(n, field, arg, ismeta) \
150   LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 32, , 1)
151
152 #define LIBUSB20_ME_UINT32_ARRAY_T(n, field, arg, ismeta) \
153   LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 32, [arg], arg)
154
155 #define LIBUSB20_ME_SINT32_T(n, field, arg, ismeta) \
156   LIBUSB20_ME_INTEGER(n, field, ismeta,,, 32, , 1)
157
158 #define LIBUSB20_ME_SINT32_ARRAY_T(n, field, arg, ismeta) \
159   LIBUSB20_ME_INTEGER(n, field, ismeta,,, 32, [arg], arg)
160
161 #define LIBUSB20_ME_UINT64_T(n, field, arg, ismeta) \
162   LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 64, , 1)
163
164 #define LIBUSB20_ME_UINT64_ARRAY_T(n, field, arg, ismeta) \
165   LIBUSB20_ME_INTEGER(n, field, ismeta, UN, u, 64, [arg], arg)
166
167 #define LIBUSB20_ME_SINT64_T(n, field, arg, ismeta) \
168   LIBUSB20_ME_INTEGER(n, field, ismeta,,, 64, , 1)
169
170 #define LIBUSB20_ME_SINT64_ARRAY_T(n, field, arg, ismeta) \
171   LIBUSB20_ME_INTEGER(n, field, ismeta,,, 64, [arg], arg)
172
173 #define LIBUSB20_MAKE_DECODED_FIELD(n, type, field, arg) \
174   LIBUSB20_ME_##type (n, field, arg, LIBUSB20_NO)
175
176 #define LIBUSB20_MAKE_STRUCT(name)                      \
177   extern const struct libusb20_me_format                        \
178          name##_FORMAT[1];                              \
179   struct name##_DECODED {                               \
180     const struct libusb20_me_format *name##_FORMAT;     \
181     name (LIBUSB20_MAKE_DECODED_FIELD,)                 \
182   }
183
184 #define LIBUSB20_MAKE_STRUCT_FORMAT(name)               \
185   const struct libusb20_me_format                       \
186     name##_FORMAT[1] = {{                       \
187       .format = LIBUSB20_MAKE_FORMAT(name),     \
188       .desc = #name,                            \
189       .fields = NULL,                           \
190   }}
191
192 #define LIBUSB20_MAKE_FORMAT_SUB(n, type, field, arg) \
193   LIBUSB20_ME_##type (n, field, arg, LIBUSB20_YES)
194
195 #define LIBUSB20_MAKE_FORMAT(what) (const uint8_t []) \
196   { what (LIBUSB20_MAKE_FORMAT_SUB, ) LIBUSB20_ME_MAX, 0, 0 }
197
198 #define LIBUSB20_INIT(what, ptr) do {           \
199     memset(ptr, 0, sizeof(*(ptr)));             \
200     (ptr)->what##_FORMAT = what##_FORMAT;       \
201 } while (0)
202
203 #define LIBUSB20_DEVICE_DESC(m,n) \
204   m(n, UINT8_T, bLength, ) \
205   m(n, UINT8_T, bDescriptorType, ) \
206   m(n, UINT16_T, bcdUSB, ) \
207   m(n, UINT8_T, bDeviceClass, ) \
208   m(n, UINT8_T, bDeviceSubClass, ) \
209   m(n, UINT8_T, bDeviceProtocol, ) \
210   m(n, UINT8_T, bMaxPacketSize0, ) \
211   m(n, UINT16_T, idVendor, ) \
212   m(n, UINT16_T, idProduct, ) \
213   m(n, UINT16_T, bcdDevice, ) \
214   m(n, UINT8_T, iManufacturer, ) \
215   m(n, UINT8_T, iProduct, ) \
216   m(n, UINT8_T, iSerialNumber, ) \
217   m(n, UINT8_T, bNumConfigurations, ) \
218
219 LIBUSB20_MAKE_STRUCT(LIBUSB20_DEVICE_DESC);
220
221 #define LIBUSB20_ENDPOINT_DESC(m,n) \
222   m(n, UINT8_T,  bLength, ) \
223   m(n, UINT8_T,  bDescriptorType, ) \
224   m(n, UINT8_T,  bEndpointAddress, ) \
225   m(n, UINT8_T,  bmAttributes, ) \
226   m(n, UINT16_T, wMaxPacketSize, ) \
227   m(n, UINT8_T,  bInterval, ) \
228   m(n, UINT8_T,  bRefresh, ) \
229   m(n, UINT8_T,  bSynchAddress, ) \
230
231 LIBUSB20_MAKE_STRUCT(LIBUSB20_ENDPOINT_DESC);
232
233 #define LIBUSB20_INTERFACE_DESC(m,n) \
234   m(n, UINT8_T,  bLength, ) \
235   m(n, UINT8_T,  bDescriptorType, ) \
236   m(n, UINT8_T,  bInterfaceNumber, ) \
237   m(n, UINT8_T,  bAlternateSetting, ) \
238   m(n, UINT8_T,  bNumEndpoints, ) \
239   m(n, UINT8_T,  bInterfaceClass, ) \
240   m(n, UINT8_T,  bInterfaceSubClass, ) \
241   m(n, UINT8_T,  bInterfaceProtocol, ) \
242   m(n, UINT8_T,  iInterface, ) \
243
244 LIBUSB20_MAKE_STRUCT(LIBUSB20_INTERFACE_DESC);
245
246 #define LIBUSB20_CONFIG_DESC(m,n) \
247   m(n, UINT8_T,  bLength, ) \
248   m(n, UINT8_T,  bDescriptorType, ) \
249   m(n, UINT16_T, wTotalLength, ) \
250   m(n, UINT8_T,  bNumInterfaces, ) \
251   m(n, UINT8_T,  bConfigurationValue, ) \
252   m(n, UINT8_T,  iConfiguration, ) \
253   m(n, UINT8_T,  bmAttributes, ) \
254   m(n, UINT8_T,  bMaxPower, ) \
255
256 LIBUSB20_MAKE_STRUCT(LIBUSB20_CONFIG_DESC);
257
258 #define LIBUSB20_CONTROL_SETUP(m,n) \
259   m(n, UINT8_T,  bmRequestType, ) \
260   m(n, UINT8_T,  bRequest, ) \
261   m(n, UINT16_T, wValue, ) \
262   m(n, UINT16_T, wIndex, ) \
263   m(n, UINT16_T, wLength, ) \
264
265 LIBUSB20_MAKE_STRUCT(LIBUSB20_CONTROL_SETUP);
266
267 #define LIBUSB20_SS_ENDPT_COMP_DESC(m,n) \
268   m(n, UINT8_T,  bLength, ) \
269   m(n, UINT8_T,  bDescriptorType, ) \
270   m(n, UINT8_T,  bMaxBurst, ) \
271   m(n, UINT8_T,  bmAttributes, ) \
272   m(n, UINT16_T, wBytesPerInterval, ) \
273
274 LIBUSB20_MAKE_STRUCT(LIBUSB20_SS_ENDPT_COMP_DESC);
275
276 #define LIBUSB20_USB_20_DEVCAP_DESC(m,n) \
277   m(n, UINT8_T,  bLength, ) \
278   m(n, UINT8_T,  bDescriptorType, ) \
279   m(n, UINT8_T,  bDevCapabilityType, ) \
280   m(n, UINT32_T, bmAttributes, ) \
281
282 LIBUSB20_MAKE_STRUCT(LIBUSB20_USB_20_DEVCAP_DESC);
283
284 #define LIBUSB20_SS_USB_DEVCAP_DESC(m,n) \
285   m(n, UINT8_T,  bLength, ) \
286   m(n, UINT8_T,  bDescriptorType, ) \
287   m(n, UINT8_T,  bDevCapabilityType, ) \
288   m(n, UINT8_T,  bmAttributes, ) \
289   m(n, UINT16_T, wSpeedSupported, ) \
290   m(n, UINT8_T,  bFunctionalitySupport, ) \
291   m(n, UINT8_T,  bU1DevExitLat, ) \
292   m(n, UINT16_T, wU2DevExitLat, ) \
293
294 LIBUSB20_MAKE_STRUCT(LIBUSB20_SS_USB_DEVCAP_DESC);
295
296 #define LIBUSB20_BOS_DESCRIPTOR(m,n) \
297   m(n, UINT8_T,  bLength, ) \
298   m(n, UINT8_T,  bDescriptorType, ) \
299   m(n, UINT16_T, wTotalLength, ) \
300   m(n, UINT8_T,  bNumDeviceCapabilities, ) \
301
302 LIBUSB20_MAKE_STRUCT(LIBUSB20_BOS_DESCRIPTOR);
303
304 /* standard USB stuff */
305
306 /** \ingroup desc
307  * Device and/or Interface Class codes */
308 enum libusb20_class_code {
309         /** In the context of a \ref LIBUSB20_DEVICE_DESC "device
310          * descriptor", this bDeviceClass value indicates that each
311          * interface specifies its own class information and all
312          * interfaces operate independently.
313          */
314         LIBUSB20_CLASS_PER_INTERFACE = 0,
315
316         /** Audio class */
317         LIBUSB20_CLASS_AUDIO = 1,
318
319         /** Communications class */
320         LIBUSB20_CLASS_COMM = 2,
321
322         /** Human Interface Device class */
323         LIBUSB20_CLASS_HID = 3,
324
325         /** Printer dclass */
326         LIBUSB20_CLASS_PRINTER = 7,
327
328         /** Picture transfer protocol class */
329         LIBUSB20_CLASS_PTP = 6,
330
331         /** Mass storage class */
332         LIBUSB20_CLASS_MASS_STORAGE = 8,
333
334         /** Hub class */
335         LIBUSB20_CLASS_HUB = 9,
336
337         /** Data class */
338         LIBUSB20_CLASS_DATA = 10,
339
340         /** Class is vendor-specific */
341         LIBUSB20_CLASS_VENDOR_SPEC = 0xff,
342 };
343
344 /** \ingroup desc
345  * Descriptor types as defined by the USB specification. */
346 enum libusb20_descriptor_type {
347         /** Device descriptor. See LIBUSB20_DEVICE_DESC. */
348         LIBUSB20_DT_DEVICE = 0x01,
349
350         /** Configuration descriptor. See LIBUSB20_CONFIG_DESC. */
351         LIBUSB20_DT_CONFIG = 0x02,
352
353         /** String descriptor */
354         LIBUSB20_DT_STRING = 0x03,
355
356         /** Interface descriptor. See LIBUSB20_INTERFACE_DESC. */
357         LIBUSB20_DT_INTERFACE = 0x04,
358
359         /** Endpoint descriptor. See LIBUSB20_ENDPOINT_DESC. */
360         LIBUSB20_DT_ENDPOINT = 0x05,
361
362         /** HID descriptor */
363         LIBUSB20_DT_HID = 0x21,
364
365         /** HID report descriptor */
366         LIBUSB20_DT_REPORT = 0x22,
367
368         /** Physical descriptor */
369         LIBUSB20_DT_PHYSICAL = 0x23,
370
371         /** Hub descriptor */
372         LIBUSB20_DT_HUB = 0x29,
373
374         /** Binary Object Store, BOS */
375         LIBUSB20_DT_BOS = 0x0f,
376
377         /** Device Capability */
378         LIBUSB20_DT_DEVICE_CAPABILITY = 0x10,
379
380         /** SuperSpeed endpoint companion */
381         LIBUSB20_DT_SS_ENDPOINT_COMPANION = 0x30,
382 };
383
384 /** \ingroup desc
385  * Device capability types as defined by the USB specification. */
386 enum libusb20_device_capability_type {
387         LIBUSB20_WIRELESS_USB_DEVICE_CAPABILITY = 0x1,
388         LIBUSB20_USB_2_0_EXTENSION_DEVICE_CAPABILITY = 0x2,
389         LIBUSB20_SS_USB_DEVICE_CAPABILITY = 0x3,
390         LIBUSB20_CONTAINER_ID_DEVICE_CAPABILITY = 0x4,
391 };
392
393 /* Descriptor sizes per descriptor type */
394 #define LIBUSB20_DT_DEVICE_SIZE                 18
395 #define LIBUSB20_DT_CONFIG_SIZE                 9
396 #define LIBUSB20_DT_INTERFACE_SIZE              9
397 #define LIBUSB20_DT_ENDPOINT_SIZE               7
398 #define LIBUSB20_DT_ENDPOINT_AUDIO_SIZE         9       /* Audio extension */
399 #define LIBUSB20_DT_HUB_NONVAR_SIZE             7
400 #define LIBUSB20_DT_SS_ENDPOINT_COMPANION_SIZE  6
401 #define LIBUSB20_DT_BOS_SIZE            5
402 #define LIBUSB20_USB_2_0_EXTENSION_DEVICE_CAPABILITY_SIZE       7
403 #define LIBUSB20_SS_USB_DEVICE_CAPABILITY_SIZE  10
404
405 #define LIBUSB20_ENDPOINT_ADDRESS_MASK  0x0f    /* in bEndpointAddress */
406 #define LIBUSB20_ENDPOINT_DIR_MASK      0x80
407
408 /** \ingroup desc
409  * Endpoint direction. Values for bit 7 of the
410  * \ref LIBUSB20_ENDPOINT_DESC::bEndpointAddress "endpoint address" scheme.
411  */
412 enum libusb20_endpoint_direction {
413         /** In: device-to-host */
414         LIBUSB20_ENDPOINT_IN = 0x80,
415
416         /** Out: host-to-device */
417         LIBUSB20_ENDPOINT_OUT = 0x00,
418 };
419
420 #define LIBUSB20_TRANSFER_TYPE_MASK     0x03    /* in bmAttributes */
421
422 /** \ingroup desc
423  * Endpoint transfer type. Values for bits 0:1 of the
424  * \ref LIBUSB20_ENDPOINT_DESC::bmAttributes "endpoint attributes" field.
425  */
426 enum libusb20_transfer_type {
427         /** Control endpoint */
428         LIBUSB20_TRANSFER_TYPE_CONTROL = 0,
429
430         /** Isochronous endpoint */
431         LIBUSB20_TRANSFER_TYPE_ISOCHRONOUS = 1,
432
433         /** Bulk endpoint */
434         LIBUSB20_TRANSFER_TYPE_BULK = 2,
435
436         /** Interrupt endpoint */
437         LIBUSB20_TRANSFER_TYPE_INTERRUPT = 3,
438 };
439
440 /** \ingroup misc
441  * Standard requests, as defined in table 9-3 of the USB2 specifications */
442 enum libusb20_standard_request {
443         /** Request status of the specific recipient */
444         LIBUSB20_REQUEST_GET_STATUS = 0x00,
445
446         /** Clear or disable a specific feature */
447         LIBUSB20_REQUEST_CLEAR_FEATURE = 0x01,
448
449         /* 0x02 is reserved */
450
451         /** Set or enable a specific feature */
452         LIBUSB20_REQUEST_SET_FEATURE = 0x03,
453
454         /* 0x04 is reserved */
455
456         /** Set device address for all future accesses */
457         LIBUSB20_REQUEST_SET_ADDRESS = 0x05,
458
459         /** Get the specified descriptor */
460         LIBUSB20_REQUEST_GET_DESCRIPTOR = 0x06,
461
462         /** Used to update existing descriptors or add new descriptors */
463         LIBUSB20_REQUEST_SET_DESCRIPTOR = 0x07,
464
465         /** Get the current device configuration value */
466         LIBUSB20_REQUEST_GET_CONFIGURATION = 0x08,
467
468         /** Set device configuration */
469         LIBUSB20_REQUEST_SET_CONFIGURATION = 0x09,
470
471         /** Return the selected alternate setting for the specified
472          * interface */
473         LIBUSB20_REQUEST_GET_INTERFACE = 0x0A,
474
475         /** Select an alternate interface for the specified interface */
476         LIBUSB20_REQUEST_SET_INTERFACE = 0x0B,
477
478         /** Set then report an endpoint's synchronization frame */
479         LIBUSB20_REQUEST_SYNCH_FRAME = 0x0C,
480 };
481
482 /** \ingroup misc
483  * Request type bits of the
484  * \ref libusb20_control_setup::bmRequestType "bmRequestType" field in
485  * control transfers. */
486 enum libusb20_request_type {
487         /** Standard */
488         LIBUSB20_REQUEST_TYPE_STANDARD = (0x00 << 5),
489
490         /** Class */
491         LIBUSB20_REQUEST_TYPE_CLASS = (0x01 << 5),
492
493         /** Vendor */
494         LIBUSB20_REQUEST_TYPE_VENDOR = (0x02 << 5),
495
496         /** Reserved */
497         LIBUSB20_REQUEST_TYPE_RESERVED = (0x03 << 5),
498 };
499
500 /** \ingroup misc
501  * Recipient bits of the
502  * \ref libusb20_control_setup::bmRequestType "bmRequestType" field in
503  * control transfers. Values 4 through 31 are reserved. */
504 enum libusb20_request_recipient {
505         /** Device */
506         LIBUSB20_RECIPIENT_DEVICE = 0x00,
507
508         /** Interface */
509         LIBUSB20_RECIPIENT_INTERFACE = 0x01,
510
511         /** Endpoint */
512         LIBUSB20_RECIPIENT_ENDPOINT = 0x02,
513
514         /** Other */
515         LIBUSB20_RECIPIENT_OTHER = 0x03,
516 };
517
518 #define LIBUSB20_ISO_SYNC_TYPE_MASK             0x0C
519
520 /** \ingroup desc
521  * Synchronization type for isochronous endpoints. Values for bits 2:3
522  * of the \ref LIBUSB20_ENDPOINT_DESC::bmAttributes "bmAttributes"
523  * field in LIBUSB20_ENDPOINT_DESC.
524  */
525 enum libusb20_iso_sync_type {
526         /** No synchronization */
527         LIBUSB20_ISO_SYNC_TYPE_NONE = 0,
528
529         /** Asynchronous */
530         LIBUSB20_ISO_SYNC_TYPE_ASYNC = 1,
531
532         /** Adaptive */
533         LIBUSB20_ISO_SYNC_TYPE_ADAPTIVE = 2,
534
535         /** Synchronous */
536         LIBUSB20_ISO_SYNC_TYPE_SYNC = 3,
537 };
538
539 #define LIBUSB20_ISO_USAGE_TYPE_MASK 0x30
540
541 /** \ingroup desc
542  * Usage type for isochronous endpoints. Values for bits 4:5 of the
543  * \ref LIBUSB20_ENDPOINT_DESC::bmAttributes "bmAttributes" field in
544  * LIBUSB20_ENDPOINT_DESC.
545  */
546 enum libusb20_iso_usage_type {
547         /** Data endpoint */
548         LIBUSB20_ISO_USAGE_TYPE_DATA = 0,
549
550         /** Feedback endpoint */
551         LIBUSB20_ISO_USAGE_TYPE_FEEDBACK = 1,
552
553         /** Implicit feedback Data endpoint */
554         LIBUSB20_ISO_USAGE_TYPE_IMPLICIT = 2,
555 };
556
557 struct libusb20_endpoint {
558         struct LIBUSB20_ENDPOINT_DESC_DECODED desc;
559         struct libusb20_me_struct extra;
560 } __aligned(sizeof(void *));
561
562 struct libusb20_interface {
563         struct LIBUSB20_INTERFACE_DESC_DECODED desc;
564         struct libusb20_me_struct extra;
565         struct libusb20_interface *altsetting;
566         struct libusb20_endpoint *endpoints;
567         uint8_t num_altsetting;
568         uint8_t num_endpoints;
569 } __aligned(sizeof(void *));
570
571 struct libusb20_config {
572         struct LIBUSB20_CONFIG_DESC_DECODED desc;
573         struct libusb20_me_struct extra;
574         struct libusb20_interface *interface;
575         uint8_t num_interface;
576 } __aligned(sizeof(void *));
577
578 uint8_t libusb20_me_get_1(const struct libusb20_me_struct *ie, uint16_t offset);
579 uint16_t libusb20_me_get_2(const struct libusb20_me_struct *ie, uint16_t offset);
580 uint16_t libusb20_me_encode(void *ptr, uint16_t len, const void *pd);
581 uint16_t libusb20_me_decode(const void *ptr, uint16_t len, void *pd);
582 const uint8_t *libusb20_desc_foreach(const struct libusb20_me_struct *pdesc, const uint8_t *psubdesc);
583 struct libusb20_config *libusb20_parse_config_desc(const void *config_desc);
584
585 #if 0
586 {                                       /* style */
587 #endif
588 #ifdef __cplusplus
589 }
590
591 #endif
592
593 #endif                                  /* _LIBUSB20_DESC_H_ */