/* packet-usb.c

 *

 * USB basic dissector

 * By Paolo Abeni <paolo.abeni@email.it>

 * Ronnie Sahlberg 2006

 *

 * http://www.usb.org/developers/docs/usb_20_122909-2.zip

 *

 * https://github.com/torvalds/linux/blob/master/Documentation/usb/usbmon.rst

 *

 * http://desowin.org/usbpcap/captureformat.html

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/exceptions.h>

#include <epan/addr_resolv.h>

#include <epan/address_types.h>

#include <epan/conversation_table.h>

#include <epan/expert.h>

#include <epan/prefs.h>

#include <epan/decode_as.h>

#include <epan/proto_data.h>

#include <epan/unit_strings.h>

#include <wsutil/pint.h>

#include <wsutil/ws_roundup.h>

#include "packet-usb.h"

#include "packet-mausb.h"

#include "packet-usbip.h"

#include "packet-netmon.h"

/* dissector handles */

static dissector_handle_t  linux_usb_handle;

static dissector_handle_t  linux_usb_mmapped_handle;

static dissector_handle_t  win32_usb_handle;

static dissector_handle_t  freebsd_usb_handle;

static dissector_handle_t  darwin_usb_handle;

static dissector_handle_t  netmon_usb_port_handle;

/* protocols and header fields */

static int proto_usb;

static int proto_usbport;

/* USB pseudoheader fields, both FreeBSD and Linux */

static int hf_usb_totlen;

static int hf_usb_busunit;

static int hf_usb_address;

static int hf_usb_mode;

static int hf_usb_freebsd_urb_type;

static int hf_usb_freebsd_transfer_type;

static int hf_usb_xferflags;

static int hf_usb_xferflags_force_short_xfer;

static int hf_usb_xferflags_short_xfer_ok;

static int hf_usb_xferflags_short_frames_ok;

static int hf_usb_xferflags_pipe_bof;

static int hf_usb_xferflags_proxy_buffer;

static int hf_usb_xferflags_ext_buffer;

static int hf_usb_xferflags_manual_status;

static int hf_usb_xferflags_no_pipe_ok;

static int hf_usb_xferflags_stall_pipe;

static int hf_usb_xferstatus;

static int hf_usb_xferstatus_open;

static int hf_usb_xferstatus_transferring;

static int hf_usb_xferstatus_did_dma_delay;

static int hf_usb_xferstatus_did_close;

static int hf_usb_xferstatus_draining;

static int hf_usb_xferstatus_started;

static int hf_usb_xferstatus_bw_reclaimed;

static int hf_usb_xferstatus_control_xfr;

static int hf_usb_xferstatus_control_hdr;

static int hf_usb_xferstatus_control_act;

static int hf_usb_xferstatus_control_stall;

static int hf_usb_xferstatus_short_frames_ok;

static int hf_usb_xferstatus_short_xfer_ok;

static int hf_usb_xferstatus_bdma_enable;

static int hf_usb_xferstatus_bdma_no_post_sync;

static int hf_usb_xferstatus_bdma_setup;

static int hf_usb_xferstatus_isochronous_xfr;

static int hf_usb_xferstatus_curr_dma_set;

static int hf_usb_xferstatus_can_cancel_immed;

static int hf_usb_xferstatus_doing_callback;

static int hf_usb_error;

static int hf_usb_interval;

static int hf_usb_nframes;

static int hf_usb_packet_size;

static int hf_usb_packet_count;

static int hf_usb_speed;

static int hf_usb_frame_length;

static int hf_usb_frame_flags;

static int hf_usb_frame_flags_read;

static int hf_usb_frame_flags_data_follows;

static int hf_usb_frame_data;

static int hf_usb_urb_id;

static int hf_usb_linux_urb_type;

static int hf_usb_linux_transfer_type;

static int hf_usb_endpoint_address;

static int hf_usb_endpoint_direction;

static int hf_usb_endpoint_number;

static int hf_usb_device_address;

static int hf_usb_bus_id;

static int hf_usb_setup_flag;

static int hf_usb_data_flag;

static int hf_usb_urb_ts_sec;

static int hf_usb_urb_ts_usec;

static int hf_usb_urb_status;

static int hf_usb_urb_len;

static int hf_usb_urb_data_len;

static int hf_usb_urb_unused_setup_header;

static int hf_usb_urb_interval;

static int hf_usb_urb_start_frame;

static int hf_usb_urb_copy_of_transfer_flags;

/* transfer_flags */

static int hf_short_not_ok;

static int hf_iso_asap;

static int hf_no_transfer_dma_map;

static int hf_no_fsbr;

static int hf_zero_packet;

static int hf_no_interrupt;

static int hf_free_buffer;

static int hf_dir_in;

static int hf_dma_map_single;

static int hf_dma_map_page;

static int hf_dma_map_sg;

static int hf_map_local;

static int hf_setup_map_single;

static int hf_setup_map_local;

static int hf_dma_sg_combined;

static int hf_aligned_temp_buffer;

static int * const transfer_flags_fields[] = {

    &hf_short_not_ok,

    &hf_iso_asap,

    &hf_no_transfer_dma_map,

    &hf_no_fsbr,

    &hf_zero_packet,

    &hf_no_interrupt,

    &hf_free_buffer,

    &hf_dir_in,

    &hf_dma_map_single,

    &hf_dma_map_page,

    &hf_dma_map_sg,

    &hf_map_local,

    &hf_setup_map_single,

    &hf_setup_map_local,

    &hf_dma_sg_combined,

    &hf_aligned_temp_buffer,

    NULL

};

/* Win32 USBPcap pseudoheader fields */

static int hf_usb_win32_header_len;

static int hf_usb_irp_id;

static int hf_usb_usbd_status;

static int hf_usb_function;

static int hf_usb_info;

static int hf_usb_usbpcap_info_reserved;

static int hf_usb_usbpcap_info_direction;

static int hf_usb_win32_device_address;

static int hf_usb_win32_transfer_type;

/* hf_usb_bus_id, hf_usb_endpoint_address, hf_usb_endpoint_direction,

 * hf_usb_endpoint_number are common with

 * FreeBSD and Linux pseudoheaders */

static int hf_usb_win32_data_len;

static int hf_usb_win32_control_stage;

static int hf_usb_win32_iso_start_frame;

static int hf_usb_win32_iso_num_packets;

static int hf_usb_win32_iso_error_count;

static int hf_usb_win32_iso_offset;

static int hf_usb_win32_iso_length;

static int hf_usb_win32_iso_status;

static int hf_usb_request;

static int hf_usb_request_unknown_class;

static int hf_usb_value;

static int hf_usb_index;

static int hf_usb_length;

/* static int hf_usb_data_len; */

static int hf_usb_capdata;

static int hf_usb_device_wFeatureSelector;

static int hf_usb_interface_wFeatureSelector;

