1276 lines · c
1/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */2/*3 * This file holds USB constants and structures that are needed for4 * USB device APIs. These are used by the USB device model, which is5 * defined in chapter 9 of the USB 2.0 specification and in the6 * Wireless USB 1.0 spec (now defunct). Linux has several APIs in C that7 * need these:8 *9 * - the master/host side Linux-USB kernel driver API;10 * - the "usbfs" user space API; and11 * - the Linux "gadget" slave/device/peripheral side driver API.12 *13 * USB 2.0 adds an additional "On The Go" (OTG) mode, which lets systems14 * act either as a USB master/host or as a USB slave/device. That means15 * the master and slave side APIs benefit from working well together.16 *17 * Note all descriptors are declared '__attribute__((packed))' so that:18 *19 * [a] they never get padded, either internally (USB spec writers20 * probably handled that) or externally;21 *22 * [b] so that accessing bigger-than-a-bytes fields will never23 * generate bus errors on any platform, even when the location of24 * its descriptor inside a bundle isn't "naturally aligned", and25 *26 * [c] for consistency, removing all doubt even when it appears to27 * someone that the two other points are non-issues for that28 * particular descriptor type.29 */30 31#ifndef _UAPI__LINUX_USB_CH9_H32#define _UAPI__LINUX_USB_CH9_H33 34#include <linux/types.h> /* __u8 etc */35#include <asm/byteorder.h> /* le16_to_cpu */36 37/*-------------------------------------------------------------------------*/38 39/* CONTROL REQUEST SUPPORT */40 41/*42 * USB directions43 *44 * This bit flag is used in endpoint descriptors' bEndpointAddress field.45 * It's also one of three fields in control requests bRequestType.46 */47#define USB_DIR_OUT 0 /* to device */48#define USB_DIR_IN 0x80 /* to host */49 50/*51 * USB types, the second of three bRequestType fields52 */53#define USB_TYPE_MASK (0x03 << 5)54#define USB_TYPE_STANDARD (0x00 << 5)55#define USB_TYPE_CLASS (0x01 << 5)56#define USB_TYPE_VENDOR (0x02 << 5)57#define USB_TYPE_RESERVED (0x03 << 5)58 59/*60 * USB recipients, the third of three bRequestType fields61 */62#define USB_RECIP_MASK 0x1f63#define USB_RECIP_DEVICE 0x0064#define USB_RECIP_INTERFACE 0x0165#define USB_RECIP_ENDPOINT 0x0266#define USB_RECIP_OTHER 0x0367/* From Wireless USB 1.0 */68#define USB_RECIP_PORT 0x0469#define USB_RECIP_RPIPE 0x0570 71/*72 * Standard requests, for the bRequest field of a SETUP packet.73 *74 * These are qualified by the bRequestType field, so that for example75 * TYPE_CLASS or TYPE_VENDOR specific feature flags could be retrieved76 * by a GET_STATUS request.77 */78#define USB_REQ_GET_STATUS 0x0079#define USB_REQ_CLEAR_FEATURE 0x0180#define USB_REQ_SET_FEATURE 0x0381#define USB_REQ_SET_ADDRESS 0x0582#define USB_REQ_GET_DESCRIPTOR 0x0683#define USB_REQ_SET_DESCRIPTOR 0x0784#define USB_REQ_GET_CONFIGURATION 0x0885#define USB_REQ_SET_CONFIGURATION 0x0986#define USB_REQ_GET_INTERFACE 0x0A87#define USB_REQ_SET_INTERFACE 0x0B88#define USB_REQ_SYNCH_FRAME 0x0C89#define USB_REQ_SET_SEL 0x3090#define USB_REQ_SET_ISOCH_DELAY 0x3191 92#define USB_REQ_SET_ENCRYPTION 0x0D /* Wireless USB */93#define USB_REQ_GET_ENCRYPTION 0x0E94#define USB_REQ_RPIPE_ABORT 0x0E95#define USB_REQ_SET_HANDSHAKE 0x0F96#define USB_REQ_RPIPE_RESET 0x0F97#define USB_REQ_GET_HANDSHAKE 0x1098#define USB_REQ_SET_CONNECTION 0x1199#define USB_REQ_SET_SECURITY_DATA 0x12100#define USB_REQ_GET_SECURITY_DATA 0x13101#define USB_REQ_SET_WUSB_DATA 0x14102#define USB_REQ_LOOPBACK_DATA_WRITE 0x15103#define USB_REQ_LOOPBACK_DATA_READ 0x16104#define USB_REQ_SET_INTERFACE_DS 0x17105 106/* specific requests for USB Power Delivery */107#define USB_REQ_GET_PARTNER_PDO 20108#define USB_REQ_GET_BATTERY_STATUS 21109#define USB_REQ_SET_PDO 22110#define USB_REQ_GET_VDM 23111#define USB_REQ_SEND_VDM 24112 113/* The Link Power Management (LPM) ECN defines USB_REQ_TEST_AND_SET command,114 * used by hubs to put ports into a new L1 suspend state, except that it115 * forgot to define its number ...116 */117 118/*119 * USB feature flags are written using USB_REQ_{CLEAR,SET}_FEATURE, and120 * are read as a bit array returned by USB_REQ_GET_STATUS. (So there121 * are at most sixteen features of each type.) Hubs may also support a122 * new USB_REQ_TEST_AND_SET_FEATURE to put ports into L1 suspend.123 */124#define USB_DEVICE_SELF_POWERED 0 /* (read only) */125#define USB_DEVICE_REMOTE_WAKEUP 1 /* dev may initiate wakeup */126#define USB_DEVICE_TEST_MODE 2 /* (wired high speed only) */127#define USB_DEVICE_BATTERY 2 /* (wireless) */128#define USB_DEVICE_B_HNP_ENABLE 3 /* (otg) dev may initiate HNP */129#define USB_DEVICE_WUSB_DEVICE 3 /* (wireless)*/130#define USB_DEVICE_A_HNP_SUPPORT 4 /* (otg) RH port supports HNP */131#define USB_DEVICE_A_ALT_HNP_SUPPORT 5 /* (otg) other RH port does */132#define USB_DEVICE_DEBUG_MODE 6 /* (special devices only) */133 134/*135 * Test Mode Selectors136 * See USB 2.0 spec Table 9-7137 */138#define USB_TEST_J 1139#define USB_TEST_K 2140#define USB_TEST_SE0_NAK 3141#define USB_TEST_PACKET 4142#define USB_TEST_FORCE_ENABLE 5143 144/* Status Type */145#define USB_STATUS_TYPE_STANDARD 0146#define USB_STATUS_TYPE_PTM 1147 148/*149 * New Feature Selectors as added by USB 3.0150 * See USB 3.0 spec Table 9-7151 */152#define USB_DEVICE_U1_ENABLE 48 /* dev may initiate U1 transition */153#define USB_DEVICE_U2_ENABLE 49 /* dev may initiate U2 transition */154#define USB_DEVICE_LTM_ENABLE 50 /* dev may send LTM */155#define USB_INTRF_FUNC_SUSPEND 0 /* function suspend */156 157#define USB_INTR_FUNC_SUSPEND_OPT_MASK 0xFF00158/*159 * Suspend Options, Table 9-8 USB 3.0 spec160 */161#define USB_INTRF_FUNC_SUSPEND_LP (1 << (8 + 0))162#define USB_INTRF_FUNC_SUSPEND_RW (1 << (8 + 1))163 164/*165 * Interface status, Figure 9-5 USB 3.0 spec166 */167#define USB_INTRF_STAT_FUNC_RW_CAP 1168#define USB_INTRF_STAT_FUNC_RW 2169 170#define USB_ENDPOINT_HALT 0 /* IN/OUT will STALL */171 172/* Bit array elements as returned by the USB_REQ_GET_STATUS request. */173#define USB_DEV_STAT_U1_ENABLED 2 /* transition into U1 state */174#define USB_DEV_STAT_U2_ENABLED 3 /* transition into U2 state */175#define USB_DEV_STAT_LTM_ENABLED 4 /* Latency tolerance messages */176 177/*178 * Feature selectors from Table 9-8 USB Power Delivery spec179 */180#define USB_DEVICE_BATTERY_WAKE_MASK 40181#define USB_DEVICE_OS_IS_PD_AWARE 41182#define USB_DEVICE_POLICY_MODE 42183#define USB_PORT_PR_SWAP 43184#define USB_PORT_GOTO_MIN 44185#define USB_PORT_RETURN_POWER 45186#define USB_PORT_ACCEPT_PD_REQUEST 46187#define USB_PORT_REJECT_PD_REQUEST 47188#define USB_PORT_PORT_PD_RESET 48189#define USB_PORT_C_PORT_PD_CHANGE 49190#define USB_PORT_CABLE_PD_RESET 50191#define USB_DEVICE_CHARGING_POLICY 54192 193/**194 * struct usb_ctrlrequest - SETUP data for a USB device control request195 * @bRequestType: matches the USB bmRequestType field196 * @bRequest: matches the USB bRequest field197 * @wValue: matches the USB wValue field (le16 byte order)198 * @wIndex: matches the USB wIndex field (le16 byte order)199 * @wLength: matches the USB wLength field (le16 byte order)200 *201 * This structure is used to send control requests to a USB device. It matches202 * the different fields of the USB 2.0 Spec section 9.3, table 9-2. See the203 * USB spec for a fuller description of the different fields, and what they are204 * used for.205 *206 * Note that the driver for any interface can issue control requests.207 * For most devices, interfaces don't coordinate with each other, so208 * such requests may be made at any time.209 */210struct usb_ctrlrequest {211 __u8 bRequestType;212 __u8 bRequest;213 __le16 wValue;214 __le16 wIndex;215 __le16 wLength;216} __attribute__ ((packed));217 218/*-------------------------------------------------------------------------*/219 220/*221 * STANDARD DESCRIPTORS ... as returned by GET_DESCRIPTOR, or222 * (rarely) accepted by SET_DESCRIPTOR.223 *224 * Note that all multi-byte values here are encoded in little endian225 * byte order "on the wire". Within the kernel and when exposed226 * through the Linux-USB APIs, they are not converted to cpu byte227 * order; it is the responsibility of the client code to do this.228 * The single exception is when device and configuration descriptors (but229 * not other descriptors) are read from character devices230 * (i.e. /dev/bus/usb/BBB/DDD);231 * in this case the fields are converted to host endianness by the kernel.232 */233 234/*235 * Descriptor types ... USB 2.0 spec table 9.5236 */237#define USB_DT_DEVICE 0x01238#define USB_DT_CONFIG 0x02239#define USB_DT_STRING 0x03240#define USB_DT_INTERFACE 0x04241#define USB_DT_ENDPOINT 0x05242#define USB_DT_DEVICE_QUALIFIER 0x06243#define USB_DT_OTHER_SPEED_CONFIG 0x07244#define USB_DT_INTERFACE_POWER 0x08245/* these are from a minor usb 2.0 revision (ECN) */246#define USB_DT_OTG 0x09247#define USB_DT_DEBUG 0x0a248#define USB_DT_INTERFACE_ASSOCIATION 0x0b249/* these are from the Wireless USB spec */250#define USB_DT_SECURITY 0x0c251#define USB_DT_KEY 0x0d252#define USB_DT_ENCRYPTION_TYPE 0x0e253#define USB_DT_BOS 0x0f254#define USB_DT_DEVICE_CAPABILITY 0x10255#define USB_DT_WIRELESS_ENDPOINT_COMP 0x11256#define USB_DT_WIRE_ADAPTER 0x21257/* From USB Device Firmware Upgrade Specification, Revision 1.1 */258#define USB_DT_DFU_FUNCTIONAL 0x21259/* these are from the Wireless USB spec */260#define USB_DT_RPIPE 0x22261#define USB_DT_CS_RADIO_CONTROL 0x23262/* From the T10 UAS specification */263#define USB_DT_PIPE_USAGE 0x24264/* From the USB 3.0 spec */265#define USB_DT_SS_ENDPOINT_COMP 0x30266/* From the USB 3.1 spec */267#define USB_DT_SSP_ISOC_ENDPOINT_COMP 0x31268 269/* Conventional codes for class-specific descriptors. The convention is270 * defined in the USB "Common Class" Spec (3.11). Individual class specs271 * are authoritative for their usage, not the "common class" writeup.272 */273#define USB_DT_CS_DEVICE (USB_TYPE_CLASS | USB_DT_DEVICE)274#define USB_DT_CS_CONFIG (USB_TYPE_CLASS | USB_DT_CONFIG)275#define USB_DT_CS_STRING (USB_TYPE_CLASS | USB_DT_STRING)276#define USB_DT_CS_INTERFACE (USB_TYPE_CLASS | USB_DT_INTERFACE)277#define USB_DT_CS_ENDPOINT (USB_TYPE_CLASS | USB_DT_ENDPOINT)278 279/* All standard descriptors have these 2 fields at the beginning */280struct usb_descriptor_header {281 __u8 bLength;282 __u8 bDescriptorType;283} __attribute__ ((packed));284 285 286/*-------------------------------------------------------------------------*/287 288/* USB_DT_DEVICE: Device descriptor */289struct usb_device_descriptor {290 __u8 bLength;291 __u8 bDescriptorType;292 293 __le16 bcdUSB;294 __u8 bDeviceClass;295 __u8 bDeviceSubClass;296 __u8 bDeviceProtocol;297 __u8 bMaxPacketSize0;298 __le16 idVendor;299 __le16 idProduct;300 __le16 bcdDevice;301 __u8 iManufacturer;302 __u8 iProduct;303 __u8 iSerialNumber;304 __u8 bNumConfigurations;305} __attribute__ ((packed));306 307#define USB_DT_DEVICE_SIZE 18308 309 310/*311 * Device and/or Interface Class codes312 * as found in bDeviceClass or bInterfaceClass313 * and defined by www.usb.org documents314 */315#define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */316#define USB_CLASS_AUDIO 1317#define USB_CLASS_COMM 2318#define USB_CLASS_HID 3319#define USB_CLASS_PHYSICAL 5320#define USB_CLASS_STILL_IMAGE 6321#define USB_CLASS_PRINTER 7322#define USB_CLASS_MASS_STORAGE 8323#define USB_CLASS_HUB 9324#define USB_CLASS_CDC_DATA 0x0a325#define USB_CLASS_CSCID 0x0b /* chip+ smart card */326#define USB_CLASS_CONTENT_SEC 0x0d /* content security */327#define USB_CLASS_VIDEO 0x0e328#define USB_CLASS_WIRELESS_CONTROLLER 0xe0329#define USB_CLASS_PERSONAL_HEALTHCARE 0x0f330#define USB_CLASS_AUDIO_VIDEO 0x10331#define USB_CLASS_BILLBOARD 0x11332#define USB_CLASS_USB_TYPE_C_BRIDGE 0x12333#define USB_CLASS_MISC 0xef334#define USB_CLASS_APP_SPEC 0xfe335#define USB_SUBCLASS_DFU 0x01336 337#define USB_CLASS_VENDOR_SPEC 0xff338#define USB_SUBCLASS_VENDOR_SPEC 0xff339 340/*-------------------------------------------------------------------------*/341 342/* USB_DT_CONFIG: Configuration descriptor information.343 *344 * USB_DT_OTHER_SPEED_CONFIG is the same descriptor, except that the345 * descriptor type is different. Highspeed-capable devices can look346 * different depending on what speed they're currently running. Only347 * devices with a USB_DT_DEVICE_QUALIFIER have any OTHER_SPEED_CONFIG348 * descriptors.349 */350struct usb_config_descriptor {351 __u8 bLength;352 __u8 bDescriptorType;353 354 __le16 wTotalLength;355 __u8 bNumInterfaces;356 __u8 bConfigurationValue;357 __u8 iConfiguration;358 __u8 bmAttributes;359 __u8 bMaxPower;360} __attribute__ ((packed));361 362#define USB_DT_CONFIG_SIZE 9363 364/* from config descriptor bmAttributes */365#define USB_CONFIG_ATT_ONE (1 << 7) /* must be set */366#define USB_CONFIG_ATT_SELFPOWER (1 << 6) /* self powered */367#define USB_CONFIG_ATT_WAKEUP (1 << 5) /* can wakeup */368#define USB_CONFIG_ATT_BATTERY (1 << 4) /* battery powered */369 370/*-------------------------------------------------------------------------*/371 372/* USB String descriptors can contain at most 126 characters. */373#define USB_MAX_STRING_LEN 126374 375/* USB_DT_STRING: String descriptor */376struct usb_string_descriptor {377 __u8 bLength;378 __u8 bDescriptorType;379 380 union {381 __le16 legacy_padding;382 __DECLARE_FLEX_ARRAY(__le16, wData); /* UTF-16LE encoded */383 };384} __attribute__ ((packed));385 386/* note that "string" zero is special, it holds language codes that387 * the device supports, not Unicode characters.388 */389 390/*-------------------------------------------------------------------------*/391 392/* USB_DT_INTERFACE: Interface descriptor */393struct usb_interface_descriptor {394 __u8 bLength;395 __u8 bDescriptorType;396 397 __u8 bInterfaceNumber;398 __u8 bAlternateSetting;399 __u8 bNumEndpoints;400 __u8 bInterfaceClass;401 __u8 bInterfaceSubClass;402 __u8 bInterfaceProtocol;403 __u8 iInterface;404} __attribute__ ((packed));405 406#define USB_DT_INTERFACE_SIZE 9407 408/*-------------------------------------------------------------------------*/409 410/* USB_DT_ENDPOINT: Endpoint descriptor */411struct usb_endpoint_descriptor {412 __u8 bLength;413 __u8 bDescriptorType;414 415 __u8 bEndpointAddress;416 __u8 bmAttributes;417 __le16 wMaxPacketSize;418 __u8 bInterval;419 420 /* NOTE: these two are _only_ in audio endpoints. */421 /* use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof. */422 __u8 bRefresh;423 __u8 bSynchAddress;424} __attribute__ ((packed));425 426#define USB_DT_ENDPOINT_SIZE 7427#define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */428 429 430/*431 * Endpoints432 */433#define USB_ENDPOINT_NUMBER_MASK 0x0f /* in bEndpointAddress */434#define USB_ENDPOINT_DIR_MASK 0x80435 436#define USB_ENDPOINT_XFERTYPE_MASK 0x03 /* in bmAttributes */437#define USB_ENDPOINT_XFER_CONTROL 0438#define USB_ENDPOINT_XFER_ISOC 1439#define USB_ENDPOINT_XFER_BULK 2440#define USB_ENDPOINT_XFER_INT 3441#define USB_ENDPOINT_MAX_ADJUSTABLE 0x80442 443#define USB_ENDPOINT_MAXP_MASK 0x07ff444#define USB_EP_MAXP_MULT_SHIFT 11445#define USB_EP_MAXP_MULT_MASK (3 << USB_EP_MAXP_MULT_SHIFT)446#define USB_EP_MAXP_MULT(m) \447 (((m) & USB_EP_MAXP_MULT_MASK) >> USB_EP_MAXP_MULT_SHIFT)448 449/* The USB 3.0 spec redefines bits 5:4 of bmAttributes as interrupt ep type. */450#define USB_ENDPOINT_INTRTYPE 0x30451#define USB_ENDPOINT_INTR_PERIODIC (0 << 4)452#define USB_ENDPOINT_INTR_NOTIFICATION (1 << 4)453 454#define USB_ENDPOINT_SYNCTYPE 0x0c455#define USB_ENDPOINT_SYNC_NONE (0 << 2)456#define USB_ENDPOINT_SYNC_ASYNC (1 << 2)457#define USB_ENDPOINT_SYNC_ADAPTIVE (2 << 2)458#define USB_ENDPOINT_SYNC_SYNC (3 << 2)459 460#define USB_ENDPOINT_USAGE_MASK 0x30461#define USB_ENDPOINT_USAGE_DATA 0x00462#define USB_ENDPOINT_USAGE_FEEDBACK 0x10463#define USB_ENDPOINT_USAGE_IMPLICIT_FB 0x20 /* Implicit feedback Data endpoint */464 465/*-------------------------------------------------------------------------*/466 467/**468 * usb_endpoint_num - get the endpoint's number469 * @epd: endpoint to be checked470 *471 * Returns @epd's number: 0 to 15.472 */473static inline int usb_endpoint_num(const struct usb_endpoint_descriptor *epd)474{475 return epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;476}477 478/**479 * usb_endpoint_type - get the endpoint's transfer type480 * @epd: endpoint to be checked481 *482 * Returns one of USB_ENDPOINT_XFER_{CONTROL, ISOC, BULK, INT} according483 * to @epd's transfer type.484 */485static inline int usb_endpoint_type(const struct usb_endpoint_descriptor *epd)486{487 return epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;488}489 490/**491 * usb_endpoint_dir_in - check if the endpoint has IN direction492 * @epd: endpoint to be checked493 *494 * Returns true if the endpoint is of type IN, otherwise it returns false.495 */496static inline int usb_endpoint_dir_in(const struct usb_endpoint_descriptor *epd)497{498 return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN);499}500 501/**502 * usb_endpoint_dir_out - check if the endpoint has OUT direction503 * @epd: endpoint to be checked504 *505 * Returns true if the endpoint is of type OUT, otherwise it returns false.506 */507static inline int usb_endpoint_dir_out(508 const struct usb_endpoint_descriptor *epd)509{510 return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT);511}512 513/**514 * usb_endpoint_xfer_bulk - check if the endpoint has bulk transfer type515 * @epd: endpoint to be checked516 *517 * Returns true if the endpoint is of type bulk, otherwise it returns false.518 */519static inline int usb_endpoint_xfer_bulk(520 const struct usb_endpoint_descriptor *epd)521{522 return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==523 USB_ENDPOINT_XFER_BULK);524}525 526/**527 * usb_endpoint_xfer_control - check if the endpoint has control transfer type528 * @epd: endpoint to be checked529 *530 * Returns true if the endpoint is of type control, otherwise it returns false.531 */532static inline int usb_endpoint_xfer_control(533 const struct usb_endpoint_descriptor *epd)534{535 return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==536 USB_ENDPOINT_XFER_CONTROL);537}538 539/**540 * usb_endpoint_xfer_int - check if the endpoint has interrupt transfer type541 * @epd: endpoint to be checked542 *543 * Returns true if the endpoint is of type interrupt, otherwise it returns544 * false.545 */546static inline int usb_endpoint_xfer_int(547 const struct usb_endpoint_descriptor *epd)548{549 return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==550 USB_ENDPOINT_XFER_INT);551}552 553/**554 * usb_endpoint_xfer_isoc - check if the endpoint has isochronous transfer type555 * @epd: endpoint to be checked556 *557 * Returns true if the endpoint is of type isochronous, otherwise it returns558 * false.559 */560static inline int usb_endpoint_xfer_isoc(561 const struct usb_endpoint_descriptor *epd)562{563 return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==564 USB_ENDPOINT_XFER_ISOC);565}566 567/**568 * usb_endpoint_is_bulk_in - check if the endpoint is bulk IN569 * @epd: endpoint to be checked570 *571 * Returns true if the endpoint has bulk transfer type and IN direction,572 * otherwise it returns false.573 */574static inline int usb_endpoint_is_bulk_in(575 const struct usb_endpoint_descriptor *epd)576{577 return usb_endpoint_xfer_bulk(epd) && usb_endpoint_dir_in(epd);578}579 580/**581 * usb_endpoint_is_bulk_out - check if the endpoint is bulk OUT582 * @epd: endpoint to be checked583 *584 * Returns true if the endpoint has bulk transfer type and OUT direction,585 * otherwise it returns false.586 */587static inline int usb_endpoint_is_bulk_out(588 const struct usb_endpoint_descriptor *epd)589{590 return usb_endpoint_xfer_bulk(epd) && usb_endpoint_dir_out(epd);591}592 593/**594 * usb_endpoint_is_int_in - check if the endpoint is interrupt IN595 * @epd: endpoint to be checked596 *597 * Returns true if the endpoint has interrupt transfer type and IN direction,598 * otherwise it returns false.599 */600static inline int usb_endpoint_is_int_in(601 const struct usb_endpoint_descriptor *epd)602{603 return usb_endpoint_xfer_int(epd) && usb_endpoint_dir_in(epd);604}605 606/**607 * usb_endpoint_is_int_out - check if the endpoint is interrupt OUT608 * @epd: endpoint to be checked609 *610 * Returns true if the endpoint has interrupt transfer type and OUT direction,611 * otherwise it returns false.612 */613static inline int usb_endpoint_is_int_out(614 const struct usb_endpoint_descriptor *epd)615{616 return usb_endpoint_xfer_int(epd) && usb_endpoint_dir_out(epd);617}618 619/**620 * usb_endpoint_is_isoc_in - check if the endpoint is isochronous IN621 * @epd: endpoint to be checked622 *623 * Returns true if the endpoint has isochronous transfer type and IN direction,624 * otherwise it returns false.625 */626static inline int usb_endpoint_is_isoc_in(627 const struct usb_endpoint_descriptor *epd)628{629 return usb_endpoint_xfer_isoc(epd) && usb_endpoint_dir_in(epd);630}631 632/**633 * usb_endpoint_is_isoc_out - check if the endpoint is isochronous OUT634 * @epd: endpoint to be checked635 *636 * Returns true if the endpoint has isochronous transfer type and OUT direction,637 * otherwise it returns false.638 */639static inline int usb_endpoint_is_isoc_out(640 const struct usb_endpoint_descriptor *epd)641{642 return usb_endpoint_xfer_isoc(epd) && usb_endpoint_dir_out(epd);643}644 645/**646 * usb_endpoint_maxp - get endpoint's max packet size647 * @epd: endpoint to be checked648 *649 * Returns @epd's max packet bits [10:0]650 */651static inline int usb_endpoint_maxp(const struct usb_endpoint_descriptor *epd)652{653 return __le16_to_cpu(epd->wMaxPacketSize) & USB_ENDPOINT_MAXP_MASK;654}655 656/**657 * usb_endpoint_maxp_mult - get endpoint's transactional opportunities658 * @epd: endpoint to be checked659 *660 * Return @epd's wMaxPacketSize[12:11] + 1661 */662static inline int663usb_endpoint_maxp_mult(const struct usb_endpoint_descriptor *epd)664{665 int maxp = __le16_to_cpu(epd->wMaxPacketSize);666 667 return USB_EP_MAXP_MULT(maxp) + 1;668}669 670static inline int usb_endpoint_interrupt_type(671 const struct usb_endpoint_descriptor *epd)672{673 return epd->bmAttributes & USB_ENDPOINT_INTRTYPE;674}675 676/*-------------------------------------------------------------------------*/677 678/* USB_DT_SSP_ISOC_ENDPOINT_COMP: SuperSpeedPlus Isochronous Endpoint Companion679 * descriptor680 */681struct usb_ssp_isoc_ep_comp_descriptor {682 __u8 bLength;683 __u8 bDescriptorType;684 __le16 wReseved;685 __le32 dwBytesPerInterval;686} __attribute__ ((packed));687 688#define USB_DT_SSP_ISOC_EP_COMP_SIZE 8689 690/*-------------------------------------------------------------------------*/691 692/* USB_DT_SS_ENDPOINT_COMP: SuperSpeed Endpoint Companion descriptor */693struct usb_ss_ep_comp_descriptor {694 __u8 bLength;695 __u8 bDescriptorType;696 697 __u8 bMaxBurst;698 __u8 bmAttributes;699 __le16 wBytesPerInterval;700} __attribute__ ((packed));701 702#define USB_DT_SS_EP_COMP_SIZE 6703 704/* Bits 4:0 of bmAttributes if this is a bulk endpoint */705static inline int706usb_ss_max_streams(const struct usb_ss_ep_comp_descriptor *comp)707{708 int max_streams;709 710 if (!comp)711 return 0;712 713 max_streams = comp->bmAttributes & 0x1f;714 715 if (!max_streams)716 return 0;717 718 max_streams = 1 << max_streams;719 720 return max_streams;721}722 723/* Bits 1:0 of bmAttributes if this is an isoc endpoint */724#define USB_SS_MULT(p) (1 + ((p) & 0x3))725/* Bit 7 of bmAttributes if a SSP isoc endpoint companion descriptor exists */726#define USB_SS_SSP_ISOC_COMP(p) ((p) & (1 << 7))727 728/*-------------------------------------------------------------------------*/729 730/* USB_DT_DEVICE_QUALIFIER: Device Qualifier descriptor */731struct usb_qualifier_descriptor {732 __u8 bLength;733 __u8 bDescriptorType;734 735 __le16 bcdUSB;736 __u8 bDeviceClass;737 __u8 bDeviceSubClass;738 __u8 bDeviceProtocol;739 __u8 bMaxPacketSize0;740 __u8 bNumConfigurations;741 __u8 bRESERVED;742} __attribute__ ((packed));743 744 745/*-------------------------------------------------------------------------*/746 747/* USB_DT_OTG (from OTG 1.0a supplement) */748struct usb_otg_descriptor {749 __u8 bLength;750 __u8 bDescriptorType;751 752 __u8 bmAttributes; /* support for HNP, SRP, etc */753} __attribute__ ((packed));754 755/* USB_DT_OTG (from OTG 2.0 supplement) */756struct usb_otg20_descriptor {757 __u8 bLength;758 __u8 bDescriptorType;759 760 __u8 bmAttributes; /* support for HNP, SRP and ADP, etc */761 __le16 bcdOTG; /* OTG and EH supplement release number762 * in binary-coded decimal(i.e. 2.0 is 0200H)763 */764} __attribute__ ((packed));765 766/* from usb_otg_descriptor.bmAttributes */767#define USB_OTG_SRP (1 << 0)768#define USB_OTG_HNP (1 << 1) /* swap host/device roles */769#define USB_OTG_ADP (1 << 2) /* support ADP */770/* OTG 3.0 */771#define USB_OTG_RSP (1 << 3) /* support RSP */772 773#define OTG_STS_SELECTOR 0xF000 /* OTG status selector */774/*-------------------------------------------------------------------------*/775 776/* USB_DT_DEBUG: for special highspeed devices, replacing serial console */777struct usb_debug_descriptor {778 __u8 bLength;779 __u8 bDescriptorType;780 781 /* bulk endpoints with 8 byte maxpacket */782 __u8 bDebugInEndpoint;783 __u8 bDebugOutEndpoint;784} __attribute__((packed));785 786/*-------------------------------------------------------------------------*/787 788/* USB_DT_INTERFACE_ASSOCIATION: groups interfaces */789struct usb_interface_assoc_descriptor {790 __u8 bLength;791 __u8 bDescriptorType;792 793 __u8 bFirstInterface;794 __u8 bInterfaceCount;795 __u8 bFunctionClass;796 __u8 bFunctionSubClass;797 __u8 bFunctionProtocol;798 __u8 iFunction;799} __attribute__ ((packed));800 801#define USB_DT_INTERFACE_ASSOCIATION_SIZE 8802 803/*-------------------------------------------------------------------------*/804 805/* USB_DT_SECURITY: group of wireless security descriptors, including806 * encryption types available for setting up a CC/association.807 */808struct usb_security_descriptor {809 __u8 bLength;810 __u8 bDescriptorType;811 812 __le16 wTotalLength;813 __u8 bNumEncryptionTypes;814} __attribute__((packed));815 816/*-------------------------------------------------------------------------*/817 818/* USB_DT_KEY: used with {GET,SET}_SECURITY_DATA; only public keys819 * may be retrieved.820 */821struct usb_key_descriptor {822 __u8 bLength;823 __u8 bDescriptorType;824 825 __u8 tTKID[3];826 __u8 bReserved;827 __u8 bKeyData[];828} __attribute__((packed));829 830/*-------------------------------------------------------------------------*/831 832/* USB_DT_ENCRYPTION_TYPE: bundled in DT_SECURITY groups */833struct usb_encryption_descriptor {834 __u8 bLength;835 __u8 bDescriptorType;836 837 __u8 bEncryptionType;838#define USB_ENC_TYPE_UNSECURE 0839#define USB_ENC_TYPE_WIRED 1 /* non-wireless mode */840#define USB_ENC_TYPE_CCM_1 2 /* aes128/cbc session */841#define USB_ENC_TYPE_RSA_1 3 /* rsa3072/sha1 auth */842 __u8 bEncryptionValue; /* use in SET_ENCRYPTION */843 __u8 bAuthKeyIndex;844} __attribute__((packed));845 846 847/*-------------------------------------------------------------------------*/848 849/* USB_DT_BOS: group of device-level capabilities */850struct usb_bos_descriptor {851 __u8 bLength;852 __u8 bDescriptorType;853 854 __le16 wTotalLength;855 __u8 bNumDeviceCaps;856} __attribute__((packed));857 858#define USB_DT_BOS_SIZE 5859/*-------------------------------------------------------------------------*/860 861/* USB_DT_DEVICE_CAPABILITY: grouped with BOS */862struct usb_dev_cap_header {863 __u8 bLength;864 __u8 bDescriptorType;865 __u8 bDevCapabilityType;866} __attribute__((packed));867 868#define USB_CAP_TYPE_WIRELESS_USB 1869 870struct usb_wireless_cap_descriptor { /* Ultra Wide Band */871 __u8 bLength;872 __u8 bDescriptorType;873 __u8 bDevCapabilityType;874 875 __u8 bmAttributes;876#define USB_WIRELESS_P2P_DRD (1 << 1)877#define USB_WIRELESS_BEACON_MASK (3 << 2)878#define USB_WIRELESS_BEACON_SELF (1 << 2)879#define USB_WIRELESS_BEACON_DIRECTED (2 << 2)880#define USB_WIRELESS_BEACON_NONE (3 << 2)881 __le16 wPHYRates; /* bit rates, Mbps */882#define USB_WIRELESS_PHY_53 (1 << 0) /* always set */883#define USB_WIRELESS_PHY_80 (1 << 1)884#define USB_WIRELESS_PHY_107 (1 << 2) /* always set */885#define USB_WIRELESS_PHY_160 (1 << 3)886#define USB_WIRELESS_PHY_200 (1 << 4) /* always set */887#define USB_WIRELESS_PHY_320 (1 << 5)888#define USB_WIRELESS_PHY_400 (1 << 6)889#define USB_WIRELESS_PHY_480 (1 << 7)890 __u8 bmTFITXPowerInfo; /* TFI power levels */891 __u8 bmFFITXPowerInfo; /* FFI power levels */892 __le16 bmBandGroup;893 __u8 bReserved;894} __attribute__((packed));895 896#define USB_DT_USB_WIRELESS_CAP_SIZE 11897 898/* USB 2.0 Extension descriptor */899#define USB_CAP_TYPE_EXT 2900 901struct usb_ext_cap_descriptor { /* Link Power Management */902 __u8 bLength;903 __u8 bDescriptorType;904 __u8 bDevCapabilityType;905 __le32 bmAttributes;906#define USB_LPM_SUPPORT (1 << 1) /* supports LPM */907#define USB_BESL_SUPPORT (1 << 2) /* supports BESL */908#define USB_BESL_BASELINE_VALID (1 << 3) /* Baseline BESL valid*/909#define USB_BESL_DEEP_VALID (1 << 4) /* Deep BESL valid */910#define USB_SET_BESL_BASELINE(p) (((p) & 0xf) << 8)911#define USB_SET_BESL_DEEP(p) (((p) & 0xf) << 12)912#define USB_GET_BESL_BASELINE(p) (((p) & (0xf << 8)) >> 8)913#define USB_GET_BESL_DEEP(p) (((p) & (0xf << 12)) >> 12)914} __attribute__((packed));915 916#define USB_DT_USB_EXT_CAP_SIZE 7917 918/*919 * SuperSpeed USB Capability descriptor: Defines the set of SuperSpeed USB920 * specific device level capabilities921 */922#define USB_SS_CAP_TYPE 3923struct usb_ss_cap_descriptor { /* Link Power Management */924 __u8 bLength;925 __u8 bDescriptorType;926 __u8 bDevCapabilityType;927 __u8 bmAttributes;928#define USB_LTM_SUPPORT (1 << 1) /* supports LTM */929 __le16 wSpeedSupported;930#define USB_LOW_SPEED_OPERATION (1) /* Low speed operation */931#define USB_FULL_SPEED_OPERATION (1 << 1) /* Full speed operation */932#define USB_HIGH_SPEED_OPERATION (1 << 2) /* High speed operation */933#define USB_5GBPS_OPERATION (1 << 3) /* Operation at 5Gbps */934 __u8 bFunctionalitySupport;935 __u8 bU1devExitLat;936 __le16 bU2DevExitLat;937} __attribute__((packed));938 939#define USB_DT_USB_SS_CAP_SIZE 10940 941/*942 * Container ID Capability descriptor: Defines the instance unique ID used to943 * identify the instance across all operating modes944 */945#define CONTAINER_ID_TYPE 4946struct usb_ss_container_id_descriptor {947 __u8 bLength;948 __u8 bDescriptorType;949 __u8 bDevCapabilityType;950 __u8 bReserved;951 __u8 ContainerID[16]; /* 128-bit number */952} __attribute__((packed));953 954#define USB_DT_USB_SS_CONTN_ID_SIZE 20955 956/*957 * Platform Device Capability descriptor: Defines platform specific device958 * capabilities959 */960#define USB_PLAT_DEV_CAP_TYPE 5961struct usb_plat_dev_cap_descriptor {962 __u8 bLength;963 __u8 bDescriptorType;964 __u8 bDevCapabilityType;965 __u8 bReserved;966 __u8 UUID[16];967 __u8 CapabilityData[];968} __attribute__((packed));969 970#define USB_DT_USB_PLAT_DEV_CAP_SIZE(capability_data_size) (20 + capability_data_size)971 972/*973 * SuperSpeed Plus USB Capability descriptor: Defines the set of974 * SuperSpeed Plus USB specific device level capabilities975 */976#define USB_SSP_CAP_TYPE 0xa977struct usb_ssp_cap_descriptor {978 __u8 bLength;979 __u8 bDescriptorType;980 __u8 bDevCapabilityType;981 __u8 bReserved;982 __le32 bmAttributes;983#define USB_SSP_SUBLINK_SPEED_ATTRIBS (0x1f << 0) /* sublink speed entries */984#define USB_SSP_SUBLINK_SPEED_IDS (0xf << 5) /* speed ID entries */985 __le16 wFunctionalitySupport;986#define USB_SSP_MIN_SUBLINK_SPEED_ATTRIBUTE_ID (0xf)987#define USB_SSP_MIN_RX_LANE_COUNT (0xf << 8)988#define USB_SSP_MIN_TX_LANE_COUNT (0xf << 12)989 __le16 wReserved;990 union {991 __le32 legacy_padding;992 /* list of sublink speed attrib entries */993 __DECLARE_FLEX_ARRAY(__le32, bmSublinkSpeedAttr);994 };995#define USB_SSP_SUBLINK_SPEED_SSID (0xf) /* sublink speed ID */996#define USB_SSP_SUBLINK_SPEED_LSE (0x3 << 4) /* Lanespeed exponent */997#define USB_SSP_SUBLINK_SPEED_LSE_BPS 0998#define USB_SSP_SUBLINK_SPEED_LSE_KBPS 1999#define USB_SSP_SUBLINK_SPEED_LSE_MBPS 21000#define USB_SSP_SUBLINK_SPEED_LSE_GBPS 31001 1002#define USB_SSP_SUBLINK_SPEED_ST (0x3 << 6) /* Sublink type */1003#define USB_SSP_SUBLINK_SPEED_ST_SYM_RX 01004#define USB_SSP_SUBLINK_SPEED_ST_ASYM_RX 11005#define USB_SSP_SUBLINK_SPEED_ST_SYM_TX 21006#define USB_SSP_SUBLINK_SPEED_ST_ASYM_TX 31007 1008#define USB_SSP_SUBLINK_SPEED_RSVD (0x3f << 8) /* Reserved */1009#define USB_SSP_SUBLINK_SPEED_LP (0x3 << 14) /* Link protocol */1010#define USB_SSP_SUBLINK_SPEED_LP_SS 01011#define USB_SSP_SUBLINK_SPEED_LP_SSP 11012 1013#define USB_SSP_SUBLINK_SPEED_LSM (0xff << 16) /* Lanespeed mantissa */1014} __attribute__((packed));1015 1016/*1017 * USB Power Delivery Capability Descriptor:1018 * Defines capabilities for PD1019 */1020/* Defines the various PD Capabilities of this device */1021#define USB_PD_POWER_DELIVERY_CAPABILITY 0x061022/* Provides information on each battery supported by the device */1023#define USB_PD_BATTERY_INFO_CAPABILITY 0x071024/* The Consumer characteristics of a Port on the device */1025#define USB_PD_PD_CONSUMER_PORT_CAPABILITY 0x081026/* The provider characteristics of a Port on the device */1027#define USB_PD_PD_PROVIDER_PORT_CAPABILITY 0x091028 1029struct usb_pd_cap_descriptor {1030 __u8 bLength;1031 __u8 bDescriptorType;1032 __u8 bDevCapabilityType; /* set to USB_PD_POWER_DELIVERY_CAPABILITY */1033 __u8 bReserved;1034 __le32 bmAttributes;1035#define USB_PD_CAP_BATTERY_CHARGING (1 << 1) /* supports Battery Charging specification */1036#define USB_PD_CAP_USB_PD (1 << 2) /* supports USB Power Delivery specification */1037#define USB_PD_CAP_PROVIDER (1 << 3) /* can provide power */1038#define USB_PD_CAP_CONSUMER (1 << 4) /* can consume power */1039#define USB_PD_CAP_CHARGING_POLICY (1 << 5) /* supports CHARGING_POLICY feature */1040#define USB_PD_CAP_TYPE_C_CURRENT (1 << 6) /* supports power capabilities defined in the USB Type-C Specification */1041 1042#define USB_PD_CAP_PWR_AC (1 << 8)1043#define USB_PD_CAP_PWR_BAT (1 << 9)1044#define USB_PD_CAP_PWR_USE_V_BUS (1 << 14)1045 1046 __le16 bmProviderPorts; /* Bit zero refers to the UFP of the device */1047 __le16 bmConsumerPorts;1048 __le16 bcdBCVersion;1049 __le16 bcdPDVersion;1050 __le16 bcdUSBTypeCVersion;1051} __attribute__((packed));1052 1053struct usb_pd_cap_battery_info_descriptor {1054 __u8 bLength;1055 __u8 bDescriptorType;1056 __u8 bDevCapabilityType;1057 /* Index of string descriptor shall contain the user friendly name for this battery */1058 __u8 iBattery;1059 /* Index of string descriptor shall contain the Serial Number String for this battery */1060 __u8 iSerial;1061 __u8 iManufacturer;1062 __u8 bBatteryId; /* uniquely identifies this battery in status Messages */1063 __u8 bReserved;1064 /*1065 * Shall contain the Battery Charge value above which this1066 * battery is considered to be fully charged but not necessarily1067 * “topped off.”1068 */1069 __le32 dwChargedThreshold; /* in mWh */1070 /*1071 * Shall contain the minimum charge level of this battery such1072 * that above this threshold, a device can be assured of being1073 * able to power up successfully (see Battery Charging 1.2).1074 */1075 __le32 dwWeakThreshold; /* in mWh */1076 __le32 dwBatteryDesignCapacity; /* in mWh */1077 __le32 dwBatteryLastFullchargeCapacity; /* in mWh */1078} __attribute__((packed));1079 1080struct usb_pd_cap_consumer_port_descriptor {1081 __u8 bLength;1082 __u8 bDescriptorType;1083 __u8 bDevCapabilityType;1084 __u8 bReserved;1085 __u8 bmCapabilities;1086/* port will oerate under: */1087#define USB_PD_CAP_CONSUMER_BC (1 << 0) /* BC */1088#define USB_PD_CAP_CONSUMER_PD (1 << 1) /* PD */1089#define USB_PD_CAP_CONSUMER_TYPE_C (1 << 2) /* USB Type-C Current */1090 __le16 wMinVoltage; /* in 50mV units */1091 __le16 wMaxVoltage; /* in 50mV units */1092 __u16 wReserved;1093 __le32 dwMaxOperatingPower; /* in 10 mW - operating at steady state */1094 __le32 dwMaxPeakPower; /* in 10mW units - operating at peak power */1095 __le32 dwMaxPeakPowerTime; /* in 100ms units - duration of peak */1096#define USB_PD_CAP_CONSUMER_UNKNOWN_PEAK_POWER_TIME 0xffff1097} __attribute__((packed));1098 1099struct usb_pd_cap_provider_port_descriptor {1100 __u8 bLength;1101 __u8 bDescriptorType;1102 __u8 bDevCapabilityType;1103 __u8 bReserved1;1104 __u8 bmCapabilities;1105/* port will oerate under: */1106#define USB_PD_CAP_PROVIDER_BC (1 << 0) /* BC */1107#define USB_PD_CAP_PROVIDER_PD (1 << 1) /* PD */1108#define USB_PD_CAP_PROVIDER_TYPE_C (1 << 2) /* USB Type-C Current */1109 __u8 bNumOfPDObjects;1110 __u8 bReserved2;1111 __le32 wPowerDataObject[];1112} __attribute__((packed));1113 1114/*1115 * Precision time measurement capability descriptor: advertised by devices and1116 * hubs that support PTM1117 */1118#define USB_PTM_CAP_TYPE 0xb1119struct usb_ptm_cap_descriptor {1120 __u8 bLength;1121 __u8 bDescriptorType;1122 __u8 bDevCapabilityType;1123} __attribute__((packed));1124 1125#define USB_DT_USB_PTM_ID_SIZE 31126/*1127 * The size of the descriptor for the Sublink Speed Attribute Count1128 * (SSAC) specified in bmAttributes[4:0]. SSAC is zero-based1129 */1130#define USB_DT_USB_SSP_CAP_SIZE(ssac) (12 + (ssac + 1) * 4)1131 1132/*-------------------------------------------------------------------------*/1133 1134/* USB_DT_WIRELESS_ENDPOINT_COMP: companion descriptor associated with1135 * each endpoint descriptor for a wireless device1136 */1137struct usb_wireless_ep_comp_descriptor {1138 __u8 bLength;1139 __u8 bDescriptorType;1140 1141 __u8 bMaxBurst;1142 __u8 bMaxSequence;1143 __le16 wMaxStreamDelay;1144 __le16 wOverTheAirPacketSize;1145 __u8 bOverTheAirInterval;1146 __u8 bmCompAttributes;1147#define USB_ENDPOINT_SWITCH_MASK 0x03 /* in bmCompAttributes */1148#define USB_ENDPOINT_SWITCH_NO 01149#define USB_ENDPOINT_SWITCH_SWITCH 11150#define USB_ENDPOINT_SWITCH_SCALE 21151} __attribute__((packed));1152 1153/*-------------------------------------------------------------------------*/1154 1155/* USB_REQ_SET_HANDSHAKE is a four-way handshake used between a wireless1156 * host and a device for connection set up, mutual authentication, and1157 * exchanging short lived session keys. The handshake depends on a CC.1158 */1159struct usb_handshake {1160 __u8 bMessageNumber;1161 __u8 bStatus;1162 __u8 tTKID[3];1163 __u8 bReserved;1164 __u8 CDID[16];1165 __u8 nonce[16];1166 __u8 MIC[8];1167} __attribute__((packed));1168 1169/*-------------------------------------------------------------------------*/1170 1171/* USB_REQ_SET_CONNECTION modifies or revokes a connection context (CC).1172 * A CC may also be set up using non-wireless secure channels (including1173 * wired USB!), and some devices may support CCs with multiple hosts.1174 */1175struct usb_connection_context {1176 __u8 CHID[16]; /* persistent host id */1177 __u8 CDID[16]; /* device id (unique w/in host context) */1178 __u8 CK[16]; /* connection key */1179} __attribute__((packed));1180 1181/*-------------------------------------------------------------------------*/1182 1183/* USB 2.0 defines three speeds, here's how Linux identifies them */1184 1185enum usb_device_speed {1186 USB_SPEED_UNKNOWN = 0, /* enumerating */1187 USB_SPEED_LOW, USB_SPEED_FULL, /* usb 1.1 */1188 USB_SPEED_HIGH, /* usb 2.0 */1189 USB_SPEED_WIRELESS, /* wireless (usb 2.5) */1190 USB_SPEED_SUPER, /* usb 3.0 */1191 USB_SPEED_SUPER_PLUS, /* usb 3.1 */1192};1193 1194 1195enum usb_device_state {1196 /* NOTATTACHED isn't in the USB spec, and this state acts1197 * the same as ATTACHED ... but it's clearer this way.1198 */1199 USB_STATE_NOTATTACHED = 0,1200 1201 /* chapter 9 and authentication (wireless) device states */1202 USB_STATE_ATTACHED,1203 USB_STATE_POWERED, /* wired */1204 USB_STATE_RECONNECTING, /* auth */1205 USB_STATE_UNAUTHENTICATED, /* auth */1206 USB_STATE_DEFAULT, /* limited function */1207 USB_STATE_ADDRESS,1208 USB_STATE_CONFIGURED, /* most functions */1209 1210 USB_STATE_SUSPENDED1211 1212 /* NOTE: there are actually four different SUSPENDED1213 * states, returning to POWERED, DEFAULT, ADDRESS, or1214 * CONFIGURED respectively when SOF tokens flow again.1215 * At this level there's no difference between L1 and L21216 * suspend states. (L2 being original USB 1.1 suspend.)1217 */1218};1219 1220enum usb3_link_state {1221 USB3_LPM_U0 = 0,1222 USB3_LPM_U1,1223 USB3_LPM_U2,1224 USB3_LPM_U31225};1226 1227/*1228 * A U1 timeout of 0x0 means the parent hub will reject any transitions to U1.1229 * 0xff means the parent hub will accept transitions to U1, but will not1230 * initiate a transition.1231 *1232 * A U1 timeout of 0x1 to 0x7F also causes the hub to initiate a transition to1233 * U1 after that many microseconds. Timeouts of 0x80 to 0xFE are reserved1234 * values.1235 *1236 * A U2 timeout of 0x0 means the parent hub will reject any transitions to U2.1237 * 0xff means the parent hub will accept transitions to U2, but will not1238 * initiate a transition.1239 *1240 * A U2 timeout of 0x1 to 0xFE also causes the hub to initiate a transition to1241 * U2 after N*256 microseconds. Therefore a U2 timeout value of 0x1 means a U21242 * idle timer of 256 microseconds, 0x2 means 512 microseconds, 0xFE means1243 * 65.024ms.1244 */1245#define USB3_LPM_DISABLED 0x01246#define USB3_LPM_U1_MAX_TIMEOUT 0x7F1247#define USB3_LPM_U2_MAX_TIMEOUT 0xFE1248#define USB3_LPM_DEVICE_INITIATED 0xFF1249 1250struct usb_set_sel_req {1251 __u8 u1_sel;1252 __u8 u1_pel;1253 __le16 u2_sel;1254 __le16 u2_pel;1255} __attribute__ ((packed));1256 1257/*1258 * The Set System Exit Latency control transfer provides one byte each for1259 * U1 SEL and U1 PEL, so the max exit latency is 0xFF. U2 SEL and U2 PEL each1260 * are two bytes long.1261 */1262#define USB3_LPM_MAX_U1_SEL_PEL 0xFF1263#define USB3_LPM_MAX_U2_SEL_PEL 0xFFFF1264 1265/*-------------------------------------------------------------------------*/1266 1267/*1268 * As per USB compliance update, a device that is actively drawing1269 * more than 100mA from USB must report itself as bus-powered in1270 * the GetStatus(DEVICE) call.1271 * https://compliance.usb.org/index.asp?UpdateFile=Electrical&Format=Standard#341272 */1273#define USB_SELF_POWER_VBUS_MAX_DRAW 1001274 1275#endif /* _UAPI__LINUX_USB_CH9_H */1276