diff options
Diffstat (limited to 'utils/hwstub/stmp/usb_ch9.h')
-rw-r--r-- | utils/hwstub/stmp/usb_ch9.h | 454 |
1 files changed, 454 insertions, 0 deletions
diff --git a/utils/hwstub/stmp/usb_ch9.h b/utils/hwstub/stmp/usb_ch9.h new file mode 100644 index 0000000000..09141b93bd --- /dev/null +++ b/utils/hwstub/stmp/usb_ch9.h | |||
@@ -0,0 +1,454 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) by Linux Kernel Developers | ||
11 | * | ||
12 | * Based on code from the Linux Kernel | ||
13 | * available at http://www.kernel.org | ||
14 | * Original file: <kernel>/include/linux/usb/ch9.h | ||
15 | * | ||
16 | * This program is free software; you can redistribute it and/or | ||
17 | * modify it under the terms of the GNU General Public License | ||
18 | * as published by the Free Software Foundation; either version 2 | ||
19 | * of the License, or (at your option) any later version. | ||
20 | * | ||
21 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
22 | * KIND, either express or implied. | ||
23 | * | ||
24 | ****************************************************************************/ | ||
25 | |||
26 | /* | ||
27 | * This file holds USB constants and structures that are needed for | ||
28 | * USB device APIs. These are used by the USB device model, which is | ||
29 | * defined in chapter 9 of the USB 2.0 specification and in the | ||
30 | * Wireless USB 1.0 (spread around). Linux has several APIs in C that | ||
31 | * need these: | ||
32 | * | ||
33 | * - the master/host side Linux-USB kernel driver API; | ||
34 | * - the "usbfs" user space API; and | ||
35 | * - the Linux "gadget" slave/device/peripheral side driver API. | ||
36 | * | ||
37 | * USB 2.0 adds an additional "On The Go" (OTG) mode, which lets systems | ||
38 | * act either as a USB master/host or as a USB slave/device. That means | ||
39 | * the master and slave side APIs benefit from working well together. | ||
40 | * | ||
41 | * There's also "Wireless USB", using low power short range radios for | ||
42 | * peripheral interconnection but otherwise building on the USB framework. | ||
43 | * | ||
44 | * Note all descriptors are declared '__attribute__((packed))' so that: | ||
45 | * | ||
46 | * [a] they never get padded, either internally (USB spec writers | ||
47 | * probably handled that) or externally; | ||
48 | * | ||
49 | * [b] so that accessing bigger-than-a-bytes fields will never | ||
50 | * generate bus errors on any platform, even when the location of | ||
51 | * its descriptor inside a bundle isn't "naturally aligned", and | ||
52 | * | ||
53 | * [c] for consistency, removing all doubt even when it appears to | ||
54 | * someone that the two other points are non-issues for that | ||
55 | * particular descriptor type. | ||
56 | */ | ||
57 | |||
58 | #ifndef _CH9_H_ | ||
59 | #define _CH9_H_ | ||
60 | |||
61 | #include "stdint.h" | ||
62 | |||
63 | /*-------------------------------------------------------------------------*/ | ||
64 | |||
65 | /* CONTROL REQUEST SUPPORT */ | ||
66 | |||
67 | /* | ||
68 | * USB directions | ||
69 | * | ||
70 | * This bit flag is used in endpoint descriptors' bEndpointAddress field. | ||
71 | * It's also one of three fields in control requests bRequestType. | ||
72 | */ | ||
73 | #define USB_DIR_OUT 0 /* to device */ | ||
74 | #define USB_DIR_IN 0x80 /* to host */ | ||
75 | |||
76 | /* | ||
77 | * USB types, the second of three bRequestType fields | ||
78 | */ | ||
79 | #define USB_TYPE_MASK (0x03 << 5) | ||
80 | #define USB_TYPE_STANDARD (0x00 << 5) | ||
81 | #define USB_TYPE_CLASS (0x01 << 5) | ||
82 | #define USB_TYPE_VENDOR (0x02 << 5) | ||
83 | #define USB_TYPE_RESERVED (0x03 << 5) | ||
84 | |||
85 | /* | ||
86 | * USB recipients, the third of three bRequestType fields | ||
87 | */ | ||
88 | #define USB_RECIP_MASK 0x1f | ||
89 | #define USB_RECIP_DEVICE 0x00 | ||
90 | #define USB_RECIP_INTERFACE 0x01 | ||
91 | #define USB_RECIP_ENDPOINT 0x02 | ||
92 | #define USB_RECIP_OTHER 0x03 | ||
93 | |||
94 | /* | ||
95 | * Standard requests, for the bRequest field of a SETUP packet. | ||
96 | * | ||
97 | * These are qualified by the bRequestType field, so that for example | ||
98 | * TYPE_CLASS or TYPE_VENDOR specific feature flags could be retrieved | ||
99 | * by a GET_STATUS request. | ||
100 | */ | ||
101 | #define USB_REQ_GET_STATUS 0x00 | ||
102 | #define USB_REQ_CLEAR_FEATURE 0x01 | ||
103 | #define USB_REQ_SET_FEATURE 0x03 | ||
104 | #define USB_REQ_SET_ADDRESS 0x05 | ||
105 | #define USB_REQ_GET_DESCRIPTOR 0x06 | ||
106 | #define USB_REQ_SET_DESCRIPTOR 0x07 | ||
107 | #define USB_REQ_GET_CONFIGURATION 0x08 | ||
108 | #define USB_REQ_SET_CONFIGURATION 0x09 | ||
109 | #define USB_REQ_GET_INTERFACE 0x0A | ||
110 | #define USB_REQ_SET_INTERFACE 0x0B | ||
111 | #define USB_REQ_SYNCH_FRAME 0x0C | ||
112 | /* | ||
113 | * USB feature flags are written using USB_REQ_{CLEAR,SET}_FEATURE, and | ||
114 | * are read as a bit array returned by USB_REQ_GET_STATUS. (So there | ||
115 | * are at most sixteen features of each type.) Hubs may also support a | ||
116 | * new USB_REQ_TEST_AND_SET_FEATURE to put ports into L1 suspend. | ||
117 | */ | ||
118 | #define USB_DEVICE_SELF_POWERED 0 /* (read only) */ | ||
119 | #define USB_DEVICE_REMOTE_WAKEUP 1 /* dev may initiate wakeup */ | ||
120 | #define USB_DEVICE_TEST_MODE 2 /* (wired high speed only) */ | ||
121 | #define USB_DEVICE_BATTERY 2 /* (wireless) */ | ||
122 | #define USB_DEVICE_B_HNP_ENABLE 3 /* (otg) dev may initiate HNP */ | ||
123 | #define USB_DEVICE_WUSB_DEVICE 3 /* (wireless)*/ | ||
124 | #define USB_DEVICE_A_HNP_SUPPORT 4 /* (otg) RH port supports HNP */ | ||
125 | #define USB_DEVICE_A_ALT_HNP_SUPPORT 5 /* (otg) other RH port does */ | ||
126 | #define USB_DEVICE_DEBUG_MODE 6 /* (special devices only) */ | ||
127 | |||
128 | #define USB_ENDPOINT_HALT 0 /* IN/OUT will STALL */ | ||
129 | |||
130 | |||
131 | /** | ||
132 | * struct usb_ctrlrequest - SETUP data for a USB device control request | ||
133 | * @bRequestType: matches the USB bmRequestType field | ||
134 | * @bRequest: matches the USB bRequest field | ||
135 | * @wValue: matches the USB wValue field (le16 byte order) | ||
136 | * @wIndex: matches the USB wIndex field (le16 byte order) | ||
137 | * @wLength: matches the USB wLength field (le16 byte order) | ||
138 | * | ||
139 | * This structure is used to send control requests to a USB device. It matches | ||
140 | * the different fields of the USB 2.0 Spec section 9.3, table 9-2. See the | ||
141 | * USB spec for a fuller description of the different fields, and what they are | ||
142 | * used for. | ||
143 | * | ||
144 | * Note that the driver for any interface can issue control requests. | ||
145 | * For most devices, interfaces don't coordinate with each other, so | ||
146 | * such requests may be made at any time. | ||
147 | */ | ||
148 | struct usb_ctrlrequest { | ||
149 | uint8_t bRequestType; | ||
150 | uint8_t bRequest; | ||
151 | uint16_t wValue; | ||
152 | uint16_t wIndex; | ||
153 | uint16_t wLength; | ||
154 | } __attribute__ ((packed)); | ||
155 | |||
156 | /*-------------------------------------------------------------------------*/ | ||
157 | |||
158 | /* | ||
159 | * STANDARD DESCRIPTORS ... as returned by GET_DESCRIPTOR, or | ||
160 | * (rarely) accepted by SET_DESCRIPTOR. | ||
161 | * | ||
162 | * Note that all multi-byte values here are encoded in little endian | ||
163 | * byte order "on the wire". But when exposed through Linux-USB APIs, | ||
164 | * they've been converted to cpu byte order. | ||
165 | */ | ||
166 | |||
167 | /* | ||
168 | * Descriptor types ... USB 2.0 spec table 9.5 | ||
169 | */ | ||
170 | #define USB_DT_DEVICE 0x01 | ||
171 | #define USB_DT_CONFIG 0x02 | ||
172 | #define USB_DT_STRING 0x03 | ||
173 | #define USB_DT_INTERFACE 0x04 | ||
174 | #define USB_DT_ENDPOINT 0x05 | ||
175 | #define USB_DT_DEVICE_QUALIFIER 0x06 | ||
176 | #define USB_DT_OTHER_SPEED_CONFIG 0x07 | ||
177 | #define USB_DT_INTERFACE_POWER 0x08 | ||
178 | /* these are from a minor usb 2.0 revision (ECN) */ | ||
179 | #define USB_DT_OTG 0x09 | ||
180 | #define USB_DT_DEBUG 0x0a | ||
181 | #define USB_DT_INTERFACE_ASSOCIATION 0x0b | ||
182 | /* these are from the Wireless USB spec */ | ||
183 | #define USB_DT_SECURITY 0x0c | ||
184 | #define USB_DT_KEY 0x0d | ||
185 | #define USB_DT_ENCRYPTION_TYPE 0x0e | ||
186 | #define USB_DT_BOS 0x0f | ||
187 | #define USB_DT_DEVICE_CAPABILITY 0x10 | ||
188 | #define USB_DT_WIRELESS_ENDPOINT_COMP 0x11 | ||
189 | #define USB_DT_WIRE_ADAPTER 0x21 | ||
190 | #define USB_DT_RPIPE 0x22 | ||
191 | #define USB_DT_CS_RADIO_CONTROL 0x23 | ||
192 | |||
193 | /* Conventional codes for class-specific descriptors. The convention is | ||
194 | * defined in the USB "Common Class" Spec (3.11). Individual class specs | ||
195 | * are authoritative for their usage, not the "common class" writeup. | ||
196 | */ | ||
197 | #define USB_DT_CS_DEVICE (USB_TYPE_CLASS | USB_DT_DEVICE) | ||
198 | #define USB_DT_CS_CONFIG (USB_TYPE_CLASS | USB_DT_CONFIG) | ||
199 | #define USB_DT_CS_STRING (USB_TYPE_CLASS | USB_DT_STRING) | ||
200 | #define USB_DT_CS_INTERFACE (USB_TYPE_CLASS | USB_DT_INTERFACE) | ||
201 | #define USB_DT_CS_ENDPOINT (USB_TYPE_CLASS | USB_DT_ENDPOINT) | ||
202 | |||
203 | /* All standard descriptors have these 2 fields at the beginning */ | ||
204 | struct usb_descriptor_header { | ||
205 | uint8_t bLength; | ||
206 | uint8_t bDescriptorType; | ||
207 | } __attribute__ ((packed)); | ||
208 | |||
209 | |||
210 | /*-------------------------------------------------------------------------*/ | ||
211 | |||
212 | /* USB_DT_DEVICE: Device descriptor */ | ||
213 | struct usb_device_descriptor { | ||
214 | uint8_t bLength; | ||
215 | uint8_t bDescriptorType; | ||
216 | |||
217 | uint16_t bcdUSB; | ||
218 | uint8_t bDeviceClass; | ||
219 | uint8_t bDeviceSubClass; | ||
220 | uint8_t bDeviceProtocol; | ||
221 | uint8_t bMaxPacketSize0; | ||
222 | uint16_t idVendor; | ||
223 | uint16_t idProduct; | ||
224 | uint16_t bcdDevice; | ||
225 | uint8_t iManufacturer; | ||
226 | uint8_t iProduct; | ||
227 | uint8_t iSerialNumber; | ||
228 | uint8_t bNumConfigurations; | ||
229 | } __attribute__ ((packed)); | ||
230 | |||
231 | #define USB_DT_DEVICE_SIZE 18 | ||
232 | |||
233 | |||
234 | /* | ||
235 | * Device and/or Interface Class codes | ||
236 | * as found in bDeviceClass or bInterfaceClass | ||
237 | * and defined by www.usb.org documents | ||
238 | */ | ||
239 | #define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */ | ||
240 | #define USB_CLASS_AUDIO 1 | ||
241 | #define USB_CLASS_COMM 2 | ||
242 | #define USB_CLASS_HID 3 | ||
243 | #define USB_CLASS_PHYSICAL 5 | ||
244 | #define USB_CLASS_STILL_IMAGE 6 | ||
245 | #define USB_CLASS_PRINTER 7 | ||
246 | #define USB_CLASS_MASS_STORAGE 8 | ||
247 | #define USB_CLASS_HUB 9 | ||
248 | #define USB_CLASS_CDC_DATA 0x0a | ||
249 | #define USB_CLASS_CSCID 0x0b /* chip+ smart card */ | ||
250 | #define USB_CLASS_CONTENT_SEC 0x0d /* content security */ | ||
251 | #define USB_CLASS_VIDEO 0x0e | ||
252 | #define USB_CLASS_WIRELESS_CONTROLLER 0xe0 | ||
253 | #define USB_CLASS_MISC 0xef | ||
254 | #define USB_CLASS_APP_SPEC 0xfe | ||
255 | #define USB_CLASS_VENDOR_SPEC 0xff | ||
256 | |||
257 | /*-------------------------------------------------------------------------*/ | ||
258 | |||
259 | /* USB_DT_CONFIG: Configuration descriptor information. | ||
260 | * | ||
261 | * USB_DT_OTHER_SPEED_CONFIG is the same descriptor, except that the | ||
262 | * descriptor type is different. Highspeed-capable devices can look | ||
263 | * different depending on what speed they're currently running. Only | ||
264 | * devices with a USB_DT_DEVICE_QUALIFIER have any OTHER_SPEED_CONFIG | ||
265 | * descriptors. | ||
266 | */ | ||
267 | struct usb_config_descriptor { | ||
268 | uint8_t bLength; | ||
269 | uint8_t bDescriptorType; | ||
270 | |||
271 | uint16_t wTotalLength; | ||
272 | uint8_t bNumInterfaces; | ||
273 | uint8_t bConfigurationValue; | ||
274 | uint8_t iConfiguration; | ||
275 | uint8_t bmAttributes; | ||
276 | uint8_t bMaxPower; | ||
277 | } __attribute__ ((packed)); | ||
278 | |||
279 | #define USB_DT_CONFIG_SIZE 9 | ||
280 | |||
281 | /* from config descriptor bmAttributes */ | ||
282 | #define USB_CONFIG_ATT_ONE (1 << 7) /* must be set */ | ||
283 | #define USB_CONFIG_ATT_SELFPOWER (1 << 6) /* self powered */ | ||
284 | #define USB_CONFIG_ATT_WAKEUP (1 << 5) /* can wakeup */ | ||
285 | #define USB_CONFIG_ATT_BATTERY (1 << 4) /* battery powered */ | ||
286 | |||
287 | /*-------------------------------------------------------------------------*/ | ||
288 | |||
289 | /* USB_DT_STRING: String descriptor */ | ||
290 | struct usb_string_descriptor { | ||
291 | uint8_t bLength; | ||
292 | uint8_t bDescriptorType; | ||
293 | |||
294 | uint16_t wString[]; /* UTF-16LE encoded */ | ||
295 | } __attribute__ ((packed)); | ||
296 | |||
297 | /* note that "string" zero is special, it holds language codes that | ||
298 | * the device supports, not Unicode characters. | ||
299 | */ | ||
300 | |||
301 | /*-------------------------------------------------------------------------*/ | ||
302 | |||
303 | /* USB_DT_INTERFACE: Interface descriptor */ | ||
304 | struct usb_interface_descriptor { | ||
305 | uint8_t bLength; | ||
306 | uint8_t bDescriptorType; | ||
307 | |||
308 | uint8_t bInterfaceNumber; | ||
309 | uint8_t bAlternateSetting; | ||
310 | uint8_t bNumEndpoints; | ||
311 | uint8_t bInterfaceClass; | ||
312 | uint8_t bInterfaceSubClass; | ||
313 | uint8_t bInterfaceProtocol; | ||
314 | uint8_t iInterface; | ||
315 | } __attribute__ ((packed)); | ||
316 | |||
317 | #define USB_DT_INTERFACE_SIZE 9 | ||
318 | |||
319 | /*-------------------------------------------------------------------------*/ | ||
320 | |||
321 | /* USB_DT_ENDPOINT: Endpoint descriptor */ | ||
322 | struct usb_endpoint_descriptor { | ||
323 | uint8_t bLength; | ||
324 | uint8_t bDescriptorType; | ||
325 | |||
326 | uint8_t bEndpointAddress; | ||
327 | uint8_t bmAttributes; | ||
328 | uint16_t wMaxPacketSize; | ||
329 | uint8_t bInterval; | ||
330 | } __attribute__ ((packed)); | ||
331 | |||
332 | #define USB_DT_ENDPOINT_SIZE 7 | ||
333 | #define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */ | ||
334 | |||
335 | |||
336 | /* | ||
337 | * Endpoints | ||
338 | */ | ||
339 | #define USB_ENDPOINT_NUMBER_MASK 0x0f /* in bEndpointAddress */ | ||
340 | #define USB_ENDPOINT_DIR_MASK 0x80 | ||
341 | |||
342 | #define USB_ENDPOINT_XFERTYPE_MASK 0x03 /* in bmAttributes */ | ||
343 | #define USB_ENDPOINT_XFER_CONTROL 0 | ||
344 | #define USB_ENDPOINT_XFER_ISOC 1 | ||
345 | #define USB_ENDPOINT_XFER_BULK 2 | ||
346 | #define USB_ENDPOINT_XFER_INT 3 | ||
347 | #define USB_ENDPOINT_MAX_ADJUSTABLE 0x80 | ||
348 | |||
349 | |||
350 | /*-------------------------------------------------------------------------*/ | ||
351 | |||
352 | /* USB_DT_DEVICE_QUALIFIER: Device Qualifier descriptor */ | ||
353 | struct usb_qualifier_descriptor { | ||
354 | uint8_t bLength; | ||
355 | uint8_t bDescriptorType; | ||
356 | |||
357 | uint16_t bcdUSB; | ||
358 | uint8_t bDeviceClass; | ||
359 | uint8_t bDeviceSubClass; | ||
360 | uint8_t bDeviceProtocol; | ||
361 | uint8_t bMaxPacketSize0; | ||
362 | uint8_t bNumConfigurations; | ||
363 | uint8_t bRESERVED; | ||
364 | } __attribute__ ((packed)); | ||
365 | |||
366 | |||
367 | /*-------------------------------------------------------------------------*/ | ||
368 | |||
369 | /* USB_DT_OTG (from OTG 1.0a supplement) */ | ||
370 | struct usb_otg_descriptor { | ||
371 | uint8_t bLength; | ||
372 | uint8_t bDescriptorType; | ||
373 | |||
374 | uint8_t bmAttributes; /* support for HNP, SRP, etc */ | ||
375 | } __attribute__ ((packed)); | ||
376 | |||
377 | /* from usb_otg_descriptor.bmAttributes */ | ||
378 | #define USB_OTG_SRP (1 << 0) | ||
379 | #define USB_OTG_HNP (1 << 1) /* swap host/device roles */ | ||
380 | |||
381 | /*-------------------------------------------------------------------------*/ | ||
382 | |||
383 | /* USB_DT_DEBUG: for special highspeed devices, replacing serial console */ | ||
384 | struct usb_debug_descriptor { | ||
385 | uint8_t bLength; | ||
386 | uint8_t bDescriptorType; | ||
387 | |||
388 | /* bulk endpoints with 8 byte maxpacket */ | ||
389 | uint8_t bDebugInEndpoint; | ||
390 | uint8_t bDebugOutEndpoint; | ||
391 | } __attribute__((packed)); | ||
392 | |||
393 | /*-------------------------------------------------------------------------*/ | ||
394 | /* USB 2.0 defines three speeds, here's how Linux identifies them */ | ||
395 | |||
396 | enum usb_device_speed { | ||
397 | USB_SPEED_UNKNOWN = 0, /* enumerating */ | ||
398 | USB_SPEED_LOW, USB_SPEED_FULL, /* usb 1.1 */ | ||
399 | USB_SPEED_HIGH, /* usb 2.0 */ | ||
400 | USB_SPEED_VARIABLE, /* wireless (usb 2.5) */ | ||
401 | }; | ||
402 | |||
403 | enum usb_device_state { | ||
404 | /* NOTATTACHED isn't in the USB spec, and this state acts | ||
405 | * the same as ATTACHED ... but it's clearer this way. | ||
406 | */ | ||
407 | USB_STATE_NOTATTACHED = 0, | ||
408 | |||
409 | /* chapter 9 and authentication (wireless) device states */ | ||
410 | USB_STATE_ATTACHED, | ||
411 | USB_STATE_POWERED, /* wired */ | ||
412 | USB_STATE_UNAUTHENTICATED, /* auth */ | ||
413 | USB_STATE_RECONNECTING, /* auth */ | ||
414 | USB_STATE_DEFAULT, /* limited function */ | ||
415 | USB_STATE_ADDRESS, | ||
416 | USB_STATE_CONFIGURED, /* most functions */ | ||
417 | |||
418 | USB_STATE_SUSPENDED | ||
419 | |||
420 | /* NOTE: there are actually four different SUSPENDED | ||
421 | * states, returning to POWERED, DEFAULT, ADDRESS, or | ||
422 | * CONFIGURED respectively when SOF tokens flow again. | ||
423 | * At this level there's no difference between L1 and L2 | ||
424 | * suspend states. (L2 being original USB 1.1 suspend.) | ||
425 | */ | ||
426 | }; | ||
427 | |||
428 | /** | ||
429 | * struct usb_string - wraps a C string and its USB id | ||
430 | * @id:the (nonzero) ID for this string | ||
431 | * @s:the string, in UTF-8 encoding | ||
432 | * | ||
433 | * If you're using usb_gadget_get_string(), use this to wrap a string | ||
434 | * together with its ID. | ||
435 | */ | ||
436 | struct usb_string { | ||
437 | uint8_t id; | ||
438 | const char* s; | ||
439 | }; | ||
440 | |||
441 | /** | ||
442 | * struct usb_gadget_strings - a set of USB strings in a given language | ||
443 | * @language:identifies the strings' language (0x0409 for en-us) | ||
444 | * @strings:array of strings with their ids | ||
445 | * | ||
446 | * If you're using usb_gadget_get_string(), use this to wrap all the | ||
447 | * strings for a given language. | ||
448 | */ | ||
449 | struct usb_gadget_strings { | ||
450 | uint16_t language; /* 0x0409 for en-us */ | ||
451 | struct usb_string* strings; | ||
452 | }; | ||
453 | |||
454 | #endif /*_CH9_H_*/ | ||