static int hf_usb_endpoint_wFeatureSelector;

static int hf_usb_wInterface;

static int hf_usb_wEndpoint;

static int hf_usb_wStatus;

static int hf_usb_wFrameNumber;

static int hf_usb_iso_error_count;

static int hf_usb_iso_numdesc;

static int hf_usb_iso_status;

static int hf_usb_iso_off;

static int hf_usb_iso_len;

static int hf_usb_iso_actual_len;

static int hf_usb_iso_pad;

static int hf_usb_iso_data;

static int hf_usb_bmRequestType;

static int hf_usb_control_response_generic;

static int hf_usb_bmRequestType_direction;

static int hf_usb_bmRequestType_type;

static int hf_usb_bmRequestType_recipient;

static int hf_usb_bDescriptorType;

static int hf_usb_get_descriptor_resp_generic;

static int hf_usb_descriptor_index;

static int hf_usb_language_id;

static int hf_usb_bLength;

static int hf_usb_bcdUSB;

static int hf_usb_bDeviceClass;

static int hf_usb_bDeviceSubClass;

static int hf_usb_bDeviceProtocol;

static int hf_usb_bMaxPacketSize0;

static int hf_usb_idVendor;

static int hf_usb_idProduct;

static int hf_usb_bcdDevice;

static int hf_usb_iManufacturer;

static int hf_usb_iProduct;

static int hf_usb_iSerialNumber;

static int hf_usb_bNumConfigurations;

static int hf_usb_wLANGID;

static int hf_usb_bString;

static int hf_usb_bInterfaceNumber;

static int hf_usb_bAlternateSetting;

static int hf_usb_bNumEndpoints;

static int hf_usb_bInterfaceClass;

static int hf_usb_bInterfaceSubClass;

static int hf_usb_bInterfaceSubClass_audio;

static int hf_usb_bInterfaceSubClass_cdc;

static int hf_usb_bInterfaceSubClass_massstorage;

static int hf_usb_bInterfaceSubClass_hid;

static int hf_usb_bInterfaceSubClass_misc;

static int hf_usb_bInterfaceSubClass_app;

static int hf_usb_bInterfaceProtocol;

static int hf_usb_bInterfaceProtocol_cdc;

static int hf_usb_bInterfaceProtocol_massstorage;

static int hf_usb_bInterfaceProtocol_cdc_data;

static int hf_usb_bInterfaceProtocol_hid_boot;

static int hf_usb_bInterfaceProtocol_app_dfu;

static int hf_usb_bInterfaceProtocol_app_irda;

static int hf_usb_bInterfaceProtocol_app_usb_test_and_measurement;

static int hf_usb_iInterface;

static int hf_usb_bEndpointAddress;

static int hf_usb_bmAttributes;

static int hf_usb_bEndpointAttributeTransfer;

static int hf_usb_bEndpointAttributeSynchonisation;

static int hf_usb_bEndpointAttributeBehaviour;

static int hf_usb_wMaxPacketSize;

static int hf_usb_wMaxPacketSize_size;

static int hf_usb_wMaxPacketSize_slots;

static int hf_usb_bInterval;

static int hf_usb_bMaxBurst;

static int hf_usb_audio_bRefresh;

static int hf_usb_audio_bSynchAddress;

static int hf_usb_bSSEndpointAttributeBulkMaxStreams;

static int hf_usb_bSSEndpointAttributeIsoMult;

static int hf_usb_wBytesPerInterval;

static int hf_usb_wTotalLength;

static int hf_usb_bNumInterfaces;

static int hf_usb_bConfigurationValue;

static int hf_usb_iConfiguration;

static int hf_usb_bMaxPower;

static int hf_usb_configuration_bmAttributes;

static int hf_usb_configuration_legacy10buspowered;

static int hf_usb_configuration_selfpowered;

static int hf_usb_configuration_remotewakeup;

static int hf_usb_bEndpointAddress_direction;

static int hf_usb_bEndpointAddress_number;

static int hf_usb_response_in;

static int hf_usb_time;

static int hf_usb_request_in;

static int hf_usb_bFirstInterface;

static int hf_usb_bInterfaceCount;

static int hf_usb_bFunctionClass;

static int hf_usb_bFunctionSubClass;

static int hf_usb_bFunctionProtocol;

static int hf_usb_iFunction;

static int hf_usb_bNumDeviceCaps;

static int hf_usb_bDevCapabilityType;

static int hf_usb_usb20ext_bmAttributes;

static int hf_usb_usb20ext_LPM;

static int hf_usb_usb20ext_BESL_HIRD;

static int hf_usb_usb20ext_baseline_BESL_valid;

static int hf_usb_usb20ext_deep_BESL_valid;

static int hf_usb_usb20ext_baseline_BESL;

static int hf_usb_usb20ext_deep_BESL;

static int hf_usb_bReserved;

static int hf_usb_PlatformCapabilityUUID;

static int hf_usb_webusb_bcdVersion;

static int hf_usb_webusb_bVendorCode;

static int hf_usb_webusb_iLandingPage;

static int hf_usb_msos20_dwWindowsVersion;

static int hf_usb_msos20_wMSOSDescriptorSetTotalLength;

static int hf_usb_msos20_bMS_VendorCode;

static int hf_usb_msos20_bAltEnumCode;

static int hf_usb_data_fragment;

static int hf_usb_src;

static int hf_usb_dst;

static int hf_usb_addr;

static int hf_usb_ss_bmAttributes;

static int hf_usb_ss_bmAttributes_reserved0;

static int hf_usb_ss_bmAttributes_LTM;

static int hf_usb_ss_bmAttributes_reserved7_2;

static int hf_usb_ss_wSpeedSupported;

static int hf_usb_ss_wSpeedSupported_LS;

static int hf_usb_ss_wSpeedSupported_FS;

static int hf_usb_ss_wSpeedSupported_HS;

static int hf_usb_ss_wSpeedSupported_Gen1;

static int hf_usb_ss_wSpeedSupported_reserved;

static int hf_usb_ss_bFunctionalitySupport;

static int hf_usb_ss_bU1DevExitLat;

static int hf_usb_ss_wU2DevExitLat;

/* macOS */

static int hf_usb_darwin_bcd_version;

static int hf_usb_darwin_header_len;

static int hf_usb_darwin_request_type;

static int hf_usb_darwin_io_len;

static int hf_usb_darwin_io_status;

static int hf_usb_darwin_iso_num_packets;

static int hf_usb_darwin_io_id;

static int hf_usb_darwin_device_location;

static int hf_usb_darwin_speed;

static int hf_usb_darwin_device_address;

static int hf_usb_darwin_endpoint_address;

static int hf_usb_darwin_endpoint_type;

static int hf_usb_darwin_iso_status;

static int hf_usb_darwin_iso_frame_number;

