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