ch9.h 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782
  1. /*
  2. * This file holds USB constants and structures that are needed for
  3. * USB device APIs. These are used by the USB device model, which is
  4. * defined in chapter 9 of the USB 2.0 specification and in the
  5. * Wireless USB 1.0 (spread around). Linux has several APIs in C that
  6. * need these:
  7. *
  8. * - the master/host side Linux-USB kernel driver API;
  9. * - the "usbfs" user space API; and
  10. * - the Linux "gadget" slave/device/peripheral side driver API.
  11. *
  12. * USB 2.0 adds an additional "On The Go" (OTG) mode, which lets systems
  13. * act either as a USB master/host or as a USB slave/device. That means
  14. * the master and slave side APIs benefit from working well together.
  15. *
  16. * There's also "Wireless USB", using low power short range radios for
  17. * peripheral interconnection but otherwise building on the USB framework.
  18. *
  19. * Note all descriptors are declared '__attribute__((packed))' so that:
  20. *
  21. * [a] they never get padded, either internally (USB spec writers
  22. * probably handled that) or externally;
  23. *
  24. * [b] so that accessing bigger-than-a-bytes fields will never
  25. * generate bus errors on any platform, even when the location of
  26. * its descriptor inside a bundle isn't "naturally aligned", and
  27. *
  28. * [c] for consistency, removing all doubt even when it appears to
  29. * someone that the two other points are non-issues for that
  30. * particular descriptor type.
  31. */
  32. #ifndef __LINUX_USB_CH9_H
  33. #define __LINUX_USB_CH9_H
  34. #include <linux/types.h> /* __u8 etc */
  35. /*-------------------------------------------------------------------------*/
  36. /* CONTROL REQUEST SUPPORT */
  37. /*
  38. * USB directions
  39. *
  40. * This bit flag is used in endpoint descriptors' bEndpointAddress field.
  41. * It's also one of three fields in control requests bRequestType.
  42. */
  43. #define USB_DIR_OUT 0 /* to device */
  44. #define USB_DIR_IN 0x80 /* to host */
  45. /*
  46. * USB types, the second of three bRequestType fields
  47. */
  48. #define USB_TYPE_MASK (0x03 << 5)
  49. #define USB_TYPE_STANDARD (0x00 << 5)
  50. #define USB_TYPE_CLASS (0x01 << 5)
  51. #define USB_TYPE_VENDOR (0x02 << 5)
  52. #define USB_TYPE_RESERVED (0x03 << 5)
  53. /*
  54. * USB recipients, the third of three bRequestType fields
  55. */
  56. #define USB_RECIP_MASK 0x1f
  57. #define USB_RECIP_DEVICE 0x00
  58. #define USB_RECIP_INTERFACE 0x01
  59. #define USB_RECIP_ENDPOINT 0x02
  60. #define USB_RECIP_OTHER 0x03
  61. /* From Wireless USB 1.0 */
  62. #define USB_RECIP_PORT 0x04
  63. #define USB_RECIP_RPIPE 0x05
  64. /*
  65. * Standard requests, for the bRequest field of a SETUP packet.
  66. *
  67. * These are qualified by the bRequestType field, so that for example
  68. * TYPE_CLASS or TYPE_VENDOR specific feature flags could be retrieved
  69. * by a GET_STATUS request.
  70. */
  71. #define USB_REQ_GET_STATUS 0x00
  72. #define USB_REQ_CLEAR_FEATURE 0x01
  73. #define USB_REQ_SET_FEATURE 0x03
  74. #define USB_REQ_SET_ADDRESS 0x05
  75. #define USB_REQ_GET_DESCRIPTOR 0x06
  76. #define USB_REQ_SET_DESCRIPTOR 0x07
  77. #define USB_REQ_GET_CONFIGURATION 0x08
  78. #define USB_REQ_SET_CONFIGURATION 0x09
  79. #define USB_REQ_GET_INTERFACE 0x0A
  80. #define USB_REQ_SET_INTERFACE 0x0B
  81. #define USB_REQ_SYNCH_FRAME 0x0C
  82. #define USB_REQ_SET_ENCRYPTION 0x0D /* Wireless USB */
  83. #define USB_REQ_GET_ENCRYPTION 0x0E
  84. #define USB_REQ_RPIPE_ABORT 0x0E
  85. #define USB_REQ_SET_HANDSHAKE 0x0F
  86. #define USB_REQ_RPIPE_RESET 0x0F
  87. #define USB_REQ_GET_HANDSHAKE 0x10
  88. #define USB_REQ_SET_CONNECTION 0x11
  89. #define USB_REQ_SET_SECURITY_DATA 0x12
  90. #define USB_REQ_GET_SECURITY_DATA 0x13
  91. #define USB_REQ_SET_WUSB_DATA 0x14
  92. #define USB_REQ_LOOPBACK_DATA_WRITE 0x15
  93. #define USB_REQ_LOOPBACK_DATA_READ 0x16
  94. #define USB_REQ_SET_INTERFACE_DS 0x17
  95. /* The Link Power Mangement (LPM) ECN defines USB_REQ_TEST_AND_SET command,
  96. * used by hubs to put ports into a new L1 suspend state, except that it
  97. * forgot to define its number ...
  98. */
  99. /*
  100. * USB feature flags are written using USB_REQ_{CLEAR,SET}_FEATURE, and
  101. * are read as a bit array returned by USB_REQ_GET_STATUS. (So there
  102. * are at most sixteen features of each type.) Hubs may also support a
  103. * new USB_REQ_TEST_AND_SET_FEATURE to put ports into L1 suspend.
  104. */
  105. #define USB_DEVICE_SELF_POWERED 0 /* (read only) */
  106. #define USB_DEVICE_REMOTE_WAKEUP 1 /* dev may initiate wakeup */
  107. #define USB_DEVICE_TEST_MODE 2 /* (wired high speed only) */
  108. #define USB_DEVICE_BATTERY 2 /* (wireless) */
  109. #define USB_DEVICE_B_HNP_ENABLE 3 /* (otg) dev may initiate HNP */
  110. #define USB_DEVICE_WUSB_DEVICE 3 /* (wireless)*/
  111. #define USB_DEVICE_A_HNP_SUPPORT 4 /* (otg) RH port supports HNP */
  112. #define USB_DEVICE_A_ALT_HNP_SUPPORT 5 /* (otg) other RH port does */
  113. #define USB_DEVICE_DEBUG_MODE 6 /* (special devices only) */
  114. #define USB_ENDPOINT_HALT 0 /* IN/OUT will STALL */
  115. /**
  116. * struct usb_ctrlrequest - SETUP data for a USB device control request
  117. * @bRequestType: matches the USB bmRequestType field
  118. * @bRequest: matches the USB bRequest field
  119. * @wValue: matches the USB wValue field (le16 byte order)
  120. * @wIndex: matches the USB wIndex field (le16 byte order)
  121. * @wLength: matches the USB wLength field (le16 byte order)
  122. *
  123. * This structure is used to send control requests to a USB device. It matches
  124. * the different fields of the USB 2.0 Spec section 9.3, table 9-2. See the
  125. * USB spec for a fuller description of the different fields, and what they are
  126. * used for.
  127. *
  128. * Note that the driver for any interface can issue control requests.
  129. * For most devices, interfaces don't coordinate with each other, so
  130. * such requests may be made at any time.
  131. */
  132. struct usb_ctrlrequest {
  133. __u8 bRequestType;
  134. __u8 bRequest;
  135. __le16 wValue;
  136. __le16 wIndex;
  137. __le16 wLength;
  138. } __attribute__ ((packed));
  139. /*-------------------------------------------------------------------------*/
  140. /*
  141. * STANDARD DESCRIPTORS ... as returned by GET_DESCRIPTOR, or
  142. * (rarely) accepted by SET_DESCRIPTOR.
  143. *
  144. * Note that all multi-byte values here are encoded in little endian
  145. * byte order "on the wire". Within the kernel and when exposed
  146. * through the Linux-USB APIs, they are not converted to cpu byte
  147. * order; it is the responsibility of the client code to do this.
  148. * The single exception is when device and configuration descriptors (but
  149. * not other descriptors) are read from usbfs (i.e. /proc/bus/usb/BBB/DDD);
  150. * in this case the fields are converted to host endianness by the kernel.
  151. */
  152. /*
  153. * Descriptor types ... USB 2.0 spec table 9.5
  154. */
  155. #define USB_DT_DEVICE 0x01
  156. #define USB_DT_CONFIG 0x02
  157. #define USB_DT_STRING 0x03
  158. #define USB_DT_INTERFACE 0x04
  159. #define USB_DT_ENDPOINT 0x05
  160. #define USB_DT_DEVICE_QUALIFIER 0x06
  161. #define USB_DT_OTHER_SPEED_CONFIG 0x07
  162. #define USB_DT_INTERFACE_POWER 0x08
  163. /* these are from a minor usb 2.0 revision (ECN) */
  164. #define USB_DT_OTG 0x09
  165. #define USB_DT_DEBUG 0x0a
  166. #define USB_DT_INTERFACE_ASSOCIATION 0x0b
  167. /* these are from the Wireless USB spec */
  168. #define USB_DT_SECURITY 0x0c
  169. #define USB_DT_KEY 0x0d
  170. #define USB_DT_ENCRYPTION_TYPE 0x0e
  171. #define USB_DT_BOS 0x0f
  172. #define USB_DT_DEVICE_CAPABILITY 0x10
  173. #define USB_DT_WIRELESS_ENDPOINT_COMP 0x11
  174. #define USB_DT_WIRE_ADAPTER 0x21
  175. #define USB_DT_RPIPE 0x22
  176. #define USB_DT_CS_RADIO_CONTROL 0x23
  177. /* Conventional codes for class-specific descriptors. The convention is
  178. * defined in the USB "Common Class" Spec (3.11). Individual class specs
  179. * are authoritative for their usage, not the "common class" writeup.
  180. */
  181. #define USB_DT_CS_DEVICE (USB_TYPE_CLASS | USB_DT_DEVICE)
  182. #define USB_DT_CS_CONFIG (USB_TYPE_CLASS | USB_DT_CONFIG)
  183. #define USB_DT_CS_STRING (USB_TYPE_CLASS | USB_DT_STRING)
  184. #define USB_DT_CS_INTERFACE (USB_TYPE_CLASS | USB_DT_INTERFACE)
  185. #define USB_DT_CS_ENDPOINT (USB_TYPE_CLASS | USB_DT_ENDPOINT)
  186. /* All standard descriptors have these 2 fields at the beginning */
  187. struct usb_descriptor_header {
  188. __u8 bLength;
  189. __u8 bDescriptorType;
  190. } __attribute__ ((packed));
  191. /*-------------------------------------------------------------------------*/
  192. /* USB_DT_DEVICE: Device descriptor */
  193. struct usb_device_descriptor {
  194. __u8 bLength;
  195. __u8 bDescriptorType;
  196. __le16 bcdUSB;
  197. __u8 bDeviceClass;
  198. __u8 bDeviceSubClass;
  199. __u8 bDeviceProtocol;
  200. __u8 bMaxPacketSize0;
  201. __le16 idVendor;
  202. __le16 idProduct;
  203. __le16 bcdDevice;
  204. __u8 iManufacturer;
  205. __u8 iProduct;
  206. __u8 iSerialNumber;
  207. __u8 bNumConfigurations;
  208. } __attribute__ ((packed));
  209. #define USB_DT_DEVICE_SIZE 18
  210. /*
  211. * Device and/or Interface Class codes
  212. * as found in bDeviceClass or bInterfaceClass
  213. * and defined by www.usb.org documents
  214. */
  215. #define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */
  216. #define USB_CLASS_AUDIO 1
  217. #define USB_CLASS_COMM 2
  218. #define USB_CLASS_HID 3
  219. #define USB_CLASS_PHYSICAL 5
  220. #define USB_CLASS_STILL_IMAGE 6
  221. #define USB_CLASS_PRINTER 7
  222. #define USB_CLASS_MASS_STORAGE 8
  223. #define USB_CLASS_HUB 9
  224. #define USB_CLASS_CDC_DATA 0x0a
  225. #define USB_CLASS_CSCID 0x0b /* chip+ smart card */
  226. #define USB_CLASS_CONTENT_SEC 0x0d /* content security */
  227. #define USB_CLASS_VIDEO 0x0e
  228. #define USB_CLASS_WIRELESS_CONTROLLER 0xe0
  229. #define USB_CLASS_MISC 0xef
  230. #define USB_CLASS_APP_SPEC 0xfe
  231. #define USB_CLASS_VENDOR_SPEC 0xff
  232. /*-------------------------------------------------------------------------*/
  233. /* USB_DT_CONFIG: Configuration descriptor information.
  234. *
  235. * USB_DT_OTHER_SPEED_CONFIG is the same descriptor, except that the
  236. * descriptor type is different. Highspeed-capable devices can look
  237. * different depending on what speed they're currently running. Only
  238. * devices with a USB_DT_DEVICE_QUALIFIER have any OTHER_SPEED_CONFIG
  239. * descriptors.
  240. */
  241. struct usb_config_descriptor {
  242. __u8 bLength;
  243. __u8 bDescriptorType;
  244. __le16 wTotalLength;
  245. __u8 bNumInterfaces;
  246. __u8 bConfigurationValue;
  247. __u8 iConfiguration;
  248. __u8 bmAttributes;
  249. __u8 bMaxPower;
  250. } __attribute__ ((packed));
  251. #define USB_DT_CONFIG_SIZE 9
  252. /* from config descriptor bmAttributes */
  253. #define USB_CONFIG_ATT_ONE (1 << 7) /* must be set */
  254. #define USB_CONFIG_ATT_SELFPOWER (1 << 6) /* self powered */
  255. #define USB_CONFIG_ATT_WAKEUP (1 << 5) /* can wakeup */
  256. #define USB_CONFIG_ATT_BATTERY (1 << 4) /* battery powered */
  257. /*-------------------------------------------------------------------------*/
  258. /* USB_DT_STRING: String descriptor */
  259. struct usb_string_descriptor {
  260. __u8 bLength;
  261. __u8 bDescriptorType;
  262. __le16 wData[1]; /* UTF-16LE encoded */
  263. } __attribute__ ((packed));
  264. /* note that "string" zero is special, it holds language codes that
  265. * the device supports, not Unicode characters.
  266. */
  267. /*-------------------------------------------------------------------------*/
  268. /* USB_DT_INTERFACE: Interface descriptor */
  269. struct usb_interface_descriptor {
  270. __u8 bLength;
  271. __u8 bDescriptorType;
  272. __u8 bInterfaceNumber;
  273. __u8 bAlternateSetting;
  274. __u8 bNumEndpoints;
  275. __u8 bInterfaceClass;
  276. __u8 bInterfaceSubClass;
  277. __u8 bInterfaceProtocol;
  278. __u8 iInterface;
  279. } __attribute__ ((packed));
  280. #define USB_DT_INTERFACE_SIZE 9
  281. /*-------------------------------------------------------------------------*/
  282. /* USB_DT_ENDPOINT: Endpoint descriptor */
  283. struct usb_endpoint_descriptor {
  284. __u8 bLength;
  285. __u8 bDescriptorType;
  286. __u8 bEndpointAddress;
  287. __u8 bmAttributes;
  288. __le16 wMaxPacketSize;
  289. __u8 bInterval;
  290. /* NOTE: these two are _only_ in audio endpoints. */
  291. /* use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof. */
  292. __u8 bRefresh;
  293. __u8 bSynchAddress;
  294. } __attribute__ ((packed));
  295. #define USB_DT_ENDPOINT_SIZE 7
  296. #define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */
  297. /*
  298. * Endpoints
  299. */
  300. #define USB_ENDPOINT_NUMBER_MASK 0x0f /* in bEndpointAddress */
  301. #define USB_ENDPOINT_DIR_MASK 0x80
  302. #define USB_ENDPOINT_XFERTYPE_MASK 0x03 /* in bmAttributes */
  303. #define USB_ENDPOINT_XFER_CONTROL 0
  304. #define USB_ENDPOINT_XFER_ISOC 1
  305. #define USB_ENDPOINT_XFER_BULK 2
  306. #define USB_ENDPOINT_XFER_INT 3
  307. #define USB_ENDPOINT_MAX_ADJUSTABLE 0x80
  308. /*-------------------------------------------------------------------------*/
  309. /**
  310. * usb_endpoint_num - get the endpoint's number
  311. * @epd: endpoint to be checked
  312. *
  313. * Returns @epd's number: 0 to 15.
  314. */
  315. static inline int usb_endpoint_num(const struct usb_endpoint_descriptor *epd)
  316. {
  317. return epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
  318. }
  319. /**
  320. * usb_endpoint_type - get the endpoint's transfer type
  321. * @epd: endpoint to be checked
  322. *
  323. * Returns one of USB_ENDPOINT_XFER_{CONTROL, ISOC, BULK, INT} according
  324. * to @epd's transfer type.
  325. */
  326. static inline int usb_endpoint_type(const struct usb_endpoint_descriptor *epd)
  327. {
  328. return epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
  329. }
  330. /**
  331. * usb_endpoint_dir_in - check if the endpoint has IN direction
  332. * @epd: endpoint to be checked
  333. *
  334. * Returns true if the endpoint is of type IN, otherwise it returns false.
  335. */
  336. static inline int usb_endpoint_dir_in(const struct usb_endpoint_descriptor *epd)
  337. {
  338. return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN);
  339. }
  340. /**
  341. * usb_endpoint_dir_out - check if the endpoint has OUT direction
  342. * @epd: endpoint to be checked
  343. *
  344. * Returns true if the endpoint is of type OUT, otherwise it returns false.
  345. */
  346. static inline int usb_endpoint_dir_out(
  347. const struct usb_endpoint_descriptor *epd)
  348. {
  349. return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT);
  350. }
  351. /**
  352. * usb_endpoint_xfer_bulk - check if the endpoint has bulk transfer type
  353. * @epd: endpoint to be checked
  354. *
  355. * Returns true if the endpoint is of type bulk, otherwise it returns false.
  356. */
  357. static inline int usb_endpoint_xfer_bulk(
  358. const struct usb_endpoint_descriptor *epd)
  359. {
  360. return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
  361. USB_ENDPOINT_XFER_BULK);
  362. }
  363. /**
  364. * usb_endpoint_xfer_control - check if the endpoint has control transfer type
  365. * @epd: endpoint to be checked
  366. *
  367. * Returns true if the endpoint is of type control, otherwise it returns false.
  368. */
  369. static inline int usb_endpoint_xfer_control(
  370. const struct usb_endpoint_descriptor *epd)
  371. {
  372. return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
  373. USB_ENDPOINT_XFER_CONTROL);
  374. }
  375. /**
  376. * usb_endpoint_xfer_int - check if the endpoint has interrupt transfer type
  377. * @epd: endpoint to be checked
  378. *
  379. * Returns true if the endpoint is of type interrupt, otherwise it returns
  380. * false.
  381. */
  382. static inline int usb_endpoint_xfer_int(
  383. const struct usb_endpoint_descriptor *epd)
  384. {
  385. return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
  386. USB_ENDPOINT_XFER_INT);
  387. }
  388. /**
  389. * usb_endpoint_xfer_isoc - check if the endpoint has isochronous transfer type
  390. * @epd: endpoint to be checked
  391. *
  392. * Returns true if the endpoint is of type isochronous, otherwise it returns
  393. * false.
  394. */
  395. static inline int usb_endpoint_xfer_isoc(
  396. const struct usb_endpoint_descriptor *epd)
  397. {
  398. return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
  399. USB_ENDPOINT_XFER_ISOC);
  400. }
  401. /**
  402. * usb_endpoint_is_bulk_in - check if the endpoint is bulk IN
  403. * @epd: endpoint to be checked
  404. *
  405. * Returns true if the endpoint has bulk transfer type and IN direction,
  406. * otherwise it returns false.
  407. */
  408. static inline int usb_endpoint_is_bulk_in(
  409. const struct usb_endpoint_descriptor *epd)
  410. {
  411. return (usb_endpoint_xfer_bulk(epd) && usb_endpoint_dir_in(epd));
  412. }
  413. /**
  414. * usb_endpoint_is_bulk_out - check if the endpoint is bulk OUT
  415. * @epd: endpoint to be checked
  416. *
  417. * Returns true if the endpoint has bulk transfer type and OUT direction,
  418. * otherwise it returns false.
  419. */
  420. static inline int usb_endpoint_is_bulk_out(
  421. const struct usb_endpoint_descriptor *epd)
  422. {
  423. return (usb_endpoint_xfer_bulk(epd) && usb_endpoint_dir_out(epd));
  424. }
  425. /**
  426. * usb_endpoint_is_int_in - check if the endpoint is interrupt IN
  427. * @epd: endpoint to be checked
  428. *
  429. * Returns true if the endpoint has interrupt transfer type and IN direction,
  430. * otherwise it returns false.
  431. */
  432. static inline int usb_endpoint_is_int_in(
  433. const struct usb_endpoint_descriptor *epd)
  434. {
  435. return (usb_endpoint_xfer_int(epd) && usb_endpoint_dir_in(epd));
  436. }
  437. /**
  438. * usb_endpoint_is_int_out - check if the endpoint is interrupt OUT
  439. * @epd: endpoint to be checked
  440. *
  441. * Returns true if the endpoint has interrupt transfer type and OUT direction,
  442. * otherwise it returns false.
  443. */
  444. static inline int usb_endpoint_is_int_out(
  445. const struct usb_endpoint_descriptor *epd)
  446. {
  447. return (usb_endpoint_xfer_int(epd) && usb_endpoint_dir_out(epd));
  448. }
  449. /**
  450. * usb_endpoint_is_isoc_in - check if the endpoint is isochronous IN
  451. * @epd: endpoint to be checked
  452. *
  453. * Returns true if the endpoint has isochronous transfer type and IN direction,
  454. * otherwise it returns false.
  455. */
  456. static inline int usb_endpoint_is_isoc_in(
  457. const struct usb_endpoint_descriptor *epd)
  458. {
  459. return (usb_endpoint_xfer_isoc(epd) && usb_endpoint_dir_in(epd));
  460. }
  461. /**
  462. * usb_endpoint_is_isoc_out - check if the endpoint is isochronous OUT
  463. * @epd: endpoint to be checked
  464. *
  465. * Returns true if the endpoint has isochronous transfer type and OUT direction,
  466. * otherwise it returns false.
  467. */
  468. static inline int usb_endpoint_is_isoc_out(
  469. const struct usb_endpoint_descriptor *epd)
  470. {
  471. return (usb_endpoint_xfer_isoc(epd) && usb_endpoint_dir_out(epd));
  472. }
  473. /*-------------------------------------------------------------------------*/
  474. /* USB_DT_DEVICE_QUALIFIER: Device Qualifier descriptor */
  475. struct usb_qualifier_descriptor {
  476. __u8 bLength;
  477. __u8 bDescriptorType;
  478. __le16 bcdUSB;
  479. __u8 bDeviceClass;
  480. __u8 bDeviceSubClass;
  481. __u8 bDeviceProtocol;
  482. __u8 bMaxPacketSize0;
  483. __u8 bNumConfigurations;
  484. __u8 bRESERVED;
  485. } __attribute__ ((packed));
  486. /*-------------------------------------------------------------------------*/
  487. /* USB_DT_OTG (from OTG 1.0a supplement) */
  488. struct usb_otg_descriptor {
  489. __u8 bLength;
  490. __u8 bDescriptorType;
  491. __u8 bmAttributes; /* support for HNP, SRP, etc */
  492. } __attribute__ ((packed));
  493. /* from usb_otg_descriptor.bmAttributes */
  494. #define USB_OTG_SRP (1 << 0)
  495. #define USB_OTG_HNP (1 << 1) /* swap host/device roles */
  496. /*-------------------------------------------------------------------------*/
  497. /* USB_DT_DEBUG: for special highspeed devices, replacing serial console */
  498. struct usb_debug_descriptor {
  499. __u8 bLength;
  500. __u8 bDescriptorType;
  501. /* bulk endpoints with 8 byte maxpacket */
  502. __u8 bDebugInEndpoint;
  503. __u8 bDebugOutEndpoint;
  504. } __attribute__((packed));
  505. /*-------------------------------------------------------------------------*/
  506. /* USB_DT_INTERFACE_ASSOCIATION: groups interfaces */
  507. struct usb_interface_assoc_descriptor {
  508. __u8 bLength;
  509. __u8 bDescriptorType;
  510. __u8 bFirstInterface;
  511. __u8 bInterfaceCount;
  512. __u8 bFunctionClass;
  513. __u8 bFunctionSubClass;
  514. __u8 bFunctionProtocol;
  515. __u8 iFunction;
  516. } __attribute__ ((packed));
  517. /*-------------------------------------------------------------------------*/
  518. /* USB_DT_SECURITY: group of wireless security descriptors, including
  519. * encryption types available for setting up a CC/association.
  520. */
  521. struct usb_security_descriptor {
  522. __u8 bLength;
  523. __u8 bDescriptorType;
  524. __le16 wTotalLength;
  525. __u8 bNumEncryptionTypes;
  526. } __attribute__((packed));
  527. /*-------------------------------------------------------------------------*/
  528. /* USB_DT_KEY: used with {GET,SET}_SECURITY_DATA; only public keys
  529. * may be retrieved.
  530. */
  531. struct usb_key_descriptor {
  532. __u8 bLength;
  533. __u8 bDescriptorType;
  534. __u8 tTKID[3];
  535. __u8 bReserved;
  536. __u8 bKeyData[0];
  537. } __attribute__((packed));
  538. /*-------------------------------------------------------------------------*/
  539. /* USB_DT_ENCRYPTION_TYPE: bundled in DT_SECURITY groups */
  540. struct usb_encryption_descriptor {
  541. __u8 bLength;
  542. __u8 bDescriptorType;
  543. __u8 bEncryptionType;
  544. #define USB_ENC_TYPE_UNSECURE 0
  545. #define USB_ENC_TYPE_WIRED 1 /* non-wireless mode */
  546. #define USB_ENC_TYPE_CCM_1 2 /* aes128/cbc session */
  547. #define USB_ENC_TYPE_RSA_1 3 /* rsa3072/sha1 auth */
  548. __u8 bEncryptionValue; /* use in SET_ENCRYPTION */
  549. __u8 bAuthKeyIndex;
  550. } __attribute__((packed));
  551. /*-------------------------------------------------------------------------*/
  552. /* USB_DT_BOS: group of device-level capabilities */
  553. struct usb_bos_descriptor {
  554. __u8 bLength;
  555. __u8 bDescriptorType;
  556. __le16 wTotalLength;
  557. __u8 bNumDeviceCaps;
  558. } __attribute__((packed));
  559. /*-------------------------------------------------------------------------*/
  560. /* USB_DT_DEVICE_CAPABILITY: grouped with BOS */
  561. struct usb_dev_cap_header {
  562. __u8 bLength;
  563. __u8 bDescriptorType;
  564. __u8 bDevCapabilityType;
  565. } __attribute__((packed));
  566. #define USB_CAP_TYPE_WIRELESS_USB 1
  567. struct usb_wireless_cap_descriptor { /* Ultra Wide Band */
  568. __u8 bLength;
  569. __u8 bDescriptorType;
  570. __u8 bDevCapabilityType;
  571. __u8 bmAttributes;
  572. #define USB_WIRELESS_P2P_DRD (1 << 1)
  573. #define USB_WIRELESS_BEACON_MASK (3 << 2)
  574. #define USB_WIRELESS_BEACON_SELF (1 << 2)
  575. #define USB_WIRELESS_BEACON_DIRECTED (2 << 2)
  576. #define USB_WIRELESS_BEACON_NONE (3 << 2)
  577. __le16 wPHYRates; /* bit rates, Mbps */
  578. #define USB_WIRELESS_PHY_53 (1 << 0) /* always set */
  579. #define USB_WIRELESS_PHY_80 (1 << 1)
  580. #define USB_WIRELESS_PHY_107 (1 << 2) /* always set */
  581. #define USB_WIRELESS_PHY_160 (1 << 3)
  582. #define USB_WIRELESS_PHY_200 (1 << 4) /* always set */
  583. #define USB_WIRELESS_PHY_320 (1 << 5)
  584. #define USB_WIRELESS_PHY_400 (1 << 6)
  585. #define USB_WIRELESS_PHY_480 (1 << 7)
  586. __u8 bmTFITXPowerInfo; /* TFI power levels */
  587. __u8 bmFFITXPowerInfo; /* FFI power levels */
  588. __le16 bmBandGroup;
  589. __u8 bReserved;
  590. } __attribute__((packed));
  591. #define USB_CAP_TYPE_EXT 2
  592. struct usb_ext_cap_descriptor { /* Link Power Management */
  593. __u8 bLength;
  594. __u8 bDescriptorType;
  595. __u8 bDevCapabilityType;
  596. __u8 bmAttributes;
  597. #define USB_LPM_SUPPORT (1 << 1) /* supports LPM */
  598. } __attribute__((packed));
  599. /*-------------------------------------------------------------------------*/
  600. /* USB_DT_WIRELESS_ENDPOINT_COMP: companion descriptor associated with
  601. * each endpoint descriptor for a wireless device
  602. */
  603. struct usb_wireless_ep_comp_descriptor {
  604. __u8 bLength;
  605. __u8 bDescriptorType;
  606. __u8 bMaxBurst;
  607. __u8 bMaxSequence;
  608. __le16 wMaxStreamDelay;
  609. __le16 wOverTheAirPacketSize;
  610. __u8 bOverTheAirInterval;
  611. __u8 bmCompAttributes;
  612. #define USB_ENDPOINT_SWITCH_MASK 0x03 /* in bmCompAttributes */
  613. #define USB_ENDPOINT_SWITCH_NO 0
  614. #define USB_ENDPOINT_SWITCH_SWITCH 1
  615. #define USB_ENDPOINT_SWITCH_SCALE 2
  616. } __attribute__((packed));
  617. /*-------------------------------------------------------------------------*/
  618. /* USB_REQ_SET_HANDSHAKE is a four-way handshake used between a wireless
  619. * host and a device for connection set up, mutual authentication, and
  620. * exchanging short lived session keys. The handshake depends on a CC.
  621. */
  622. struct usb_handshake {
  623. __u8 bMessageNumber;
  624. __u8 bStatus;
  625. __u8 tTKID[3];
  626. __u8 bReserved;
  627. __u8 CDID[16];
  628. __u8 nonce[16];
  629. __u8 MIC[8];
  630. } __attribute__((packed));
  631. /*-------------------------------------------------------------------------*/
  632. /* USB_REQ_SET_CONNECTION modifies or revokes a connection context (CC).
  633. * A CC may also be set up using non-wireless secure channels (including
  634. * wired USB!), and some devices may support CCs with multiple hosts.
  635. */
  636. struct usb_connection_context {
  637. __u8 CHID[16]; /* persistent host id */
  638. __u8 CDID[16]; /* device id (unique w/in host context) */
  639. __u8 CK[16]; /* connection key */
  640. } __attribute__((packed));
  641. /*-------------------------------------------------------------------------*/
  642. /* USB 2.0 defines three speeds, here's how Linux identifies them */
  643. enum usb_device_speed {
  644. USB_SPEED_UNKNOWN = 0, /* enumerating */
  645. USB_SPEED_LOW, USB_SPEED_FULL, /* usb 1.1 */
  646. USB_SPEED_HIGH, /* usb 2.0 */
  647. USB_SPEED_VARIABLE, /* wireless (usb 2.5) */
  648. };
  649. enum usb_device_state {
  650. /* NOTATTACHED isn't in the USB spec, and this state acts
  651. * the same as ATTACHED ... but it's clearer this way.
  652. */
  653. USB_STATE_NOTATTACHED = 0,
  654. /* chapter 9 and authentication (wireless) device states */
  655. USB_STATE_ATTACHED,
  656. USB_STATE_POWERED, /* wired */
  657. USB_STATE_RECONNECTING, /* auth */
  658. USB_STATE_UNAUTHENTICATED, /* auth */
  659. USB_STATE_DEFAULT, /* limited function */
  660. USB_STATE_ADDRESS,
  661. USB_STATE_CONFIGURED, /* most functions */
  662. USB_STATE_SUSPENDED
  663. /* NOTE: there are actually four different SUSPENDED
  664. * states, returning to POWERED, DEFAULT, ADDRESS, or
  665. * CONFIGURED respectively when SOF tokens flow again.
  666. * At this level there's no difference between L1 and L2
  667. * suspend states. (L2 being original USB 1.1 suspend.)
  668. */
  669. };
  670. #endif /* __LINUX_USB_CH9_H */