static int hf_usb_darwin_iso_timestamp;

/* NetMon */

static int hf_usbport_event_id;

static int hf_usbport_device_object;

static int hf_usbport_pci_bus;

static int hf_usbport_pci_device;

static int hf_usbport_pci_function;

static int hf_usbport_pci_vendor_id;

static int hf_usbport_pci_device_id;

static int hf_usbport_port_path_depth;

static int hf_usbport_port_path0;

static int hf_usbport_port_path1;

static int hf_usbport_port_path2;

static int hf_usbport_port_path3;

static int hf_usbport_port_path4;

static int hf_usbport_port_path5;

static int hf_usbport_device_handle;

static int hf_usbport_device_speed;

static int hf_usbport_endpoint;

static int hf_usbport_pipehandle;

static int hf_usbport_endpoint_desc_length;

static int hf_usbport_endpoint_desc_type;

static int hf_usbport_endpoint_address;

static int hf_usbport_bm_attributes;

static int hf_usbport_max_packet_size;

static int hf_usbport_interval;

static int hf_usbport_irp;

static int hf_usbport_urb;

static int hf_usbport_urb_transfer_data;

static int hf_usbport_urb_header_length;

static int hf_usbport_urb_header_function;

static int hf_usbport_urb_header_status;

static int hf_usbport_urb_header_usbddevice_handle;

static int hf_usbport_urb_header_usbdflags;

static int hf_usbport_urb_configuration_desc;

static int hf_usbport_urb_configuration_handle;

static int hf_usbport_urb_pipe_handle;

static int hf_usbport_urb_xferflags;

static int hf_usbport_urb_transfer_buffer_length;

static int hf_usbport_urb_transfer_buffer;

static int hf_usbport_urb_transfer_buffer_mdl;

static int hf_usbport_urb_reserved_mbz;

static int hf_usbport_urb_reserved_hcd;

static int hf_usbport_urb_reserved;

static int hf_usbport_keyword;

static int hf_usbport_keyword_diagnostic;

static int hf_usbport_keyword_power_diagnostics;

static int hf_usbport_keyword_perf_diagnostics;

static int hf_usbport_keyword_reserved1;

static int ett_usb_hdr;

static int ett_usb_setup_hdr;

static int ett_usb_isodesc;

static int ett_usb_win32_iso_packet;

static int ett_usb_endpoint;

static int ett_usb_setup_bmrequesttype;

static int ett_usb_usbpcap_info;

static int ett_descriptor_device;

static int ett_configuration_bmAttributes;

static int ett_configuration_bEndpointAddress;

static int ett_endpoint_bmAttributes;

static int ett_endpoint_wMaxPacketSize;

static int ett_usb_xferflags;

static int ett_usb_xferstatus;

static int ett_usb_frame;

static int ett_usb_frame_flags;

static int ett_usbport;

static int ett_usbport_host_controller;

static int ett_usbport_path;

static int ett_usbport_device;

static int ett_usbport_endpoint;

static int ett_usbport_endpoint_desc;

static int ett_usbport_urb;

static int ett_usbport_keyword;

static int ett_transfer_flags;

static int ett_usb20ext_bmAttributes;

static int ett_ss_bmAttributes;

static int ett_ss_wSpeedSupported;

static expert_field ei_usb_undecoded;

static expert_field ei_usb_bLength_even;

static expert_field ei_usb_bLength_too_short;

static expert_field ei_usb_desc_length_invalid;

static expert_field ei_usb_invalid_setup;

static expert_field ei_usb_ss_ep_companion_before_ep;

static expert_field ei_usb_usbpcap_unknown_urb;

static expert_field ei_usb_bad_length;

static expert_field ei_usb_invalid_max_packet_size;

static expert_field ei_usb_invalid_max_packet_size0;

static expert_field ei_usb_invalid_endpoint_type;

static expert_field ei_usb_unexpected_desc_type;

static expert_field ei_usbport_invalid_path_depth;

static int usb_address_type = -1;

static int * const usb_endpoint_fields[] = {

    &hf_usb_endpoint_direction,

    &hf_usb_endpoint_number,

    NULL

};

static int * const usb_usbpcap_info_fields[] = {

    &hf_usb_usbpcap_info_reserved,

    &hf_usb_usbpcap_info_direction,

    NULL

};

static int usb_tap;

static bool try_heuristics = true;

static dissector_table_t usb_bulk_dissector_table;

static dissector_table_t usb_control_dissector_table;

static dissector_table_t usb_interrupt_dissector_table;

static dissector_table_t usb_descriptor_dissector_table;

static heur_dissector_list_t heur_bulk_subdissector_list;

static heur_dissector_list_t heur_control_subdissector_list;

static heur_dissector_list_t heur_interrupt_subdissector_list;

static wmem_tree_t *device_to_protocol_table;

static wmem_tree_t *device_to_product_table;

static wmem_tree_t *usbpcap_setup_data;

static dissector_table_t device_to_dissector;

static dissector_table_t protocol_to_dissector;

static dissector_table_t product_to_dissector;

typedef struct _device_product_data_t {

    uint16_t vendor;

    uint16_t product;

    uint16_t device;

    unsigned  bus_id;

    unsigned  device_address;

} device_product_data_t;

typedef struct _device_protocol_data_t {

    uint32_t protocol;

    unsigned  bus_id;

    unsigned  device_address;

} device_protocol_data_t;

typedef struct _usb_alt_setting_t {

    uint8_t altSetting;

    uint8_t interfaceClass;

    uint8_t interfaceSubclass;

    uint8_t interfaceProtocol;

    uint8_t interfaceNum;

} usb_alt_setting_t;

typedef struct {

    uint64_t usb_id;

    uint8_t setup_data[8];

} usbpcap_setup_data_t;

static const value_string usb_speed_vals[] = {

    {USB_SPEED_UNKNOWN, "Unknown Speed"},

    {USB_SPEED_LOW,     "Low-Speed"},

    {USB_SPEED_FULL,    "Full-Speed"},

    {USB_SPEED_HIGH,    "High-Speed"},

    {0, NULL}

};

/* http://www.usb.org/developers/docs/USB_LANGIDs.pdf */

