cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

ch9.h (39491B)


      1/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
      2/*
      3 * This file holds USB constants and structures that are needed for
      4 * USB device APIs.  These are used by the USB device model, which is
      5 * defined in chapter 9 of the USB 2.0 specification and in the
      6 * Wireless USB 1.0 (spread around).  Linux has several APIs in C that
      7 * need these:
      8 *
      9 * - the master/host side Linux-USB kernel driver API;
     10 * - the "usbfs" user space API; and
     11 * - the Linux "gadget" slave/device/peripheral side driver API.
     12 *
     13 * USB 2.0 adds an additional "On The Go" (OTG) mode, which lets systems
     14 * act either as a USB master/host or as a USB slave/device.  That means
     15 * the master and slave side APIs benefit from working well together.
     16 *
     17 * There's also "Wireless USB", using low power short range radios for
     18 * peripheral interconnection but otherwise building on the USB framework.
     19 *
     20 * Note all descriptors are declared '__attribute__((packed))' so that:
     21 *
     22 * [a] they never get padded, either internally (USB spec writers
     23 *     probably handled that) or externally;
     24 *
     25 * [b] so that accessing bigger-than-a-bytes fields will never
     26 *     generate bus errors on any platform, even when the location of
     27 *     its descriptor inside a bundle isn't "naturally aligned", and
     28 *
     29 * [c] for consistency, removing all doubt even when it appears to
     30 *     someone that the two other points are non-issues for that
     31 *     particular descriptor type.
     32 */
     33
     34#ifndef _UAPI__LINUX_USB_CH9_H
     35#define _UAPI__LINUX_USB_CH9_H
     36
     37#include <linux/types.h>	/* __u8 etc */
     38#include <asm/byteorder.h>	/* le16_to_cpu */
     39
     40/*-------------------------------------------------------------------------*/
     41
     42/* CONTROL REQUEST SUPPORT */
     43
     44/*
     45 * USB directions
     46 *
     47 * This bit flag is used in endpoint descriptors' bEndpointAddress field.
     48 * It's also one of three fields in control requests bRequestType.
     49 */
     50#define USB_DIR_OUT			0		/* to device */
     51#define USB_DIR_IN			0x80		/* to host */
     52
     53/*
     54 * USB types, the second of three bRequestType fields
     55 */
     56#define USB_TYPE_MASK			(0x03 << 5)
     57#define USB_TYPE_STANDARD		(0x00 << 5)
     58#define USB_TYPE_CLASS			(0x01 << 5)
     59#define USB_TYPE_VENDOR			(0x02 << 5)
     60#define USB_TYPE_RESERVED		(0x03 << 5)
     61
     62/*
     63 * USB recipients, the third of three bRequestType fields
     64 */
     65#define USB_RECIP_MASK			0x1f
     66#define USB_RECIP_DEVICE		0x00
     67#define USB_RECIP_INTERFACE		0x01
     68#define USB_RECIP_ENDPOINT		0x02
     69#define USB_RECIP_OTHER			0x03
     70/* From Wireless USB 1.0 */
     71#define USB_RECIP_PORT			0x04
     72#define USB_RECIP_RPIPE		0x05
     73
     74/*
     75 * Standard requests, for the bRequest field of a SETUP packet.
     76 *
     77 * These are qualified by the bRequestType field, so that for example
     78 * TYPE_CLASS or TYPE_VENDOR specific feature flags could be retrieved
     79 * by a GET_STATUS request.
     80 */
     81#define USB_REQ_GET_STATUS		0x00
     82#define USB_REQ_CLEAR_FEATURE		0x01
     83#define USB_REQ_SET_FEATURE		0x03
     84#define USB_REQ_SET_ADDRESS		0x05
     85#define USB_REQ_GET_DESCRIPTOR		0x06
     86#define USB_REQ_SET_DESCRIPTOR		0x07
     87#define USB_REQ_GET_CONFIGURATION	0x08
     88#define USB_REQ_SET_CONFIGURATION	0x09
     89#define USB_REQ_GET_INTERFACE		0x0A
     90#define USB_REQ_SET_INTERFACE		0x0B
     91#define USB_REQ_SYNCH_FRAME		0x0C
     92#define USB_REQ_SET_SEL			0x30
     93#define USB_REQ_SET_ISOCH_DELAY		0x31
     94
     95#define USB_REQ_SET_ENCRYPTION		0x0D	/* Wireless USB */
     96#define USB_REQ_GET_ENCRYPTION		0x0E
     97#define USB_REQ_RPIPE_ABORT		0x0E
     98#define USB_REQ_SET_HANDSHAKE		0x0F
     99#define USB_REQ_RPIPE_RESET		0x0F
    100#define USB_REQ_GET_HANDSHAKE		0x10
    101#define USB_REQ_SET_CONNECTION		0x11
    102#define USB_REQ_SET_SECURITY_DATA	0x12
    103#define USB_REQ_GET_SECURITY_DATA	0x13
    104#define USB_REQ_SET_WUSB_DATA		0x14
    105#define USB_REQ_LOOPBACK_DATA_WRITE	0x15
    106#define USB_REQ_LOOPBACK_DATA_READ	0x16
    107#define USB_REQ_SET_INTERFACE_DS	0x17
    108
    109/* specific requests for USB Power Delivery */
    110#define USB_REQ_GET_PARTNER_PDO		20
    111#define USB_REQ_GET_BATTERY_STATUS	21
    112#define USB_REQ_SET_PDO			22
    113#define USB_REQ_GET_VDM			23
    114#define USB_REQ_SEND_VDM		24
    115
    116/* The Link Power Management (LPM) ECN defines USB_REQ_TEST_AND_SET command,
    117 * used by hubs to put ports into a new L1 suspend state, except that it
    118 * forgot to define its number ...
    119 */
    120
    121/*
    122 * USB feature flags are written using USB_REQ_{CLEAR,SET}_FEATURE, and
    123 * are read as a bit array returned by USB_REQ_GET_STATUS.  (So there
    124 * are at most sixteen features of each type.)  Hubs may also support a
    125 * new USB_REQ_TEST_AND_SET_FEATURE to put ports into L1 suspend.
    126 */
    127#define USB_DEVICE_SELF_POWERED		0	/* (read only) */
    128#define USB_DEVICE_REMOTE_WAKEUP	1	/* dev may initiate wakeup */
    129#define USB_DEVICE_TEST_MODE		2	/* (wired high speed only) */
    130#define USB_DEVICE_BATTERY		2	/* (wireless) */
    131#define USB_DEVICE_B_HNP_ENABLE		3	/* (otg) dev may initiate HNP */
    132#define USB_DEVICE_WUSB_DEVICE		3	/* (wireless)*/
    133#define USB_DEVICE_A_HNP_SUPPORT	4	/* (otg) RH port supports HNP */
    134#define USB_DEVICE_A_ALT_HNP_SUPPORT	5	/* (otg) other RH port does */
    135#define USB_DEVICE_DEBUG_MODE		6	/* (special devices only) */
    136
    137/*
    138 * Test Mode Selectors
    139 * See USB 2.0 spec Table 9-7
    140 */
    141#define	USB_TEST_J		1
    142#define	USB_TEST_K		2
    143#define	USB_TEST_SE0_NAK	3
    144#define	USB_TEST_PACKET		4
    145#define	USB_TEST_FORCE_ENABLE	5
    146
    147/* Status Type */
    148#define USB_STATUS_TYPE_STANDARD	0
    149#define USB_STATUS_TYPE_PTM		1
    150
    151/*
    152 * New Feature Selectors as added by USB 3.0
    153 * See USB 3.0 spec Table 9-7
    154 */
    155#define USB_DEVICE_U1_ENABLE	48	/* dev may initiate U1 transition */
    156#define USB_DEVICE_U2_ENABLE	49	/* dev may initiate U2 transition */
    157#define USB_DEVICE_LTM_ENABLE	50	/* dev may send LTM */
    158#define USB_INTRF_FUNC_SUSPEND	0	/* function suspend */
    159
    160#define USB_INTR_FUNC_SUSPEND_OPT_MASK	0xFF00
    161/*
    162 * Suspend Options, Table 9-8 USB 3.0 spec
    163 */
    164#define USB_INTRF_FUNC_SUSPEND_LP	(1 << (8 + 0))
    165#define USB_INTRF_FUNC_SUSPEND_RW	(1 << (8 + 1))
    166
    167/*
    168 * Interface status, Figure 9-5 USB 3.0 spec
    169 */
    170#define USB_INTRF_STAT_FUNC_RW_CAP     1
    171#define USB_INTRF_STAT_FUNC_RW         2
    172
    173#define USB_ENDPOINT_HALT		0	/* IN/OUT will STALL */
    174
    175/* Bit array elements as returned by the USB_REQ_GET_STATUS request. */
    176#define USB_DEV_STAT_U1_ENABLED		2	/* transition into U1 state */
    177#define USB_DEV_STAT_U2_ENABLED		3	/* transition into U2 state */
    178#define USB_DEV_STAT_LTM_ENABLED	4	/* Latency tolerance messages */
    179
    180/*
    181 * Feature selectors from Table 9-8 USB Power Delivery spec
    182 */
    183#define USB_DEVICE_BATTERY_WAKE_MASK	40
    184#define USB_DEVICE_OS_IS_PD_AWARE	41
    185#define USB_DEVICE_POLICY_MODE		42
    186#define USB_PORT_PR_SWAP		43
    187#define USB_PORT_GOTO_MIN		44
    188#define USB_PORT_RETURN_POWER		45
    189#define USB_PORT_ACCEPT_PD_REQUEST	46
    190#define USB_PORT_REJECT_PD_REQUEST	47
    191#define USB_PORT_PORT_PD_RESET		48
    192#define USB_PORT_C_PORT_PD_CHANGE	49
    193#define USB_PORT_CABLE_PD_RESET		50
    194#define USB_DEVICE_CHARGING_POLICY	54
    195
    196/**
    197 * struct usb_ctrlrequest - SETUP data for a USB device control request
    198 * @bRequestType: matches the USB bmRequestType field
    199 * @bRequest: matches the USB bRequest field
    200 * @wValue: matches the USB wValue field (le16 byte order)
    201 * @wIndex: matches the USB wIndex field (le16 byte order)
    202 * @wLength: matches the USB wLength field (le16 byte order)
    203 *
    204 * This structure is used to send control requests to a USB device.  It matches
    205 * the different fields of the USB 2.0 Spec section 9.3, table 9-2.  See the
    206 * USB spec for a fuller description of the different fields, and what they are
    207 * used for.
    208 *
    209 * Note that the driver for any interface can issue control requests.
    210 * For most devices, interfaces don't coordinate with each other, so
    211 * such requests may be made at any time.
    212 */
    213struct usb_ctrlrequest {
    214	__u8 bRequestType;
    215	__u8 bRequest;
    216	__le16 wValue;
    217	__le16 wIndex;
    218	__le16 wLength;
    219} __attribute__ ((packed));
    220
    221/*-------------------------------------------------------------------------*/
    222
    223/*
    224 * STANDARD DESCRIPTORS ... as returned by GET_DESCRIPTOR, or
    225 * (rarely) accepted by SET_DESCRIPTOR.
    226 *
    227 * Note that all multi-byte values here are encoded in little endian
    228 * byte order "on the wire".  Within the kernel and when exposed
    229 * through the Linux-USB APIs, they are not converted to cpu byte
    230 * order; it is the responsibility of the client code to do this.
    231 * The single exception is when device and configuration descriptors (but
    232 * not other descriptors) are read from character devices
    233 * (i.e. /dev/bus/usb/BBB/DDD);
    234 * in this case the fields are converted to host endianness by the kernel.
    235 */
    236
    237/*
    238 * Descriptor types ... USB 2.0 spec table 9.5
    239 */
    240#define USB_DT_DEVICE			0x01
    241#define USB_DT_CONFIG			0x02
    242#define USB_DT_STRING			0x03
    243#define USB_DT_INTERFACE		0x04
    244#define USB_DT_ENDPOINT			0x05
    245#define USB_DT_DEVICE_QUALIFIER		0x06
    246#define USB_DT_OTHER_SPEED_CONFIG	0x07
    247#define USB_DT_INTERFACE_POWER		0x08
    248/* these are from a minor usb 2.0 revision (ECN) */
    249#define USB_DT_OTG			0x09
    250#define USB_DT_DEBUG			0x0a
    251#define USB_DT_INTERFACE_ASSOCIATION	0x0b
    252/* these are from the Wireless USB spec */
    253#define USB_DT_SECURITY			0x0c
    254#define USB_DT_KEY			0x0d
    255#define USB_DT_ENCRYPTION_TYPE		0x0e
    256#define USB_DT_BOS			0x0f
    257#define USB_DT_DEVICE_CAPABILITY	0x10
    258#define USB_DT_WIRELESS_ENDPOINT_COMP	0x11
    259#define USB_DT_WIRE_ADAPTER		0x21
    260#define USB_DT_RPIPE			0x22
    261#define USB_DT_CS_RADIO_CONTROL		0x23
    262/* From the T10 UAS specification */
    263#define USB_DT_PIPE_USAGE		0x24
    264/* From the USB 3.0 spec */
    265#define	USB_DT_SS_ENDPOINT_COMP		0x30
    266/* From the USB 3.1 spec */
    267#define	USB_DT_SSP_ISOC_ENDPOINT_COMP	0x31
    268
    269/* Conventional codes for class-specific descriptors.  The convention is
    270 * defined in the USB "Common Class" Spec (3.11).  Individual class specs
    271 * 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		18
    308
    309
    310/*
    311 * Device and/or Interface Class codes
    312 * as found in bDeviceClass or bInterfaceClass
    313 * and defined by www.usb.org documents
    314 */
    315#define USB_CLASS_PER_INTERFACE		0	/* for DeviceClass */
    316#define USB_CLASS_AUDIO			1
    317#define USB_CLASS_COMM			2
    318#define USB_CLASS_HID			3
    319#define USB_CLASS_PHYSICAL		5
    320#define USB_CLASS_STILL_IMAGE		6
    321#define USB_CLASS_PRINTER		7
    322#define USB_CLASS_MASS_STORAGE		8
    323#define USB_CLASS_HUB			9
    324#define USB_CLASS_CDC_DATA		0x0a
    325#define USB_CLASS_CSCID			0x0b	/* chip+ smart card */
    326#define USB_CLASS_CONTENT_SEC		0x0d	/* content security */
    327#define USB_CLASS_VIDEO			0x0e
    328#define USB_CLASS_WIRELESS_CONTROLLER	0xe0
    329#define USB_CLASS_PERSONAL_HEALTHCARE	0x0f
    330#define USB_CLASS_AUDIO_VIDEO		0x10
    331#define USB_CLASS_BILLBOARD		0x11
    332#define USB_CLASS_USB_TYPE_C_BRIDGE	0x12
    333#define USB_CLASS_MISC			0xef
    334#define USB_CLASS_APP_SPEC		0xfe
    335#define USB_CLASS_VENDOR_SPEC		0xff
    336
    337#define USB_SUBCLASS_VENDOR_SPEC	0xff
    338
    339/*-------------------------------------------------------------------------*/
    340
    341/* USB_DT_CONFIG: Configuration descriptor information.
    342 *
    343 * USB_DT_OTHER_SPEED_CONFIG is the same descriptor, except that the
    344 * descriptor type is different.  Highspeed-capable devices can look
    345 * different depending on what speed they're currently running.  Only
    346 * devices with a USB_DT_DEVICE_QUALIFIER have any OTHER_SPEED_CONFIG
    347 * descriptors.
    348 */
    349struct usb_config_descriptor {
    350	__u8  bLength;
    351	__u8  bDescriptorType;
    352
    353	__le16 wTotalLength;
    354	__u8  bNumInterfaces;
    355	__u8  bConfigurationValue;
    356	__u8  iConfiguration;
    357	__u8  bmAttributes;
    358	__u8  bMaxPower;
    359} __attribute__ ((packed));
    360
    361#define USB_DT_CONFIG_SIZE		9
    362
    363/* from config descriptor bmAttributes */
    364#define USB_CONFIG_ATT_ONE		(1 << 7)	/* must be set */
    365#define USB_CONFIG_ATT_SELFPOWER	(1 << 6)	/* self powered */
    366#define USB_CONFIG_ATT_WAKEUP		(1 << 5)	/* can wakeup */
    367#define USB_CONFIG_ATT_BATTERY		(1 << 4)	/* battery powered */
    368
    369/*-------------------------------------------------------------------------*/
    370
    371/* USB String descriptors can contain at most 126 characters. */
    372#define USB_MAX_STRING_LEN	126
    373
    374/* USB_DT_STRING: String descriptor */
    375struct usb_string_descriptor {
    376	__u8  bLength;
    377	__u8  bDescriptorType;
    378
    379	__le16 wData[1];		/* UTF-16LE encoded */
    380} __attribute__ ((packed));
    381
    382/* note that "string" zero is special, it holds language codes that
    383 * the device supports, not Unicode characters.
    384 */
    385
    386/*-------------------------------------------------------------------------*/
    387
    388/* USB_DT_INTERFACE: Interface descriptor */
    389struct usb_interface_descriptor {
    390	__u8  bLength;
    391	__u8  bDescriptorType;
    392
    393	__u8  bInterfaceNumber;
    394	__u8  bAlternateSetting;
    395	__u8  bNumEndpoints;
    396	__u8  bInterfaceClass;
    397	__u8  bInterfaceSubClass;
    398	__u8  bInterfaceProtocol;
    399	__u8  iInterface;
    400} __attribute__ ((packed));
    401
    402#define USB_DT_INTERFACE_SIZE		9
    403
    404/*-------------------------------------------------------------------------*/
    405
    406/* USB_DT_ENDPOINT: Endpoint descriptor */
    407struct usb_endpoint_descriptor {
    408	__u8  bLength;
    409	__u8  bDescriptorType;
    410
    411	__u8  bEndpointAddress;
    412	__u8  bmAttributes;
    413	__le16 wMaxPacketSize;
    414	__u8  bInterval;
    415
    416	/* NOTE:  these two are _only_ in audio endpoints. */
    417	/* use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof. */
    418	__u8  bRefresh;
    419	__u8  bSynchAddress;
    420} __attribute__ ((packed));
    421
    422#define USB_DT_ENDPOINT_SIZE		7
    423#define USB_DT_ENDPOINT_AUDIO_SIZE	9	/* Audio extension */
    424
    425
    426/*
    427 * Endpoints
    428 */
    429#define USB_ENDPOINT_NUMBER_MASK	0x0f	/* in bEndpointAddress */
    430#define USB_ENDPOINT_DIR_MASK		0x80
    431
    432#define USB_ENDPOINT_XFERTYPE_MASK	0x03	/* in bmAttributes */
    433#define USB_ENDPOINT_XFER_CONTROL	0
    434#define USB_ENDPOINT_XFER_ISOC		1
    435#define USB_ENDPOINT_XFER_BULK		2
    436#define USB_ENDPOINT_XFER_INT		3
    437#define USB_ENDPOINT_MAX_ADJUSTABLE	0x80
    438
    439#define USB_ENDPOINT_MAXP_MASK	0x07ff
    440#define USB_EP_MAXP_MULT_SHIFT	11
    441#define USB_EP_MAXP_MULT_MASK	(3 << USB_EP_MAXP_MULT_SHIFT)
    442#define USB_EP_MAXP_MULT(m) \
    443	(((m) & USB_EP_MAXP_MULT_MASK) >> USB_EP_MAXP_MULT_SHIFT)
    444
    445/* The USB 3.0 spec redefines bits 5:4 of bmAttributes as interrupt ep type. */
    446#define USB_ENDPOINT_INTRTYPE		0x30
    447#define USB_ENDPOINT_INTR_PERIODIC	(0 << 4)
    448#define USB_ENDPOINT_INTR_NOTIFICATION	(1 << 4)
    449
    450#define USB_ENDPOINT_SYNCTYPE		0x0c
    451#define USB_ENDPOINT_SYNC_NONE		(0 << 2)
    452#define USB_ENDPOINT_SYNC_ASYNC		(1 << 2)
    453#define USB_ENDPOINT_SYNC_ADAPTIVE	(2 << 2)
    454#define USB_ENDPOINT_SYNC_SYNC		(3 << 2)
    455
    456#define USB_ENDPOINT_USAGE_MASK		0x30
    457#define USB_ENDPOINT_USAGE_DATA		0x00
    458#define USB_ENDPOINT_USAGE_FEEDBACK	0x10
    459#define USB_ENDPOINT_USAGE_IMPLICIT_FB	0x20	/* Implicit feedback Data endpoint */
    460
    461/*-------------------------------------------------------------------------*/
    462
    463/**
    464 * usb_endpoint_num - get the endpoint's number
    465 * @epd: endpoint to be checked
    466 *
    467 * Returns @epd's number: 0 to 15.
    468 */
    469static inline int usb_endpoint_num(const struct usb_endpoint_descriptor *epd)
    470{
    471	return epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
    472}
    473
    474/**
    475 * usb_endpoint_type - get the endpoint's transfer type
    476 * @epd: endpoint to be checked
    477 *
    478 * Returns one of USB_ENDPOINT_XFER_{CONTROL, ISOC, BULK, INT} according
    479 * to @epd's transfer type.
    480 */
    481static inline int usb_endpoint_type(const struct usb_endpoint_descriptor *epd)
    482{
    483	return epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
    484}
    485
    486/**
    487 * usb_endpoint_dir_in - check if the endpoint has IN direction
    488 * @epd: endpoint to be checked
    489 *
    490 * Returns true if the endpoint is of type IN, otherwise it returns false.
    491 */
    492static inline int usb_endpoint_dir_in(const struct usb_endpoint_descriptor *epd)
    493{
    494	return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN);
    495}
    496
    497/**
    498 * usb_endpoint_dir_out - check if the endpoint has OUT direction
    499 * @epd: endpoint to be checked
    500 *
    501 * Returns true if the endpoint is of type OUT, otherwise it returns false.
    502 */
    503static inline int usb_endpoint_dir_out(
    504				const struct usb_endpoint_descriptor *epd)
    505{
    506	return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT);
    507}
    508
    509/**
    510 * usb_endpoint_xfer_bulk - check if the endpoint has bulk transfer type
    511 * @epd: endpoint to be checked
    512 *
    513 * Returns true if the endpoint is of type bulk, otherwise it returns false.
    514 */
    515static inline int usb_endpoint_xfer_bulk(
    516				const struct usb_endpoint_descriptor *epd)
    517{
    518	return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
    519		USB_ENDPOINT_XFER_BULK);
    520}
    521
    522/**
    523 * usb_endpoint_xfer_control - check if the endpoint has control transfer type
    524 * @epd: endpoint to be checked
    525 *
    526 * Returns true if the endpoint is of type control, otherwise it returns false.
    527 */
    528static inline int usb_endpoint_xfer_control(
    529				const struct usb_endpoint_descriptor *epd)
    530{
    531	return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
    532		USB_ENDPOINT_XFER_CONTROL);
    533}
    534
    535/**
    536 * usb_endpoint_xfer_int - check if the endpoint has interrupt transfer type
    537 * @epd: endpoint to be checked
    538 *
    539 * Returns true if the endpoint is of type interrupt, otherwise it returns
    540 * false.
    541 */
    542static inline int usb_endpoint_xfer_int(
    543				const struct usb_endpoint_descriptor *epd)
    544{
    545	return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
    546		USB_ENDPOINT_XFER_INT);
    547}
    548
    549/**
    550 * usb_endpoint_xfer_isoc - check if the endpoint has isochronous transfer type
    551 * @epd: endpoint to be checked
    552 *
    553 * Returns true if the endpoint is of type isochronous, otherwise it returns
    554 * false.
    555 */
    556static inline int usb_endpoint_xfer_isoc(
    557				const struct usb_endpoint_descriptor *epd)
    558{
    559	return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
    560		USB_ENDPOINT_XFER_ISOC);
    561}
    562
    563/**
    564 * usb_endpoint_is_bulk_in - check if the endpoint is bulk IN
    565 * @epd: endpoint to be checked
    566 *
    567 * Returns true if the endpoint has bulk transfer type and IN direction,
    568 * otherwise it returns false.
    569 */
    570static inline int usb_endpoint_is_bulk_in(
    571				const struct usb_endpoint_descriptor *epd)
    572{
    573	return usb_endpoint_xfer_bulk(epd) && usb_endpoint_dir_in(epd);
    574}
    575
    576/**
    577 * usb_endpoint_is_bulk_out - check if the endpoint is bulk OUT
    578 * @epd: endpoint to be checked
    579 *
    580 * Returns true if the endpoint has bulk transfer type and OUT direction,
    581 * otherwise it returns false.
    582 */
    583static inline int usb_endpoint_is_bulk_out(
    584				const struct usb_endpoint_descriptor *epd)
    585{
    586	return usb_endpoint_xfer_bulk(epd) && usb_endpoint_dir_out(epd);
    587}
    588
    589/**
    590 * usb_endpoint_is_int_in - check if the endpoint is interrupt IN
    591 * @epd: endpoint to be checked
    592 *
    593 * Returns true if the endpoint has interrupt transfer type and IN direction,
    594 * otherwise it returns false.
    595 */
    596static inline int usb_endpoint_is_int_in(
    597				const struct usb_endpoint_descriptor *epd)
    598{
    599	return usb_endpoint_xfer_int(epd) && usb_endpoint_dir_in(epd);
    600}
    601
    602/**
    603 * usb_endpoint_is_int_out - check if the endpoint is interrupt OUT
    604 * @epd: endpoint to be checked
    605 *
    606 * Returns true if the endpoint has interrupt transfer type and OUT direction,
    607 * otherwise it returns false.
    608 */
    609static inline int usb_endpoint_is_int_out(
    610				const struct usb_endpoint_descriptor *epd)
    611{
    612	return usb_endpoint_xfer_int(epd) && usb_endpoint_dir_out(epd);
    613}
    614
    615/**
    616 * usb_endpoint_is_isoc_in - check if the endpoint is isochronous IN
    617 * @epd: endpoint to be checked
    618 *
    619 * Returns true if the endpoint has isochronous transfer type and IN direction,
    620 * otherwise it returns false.
    621 */
    622static inline int usb_endpoint_is_isoc_in(
    623				const struct usb_endpoint_descriptor *epd)
    624{
    625	return usb_endpoint_xfer_isoc(epd) && usb_endpoint_dir_in(epd);
    626}
    627
    628/**
    629 * usb_endpoint_is_isoc_out - check if the endpoint is isochronous OUT
    630 * @epd: endpoint to be checked
    631 *
    632 * Returns true if the endpoint has isochronous transfer type and OUT direction,
    633 * otherwise it returns false.
    634 */
    635static inline int usb_endpoint_is_isoc_out(
    636				const struct usb_endpoint_descriptor *epd)
    637{
    638	return usb_endpoint_xfer_isoc(epd) && usb_endpoint_dir_out(epd);
    639}
    640
    641/**
    642 * usb_endpoint_maxp - get endpoint's max packet size
    643 * @epd: endpoint to be checked
    644 *
    645 * Returns @epd's max packet bits [10:0]
    646 */
    647static inline int usb_endpoint_maxp(const struct usb_endpoint_descriptor *epd)
    648{
    649	return __le16_to_cpu(epd->wMaxPacketSize) & USB_ENDPOINT_MAXP_MASK;
    650}
    651
    652/**
    653 * usb_endpoint_maxp_mult - get endpoint's transactional opportunities
    654 * @epd: endpoint to be checked
    655 *
    656 * Return @epd's wMaxPacketSize[12:11] + 1
    657 */
    658static inline int
    659usb_endpoint_maxp_mult(const struct usb_endpoint_descriptor *epd)
    660{
    661	int maxp = __le16_to_cpu(epd->wMaxPacketSize);
    662
    663	return USB_EP_MAXP_MULT(maxp) + 1;
    664}
    665
    666static inline int usb_endpoint_interrupt_type(
    667		const struct usb_endpoint_descriptor *epd)
    668{
    669	return epd->bmAttributes & USB_ENDPOINT_INTRTYPE;
    670}
    671
    672/*-------------------------------------------------------------------------*/
    673
    674/* USB_DT_SSP_ISOC_ENDPOINT_COMP: SuperSpeedPlus Isochronous Endpoint Companion
    675 * descriptor
    676 */
    677struct usb_ssp_isoc_ep_comp_descriptor {
    678	__u8  bLength;
    679	__u8  bDescriptorType;
    680	__le16 wReseved;
    681	__le32 dwBytesPerInterval;
    682} __attribute__ ((packed));
    683
    684#define USB_DT_SSP_ISOC_EP_COMP_SIZE		8
    685
    686/*-------------------------------------------------------------------------*/
    687
    688/* USB_DT_SS_ENDPOINT_COMP: SuperSpeed Endpoint Companion descriptor */
    689struct usb_ss_ep_comp_descriptor {
    690	__u8  bLength;
    691	__u8  bDescriptorType;
    692
    693	__u8  bMaxBurst;
    694	__u8  bmAttributes;
    695	__le16 wBytesPerInterval;
    696} __attribute__ ((packed));
    697
    698#define USB_DT_SS_EP_COMP_SIZE		6
    699
    700/* Bits 4:0 of bmAttributes if this is a bulk endpoint */
    701static inline int
    702usb_ss_max_streams(const struct usb_ss_ep_comp_descriptor *comp)
    703{
    704	int		max_streams;
    705
    706	if (!comp)
    707		return 0;
    708
    709	max_streams = comp->bmAttributes & 0x1f;
    710
    711	if (!max_streams)
    712		return 0;
    713
    714	max_streams = 1 << max_streams;
    715
    716	return max_streams;
    717}
    718
    719/* Bits 1:0 of bmAttributes if this is an isoc endpoint */
    720#define USB_SS_MULT(p)			(1 + ((p) & 0x3))
    721/* Bit 7 of bmAttributes if a SSP isoc endpoint companion descriptor exists */
    722#define USB_SS_SSP_ISOC_COMP(p)		((p) & (1 << 7))
    723
    724/*-------------------------------------------------------------------------*/
    725
    726/* USB_DT_DEVICE_QUALIFIER: Device Qualifier descriptor */
    727struct usb_qualifier_descriptor {
    728	__u8  bLength;
    729	__u8  bDescriptorType;
    730
    731	__le16 bcdUSB;
    732	__u8  bDeviceClass;
    733	__u8  bDeviceSubClass;
    734	__u8  bDeviceProtocol;
    735	__u8  bMaxPacketSize0;
    736	__u8  bNumConfigurations;
    737	__u8  bRESERVED;
    738} __attribute__ ((packed));
    739
    740
    741/*-------------------------------------------------------------------------*/
    742
    743/* USB_DT_OTG (from OTG 1.0a supplement) */
    744struct usb_otg_descriptor {
    745	__u8  bLength;
    746	__u8  bDescriptorType;
    747
    748	__u8  bmAttributes;	/* support for HNP, SRP, etc */
    749} __attribute__ ((packed));
    750
    751/* USB_DT_OTG (from OTG 2.0 supplement) */
    752struct usb_otg20_descriptor {
    753	__u8  bLength;
    754	__u8  bDescriptorType;
    755
    756	__u8  bmAttributes;	/* support for HNP, SRP and ADP, etc */
    757	__le16 bcdOTG;		/* OTG and EH supplement release number
    758				 * in binary-coded decimal(i.e. 2.0 is 0200H)
    759				 */
    760} __attribute__ ((packed));
    761
    762/* from usb_otg_descriptor.bmAttributes */
    763#define USB_OTG_SRP		(1 << 0)
    764#define USB_OTG_HNP		(1 << 1)	/* swap host/device roles */
    765#define USB_OTG_ADP		(1 << 2)	/* support ADP */
    766
    767#define OTG_STS_SELECTOR	0xF000		/* OTG status selector */
    768/*-------------------------------------------------------------------------*/
    769
    770/* USB_DT_DEBUG:  for special highspeed devices, replacing serial console */
    771struct usb_debug_descriptor {
    772	__u8  bLength;
    773	__u8  bDescriptorType;
    774
    775	/* bulk endpoints with 8 byte maxpacket */
    776	__u8  bDebugInEndpoint;
    777	__u8  bDebugOutEndpoint;
    778} __attribute__((packed));
    779
    780/*-------------------------------------------------------------------------*/
    781
    782/* USB_DT_INTERFACE_ASSOCIATION: groups interfaces */
    783struct usb_interface_assoc_descriptor {
    784	__u8  bLength;
    785	__u8  bDescriptorType;
    786
    787	__u8  bFirstInterface;
    788	__u8  bInterfaceCount;
    789	__u8  bFunctionClass;
    790	__u8  bFunctionSubClass;
    791	__u8  bFunctionProtocol;
    792	__u8  iFunction;
    793} __attribute__ ((packed));
    794
    795#define USB_DT_INTERFACE_ASSOCIATION_SIZE	8
    796
    797/*-------------------------------------------------------------------------*/
    798
    799/* USB_DT_SECURITY:  group of wireless security descriptors, including
    800 * encryption types available for setting up a CC/association.
    801 */
    802struct usb_security_descriptor {
    803	__u8  bLength;
    804	__u8  bDescriptorType;
    805
    806	__le16 wTotalLength;
    807	__u8  bNumEncryptionTypes;
    808} __attribute__((packed));
    809
    810/*-------------------------------------------------------------------------*/
    811
    812/* USB_DT_KEY:  used with {GET,SET}_SECURITY_DATA; only public keys
    813 * may be retrieved.
    814 */
    815struct usb_key_descriptor {
    816	__u8  bLength;
    817	__u8  bDescriptorType;
    818
    819	__u8  tTKID[3];
    820	__u8  bReserved;
    821	__u8  bKeyData[0];
    822} __attribute__((packed));
    823
    824/*-------------------------------------------------------------------------*/
    825
    826/* USB_DT_ENCRYPTION_TYPE:  bundled in DT_SECURITY groups */
    827struct usb_encryption_descriptor {
    828	__u8  bLength;
    829	__u8  bDescriptorType;
    830
    831	__u8  bEncryptionType;
    832#define	USB_ENC_TYPE_UNSECURE		0
    833#define	USB_ENC_TYPE_WIRED		1	/* non-wireless mode */
    834#define	USB_ENC_TYPE_CCM_1		2	/* aes128/cbc session */
    835#define	USB_ENC_TYPE_RSA_1		3	/* rsa3072/sha1 auth */
    836	__u8  bEncryptionValue;		/* use in SET_ENCRYPTION */
    837	__u8  bAuthKeyIndex;
    838} __attribute__((packed));
    839
    840
    841/*-------------------------------------------------------------------------*/
    842
    843/* USB_DT_BOS:  group of device-level capabilities */
    844struct usb_bos_descriptor {
    845	__u8  bLength;
    846	__u8  bDescriptorType;
    847
    848	__le16 wTotalLength;
    849	__u8  bNumDeviceCaps;
    850} __attribute__((packed));
    851
    852#define USB_DT_BOS_SIZE		5
    853/*-------------------------------------------------------------------------*/
    854
    855/* USB_DT_DEVICE_CAPABILITY:  grouped with BOS */
    856struct usb_dev_cap_header {
    857	__u8  bLength;
    858	__u8  bDescriptorType;
    859	__u8  bDevCapabilityType;
    860} __attribute__((packed));
    861
    862#define	USB_CAP_TYPE_WIRELESS_USB	1
    863
    864struct usb_wireless_cap_descriptor {	/* Ultra Wide Band */
    865	__u8  bLength;
    866	__u8  bDescriptorType;
    867	__u8  bDevCapabilityType;
    868
    869	__u8  bmAttributes;
    870#define	USB_WIRELESS_P2P_DRD		(1 << 1)
    871#define	USB_WIRELESS_BEACON_MASK	(3 << 2)
    872#define	USB_WIRELESS_BEACON_SELF	(1 << 2)
    873#define	USB_WIRELESS_BEACON_DIRECTED	(2 << 2)
    874#define	USB_WIRELESS_BEACON_NONE	(3 << 2)
    875	__le16 wPHYRates;	/* bit rates, Mbps */
    876#define	USB_WIRELESS_PHY_53		(1 << 0)	/* always set */
    877#define	USB_WIRELESS_PHY_80		(1 << 1)
    878#define	USB_WIRELESS_PHY_107		(1 << 2)	/* always set */
    879#define	USB_WIRELESS_PHY_160		(1 << 3)
    880#define	USB_WIRELESS_PHY_200		(1 << 4)	/* always set */
    881#define	USB_WIRELESS_PHY_320		(1 << 5)
    882#define	USB_WIRELESS_PHY_400		(1 << 6)
    883#define	USB_WIRELESS_PHY_480		(1 << 7)
    884	__u8  bmTFITXPowerInfo;	/* TFI power levels */
    885	__u8  bmFFITXPowerInfo;	/* FFI power levels */
    886	__le16 bmBandGroup;
    887	__u8  bReserved;
    888} __attribute__((packed));
    889
    890#define USB_DT_USB_WIRELESS_CAP_SIZE	11
    891
    892/* USB 2.0 Extension descriptor */
    893#define	USB_CAP_TYPE_EXT		2
    894
    895struct usb_ext_cap_descriptor {		/* Link Power Management */
    896	__u8  bLength;
    897	__u8  bDescriptorType;
    898	__u8  bDevCapabilityType;
    899	__le32 bmAttributes;
    900#define USB_LPM_SUPPORT			(1 << 1)	/* supports LPM */
    901#define USB_BESL_SUPPORT		(1 << 2)	/* supports BESL */
    902#define USB_BESL_BASELINE_VALID		(1 << 3)	/* Baseline BESL valid*/
    903#define USB_BESL_DEEP_VALID		(1 << 4)	/* Deep BESL valid */
    904#define USB_SET_BESL_BASELINE(p)	(((p) & 0xf) << 8)
    905#define USB_SET_BESL_DEEP(p)		(((p) & 0xf) << 12)
    906#define USB_GET_BESL_BASELINE(p)	(((p) & (0xf << 8)) >> 8)
    907#define USB_GET_BESL_DEEP(p)		(((p) & (0xf << 12)) >> 12)
    908} __attribute__((packed));
    909
    910#define USB_DT_USB_EXT_CAP_SIZE	7
    911
    912/*
    913 * SuperSpeed USB Capability descriptor: Defines the set of SuperSpeed USB
    914 * specific device level capabilities
    915 */
    916#define		USB_SS_CAP_TYPE		3
    917struct usb_ss_cap_descriptor {		/* Link Power Management */
    918	__u8  bLength;
    919	__u8  bDescriptorType;
    920	__u8  bDevCapabilityType;
    921	__u8  bmAttributes;
    922#define USB_LTM_SUPPORT			(1 << 1) /* supports LTM */
    923	__le16 wSpeedSupported;
    924#define USB_LOW_SPEED_OPERATION		(1)	 /* Low speed operation */
    925#define USB_FULL_SPEED_OPERATION	(1 << 1) /* Full speed operation */
    926#define USB_HIGH_SPEED_OPERATION	(1 << 2) /* High speed operation */
    927#define USB_5GBPS_OPERATION		(1 << 3) /* Operation at 5Gbps */
    928	__u8  bFunctionalitySupport;
    929	__u8  bU1devExitLat;
    930	__le16 bU2DevExitLat;
    931} __attribute__((packed));
    932
    933#define USB_DT_USB_SS_CAP_SIZE	10
    934
    935/*
    936 * Container ID Capability descriptor: Defines the instance unique ID used to
    937 * identify the instance across all operating modes
    938 */
    939#define	CONTAINER_ID_TYPE	4
    940struct usb_ss_container_id_descriptor {
    941	__u8  bLength;
    942	__u8  bDescriptorType;
    943	__u8  bDevCapabilityType;
    944	__u8  bReserved;
    945	__u8  ContainerID[16]; /* 128-bit number */
    946} __attribute__((packed));
    947
    948#define USB_DT_USB_SS_CONTN_ID_SIZE	20
    949
    950/*
    951 * SuperSpeed Plus USB Capability descriptor: Defines the set of
    952 * SuperSpeed Plus USB specific device level capabilities
    953 */
    954#define	USB_SSP_CAP_TYPE	0xa
    955struct usb_ssp_cap_descriptor {
    956	__u8  bLength;
    957	__u8  bDescriptorType;
    958	__u8  bDevCapabilityType;
    959	__u8  bReserved;
    960	__le32 bmAttributes;
    961#define USB_SSP_SUBLINK_SPEED_ATTRIBS	(0x1f << 0) /* sublink speed entries */
    962#define USB_SSP_SUBLINK_SPEED_IDS	(0xf << 5)  /* speed ID entries */
    963	__le16  wFunctionalitySupport;
    964#define USB_SSP_MIN_SUBLINK_SPEED_ATTRIBUTE_ID	(0xf)
    965#define USB_SSP_MIN_RX_LANE_COUNT		(0xf << 8)
    966#define USB_SSP_MIN_TX_LANE_COUNT		(0xf << 12)
    967	__le16 wReserved;
    968	__le32 bmSublinkSpeedAttr[1]; /* list of sublink speed attrib entries */
    969#define USB_SSP_SUBLINK_SPEED_SSID	(0xf)		/* sublink speed ID */
    970#define USB_SSP_SUBLINK_SPEED_LSE	(0x3 << 4)	/* Lanespeed exponent */
    971#define USB_SSP_SUBLINK_SPEED_LSE_BPS		0
    972#define USB_SSP_SUBLINK_SPEED_LSE_KBPS		1
    973#define USB_SSP_SUBLINK_SPEED_LSE_MBPS		2
    974#define USB_SSP_SUBLINK_SPEED_LSE_GBPS		3
    975
    976#define USB_SSP_SUBLINK_SPEED_ST	(0x3 << 6)	/* Sublink type */
    977#define USB_SSP_SUBLINK_SPEED_ST_SYM_RX		0
    978#define USB_SSP_SUBLINK_SPEED_ST_ASYM_RX	1
    979#define USB_SSP_SUBLINK_SPEED_ST_SYM_TX		2
    980#define USB_SSP_SUBLINK_SPEED_ST_ASYM_TX	3
    981
    982#define USB_SSP_SUBLINK_SPEED_RSVD	(0x3f << 8)	/* Reserved */
    983#define USB_SSP_SUBLINK_SPEED_LP	(0x3 << 14)	/* Link protocol */
    984#define USB_SSP_SUBLINK_SPEED_LP_SS		0
    985#define USB_SSP_SUBLINK_SPEED_LP_SSP		1
    986
    987#define USB_SSP_SUBLINK_SPEED_LSM	(0xff << 16)	/* Lanespeed mantissa */
    988} __attribute__((packed));
    989
    990/*
    991 * USB Power Delivery Capability Descriptor:
    992 * Defines capabilities for PD
    993 */
    994/* Defines the various PD Capabilities of this device */
    995#define USB_PD_POWER_DELIVERY_CAPABILITY	0x06
    996/* Provides information on each battery supported by the device */
    997#define USB_PD_BATTERY_INFO_CAPABILITY		0x07
    998/* The Consumer characteristics of a Port on the device */
    999#define USB_PD_PD_CONSUMER_PORT_CAPABILITY	0x08
   1000/* The provider characteristics of a Port on the device */
   1001#define USB_PD_PD_PROVIDER_PORT_CAPABILITY	0x09
   1002
   1003struct usb_pd_cap_descriptor {
   1004	__u8  bLength;
   1005	__u8  bDescriptorType;
   1006	__u8  bDevCapabilityType; /* set to USB_PD_POWER_DELIVERY_CAPABILITY */
   1007	__u8  bReserved;
   1008	__le32 bmAttributes;
   1009#define USB_PD_CAP_BATTERY_CHARGING	(1 << 1) /* supports Battery Charging specification */
   1010#define USB_PD_CAP_USB_PD		(1 << 2) /* supports USB Power Delivery specification */
   1011#define USB_PD_CAP_PROVIDER		(1 << 3) /* can provide power */
   1012#define USB_PD_CAP_CONSUMER		(1 << 4) /* can consume power */
   1013#define USB_PD_CAP_CHARGING_POLICY	(1 << 5) /* supports CHARGING_POLICY feature */
   1014#define USB_PD_CAP_TYPE_C_CURRENT	(1 << 6) /* supports power capabilities defined in the USB Type-C Specification */
   1015
   1016#define USB_PD_CAP_PWR_AC		(1 << 8)
   1017#define USB_PD_CAP_PWR_BAT		(1 << 9)
   1018#define USB_PD_CAP_PWR_USE_V_BUS	(1 << 14)
   1019
   1020	__le16 bmProviderPorts; /* Bit zero refers to the UFP of the device */
   1021	__le16 bmConsumerPorts;
   1022	__le16 bcdBCVersion;
   1023	__le16 bcdPDVersion;
   1024	__le16 bcdUSBTypeCVersion;
   1025} __attribute__((packed));
   1026
   1027struct usb_pd_cap_battery_info_descriptor {
   1028	__u8 bLength;
   1029	__u8 bDescriptorType;
   1030	__u8 bDevCapabilityType;
   1031	/* Index of string descriptor shall contain the user friendly name for this battery */
   1032	__u8 iBattery;
   1033	/* Index of string descriptor shall contain the Serial Number String for this battery */
   1034	__u8 iSerial;
   1035	__u8 iManufacturer;
   1036	__u8 bBatteryId; /* uniquely identifies this battery in status Messages */
   1037	__u8 bReserved;
   1038	/*
   1039	 * Shall contain the Battery Charge value above which this
   1040	 * battery is considered to be fully charged but not necessarily
   1041	 * “topped off.”
   1042	 */
   1043	__le32 dwChargedThreshold; /* in mWh */
   1044	/*
   1045	 * Shall contain the minimum charge level of this battery such
   1046	 * that above this threshold, a device can be assured of being
   1047	 * able to power up successfully (see Battery Charging 1.2).
   1048	 */
   1049	__le32 dwWeakThreshold; /* in mWh */
   1050	__le32 dwBatteryDesignCapacity; /* in mWh */
   1051	__le32 dwBatteryLastFullchargeCapacity; /* in mWh */
   1052} __attribute__((packed));
   1053
   1054struct usb_pd_cap_consumer_port_descriptor {
   1055	__u8 bLength;
   1056	__u8 bDescriptorType;
   1057	__u8 bDevCapabilityType;
   1058	__u8 bReserved;
   1059	__u8 bmCapabilities;
   1060/* port will oerate under: */
   1061#define USB_PD_CAP_CONSUMER_BC		(1 << 0) /* BC */
   1062#define USB_PD_CAP_CONSUMER_PD		(1 << 1) /* PD */
   1063#define USB_PD_CAP_CONSUMER_TYPE_C	(1 << 2) /* USB Type-C Current */
   1064	__le16 wMinVoltage; /* in 50mV units */
   1065	__le16 wMaxVoltage; /* in 50mV units */
   1066	__u16 wReserved;
   1067	__le32 dwMaxOperatingPower; /* in 10 mW - operating at steady state */
   1068	__le32 dwMaxPeakPower; /* in 10mW units - operating at peak power */
   1069	__le32 dwMaxPeakPowerTime; /* in 100ms units - duration of peak */
   1070#define USB_PD_CAP_CONSUMER_UNKNOWN_PEAK_POWER_TIME 0xffff
   1071} __attribute__((packed));
   1072
   1073struct usb_pd_cap_provider_port_descriptor {
   1074	__u8 bLength;
   1075	__u8 bDescriptorType;
   1076	__u8 bDevCapabilityType;
   1077	__u8 bReserved1;
   1078	__u8 bmCapabilities;
   1079/* port will oerate under: */
   1080#define USB_PD_CAP_PROVIDER_BC		(1 << 0) /* BC */
   1081#define USB_PD_CAP_PROVIDER_PD		(1 << 1) /* PD */
   1082#define USB_PD_CAP_PROVIDER_TYPE_C	(1 << 2) /* USB Type-C Current */
   1083	__u8 bNumOfPDObjects;
   1084	__u8 bReserved2;
   1085	__le32 wPowerDataObject[];
   1086} __attribute__((packed));
   1087
   1088/*
   1089 * Precision time measurement capability descriptor: advertised by devices and
   1090 * hubs that support PTM
   1091 */
   1092#define	USB_PTM_CAP_TYPE	0xb
   1093struct usb_ptm_cap_descriptor {
   1094	__u8  bLength;
   1095	__u8  bDescriptorType;
   1096	__u8  bDevCapabilityType;
   1097} __attribute__((packed));
   1098
   1099#define USB_DT_USB_PTM_ID_SIZE		3
   1100/*
   1101 * The size of the descriptor for the Sublink Speed Attribute Count
   1102 * (SSAC) specified in bmAttributes[4:0]. SSAC is zero-based
   1103 */
   1104#define USB_DT_USB_SSP_CAP_SIZE(ssac)	(12 + (ssac + 1) * 4)
   1105
   1106/*-------------------------------------------------------------------------*/
   1107
   1108/* USB_DT_WIRELESS_ENDPOINT_COMP:  companion descriptor associated with
   1109 * each endpoint descriptor for a wireless device
   1110 */
   1111struct usb_wireless_ep_comp_descriptor {
   1112	__u8  bLength;
   1113	__u8  bDescriptorType;
   1114
   1115	__u8  bMaxBurst;
   1116	__u8  bMaxSequence;
   1117	__le16 wMaxStreamDelay;
   1118	__le16 wOverTheAirPacketSize;
   1119	__u8  bOverTheAirInterval;
   1120	__u8  bmCompAttributes;
   1121#define USB_ENDPOINT_SWITCH_MASK	0x03	/* in bmCompAttributes */
   1122#define USB_ENDPOINT_SWITCH_NO		0
   1123#define USB_ENDPOINT_SWITCH_SWITCH	1
   1124#define USB_ENDPOINT_SWITCH_SCALE	2
   1125} __attribute__((packed));
   1126
   1127/*-------------------------------------------------------------------------*/
   1128
   1129/* USB_REQ_SET_HANDSHAKE is a four-way handshake used between a wireless
   1130 * host and a device for connection set up, mutual authentication, and
   1131 * exchanging short lived session keys.  The handshake depends on a CC.
   1132 */
   1133struct usb_handshake {
   1134	__u8 bMessageNumber;
   1135	__u8 bStatus;
   1136	__u8 tTKID[3];
   1137	__u8 bReserved;
   1138	__u8 CDID[16];
   1139	__u8 nonce[16];
   1140	__u8 MIC[8];
   1141} __attribute__((packed));
   1142
   1143/*-------------------------------------------------------------------------*/
   1144
   1145/* USB_REQ_SET_CONNECTION modifies or revokes a connection context (CC).
   1146 * A CC may also be set up using non-wireless secure channels (including
   1147 * wired USB!), and some devices may support CCs with multiple hosts.
   1148 */
   1149struct usb_connection_context {
   1150	__u8 CHID[16];		/* persistent host id */
   1151	__u8 CDID[16];		/* device id (unique w/in host context) */
   1152	__u8 CK[16];		/* connection key */
   1153} __attribute__((packed));
   1154
   1155/*-------------------------------------------------------------------------*/
   1156
   1157/* USB 2.0 defines three speeds, here's how Linux identifies them */
   1158
   1159enum usb_device_speed {
   1160	USB_SPEED_UNKNOWN = 0,			/* enumerating */
   1161	USB_SPEED_LOW, USB_SPEED_FULL,		/* usb 1.1 */
   1162	USB_SPEED_HIGH,				/* usb 2.0 */
   1163	USB_SPEED_WIRELESS,			/* wireless (usb 2.5) */
   1164	USB_SPEED_SUPER,			/* usb 3.0 */
   1165	USB_SPEED_SUPER_PLUS,			/* usb 3.1 */
   1166};
   1167
   1168
   1169enum usb_device_state {
   1170	/* NOTATTACHED isn't in the USB spec, and this state acts
   1171	 * the same as ATTACHED ... but it's clearer this way.
   1172	 */
   1173	USB_STATE_NOTATTACHED = 0,
   1174
   1175	/* chapter 9 and authentication (wireless) device states */
   1176	USB_STATE_ATTACHED,
   1177	USB_STATE_POWERED,			/* wired */
   1178	USB_STATE_RECONNECTING,			/* auth */
   1179	USB_STATE_UNAUTHENTICATED,		/* auth */
   1180	USB_STATE_DEFAULT,			/* limited function */
   1181	USB_STATE_ADDRESS,
   1182	USB_STATE_CONFIGURED,			/* most functions */
   1183
   1184	USB_STATE_SUSPENDED
   1185
   1186	/* NOTE:  there are actually four different SUSPENDED
   1187	 * states, returning to POWERED, DEFAULT, ADDRESS, or
   1188	 * CONFIGURED respectively when SOF tokens flow again.
   1189	 * At this level there's no difference between L1 and L2
   1190	 * suspend states.  (L2 being original USB 1.1 suspend.)
   1191	 */
   1192};
   1193
   1194enum usb3_link_state {
   1195	USB3_LPM_U0 = 0,
   1196	USB3_LPM_U1,
   1197	USB3_LPM_U2,
   1198	USB3_LPM_U3
   1199};
   1200
   1201/*
   1202 * A U1 timeout of 0x0 means the parent hub will reject any transitions to U1.
   1203 * 0xff means the parent hub will accept transitions to U1, but will not
   1204 * initiate a transition.
   1205 *
   1206 * A U1 timeout of 0x1 to 0x7F also causes the hub to initiate a transition to
   1207 * U1 after that many microseconds.  Timeouts of 0x80 to 0xFE are reserved
   1208 * values.
   1209 *
   1210 * A U2 timeout of 0x0 means the parent hub will reject any transitions to U2.
   1211 * 0xff means the parent hub will accept transitions to U2, but will not
   1212 * initiate a transition.
   1213 *
   1214 * A U2 timeout of 0x1 to 0xFE also causes the hub to initiate a transition to
   1215 * U2 after N*256 microseconds.  Therefore a U2 timeout value of 0x1 means a U2
   1216 * idle timer of 256 microseconds, 0x2 means 512 microseconds, 0xFE means
   1217 * 65.024ms.
   1218 */
   1219#define USB3_LPM_DISABLED		0x0
   1220#define USB3_LPM_U1_MAX_TIMEOUT		0x7F
   1221#define USB3_LPM_U2_MAX_TIMEOUT		0xFE
   1222#define USB3_LPM_DEVICE_INITIATED	0xFF
   1223
   1224struct usb_set_sel_req {
   1225	__u8	u1_sel;
   1226	__u8	u1_pel;
   1227	__le16	u2_sel;
   1228	__le16	u2_pel;
   1229} __attribute__ ((packed));
   1230
   1231/*
   1232 * The Set System Exit Latency control transfer provides one byte each for
   1233 * U1 SEL and U1 PEL, so the max exit latency is 0xFF.  U2 SEL and U2 PEL each
   1234 * are two bytes long.
   1235 */
   1236#define USB3_LPM_MAX_U1_SEL_PEL		0xFF
   1237#define USB3_LPM_MAX_U2_SEL_PEL		0xFFFF
   1238
   1239/*-------------------------------------------------------------------------*/
   1240
   1241/*
   1242 * As per USB compliance update, a device that is actively drawing
   1243 * more than 100mA from USB must report itself as bus-powered in
   1244 * the GetStatus(DEVICE) call.
   1245 * https://compliance.usb.org/index.asp?UpdateFile=Electrical&Format=Standard#34
   1246 */
   1247#define USB_SELF_POWER_VBUS_MAX_DRAW		100
   1248
   1249#endif /* _UAPI__LINUX_USB_CH9_H */