static const value_string usb_langid_vals[] = {

    {0x0000, "no language specified"},

    {0x0401, "Arabic (Saudi Arabia)"},

    {0x0402, "Bulgarian"},

    {0x0403, "Catalan"},

    {0x0404, "Chinese (Taiwan)"},

    {0x0405, "Czech"},

    {0x0406, "Danish"},

    {0x0407, "German (Standard)"},

    {0x0408, "Greek"},

    {0x0409, "English (United States)"},

    {0x040a, "Spanish (Traditional Sort)"},

    {0x040b, "Finnish"},

    {0x040c, "French (Standard)"},

    {0x040d, "Hebrew"},

    {0x040e, "Hungarian"},

    {0x040f, "Icelandic"},

    {0x0410, "Italian (Standard)"},

    {0x0411, "Japanese"},

    {0x0412, "Korean"},

    {0x0413, "Dutch (Netherlands)"},

    {0x0414, "Norwegian (Bokmal)"},

    {0x0415, "Polish"},

    {0x0416, "Portuguese (Brazil)"},

    {0x0418, "Romanian"},

    {0x0419, "Russian"},

    {0x041a, "Croatian"},

    {0x041b, "Slovak"},

    {0x041c, "Albanian"},

    {0x041d, "Swedish"},

    {0x041e, "Thai"},

    {0x041f, "Turkish"},

    {0x0420, "Urdu (Pakistan)"},

    {0x0421, "Indonesian"},

    {0x0422, "Ukrainian"},

    {0x0423, "Belarussian"},

    {0x0424, "Slovenian"},

    {0x0425, "Estonian"},

    {0x0426, "Latvian"},

    {0x0427, "Lithuanian"},

    {0x0429, "Farsi"},

    {0x042a, "Vietnamese"},

    {0x042b, "Armenian"},

    {0x042c, "Azeri (Latin)"},

    {0x042d, "Basque"},

    {0x042f, "Macedonian"},

    {0x0430, "Sutu"},

    {0x0436, "Afrikaans"},

    {0x0437, "Georgian"},

    {0x0438, "Faeroese"},

    {0x0439, "Hindi"},

    {0x043e, "Malay (Malaysian)"},

    {0x043f, "Kazakh"},

    {0x0441, "Swahili (Kenya)"},

    {0x0443, "Uzbek (Latin)"},

    {0x0444, "Tatar (Tatarstan)"},

    {0x0445, "Bengali"},

    {0x0446, "Punjabi"},

    {0x0447, "Gujarati"},

    {0x0448, "Oriya"},

    {0x0449, "Tamil"},

    {0x044a, "Telugu"},

    {0x044b, "Kannada"},

    {0x044c, "Malayalam"},

    {0x044d, "Assamese"},

    {0x044e, "Marathi"},

    {0x044f, "Sanskrit"},

    {0x0455, "Burmese"},

    {0x0457, "Konkani"},

    {0x0458, "Manipuri"},

    {0x0459, "Sindhi"},

    {0x04ff, "HID (Usage Data Descriptor)"},

    {0x0801, "Arabic (Iraq)"},

    {0x0804, "Chinese (PRC)"},

    {0x0807, "German (Switzerland)"},

    {0x0809, "English (United Kingdom)"},

    {0x080a, "Spanish (Mexican)"},

    {0x080c, "French (Belgian)"},

    {0x0810, "Italian (Switzerland)"},

    {0x0812, "Korean (Johab)"},

    {0x0813, "Dutch (Belgium)"},

    {0x0814, "Norwegian (Nynorsk)"},

    {0x0816, "Portuguese (Standard)"},

    {0x081a, "Serbian (Latin)"},

    {0x081d, "Swedish (Finland)"},

    {0x0820, "Urdu (India)"},

    {0x0827, "Lithuanian (Classic)"},

    {0x082c, "Azeri (Cyrillic)"},

    {0x083e, "Malay (Brunei Darussalam)"},

    {0x0843, "Uzbek (Cyrillic)"},

    {0x0860, "Kashmiri (India)"},

    {0x0861, "Nepali (India)"},

    {0x0c01, "Arabic (Egypt)"},

    {0x0c04, "Chinese (Hong Kong SAR, PRC)"},

    {0x0c07, "German (Austria)"},

    {0x0c09, "English (Australian)"},

    {0x0c0a, "Spanish (Modern Sort)"},

    {0x0c0c, "French (Canadian)"},

    {0x0c1a, "Serbian (Cyrillic)"},

    {0x1001, "Arabic (Libya)"},

    {0x1004, "Chinese (Singapore)"},

    {0x1007, "German (Luxembourg)"},

    {0x1009, "English (Canadian)"},

    {0x100a, "Spanish (Guatemala)"},

    {0x100c, "French (Switzerland)"},

    {0x1401, "Arabic (Algeria)"},

    {0x1404, "Chinese (Macau SAR)"},

    {0x1407, "German (Liechtenstein)"},

    {0x1409, "English (New Zealand)"},

    {0x140a, "Spanish (Costa Rica)"},

    {0x140c, "French (Luxembourg)"},

    {0x1801, "Arabic (Morocco)"},

    {0x1809, "English (Ireland)"},

    {0x180a, "Spanish (Panama)"},

    {0x180c, "French (Monaco)"},

    {0x1c01, "Arabic (Tunisia)"},

    {0x1c09, "English (South Africa)"},

    {0x1c0a, "Spanish (Dominican Republic)"},

    {0x2001, "Arabic (Oman)"},

    {0x2009, "English (Jamaica)"},

    {0x200a, "Spanish (Venezuela)"},

    {0x2401, "Arabic (Yemen)"},

    {0x2409, "English (Caribbean)"},

    {0x240a, "Spanish (Colombia)"},

    {0x2801, "Arabic (Syria)"},

    {0x2809, "English (Belize)"},

    {0x280a, "Spanish (Peru)"},

    {0x2c01, "Arabic (Jordan)"},

    {0x2c09, "English (Trinidad)"},

    {0x2c0a, "Spanish (Argentina)"},

    {0x3001, "Arabic (Lebanon)"},

    {0x3009, "English (Zimbabwe)"},

    {0x300a, "Spanish (Ecuador)"},

    {0x3401, "Arabic (Kuwait)"},

    {0x3409, "English (Philippines)"},

    {0x340a, "Spanish (Chile)"},

    {0x3801, "Arabic (U.A.E.)"},

    {0x380a, "Spanish (Uruguay)"},

    {0x3c01, "Arabic (Bahrain)"},

    {0x3c0a, "Spanish (Paraguay)"},

    {0x4001, "Arabic (Qatar)"},

    {0x400a, "Spanish (Bolivia)"},

    {0x440a, "Spanish (El Salvador)"},

    {0x480a, "Spanish (Honduras)"},

    {0x4c0a, "Spanish (Nicaragua)"},

    {0x500a, "Spanish (Puerto Rico)"},

    {0xf0ff, "HID (Vendor Defined 1)"},

    {0xf4ff, "HID (Vendor Defined 2)"},

    {0xf8ff, "HID (Vendor Defined 3)"},

    {0xfcff, "HID (Vendor Defined 4)"},

    {0, NULL}

};

value_string_ext usb_langid_vals_ext = VALUE_STRING_EXT_INIT(usb_langid_vals);

static const value_string usb_class_vals[] = {

    {IF_CLASS_DEVICE,                   "Device"},

    {IF_CLASS_AUDIO,                    "Audio"},

    {IF_CLASS_COMMUNICATIONS,           "Communications and CDC Control"},

    {IF_CLASS_HID,                      "HID"},

    {IF_CLASS_PHYSICAL,                 "Physical"},

    {IF_CLASS_IMAGE,                    "Imaging"},

    {IF_CLASS_PRINTER,                  "Printer"},

    {IF_CLASS_MASS_STORAGE,             "Mass Storage"},

    {IF_CLASS_HUB,                      "Hub"},

    {IF_CLASS_CDC_DATA,                 "CDC-Data"},

    {IF_CLASS_SMART_CARD,               "Smart Card"},

    {IF_CLASS_CONTENT_SECURITY,         "Content Security"},

    {IF_CLASS_VIDEO,                    "Video"},

    {IF_CLASS_PERSONAL_HEALTHCARE,      "Personal Healthcare"},

    {IF_CLASS_AUDIO_VIDEO,              "Audio/Video Devices"},

    {IF_CLASS_BILLBOARD,                "Billboard Device"},

    {IF_CLASS_USB_C_BRIDGE,             "USB Type-C Bridge"},

    {IF_CLASS_BULK_DISPLAY_PROTO,       "USB Bulk Display Protocol Device"},

    {IF_CLASS_MCTP_USB_EP,              "MCTP over USB Protocol Endpoint Device"},

    {IF_CLASS_I3C,                      "I3C Device"},

    {IF_CLASS_DIAGNOSTIC_DEVICE,        "Diagnostic Device"},

    {IF_CLASS_WIRELESS_CONTROLLER,      "Wireless Controller"},

    {IF_CLASS_MISCELLANEOUS,            "Miscellaneous"},

    {IF_CLASS_APPLICATION_SPECIFIC,     "Application Specific"},

    {IF_CLASS_VENDOR_SPECIFIC,          "Vendor Specific"},

    {0, NULL}

};

value_string_ext usb_class_vals_ext = VALUE_STRING_EXT_INIT(usb_class_vals);

/* use usb class, subclass and protocol id together

  http://www.usb.org/developers/defined_class

  USB Class Definitions for Communications Devices, Revision 1.2 December 6, 2012

*/

static const value_string usb_protocols[] = {

    {0x000000,    "Use class code info from Interface Descriptors"},

    {0x060101,    "Still Imaging"},

    {0x090000,    "Full speed Hub"},

    {0x090001,    "Hi-speed hub with single TT"},

    {0x090002,    "Hi-speed hub with multiple TTs"},

    {0x0D0000,    "Content Security"},

    {0x100100,    "AVControl Interface"},

    {0x100200,    "AVData Video Streaming Interface"},

    {0x100300,    "AVData Audio Streaming Interface"},

    {0x140001,    "MCTP 1.x - MCTP Management-controller and Managed-Device endpoints"},

    {0x140002,    "MCTP 2.x - MCTP Management-controller and Managed-Device endpoints"},

    {0x140101,    "MCTP 1.x - MCTP Host Interface endpoint"},

    {0x140102,    "MCTP 2.x - MCTP Host Interface endpoint"},

    {0xDC0101,    "USB2 Compliance Device"},

    {0xDC0200,    "Debug Target vendor defined"},

    {0xDC0201,    "GNU Remote Debug Command Set"},

    {0xDC0301,    "Vendor defined Trace protocol on DbC"},

    {0xDC0401,    "Vendor defined Dfx protocol on DbC"},

    {0xDC0500,    "Vendor defined Trace protocol over General Purpose (GP) endpoint on DvC"},

    {0xDC0501,    "GNU Protocol protocol over General Purpose (GP) endpoint on DvC"},

    {0xDC0601,    "Vendor defined Dfx protocol on DvC"},

    {0xDC0701,    "Vendor defined Trace protocol on DvC"},

    {0xE00101,    "Bluetooth Programming Interface"},

    {0xE00102,    "UWB Radio Control Interface"},

    {0xE00103,    "Remote NDIS"},

    {0xE00104,    "Bluetooth AMP Controller"},

    {0xE00201,    "Host Wire Adapter Control/Data interface"},

    {0xE00202,    "Device Wire Adapter Control/Data interface"},

    {0xE00203,    "Device Wire Adapter Isochronous interface"},

    {0xEF0101,    "Active Sync device"},

    {0xEF0102,    "Palm Sync"},

    {0xEF0201,    "Interface Association Descriptor"},

    {0xEF0202,    "Wire Adapter Multifunction Peripheral programming interface"},

    {0xEF0301,    "Cable Based Association Framework"},

    {0xEF0401,    "RNDIS over Ethernet"},

    {0xEF0402,    "RNDIS over WiFi"},

    {0xEF0403,    "RNDIS over WiMAX"},

    {0xEF0404,    "RNDIS over WWAN"},

    {0xEF0405,    "RNDIS for Raw IPv4"},

    {0xEF0406,    "RNDIS for Raw IPv6"},

    {0xEF0407,    "RNDIS for GPRS"},

    {0xEF0500,    "USB3 Vision Control Interface"},

    {0xEF0501,    "USB3 Vision Event Interface"},

    {0xEF0502,    "USB3 Vision Streaming Interface"},

    {0xEF0601,    "Stream Transport Efficient Protocol for content protection"},

    {0xEF0602,    "Stream Transport Efficient Protocol for Raw content protection"},

    {0xEF0700,    "Command Interface in IAD"},

    {0xEF0702,    "Command Interface in Interface Descriptor"},

    {0xEF0703,    "Media Interface in Interface Descriptor"},

    {0xFE0101,    "Device Firmware Upgrade"},

    {0xFE0200,    "IRDA Bridge device"},

    {0xFE0300,    "USB Test and Measurement Device"},

    {0xFE0301,    "USB Test and Measurement Device conforming to the USBTMC USB488"},

    {0, NULL}

};

static value_string_ext usb_protocols_ext = VALUE_STRING_EXT_INIT(usb_protocols);

/* BOS Descriptor Device Capability Type Codes

   https://www.usb.org/bos-descriptor-types

*/

#define BOS_CAP_WIRELESS_USB           0x01

#define BOS_CAP_USB_20_EXTENSION       0x02

#define BOS_CAP_SUPERSPEED_USB         0x03

#define BOS_CAP_CONTAINER_ID           0x04

#define BOS_CAP_PLATFORM               0x05

#define BOS_CAP_POWER_DELIVERY         0x06

#define BOS_CAP_BATTERY_INFO           0x07

#define BOS_CAP_PD_CONSUMER_PORT       0x08

#define BOS_CAP_PD_PROVIDER_PORT       0x09

#define BOS_CAP_SUPERSPEED_PLUS        0x0A

#define BOS_CAP_PRECISION_TIME_MEAS    0x0B

#define BOS_CAP_WIRELESS_USB_EXT       0x0C

#define BOS_CAP_BILLBOARD              0x0D

#define BOS_CAP_AUTHENTICATION         0x0E

#define BOS_CAP_BILLBOARD_EX           0x0F

#define BOS_CAP_CONFIGURATION_SUMMARY  0x10

#define BOS_CAP_FWSTATUS               0x11

#define BOS_CAP_USB3_GEN_T             0x13

static const value_string usb_capability_vals[] = {

    {BOS_CAP_WIRELESS_USB,          "Wireless USB"},

    {BOS_CAP_USB_20_EXTENSION,      "USB 2.0 Extension Descriptor"},

    {BOS_CAP_SUPERSPEED_USB,        "SuperSpeed USB"},

    {BOS_CAP_CONTAINER_ID,          "Container ID"},

    {BOS_CAP_PLATFORM,              "Platform"},

    {BOS_CAP_POWER_DELIVERY,        "Power Delivery Capability"},

    {BOS_CAP_BATTERY_INFO,          "Battery Info Capability"},

    {BOS_CAP_PD_CONSUMER_PORT,      "PD Consumer Port Capability"},

    {BOS_CAP_PD_PROVIDER_PORT,      "PD Provider Port Capability"},

    {BOS_CAP_SUPERSPEED_PLUS,       "SuperSpeed Plus"},

    {BOS_CAP_PRECISION_TIME_MEAS,   "Precision Time Measurement"},

    {BOS_CAP_WIRELESS_USB_EXT,      "Wireless USB Ext"},

    {BOS_CAP_BILLBOARD,             "Billboard Capability"},

    {BOS_CAP_AUTHENTICATION,        "Authentication Capability Descriptor"},

    {BOS_CAP_BILLBOARD_EX,          "Billboard Ex capability"},

    {BOS_CAP_CONFIGURATION_SUMMARY, "Configuration Summary"},

    {BOS_CAP_FWSTATUS,              "Firmware Status"},

    {0x12,                          "TBD (reserved for USB Audio 4.0)"},

    {BOS_CAP_USB3_GEN_T,            "USB 3 Gen T Capability"},

    {0x14,                          "TBD (reserved for USB PD)"},

    {0, NULL}

};

static value_string_ext usb_capability_vals_ext = VALUE_STRING_EXT_INIT(usb_capability_vals);

#define SS_SPEED_SUPPORTED_BIT_LS        0

#define SS_SPEED_SUPPORTED_BIT_FS        1

#define SS_SPEED_SUPPORTED_BIT_HS        2

#define SS_SPEED_SUPPORTED_BIT_GEN1      3

#define SS_SPEED_SUPPORTED_STR_LS        "low-speed"

#define SS_SPEED_SUPPORTED_STR_FS        "full-speed"

#define SS_SPEED_SUPPORTED_STR_HS        "high-speed"

#define SS_SPEED_SUPPORTED_STR_GEN1      "Gen 1 speed"

static const value_string usb_ss_bFunctionalitySupport_vals[] = {

    {SS_SPEED_SUPPORTED_BIT_LS,        SS_SPEED_SUPPORTED_STR_LS},

    {SS_SPEED_SUPPORTED_BIT_FS,        SS_SPEED_SUPPORTED_STR_FS},

    {SS_SPEED_SUPPORTED_BIT_HS,        SS_SPEED_SUPPORTED_STR_HS},

    {SS_SPEED_SUPPORTED_BIT_GEN1,      SS_SPEED_SUPPORTED_STR_GEN1},

    {0, NULL}

};

static value_string_ext usb_ss_bFunctionalitySupport_vals_ext =

    VALUE_STRING_EXT_INIT(usb_ss_bFunctionalitySupport_vals);

static const true_false_string tfs_usb_ss_bmAttributes_reserved0 = {

    "FIXME: Shall be set to zero",

    "Shall be set to zero"

};

/* FreeBSD header */

/* Transfer mode */

#define FREEBSD_MODE_HOST       0

#define FREEBSD_MODE_DEVICE     1

static const value_string usb_freebsd_transfer_mode_vals[] = {

    {FREEBSD_MODE_HOST,   "Host"},

    {FREEBSD_MODE_DEVICE, "Device"},

    {0, NULL}

};

/* Type */

#define FREEBSD_URB_SUBMIT   0

#define FREEBSD_URB_COMPLETE 1

static const value_string usb_freebsd_urb_type_vals[] = {

    {FREEBSD_URB_SUBMIT,   "URB_SUBMIT"},

    {FREEBSD_URB_COMPLETE, "URB_COMPLETE"},

    {0, NULL}

};

/* Transfer type */

#define FREEBSD_URB_CONTROL     0

#define FREEBSD_URB_ISOCHRONOUS 1

#define FREEBSD_URB_BULK        2

#define FREEBSD_URB_INTERRUPT   3

static const value_string usb_freebsd_transfer_type_vals[] = {

    {FREEBSD_URB_CONTROL,     "URB_CONTROL"},

    {FREEBSD_URB_ISOCHRONOUS, "URB_ISOCHRONOUS"},

    {FREEBSD_URB_BULK,        "URB_BULK"},

    {FREEBSD_URB_INTERRUPT,   "URB_INTERRUPT"},

    {0, NULL}

};

/* Transfer flags */

#define FREEBSD_FLAG_FORCE_SHORT_XFER 0x00000001

#define FREEBSD_FLAG_SHORT_XFER_OK    0x00000002

#define FREEBSD_FLAG_SHORT_FRAMES_OK  0x00000004

#define FREEBSD_FLAG_PIPE_BOF         0x00000008

#define FREEBSD_FLAG_PROXY_BUFFER     0x00000010

#define FREEBSD_FLAG_EXT_BUFFER       0x00000020

#define FREEBSD_FLAG_MANUAL_STATUS    0x00000040

#define FREEBSD_FLAG_NO_PIPE_OK       0x00000080

#define FREEBSD_FLAG_STALL_PIPE       0x00000100

static int * const usb_xferflags_fields[] = {

    &hf_usb_xferflags_force_short_xfer,

    &hf_usb_xferflags_short_xfer_ok,

    &hf_usb_xferflags_short_frames_ok,

    &hf_usb_xferflags_pipe_bof,

    &hf_usb_xferflags_proxy_buffer,

    &hf_usb_xferflags_ext_buffer,

    &hf_usb_xferflags_manual_status,

    &hf_usb_xferflags_no_pipe_ok,

    &hf_usb_xferflags_stall_pipe,

    NULL

};

/* Transfer status */

#define FREEBSD_STATUS_OPEN              0x00000001

#define FREEBSD_STATUS_TRANSFERRING      0x00000002

#define FREEBSD_STATUS_DID_DMA_DELAY     0x00000004

#define FREEBSD_STATUS_DID_CLOSE         0x00000008

#define FREEBSD_STATUS_DRAINING          0x00000010

#define FREEBSD_STATUS_STARTED           0x00000020

#define FREEBSD_STATUS_BW_RECLAIMED      0x00000040

#define FREEBSD_STATUS_CONTROL_XFR       0x00000080

#define FREEBSD_STATUS_CONTROL_HDR       0x00000100

#define FREEBSD_STATUS_CONTROL_ACT       0x00000200

#define FREEBSD_STATUS_CONTROL_STALL     0x00000400

#define FREEBSD_STATUS_SHORT_FRAMES_OK   0x00000800

#define FREEBSD_STATUS_SHORT_XFER_OK     0x00001000

#define FREEBSD_STATUS_BDMA_ENABLE       0x00002000

#define FREEBSD_STATUS_BDMA_NO_POST_SYNC 0x00004000

#define FREEBSD_STATUS_BDMA_SETUP        0x00008000

#define FREEBSD_STATUS_ISOCHRONOUS_XFR   0x00010000

#define FREEBSD_STATUS_CURR_DMA_SET      0x00020000

#define FREEBSD_STATUS_CAN_CANCEL_IMMED  0x00040000

#define FREEBSD_STATUS_DOING_CALLBACK    0x00080000

static int * const usb_xferstatus_fields[] = {

    &hf_usb_xferstatus_open,

    &hf_usb_xferstatus_transferring,

    &hf_usb_xferstatus_did_dma_delay,

    &hf_usb_xferstatus_did_close,

    &hf_usb_xferstatus_draining,

    &hf_usb_xferstatus_started,

    &hf_usb_xferstatus_bw_reclaimed,

    &hf_usb_xferstatus_control_xfr,

    &hf_usb_xferstatus_control_hdr,

    &hf_usb_xferstatus_control_act,

    &hf_usb_xferstatus_control_stall,

    &hf_usb_xferstatus_short_frames_ok,

    &hf_usb_xferstatus_short_xfer_ok,

    &hf_usb_xferstatus_bdma_enable,

    &hf_usb_xferstatus_bdma_no_post_sync,

    &hf_usb_xferstatus_bdma_setup,

    &hf_usb_xferstatus_isochronous_xfr,

    &hf_usb_xferstatus_curr_dma_set,

    &hf_usb_xferstatus_can_cancel_immed,

    &hf_usb_xferstatus_doing_callback,

    NULL

};

/* USB errors */

#define FREEBSD_ERR_NORMAL_COMPLETION 0

#define FREEBSD_ERR_PENDING_REQUESTS  1

#define FREEBSD_ERR_NOT_STARTED       2

#define FREEBSD_ERR_INVAL             3

#define FREEBSD_ERR_NOMEM             4

#define FREEBSD_ERR_CANCELLED         5

#define FREEBSD_ERR_BAD_ADDRESS       6

#define FREEBSD_ERR_BAD_BUFSIZE       7

#define FREEBSD_ERR_BAD_FLAG          8

#define FREEBSD_ERR_NO_CALLBACK       9

#define FREEBSD_ERR_IN_USE            10

#define FREEBSD_ERR_NO_ADDR           11

#define FREEBSD_ERR_NO_PIPE           12

#define FREEBSD_ERR_ZERO_NFRAMES      13

#define FREEBSD_ERR_ZERO_MAXP         14

#define FREEBSD_ERR_SET_ADDR_FAILED   15

#define FREEBSD_ERR_NO_POWER          16

#define FREEBSD_ERR_TOO_DEEP          17

#define FREEBSD_ERR_IOERROR           18

#define FREEBSD_ERR_NOT_CONFIGURED    19

#define FREEBSD_ERR_TIMEOUT           20

#define FREEBSD_ERR_SHORT_XFER        21

#define FREEBSD_ERR_STALLED           22

#define FREEBSD_ERR_INTERRUPTED       23

#define FREEBSD_ERR_DMA_LOAD_FAILED   24

#define FREEBSD_ERR_BAD_CONTEXT       25

#define FREEBSD_ERR_NO_ROOT_HUB       26

#define FREEBSD_ERR_NO_INTR_THREAD    27

#define FREEBSD_ERR_NOT_LOCKED        28

static const value_string usb_freebsd_err_vals[] = {

    {FREEBSD_ERR_NORMAL_COMPLETION, "Normal completion"},

    {FREEBSD_ERR_PENDING_REQUESTS,  "Pending requests"},

    {FREEBSD_ERR_NOT_STARTED,       "Not started"},

    {FREEBSD_ERR_INVAL,             "Invalid"},

    {FREEBSD_ERR_NOMEM,             "No memory"},

    {FREEBSD_ERR_CANCELLED,         "Cancelled"},

    {FREEBSD_ERR_BAD_ADDRESS,       "Bad address"},

    {FREEBSD_ERR_BAD_BUFSIZE,       "Bad buffer size"},

    {FREEBSD_ERR_BAD_FLAG,          "Bad flag"},

    {FREEBSD_ERR_NO_CALLBACK,       "No callback"},

    {FREEBSD_ERR_IN_USE,            "In use"},

    {FREEBSD_ERR_NO_ADDR,           "No address"},

    {FREEBSD_ERR_NO_PIPE,           "No pipe"},

    {FREEBSD_ERR_ZERO_NFRAMES,      "Number of frames is zero"},

    {FREEBSD_ERR_ZERO_MAXP,         "MAXP is zero"},

    {FREEBSD_ERR_SET_ADDR_FAILED,   "Set address failed"},

    {FREEBSD_ERR_NO_POWER,          "No power"},

    {FREEBSD_ERR_TOO_DEEP,          "Too deep"},

    {FREEBSD_ERR_IOERROR,           "I/O error"},

    {FREEBSD_ERR_NOT_CONFIGURED,    "Not configured"},

    {FREEBSD_ERR_TIMEOUT,           "Timeout"},

    {FREEBSD_ERR_SHORT_XFER,        "Short transfer"},

    {FREEBSD_ERR_STALLED,           "Stalled"},

    {FREEBSD_ERR_INTERRUPTED,       "Interrupted"},

    {FREEBSD_ERR_DMA_LOAD_FAILED,   "DMA load failed"},

    {FREEBSD_ERR_BAD_CONTEXT,       "Bad context"},

    {FREEBSD_ERR_NO_ROOT_HUB,       "No root hub"},

    {FREEBSD_ERR_NO_INTR_THREAD,    "No interrupt thread"},

    {FREEBSD_ERR_NOT_LOCKED,        "Not locked"},

    {0, NULL}

};

/* USB speeds */

#define FREEBSD_SPEED_VARIABLE 0

#define FREEBSD_SPEED_LOW      1

#define FREEBSD_SPEED_FULL     2

#define FREEBSD_SPEED_HIGH     3

#define FREEBSD_SPEED_SUPER    4

static const value_string usb_freebsd_speed_vals[] = {

    {FREEBSD_SPEED_VARIABLE, "Variable"},

    {FREEBSD_SPEED_LOW,      "Low"},

    {FREEBSD_SPEED_FULL,     "Full"},

    {FREEBSD_SPEED_HIGH,     "High"},

    {FREEBSD_SPEED_SUPER,    "Super"},

    {0, NULL}

};

/* Frame flags */

#define FREEBSD_FRAMEFLAG_READ         0x00000001

#define FREEBSD_FRAMEFLAG_DATA_FOLLOWS 0x00000002

static int * const usb_frame_flags_fields[] = {

    &hf_usb_frame_flags_read,

    &hf_usb_frame_flags_data_follows,

    NULL

};

static const value_string usb_linux_urb_type_vals[] = {

    {URB_SUBMIT,   "URB_SUBMIT"},

    {URB_COMPLETE, "URB_COMPLETE"},

    {URB_ERROR,    "URB_ERROR"},

    {0, NULL}

};

static const value_string usb_linux_transfer_type_vals[] = {

    {URB_CONTROL,                       "URB_CONTROL"},

    {URB_ISOCHRONOUS,                   "URB_ISOCHRONOUS"},

    {URB_INTERRUPT,                     "URB_INTERRUPT"},

    {URB_BULK,                          "URB_BULK"},

    {0, NULL}

};

static const value_string usb_transfer_type_and_direction_vals[] = {

    {URB_CONTROL,                       "URB_CONTROL out"},

    {URB_ISOCHRONOUS,                   "URB_ISOCHRONOUS out"},

    {URB_INTERRUPT,                     "URB_INTERRUPT out"},

    {URB_BULK,                          "URB_BULK out"},

    {URB_CONTROL | URB_TRANSFER_IN,     "URB_CONTROL in"},

    {URB_ISOCHRONOUS | URB_TRANSFER_IN, "URB_ISOCHRONOUS in"},

    {URB_INTERRUPT | URB_TRANSFER_IN,   "URB_INTERRUPT in"},

    {URB_BULK | URB_TRANSFER_IN,        "URB_BULK in"},

    {0, NULL}

};

static const value_string usb_endpoint_direction_vals[] = {

    {0, "OUT"},

    {1, "IN"},

    {0, NULL}

};

static const range_string usb_setup_flag_rvals[] = {

    {0, 0, "relevant"},

    {1, 255, "not relevant"},

    {0, 0, NULL}

};

static const range_string usb_data_flag_rvals[] = {

    {0, 0, "present"},

    {1, 255, "not present"},

    {0, 0, NULL}

};

extern value_string_ext ext_usb_vendors_vals;

extern value_string_ext ext_usb_products_vals;

extern value_string_ext ext_usb_audio_subclass_vals;

extern value_string_ext ext_usb_com_subclass_vals;

extern value_string_ext ext_usb_massstorage_subclass_vals;

extern value_string_ext linux_negative_errno_vals_ext;

/*

 * Standard descriptor types.

 *

 * all class specific descriptor types were removed from this list

 * a descriptor type is not globally unique

 * dissectors for the USB classes should provide their own value string

 *  and pass it to dissect_usb_descriptor_header()

 *

 */

#define USB_DT_DEVICE                          1

#define USB_DT_CONFIG                          2

#define USB_DT_STRING                          3

#define USB_DT_INTERFACE                       4

#define USB_DT_ENDPOINT                        5

#define USB_DT_DEVICE_QUALIFIER                6

#define USB_DT_OTHER_SPEED_CONFIG              7

#define USB_DT_INTERFACE_POWER                 8

/* these are from a minor usb 2.0 revision (ECN) */

#define USB_DT_OTG                             9

#define USB_DT_DEBUG                          10

#define USB_DT_INTERFACE_ASSOCIATION          11

/* these are from usb 3.0 specification */

#define USB_DT_BOS                          0x0F

#define USB_DT_DEVICE_CAPABILITY            0x10

#define USB_DT_SUPERSPEED_EP_COMPANION      0x30

/* these are from usb 3.1 specification */

#define USB_DT_SUPERSPEED_ISO_EP_COMPANION  0x31

/* There are only Standard Descriptor Types, Class-specific types are

   provided by "usb.descriptor" descriptors table*/

static const value_string std_descriptor_type_vals[] = {

    {USB_DT_DEVICE,                         "DEVICE"},

    {USB_DT_CONFIG,                         "CONFIGURATION"},

    {USB_DT_STRING,                         "STRING"},

    {USB_DT_INTERFACE,                      "INTERFACE"},

    {USB_DT_ENDPOINT,                       "ENDPOINT"},

    {USB_DT_DEVICE_QUALIFIER,               "DEVICE QUALIFIER"},

    {USB_DT_OTHER_SPEED_CONFIG,             "OTHER SPEED CONFIG"},

    {USB_DT_INTERFACE_POWER,                "INTERFACE POWER"},

    {USB_DT_OTG,                            "OTG"},

    {USB_DT_DEBUG,                          "DEBUG"},

    {USB_DT_INTERFACE_ASSOCIATION,          "INTERFACE ASSOCIATION"},

    {USB_DT_BOS,                            "BOS"},

    {USB_DT_DEVICE_CAPABILITY,              "DEVICE CAPABILITY"},

    {USB_DT_SUPERSPEED_EP_COMPANION,        "SUPERSPEED USB ENDPOINT COMPANION"},

    {USB_DT_SUPERSPEED_ISO_EP_COMPANION,    "SUPERSPEED PLUS ISOCHRONOUS ENDPOINT COMPANION"},

    {0,NULL}

};

static value_string_ext std_descriptor_type_vals_ext =

               VALUE_STRING_EXT_INIT(std_descriptor_type_vals);

/*

 * Feature selectors.

 * Per USB 3.1 spec, Table 9-7

 */

#define USB_FS_ENDPOINT_HALT            0

#define USB_FS_FUNCTION_SUSPEND         0 /* same as ENDPOINT_HALT */

#define USB_FS_DEVICE_REMOTE_WAKEUP     1

#define USB_FS_TEST_MODE                2

#define USB_FS_B_HNP_ENABLE             3

#define USB_FS_A_HNP_SUPPORT            4

#define USB_FS_A_ALT_HNP_SUPPORT        5

#define USB_FS_WUSB_DEVICE              6

#define USB_FS_U1_ENABLE                48

#define USB_FS_U2_ENABLE                49

#define USB_FS_LTM_ENABLE               50

#define USB_FS_B3_NTF_HOST_REL          51

#define USB_FS_B3_RSP_ENABLE            52

#define USB_FS_LDM_ENABLE               53

static const value_string usb_endpoint_feature_selector_vals[] = {

    {USB_FS_ENDPOINT_HALT,              "ENDPOINT HALT"},

    {0, NULL}

};