/* packet-usb-hid.c

 *

 * USB HID dissector

 * By Adam Nielsen <a.nielsen@shikadi.net> 2009

 *

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

 */

/* See specification at

 * https://www.usb.org/sites/default/files/hid1_11.pdf

 * https://www.usb.org/sites/default/files/hut1_22.pdf

 */

#include "config.h"

#include <epan/packet.h>

#include "wsutil/sign_ext.h"

#include "wsutil/pint.h"

#include "packet-usb.h"

#include "packet-usb-hid.h"

#include "packet-btsdp.h"

void proto_register_usb_hid(void);

void proto_reg_handoff_usb_hid(void);

/* Dissector handles */

static dissector_handle_t usb_hid_control_handle;

static dissector_handle_t usb_hid_interrupt_handle;

static dissector_handle_t usb_hid_descr_handle;

/* protocols and header fields */

static int proto_usb_hid;

static int hf_usb_hid_item_bSize;

static int hf_usb_hid_item_bType;

static int hf_usb_hid_mainitem_bTag;

static int hf_usb_hid_globalitem_bTag;

static int hf_usb_hid_localitem_bTag;

static int hf_usb_hid_longitem_bTag;

static int hf_usb_hid_item_bDataSize;

static int hf_usb_hid_item_bLongItemTag;

static int hf_usb_hid_item_unk_data;

static int hf_usb_hid_mainitem_bit0;

static int hf_usb_hid_mainitem_bit1;

static int hf_usb_hid_mainitem_bit2;

static int hf_usb_hid_mainitem_bit3;

static int hf_usb_hid_mainitem_bit4;

static int hf_usb_hid_mainitem_bit5;

static int hf_usb_hid_mainitem_bit6;

static int hf_usb_hid_mainitem_bit7;

static int hf_usb_hid_mainitem_bit7_input;

static int hf_usb_hid_mainitem_bit8;

static int hf_usb_hid_mainitem_colltype;

static int hf_usb_hid_globalitem_usage;

static int hf_usb_hid_globalitem_log_min;

static int hf_usb_hid_globalitem_log_max;

static int hf_usb_hid_globalitem_phy_min;

static int hf_usb_hid_globalitem_phy_max;

static int hf_usb_hid_globalitem_unit_exp;

static int hf_usb_hid_globalitem_unit_sys;

static int hf_usb_hid_globalitem_unit_len;

static int hf_usb_hid_globalitem_unit_mass;

static int hf_usb_hid_globalitem_unit_time;

static int hf_usb_hid_globalitem_unit_temp;

static int hf_usb_hid_globalitem_unit_current;

static int hf_usb_hid_globalitem_unit_brightness;

static int hf_usb_hid_globalitem_report_size;

static int hf_usb_hid_globalitem_report_id;

static int hf_usb_hid_globalitem_report_count;

static int hf_usb_hid_globalitem_push;

static int hf_usb_hid_globalitem_pop;

static int hf_usb_hid_localitem_usage;

static int hf_usb_hid_localitem_usage_min;

static int hf_usb_hid_localitem_usage_max;

static int hf_usb_hid_localitem_desig_index;

static int hf_usb_hid_localitem_desig_min;

static int hf_usb_hid_localitem_desig_max;

static int hf_usb_hid_localitem_string_index;

static int hf_usb_hid_localitem_string_min;

static int hf_usb_hid_localitem_string_max;

static int hf_usb_hid_localitem_delimiter;

static int ett_usb_hid_report;

static int ett_usb_hid_item_header;

static int ett_usb_hid_wValue;

static int ett_usb_hid_descriptor;

static int ett_usb_hid_data;

static int ett_usb_hid_unknown_data;

static int ett_usb_hid_array;

static int hf_usb_hid_request;

static int hf_usb_hid_value;

static int hf_usb_hid_index;

static int hf_usb_hid_length;

static int hf_usb_hid_report_type;

static int hf_usb_hid_report_id;

static int hf_usb_hid_duration;

static int hf_usb_hid_zero;

static int hf_usb_hid_protocol;

static int hf_usb_hid_bcdHID;

static int hf_usb_hid_bCountryCode;

static int hf_usb_hid_bNumDescriptors;

static int hf_usb_hid_bDescriptorIndex;

static int hf_usb_hid_bDescriptorType;

static int hf_usb_hid_wInterfaceNumber;

static int hf_usb_hid_wDescriptorLength;

static int hf_usbhid_boot_report_keyboard_modifier_right_gui;

static int hf_usbhid_boot_report_keyboard_modifier_right_alt;

static int hf_usbhid_boot_report_keyboard_modifier_right_shift;

static int hf_usbhid_boot_report_keyboard_modifier_right_ctrl;

static int hf_usbhid_boot_report_keyboard_modifier_left_gui;

static int hf_usbhid_boot_report_keyboard_modifier_left_alt;

static int hf_usbhid_boot_report_keyboard_modifier_left_shift;

static int hf_usbhid_boot_report_keyboard_modifier_left_ctrl;

static int hf_usbhid_boot_report_keyboard_reserved;

static int hf_usbhid_boot_report_keyboard_keycode_1;

static int hf_usbhid_boot_report_keyboard_keycode_2;

static int hf_usbhid_boot_report_keyboard_keycode_3;

static int hf_usbhid_boot_report_keyboard_keycode_4;

static int hf_usbhid_boot_report_keyboard_keycode_5;

static int hf_usbhid_boot_report_keyboard_keycode_6;

static int hf_usbhid_boot_report_keyboard_leds_constants;

static int hf_usbhid_boot_report_keyboard_leds_kana;

static int hf_usbhid_boot_report_keyboard_leds_compose;

static int hf_usbhid_boot_report_keyboard_leds_scroll_lock;

static int hf_usbhid_boot_report_keyboard_leds_caps_lock;

static int hf_usbhid_boot_report_keyboard_leds_num_lock;

static int hf_usbhid_boot_report_mouse_button_8;

static int hf_usbhid_boot_report_mouse_button_7;

static int hf_usbhid_boot_report_mouse_button_6;

static int hf_usbhid_boot_report_mouse_button_5;

static int hf_usbhid_boot_report_mouse_button_4;

static int hf_usbhid_boot_report_mouse_button_middle;

static int hf_usbhid_boot_report_mouse_button_right;

static int hf_usbhid_boot_report_mouse_button_left;

static int hf_usbhid_boot_report_mouse_x_displacement;

static int hf_usbhid_boot_report_mouse_y_displacement;

static int hf_usbhid_boot_report_mouse_horizontal_scroll_wheel;

static int hf_usbhid_boot_report_mouse_vertical_scroll_wheel;

static int hf_usbhid_data;

static int hf_usbhid_unknown_data;

static int hf_usbhid_vendor_data;

static int hf_usbhid_report_id;

static int hf_usbhid_padding;

static int hf_usbhid_axis_x;

static int hf_usbhid_axis_y;

static int hf_usbhid_axis_z;

static int hf_usbhid_axis_rx;

static int hf_usbhid_axis_ry;

static int hf_usbhid_axis_rz;

static int hf_usbhid_axis_slider;

static int hf_usbhid_axis_vx;

static int hf_usbhid_axis_vy;

static int hf_usbhid_axis_vz;

static int hf_usbhid_axis_vbrx;

static int hf_usbhid_axis_vbry;

static int hf_usbhid_axis_vbrz;

static int hf_usbhid_axis_vno;

static int hf_usbhid_button;

static int hf_usbhid_key;

static int hf_usbhid_array;

static int hf_usbhid_array_usage;

static const true_false_string tfs_mainitem_bit0 = {"Constant", "Data"};

static const true_false_string tfs_mainitem_bit1 = {"Variable", "Array"};

static const true_false_string tfs_mainitem_bit2 = {"Relative", "Absolute"};

static const true_false_string tfs_mainitem_bit3 = {"Wrap", "No Wrap"};

static const true_false_string tfs_mainitem_bit4 = {"Non Linear", "Linear"};

static const true_false_string tfs_mainitem_bit5 = {"No Preferred", "Preferred State"};

static const true_false_string tfs_mainitem_bit6 = {"Null state", "No Null position"};

static const true_false_string tfs_mainitem_bit7 = {"Volatile", "Non Volatile"};

static const true_false_string tfs_mainitem_bit8 = {"Buffered Bytes", "Bit Field"};

struct usb_hid_global_state {

    unsigned int usage_page;

};

static wmem_tree_t *report_descriptors;

/* local items */

#define HID_USAGE_MIN       (1 << 0)

#define HID_USAGE_MAX       (1 << 1)

/* global items */

#define HID_REPORT_ID       (1 << 2)

#define HID_REPORT_COUNT    (1 << 3)

#define HID_REPORT_SIZE     (1 << 4)

#define HID_LOGICAL_MIN     (1 << 5)

#define HID_LOGICAL_MAX     (1 << 6)

#define HID_USAGE_PAGE      (1 << 7)

/* main items */

#define HID_INPUT           (1 << 8)

#define HID_OUTPUT          (1 << 9)

#define HID_FEATURE         (1 << 10)

#define HID_EXTENDED_USAGE  (1 << 11)

/* masks */

#define HID_GLOBAL_MASK     (HID_REPORT_ID | \

                             HID_REPORT_COUNT | \

                             HID_REPORT_SIZE | \

                             HID_LOGICAL_MIN | \

                             HID_LOGICAL_MAX | \

                             HID_USAGE_PAGE)

#define HID_REQUIRED_MASK   (HID_REPORT_COUNT | \

                             HID_REPORT_SIZE | \

                             HID_LOGICAL_MIN | \

                             HID_LOGICAL_MAX)

#define HID_MAIN_CONSTANT       (1 << 0) /* data / constant                 */

#define HID_MAIN_TYPE           (1 << 1) /* array / variable                */

#define HID_MAIN_RELATIVE       (1 << 2) /* absolute / relative             */

#define HID_MAIN_WRAP           (1 << 3) /* no wrap / wrap                  */

#define HID_MAIN_NON_LINEAR     (1 << 4) /* linear / non linear             */

#define HID_MAIN_NO_PREFERRED   (1 << 5) /* preferred state / no preferred  */

#define HID_MAIN_NULL_STATE     (1 << 6) /* no null position / null state   */

#define HID_MAIN_BUFFERED_BYTES (1 << 8) /* bit field / buffered bytes      */

#define HID_MAIN_ARRAY          (0 << 1)

#define HID_MAIN_VARIABLE       (1 << 1)

#define HID_USAGE_UNSET         0

#define HID_USAGE_SINGLE        1

#define HID_USAGE_RANGE         2

#define USAGE_ID(usage)    (usage & 0x0000FFFF)

#define USAGE_PAGE(usage) ((usage & 0xFFFF0000) >> 16)

typedef struct _hid_field hid_field_t;

struct _hid_field {

    wmem_array_t   *usages;

    uint32_t        report_id;  /* optional */

    uint32_t        report_count;

    uint32_t        report_size;

    int32_t         logical_min;

    int32_t         logical_max;

    uint32_t        properties;

    hid_field_t *next;

};

typedef struct _report_descriptor report_descriptor_t;

struct _report_descriptor {

    uint16_t                bus_id;

    uint16_t                device_address;

    uint8_t                 interface;

    uint32_t                frame_num;

    int                     desc_length;

    uint8_t                *desc_body;

    bool                    uses_report_id;

    wmem_array_t           *fields_in;

    wmem_array_t           *fields_out;

    /* TODO: features */

    report_descriptor_t    *next;

};

#define USBHID_GENERIC_DESKTOP_CONTROLS_X           0x0030

#define USBHID_GENERIC_DESKTOP_CONTROLS_Y           0x0031

#define USBHID_GENERIC_DESKTOP_CONTROLS_Z           0x0032

#define USBHID_GENERIC_DESKTOP_CONTROLS_RX          0x0033

#define USBHID_GENERIC_DESKTOP_CONTROLS_RY          0x0034

#define USBHID_GENERIC_DESKTOP_CONTROLS_RZ          0x0035

#define USBHID_GENERIC_DESKTOP_CONTROLS_SLIDER      0x0036

#define USBHID_GENERIC_DESKTOP_CONTROLS_VX          0x0040

#define USBHID_GENERIC_DESKTOP_CONTROLS_VY          0x0041

#define USBHID_GENERIC_DESKTOP_CONTROLS_VZ          0x0042

#define USBHID_GENERIC_DESKTOP_CONTROLS_VBRX        0x0043

#define USBHID_GENERIC_DESKTOP_CONTROLS_VBRY        0x0044

#define USBHID_GENERIC_DESKTOP_CONTROLS_VBRZ        0x0045

#define USBHID_GENERIC_DESKTOP_CONTROLS_VNO         0x0046

/* HID class specific descriptor types */

#define USB_DT_HID        0x21

#define USB_DT_HID_REPORT 0x22

static const value_string hid_descriptor_type_vals[] = {

    {USB_DT_HID, "HID"},

    {USB_DT_HID_REPORT, "HID Report"},

    {0, NULL}

};

static value_string_ext hid_descriptor_type_vals_ext =

               VALUE_STRING_EXT_INIT(hid_descriptor_type_vals);

#define USBHID_SIZE_MASK  0x03

#define USBHID_TYPE_MASK  0x0C

#define USBHID_TAG_MASK   0xF0

static const value_string usb_hid_item_bSize_vals[] = {

    {0, "0 bytes"},

    {1, "1 byte"},

    {2, "2 bytes"},

    {3, "4 bytes"},

    {0, NULL}

};

#define USBHID_ITEMTYPE_MAIN    0

#define USBHID_ITEMTYPE_GLOBAL  1

#define USBHID_ITEMTYPE_LOCAL   2

#define USBHID_ITEMTYPE_LONG    3

static const value_string usb_hid_item_bType_vals[] = {

    {USBHID_ITEMTYPE_MAIN,   "Main"},

    {USBHID_ITEMTYPE_GLOBAL, "Global"},

    {USBHID_ITEMTYPE_LOCAL,  "Local"},

    {USBHID_ITEMTYPE_LONG,   "Long item"},

    {0, NULL}

};

#define USBHID_MAINITEM_TAG_INPUT           8

#define USBHID_MAINITEM_TAG_OUTPUT          9

#define USBHID_MAINITEM_TAG_FEATURE        11

#define USBHID_MAINITEM_TAG_COLLECTION     10

#define USBHID_MAINITEM_TAG_ENDCOLLECTION  12

static const value_string usb_hid_mainitem_bTag_vals[] = {

    {USBHID_MAINITEM_TAG_INPUT,         "Input"},

    {USBHID_MAINITEM_TAG_OUTPUT,        "Output"},

    {USBHID_MAINITEM_TAG_FEATURE,       "Feature"},

    {USBHID_MAINITEM_TAG_COLLECTION,    "Collection"},

    {USBHID_MAINITEM_TAG_ENDCOLLECTION, "End Collection"},

    {0, NULL}

};

#define USBHID_GLOBALITEM_TAG_USAGE_PAGE    0

#define USBHID_GLOBALITEM_TAG_LOG_MIN       1

#define USBHID_GLOBALITEM_TAG_LOG_MAX       2

#define USBHID_GLOBALITEM_TAG_PHY_MIN       3

#define USBHID_GLOBALITEM_TAG_PHY_MAX       4

#define USBHID_GLOBALITEM_TAG_UNIT_EXP      5

#define USBHID_GLOBALITEM_TAG_UNIT          6

#define USBHID_GLOBALITEM_TAG_REPORT_SIZE   7

#define USBHID_GLOBALITEM_TAG_REPORT_ID     8

#define USBHID_GLOBALITEM_TAG_REPORT_COUNT  9

#define USBHID_GLOBALITEM_TAG_PUSH         10

#define USBHID_GLOBALITEM_TAG_POP          11

static const value_string usb_hid_globalitem_bTag_vals[] = {

    {USBHID_GLOBALITEM_TAG_USAGE_PAGE,   "Usage Page"},

    {USBHID_GLOBALITEM_TAG_LOG_MIN,      "Logical Minimum"},

    {USBHID_GLOBALITEM_TAG_LOG_MAX,      "Logical Maximum"},

    {USBHID_GLOBALITEM_TAG_PHY_MIN,      "Physical Minimum"},

    {USBHID_GLOBALITEM_TAG_PHY_MAX,      "Physical Maximum"},

    {USBHID_GLOBALITEM_TAG_UNIT_EXP,     "Unit Exponent"},

    {USBHID_GLOBALITEM_TAG_UNIT,         "Unit"},

    {USBHID_GLOBALITEM_TAG_REPORT_SIZE,  "Report Size"},

    {USBHID_GLOBALITEM_TAG_REPORT_ID,    "Report ID"},

    {USBHID_GLOBALITEM_TAG_REPORT_COUNT, "Report Count"},

    {USBHID_GLOBALITEM_TAG_PUSH,         "Push"},

    {USBHID_GLOBALITEM_TAG_POP,          "Pop"},

    {12, "[Reserved]"},

    {13, "[Reserved]"},

    {14, "[Reserved]"},

    {15, "[Reserved]"},

    {0, NULL}

};

#define USBHID_LOCALITEM_TAG_USAGE          0

#define USBHID_LOCALITEM_TAG_USAGE_MIN      1

#define USBHID_LOCALITEM_TAG_USAGE_MAX      2

#define USBHID_LOCALITEM_TAG_DESIG_INDEX    3

#define USBHID_LOCALITEM_TAG_DESIG_MIN      4

#define USBHID_LOCALITEM_TAG_DESIG_MAX      5

/* No 6 in spec */

#define USBHID_LOCALITEM_TAG_STRING_INDEX   7

#define USBHID_LOCALITEM_TAG_STRING_MIN     8

#define USBHID_LOCALITEM_TAG_STRING_MAX     9

#define USBHID_LOCALITEM_TAG_DELIMITER     10 /* Also listed as reserved in spec! */

static const value_string usb_hid_localitem_bTag_vals[] = {

    {USBHID_LOCALITEM_TAG_USAGE,        "Usage"},

    {USBHID_LOCALITEM_TAG_USAGE_MIN,    "Usage Minimum"},

    {USBHID_LOCALITEM_TAG_USAGE_MAX,    "Usage Maximum"},

    {USBHID_LOCALITEM_TAG_DESIG_INDEX,  "Designator Index"},

    {USBHID_LOCALITEM_TAG_DESIG_MIN,    "Designator Minimum"},

    {USBHID_LOCALITEM_TAG_DESIG_MAX,    "Designator Maximum"},

    {USBHID_LOCALITEM_TAG_STRING_INDEX, "String Index"},

    {USBHID_LOCALITEM_TAG_STRING_MIN,   "String Minimum"},

    {USBHID_LOCALITEM_TAG_STRING_MAX,   "String Maximum"},

    {USBHID_LOCALITEM_TAG_DELIMITER,    "Delimiter"},

    {11, "[Reserved]"},

    {12, "[Reserved]"},

    {13, "[Reserved]"},

    {14, "[Reserved]"},

    {15, "[Reserved]"},

    {0, NULL}

};

static const value_string usb_hid_longitem_bTag_vals[] = {

    {15, "Long item"},

    {0, NULL}

};

static const range_string usb_hid_mainitem_colltype_vals[] = {

    {0x00, 0x00, "Physical"},

    {0x01, 0x01, "Application"},

    {0x02, 0x02, "Logical"},

    {0x03, 0x03, "Report"},

    {0x04, 0x04, "Named array"},

    {0x05, 0x05, "Usage switch"},

    {0x06, 0x06, "Usage modifier"},

    {0x07, 0x7F, "[Reserved]"},

    {0x80, 0xFF, "[Vendor-defined]"},

    {0, 0, NULL}

};

static const value_string usb_hid_globalitem_unit_exp_vals[] = {

    {0x0, "n^0"},

    {0x1, "n^1"},

    {0x2, "n^2"},

    {0x3, "n^3"},

    {0x4, "n^4"},

    {0x5, "n^5"},

    {0x6, "n^6"},

    {0x7, "n^7"},

    {0x8, "n^-8"},

    {0x9, "n^-7"},

    {0xA, "n^-6"},

    {0xB, "n^-5"},

    {0xC, "n^-4"},

    {0xD, "n^-3"},

    {0xE, "n^-2"},

    {0xF, "n^-1"},

    {0, NULL}

};

#define GENERIC_DESKTOP_CONTROLS_PAGE   0x01

#define SIMULATION_CONTROLS_PAGE        0x02

#define VR_CONTROLS_PAGE                0x03

#define SPORT_CONTROLS_PAGE             0x04

#define GAME_CONTROLS_PAGE              0x05

#define GENERIC_DEVICE_CONTROLS_PAGE    0x06

#define KEYBOARD_KEYPAD_PAGE            0x07

#define LED_PAGE                        0x08

#define BUTTON_PAGE                     0x09

#define ORDINAL_PAGE                    0x0A

#define TELEPHONY_PAGE                  0x0B

#define CONSUMER_PAGE                   0x0C

#define DIGITIZER_PAGE                  0x0D

#define HAPTICS_PAGE                    0x0E

#define PID_PAGE                        0x0F

#define UNICODE_PAGE                    0x10

#define SOC_PAGE                        0x11

#define EYE_AND_HEAD_TRACKER_PAGE       0x12

#define ALPHANUMERIC_DISPLAY_PAGE       0x14

#define SENSOR_PAGE                     0x20

#define MEDICAL_INSTRUMENTS_PAGE        0x40

#define BRAILLE_DISPLAY_PAGE            0x41

#define LIGHTING_AND_ILLUMINATION_PAGE  0x59

#define USB_MONITOR_PAGE                0x80

#define USB_ENUMERATED_VALUES_PAGE      0x81

#define VESA_VIRTUAL_CONTROLS_PAGE      0x82

#define POWER_DEVICE_PAGE               0x84

#define BATTERY_SYSTEM_PAGE             0x85

#define BARCODE_SCANNER_PAGE            0x8C

#define WEIGHING_PAGE                   0x8D

#define MSR_PAGE                        0x8E

#define RESERVED_POS_PAGE               0x8F

#define CAMERA_CONTROL_PAGE             0x90

#define ARCADE_PAGE                     0x91

#define GAMING_DEVICE_PAGE              0x92

#define FIDO_ALLIANCE_PAGE              0xF1D0

#define VENDOR_PAGE_HBYTE               0xFF00

static const value_string usb_hid_item_usage_page_vals[] = {

    {0x00, "Undefined"},

    {GENERIC_DESKTOP_CONTROLS_PAGE,     "Generic Desktop Controls"},

    {SIMULATION_CONTROLS_PAGE,          "Simulation Controls"},

    {VR_CONTROLS_PAGE,                  "VR Controls"},

    {SPORT_CONTROLS_PAGE,               "Sport Controls"},

    {GAME_CONTROLS_PAGE,                "Game Controls"},

    {GENERIC_DEVICE_CONTROLS_PAGE,      "Generic Device Controls"},

    {KEYBOARD_KEYPAD_PAGE,              "Keyboard/Keypad"},

    {LED_PAGE,                          "LED"},

    {BUTTON_PAGE,                       "Button"},

    {ORDINAL_PAGE,                      "Ordinal"},

    {TELEPHONY_PAGE,                    "Telephony"},

    {CONSUMER_PAGE,                     "Consumer"},

    {DIGITIZER_PAGE,                    "Digitizer"},

    {HAPTICS_PAGE,                      "Haptics"},

    {PID_PAGE,                          "Physical Interface Device (PID)"},

    {UNICODE_PAGE,                      "Unicode"},

    {SOC_PAGE,                          "System-on-Chip"},

    {EYE_AND_HEAD_TRACKER_PAGE,         "Eye and Head Tracker"},

    {ALPHANUMERIC_DISPLAY_PAGE,         "Alphanumeric Display"},

    {SENSOR_PAGE,                       "Sensor"},

    {MEDICAL_INSTRUMENTS_PAGE,          "Medical Instruments"},

    {BRAILLE_DISPLAY_PAGE,              "Braille Display"},

    {LIGHTING_AND_ILLUMINATION_PAGE,    "Lighting and Illumination"},

    {USB_MONITOR_PAGE,                  "USB Monitor"},

    {USB_ENUMERATED_VALUES_PAGE,        "USB Enumerated Values"},

    {VESA_VIRTUAL_CONTROLS_PAGE,        "VESA Virtual Controls"},

    {POWER_DEVICE_PAGE,                 "Power Device"},

    {BATTERY_SYSTEM_PAGE,               "Battery Device"},

    {BARCODE_SCANNER_PAGE,              "Barcode Scanner"},

    {WEIGHING_PAGE,                     "Weighing"},

    {MSR_PAGE,                          "Magnetic Stripe Reading (MSR) Devices"},

    {RESERVED_POS_PAGE,                 "[Reserved Point of Sale page]"},

    {CAMERA_CONTROL_PAGE,               "Camera Control Page"},

    {ARCADE_PAGE,                       "Arcade"},

    {GAMING_DEVICE_PAGE,                "Gaming Device"},

    {FIDO_ALLIANCE_PAGE ,               "FIDO Alliance"},

    {0, NULL}

};

static const value_string usb_hid_generic_desktop_controls_usage_page_vals[] = {

    {0x00, "Undefined"},

    {0x01, "Pointer"},

    {0x02, "Mouse"},

    {0x04, "Joystick"},

    {0x05, "Game Pad"},

    {0x06, "Keyboard"},

    {0x07, "Keypad"},

    {0x08, "Multi-axis Controller"},

    {0x09, "Tablet PC System Controls"},

    {0x0A, "Water Cooling Device"},

    {0x0B, "Computer Chassis Device"},

    {0x0C, "Wireless Radio Controls"},

    {0x0D, "Portable Device Control"},

    {0x0E, "System Multi-Axis Controller"},

    {0x0F, "Spatial Controller"},

    {0x10, "Assistive Control"},

    {0x11, "Device Dock"},

    {0x12, "Dockable Device"},

    {0x13, "Call State Management Control"},

    {0x30, "X"},

    {0x31, "Y"},

    {0x32, "Z"},

    {0x33, "Rx"},

    {0x34, "Ry"},

    {0x35, "Rz"},

    {0x36, "Slider"},

    {0x37, "Dial"},

    {0x38, "Wheel"},

    {0x39, "Hat switch"},

    {0x3A, "Counted Buffer"},

    {0x3B, "Byte Count"},

    {0x3C, "Motion Wakeup"},

    {0x3D, "Start"},

    {0x3E, "Select"},

    {0x40, "Vx"},

    {0x41, "Vy"},

    {0x42, "Vz"},

    {0x43, "Vbrx"},

    {0x44, "Vbry"},

    {0x45, "Vbrz"},

    {0x46, "Vno"},

    {0x47, "Feature Notification"},

    {0x48, "Resolution Multiplier"},

    {0x49, "Qx"},

    {0x4A, "Qy"},

    {0x4B, "Qz"},

    {0x4C, "Qw"},

    {0x80, "System Control"},

    {0x81, "System Power Down"},

    {0x82, "System Sleep"},

    {0x83, "System Wake Up"},

    {0x84, "System Context Menu"},

    {0x85, "System Main Menu"},

    {0x86, "System App Menu"},

    {0x87, "System Menu Help"},

    {0x88, "System Menu Exit"},

    {0x89, "System Menu Select"},

    {0x8A, "System Menu Right"},

    {0x8B, "System Menu Left"},

    {0x8C, "System Menu Up"},

    {0x8D, "System Menu Down"},

    {0x8E, "System Cold Restart"},

    {0x8F, "System Warm Restart"},

    {0x90, "D-pad Up"},

    {0x91, "D-pad Down"},

    {0x92, "D-pad Right"},

    {0x93, "D-pad Left"},

    {0x94, "Index Trigger"},

    {0x95, "Palm Trigger"},

    {0x96, "Thumbstick"},

    {0x97, "System Function Shift"},

    {0x98, "System Function Shift Lock"},

    {0x99, "System Function Shift Lock Indicator"},

    {0x9A, "System Dismiss Notification"},

    {0x9B, "System Do Not Disturb"},

    {0xA0, "System Dock"},

    {0xA1, "System Undock"},

    {0xA2, "System Setup"},

    {0xA3, "System Break"},

    {0xA4, "System Debugger Break"},

    {0xA5, "Application Break"},

    {0xA6, "Application Debugger Break"},

    {0xA7, "System Speaker Mute"},

    {0xA8, "System Hibernate"},

    {0xA9, "System Microphone Mute"},

    {0xB0, "System Display Invert"},

    {0xB1, "System Display Internal"},

    {0xB2, "System Display External"},

    {0xB3, "System Display Both"},

    {0xB4, "System Display Dual"},

    {0xB5, "System Display Toggle Int/Ext"},

    {0xB6, "System Display Swap Primary/Secondary"},

    {0xB7, "System Display LCD Autoscale"},

    {0xC0, "Sensor Zone"},

    {0xC1, "RPM"},

    {0xC2, "Coolant Level"},

    {0xC3, "Coolant Critical Level"},

    {0xC4, "Coolant Pump"},

    {0xC5, "Chassis Enclosure"},

    {0xC6, "Wireless Radio Button"},

    {0xC7, "Wireless Radio LED"},

    {0xC8, "Wireless Radio Slider Switch"},

    {0xC9, "System Display Rotation Lock Button"},

    {0xCA, "System Display Rotation Lock Slider Switch"},

    {0xCB, "Control Enable"},

    {0xD0, "Dockable Device Unique ID"},

    {0xD1, "Dockable Device Vendor ID"},

    {0xD2, "Dockable Device Primary Usage Page"},

    {0xD3, "Dockable Device Primary Usage ID"},

    {0xD4, "Dockable Device Docking State"},

    {0xD5, "Dockable Device Display Occlusion"},

    {0xD6, "Dockable Device Object Type"},

    {0xE0, "Call Active LED"},

    {0xE1, "Call Mute Toggle"},

    {0xE2, "Call Mute LED"},

    {0, NULL}

};

static const value_string usb_hid_simulation_control_usage_page_vals[] = {

    {0x00, "Undefined"},

    {0x01, "Flight Simulation Device"},

    {0x02, "Automobile Simulation Device"},

    {0x03, "Tank Simulation Device"},

    {0x04, "Spaceship Simulation Device"},

    {0x05, "Submarine Simulation Device"},

    {0x06, "Sailing Simulation Device"},

    {0x07, "Motorcycle Simulation Device"},

    {0x08, "Sports Simulation Device"},

    {0x09, "Airplane Simulation Device"},

    {0x0A, "Helicopter Simulation Device"},

    {0x0B, "Magic Carpet Simulation Device"},

    {0x0C, "Bicycle Simulation Device"},

    {0x20, "Flight Control Stick"},

    {0x21, "Flight Stick"},

    {0x22, "Cyclic Control"},

    {0x23, "Cyclic Trim"},

    {0x24, "Flight Yoke"},

    {0x25, "Track Control"},

    {0xB0, "Aileron"},

    {0xB1, "Aileron Trim"},

    {0xB2, "Anti-Torque Control"},

    {0xB3, "Autopilot Enable"},

    {0xB4, "Chaff Release"},

    {0xB5, "Collective Control"},

    {0xB6, "Dive Brake"},

    {0xB7, "Electronic Countermeasures"},

    {0xB8, "Elevator"},

    {0xB9, "Elevator Trim"},

    {0xBA, "Rudder"},

    {0xBB, "Throttle"},

    {0xBC, "Flight Communications"},

    {0xBD, "Flare Release"},

    {0xBE, "Landing Gear"},

    {0xBF, "Toe Brake"},

    {0xC0, "Trigger"},

    {0xC1, "Weapons Arm"},

    {0xC2, "Weapons Select"},

    {0xC3, "Wing Flaps"},

    {0xC4, "Accelerator"},

    {0xC5, "Brake"},

    {0xC6, "Clutch"},

    {0xC7, "Shifter"},

    {0xC8, "Steering"},

    {0xC9, "Turret Direction"},

    {0xCA, "Barrel Elevation"},

    {0xCB, "Dive Plane"},

    {0xCC, "Ballast"},

    {0xCD, "Bicycle Crank"},

    {0xCE, "Handle Bars"},

    {0xCF, "Front Brake"},

    {0xD0, "Rear Brake"},

    {0, NULL}

};

static const value_string usb_hid_vr_controls_usage_page_vals[] = {

    {0x00, "Undefined"},

    {0x01, "Belt"},

    {0x02, "Body Suit"},

    {0x03, "Flexor"},

    {0x04, "Glove"},

    {0x05, "Head Tracker"},

    {0x06, "Head Mounted Display"},

    {0x07, "Hand Tracker"},

    {0x08, "Oculometer"},

    {0x09, "Vest"},

    {0x0A, "Animatronic Device"},

    {0x20, "Stereo Enable"},

    {0x21, "Display Enable"},

    {0, NULL}

};

static const value_string usb_hid_sport_controls_usage_page_vals[] = {

    {0x00, "Undefined"},

    {0x01, "Baseball Bat"},

    {0x02, "Golf Club"},

    {0x03, "Rowing Machine"},

    {0x04, "Treadmill"},

    {0x30, "Oar"},

    {0x31, "Slope"},

    {0x32, "Rate"},

    {0x33, "Stick Speed"},

    {0x34, "Stick Face Angle"},

    {0x35, "Stick Heel/Toe"},

    {0x36, "Stick Follow Through"},

    {0x37, "Stick Tempo"},

    {0x38, "Stick Type"},

    {0x39, "Stick Height"},

    {0x50, "Putter"},

    {0x51, "1 Iron"},

    {0x52, "2 Iron"},

    {0x53, "3 Iron"},

    {0x54, "4 Iron"},

    {0x55, "5 Iron"},

    {0x56, "6 Iron"},

    {0x57, "7 Iron"},

    {0x58, "8 Iron"},

    {0x59, "9 Iron"},

    {0x5A, "10 Iron"},

    {0x5B, "11 Iron"},

    {0x5C, "Sand Wedge"},

    {0x5D, "Loft Wedge"},

    {0x5E, "Power Wedge"},

    {0x5F, "1 Wood"},

    {0x60, "3 Wood"},

    {0x61, "5 Wood"},

    {0x62, "7 Wood"},

    {0x63, "9 Wood"},

    {0, NULL}

};

static const value_string usb_hid_game_controls_usage_page_vals[] = {

    {0x00, "Undefined"},

    {0x01, "3D Game Controller"},

    {0x02, "Pinball Device"},

    {0x03, "Gun Device"},

    {0x20, "Point of View"},

    {0x21, "Turn Right/Left"},

    {0x22, "Pitch Forward/Backward"},

    {0x23, "Roll Right/Left"},

    {0x24, "Move Right/Left"},

    {0x25, "Move Forward/Backward"},

    {0x26, "Move Up/Down"},

    {0x27, "Lean Right/Left"},

    {0x28, "Lean Forward/Backward"},

    {0x29, "Height of POV"},

    {0x2A, "Flipper"},

    {0x2B, "Secondary Flipper"},

    {0x2C, "Bump"},

    {0x2D, "New Game"},

    {0x2E, "Shoot Ball"},

    {0x2F, "Player"},

    {0x30, "Gun Bolt"},

    {0x31, "Gun Clip"},

    {0x32, "Gun Selector"},

    {0x33, "Gun Single Shot"},

    {0x34, "Gun Burst"},

    {0x35, "Gun Automatic"},

    {0x36, "Gun Safety"},

    {0x37, "Gamepad Fire/Jump"},

    {0x39, "Gamepad Trigger"},

    {0x3A, "Form-fitting Gamepad"},

    {0, NULL}

};

static const value_string usb_hid_generic_device_controls_usage_page_vals[] = {

    {0x00, "Undefined"},

    {0x01, "Background/Nonuser Controls"},

    {0x20, "Battery Strength"},

    {0x21, "Wireless Channel"},

    {0x22, "Wireless ID"},

    {0x23, "Discover Wireless Control"},

    {0x24, "Security Code Character Entered"},

    {0x25, "Security Code Character Erased"},

    {0x26, "Security Code Cleared"},

    {0x27, "Sequence ID"},

    {0x28, "Sequence ID Reset"},

    {0x29, "RF Signal Strength"},

    {0x2A, "Software Version"},

    {0x2B, "Protocol Version"},

    {0x2C, "Hardware Version"},

    {0x2D, "Major"},

    {0x2E, "Minor"},

    {0x2F, "Revision"},

    {0x30, "Handedness"},

    {0x31, "Either Hand"},

    {0x32, "Left Hand"},

    {0x33, "Right Hand"},

    {0x34, "Both Hands"},

    {0x40, "Grip Pose Offset"},

    {0x41, "Pointer Pose Offset"},

    {0, NULL}

};

static const value_string usb_hid_keyboard_keypad_usage_page_vals[] = {

    {0x00, "Reserved (no event indicated)"},

    {0x01, "Keyboard ErrorRollOver"},

    {0x02, "Keyboard POSTFail"},

    {0x03, "Keyboard ErrorUndefined"},

    {0x04, "Keyboard a and A"},

    {0x05, "Keyboard b and B"},

    {0x06, "Keyboard c and C"},

    {0x07, "Keyboard d and D"},

    {0x08, "Keyboard e and E"},

    {0x09, "Keyboard f and F"},

    {0x0A, "Keyboard g and G"},

    {0x0B, "Keyboard h and H"},

    {0x0C, "Keyboard i and I"},

    {0x0D, "Keyboard j and J"},

    {0x0E, "Keyboard k and K"},

    {0x0F, "Keyboard l and L"},

    {0x10, "Keyboard m and M"},

    {0x11, "Keyboard n and N"},

    {0x12, "Keyboard o and O"},

    {0x13, "Keyboard p and P"},

    {0x14, "Keyboard q and Q"},

    {0x15, "Keyboard r and R"},

    {0x16, "Keyboard s and S"},

    {0x17, "Keyboard t and T"},

    {0x18, "Keyboard u and U"},

    {0x19, "Keyboard v and V"},

    {0x1A, "Keyboard w and W"},

    {0x1B, "Keyboard x and X"},

    {0x1C, "Keyboard y and Y"},

    {0x1D, "Keyboard z and Z"},

    {0x1E, "Keyboard 1 and !"},

    {0x1F, "Keyboard 2 and @"},

    {0x20, "Keyboard 3 and #"},

    {0x21, "Keyboard 4 and $"},

    {0x22, "Keyboard 5 and %"},

    {0x23, "Keyboard 6 and ^"},

    {0x24, "Keyboard 7 and &"},

    {0x25, "Keyboard 8 and *"},

    {0x26, "Keyboard 9 and ("},

    {0x27, "Keyboard 0 and )"},

    {0x28, "Keyboard Return (ENTER)"},

    {0x29, "Keyboard ESCAPE"},

    {0x2A, "Keyboard DELETE (Backspace)"},

    {0x2B, "Keyboard Tab"},

    {0x2C, "Keyboard Spacebar"},

    {0x2D, "Keyboard - and (underscore)"},

    {0x2E, "Keyboard = and +"},

    {0x2F, "Keyboard [ and {"},

    {0x30, "Keyboard ] and }"},

    {0x31, "Keyboard \\ and |"},

    {0x32, "Keyboard Non-US # and ~"},

    {0x33, "Keyboard ; and :"},

    {0x34, "Keyboard ' and \""},

    {0x35, "Keyboard Grave Accent and Tilde"},

    {0x36, "Keyboard , and <"},

    {0x37, "Keyboard . and >"},

    {0x38, "Keyboard / and ?"},

    {0x39, "Keyboard Caps Lock"},

    {0x3A, "Keyboard F1"},

    {0x3B, "Keyboard F2"},

    {0x3C, "Keyboard F3"},

    {0x3D, "Keyboard F4"},

    {0x3E, "Keyboard F5"},

    {0x3F, "Keyboard F6"},

    {0x40, "Keyboard F7"},

    {0x41, "Keyboard F8"},

    {0x42, "Keyboard F9"},

    {0x43, "Keyboard F10"},

    {0x44, "Keyboard F11"},

    {0x45, "Keyboard F12"},

    {0x46, "Keyboard PrintScreen"},

    {0x47, "Keyboard Scroll Lock"},

    {0x48, "Keyboard Pause"},

    {0x49, "Keyboard Insert"},

    {0x4A, "Keyboard Home"},

    {0x4B, "Keyboard PageUp"},

    {0x4C, "Keyboard Delete Forward"},

    {0x4D, "Keyboard End"},

    {0x4E, "Keyboard PageDown"},

    {0x4F, "Keyboard RightArrow"},

    {0x50, "Keyboard LeftArrow"},

    {0x51, "Keyboard DownArrow"},

    {0x52, "Keyboard UpArrow"},

    {0x53, "Keypad Num Lock and Clear"},

    {0x54, "Keypad /"},

    {0x55, "Keypad *"},

    {0x56, "Keypad -"},

    {0x57, "Keypad +"},

    {0x58, "Keypad ENTER"},

    {0x59, "Keypad 1 and End"},

    {0x5A, "Keypad 2 and Down Arrow"},

    {0x5B, "Keypad 3 and PageDn"},

    {0x5C, "Keypad 4 and Left Arrow"},

    {0x5D, "Keypad 5"},

    {0x5E, "Keypad 6 and Right Arrow"},

    {0x5F, "Keypad 7 and Home"},

    {0x60, "Keypad 8 and Up Arrow"},

    {0x61, "Keypad 9 and PageUp"},

    {0x62, "Keypad 0 and Insert"},

    {0x63, "Keypad . and Delete"},

    {0x64, "Keyboard Non-US \\ and |"},

    {0x65, "Keyboard Application"},

    {0x66, "Keyboard Power"},

    {0x67, "Keypad ="},

    {0x68, "Keyboard F13"},

    {0x69, "Keyboard F14"},

    {0x6A, "Keyboard F15"},

    {0x6B, "Keyboard F16"},

    {0x6C, "Keyboard F17"},

    {0x6D, "Keyboard F18"},

    {0x6E, "Keyboard F19"},

    {0x6F, "Keyboard F20"},

    {0x70, "Keyboard F21"},

    {0x71, "Keyboard F22"},

    {0x72, "Keyboard F23"},

    {0x73, "Keyboard F24"},

    {0x74, "Keyboard Execute"},

    {0x75, "Keyboard Help"},

    {0x76, "Keyboard Menu"},

    {0x77, "Keyboard Select"},

    {0x78, "Keyboard Stop"},

    {0x79, "Keyboard Again"},

    {0x7A, "Keyboard Undo"},

    {0x7B, "Keyboard Cut"},

    {0x7C, "Keyboard Copy"},

    {0x7D, "Keyboard Paste"},

    {0x7E, "Keyboard Find"},

    {0x7F, "Keyboard Mute"},

    {0x80, "Keyboard Volume Up"},

    {0x81, "Keyboard Volume Down"},

    {0x82, "Keyboard Locking Caps Lock"},

    {0x83, "Keyboard Locking Num Lock"},

    {0x84, "Keyboard Locking Scroll Lock"},

    {0x85, "Keypad Comma"},

    {0x86, "Keypad Equal Sign"},

    {0x87, "Keyboard International1"},

    {0x88, "Keyboard International2"},

    {0x89, "Keyboard International3"},

    {0x8A, "Keyboard International4"},

    {0x8B, "Keyboard International5"},

    {0x8C, "Keyboard International6"},

    {0x8D, "Keyboard International7"},

    {0x8E, "Keyboard International8"},

    {0x8F, "Keyboard International9"},

    {0x90, "Keyboard LANG1"},

    {0x91, "Keyboard LANG2"},

    {0x92, "Keyboard LANG3"},

    {0x93, "Keyboard LANG4"},

    {0x94, "Keyboard LANG5"},

    {0x95, "Keyboard LANG6"},

    {0x96, "Keyboard LANG7"},

    {0x97, "Keyboard LANG8"},

    {0x98, "Keyboard LANG9"},

    {0x99, "Keyboard Alternate Erase"},

    {0x9A, "Keyboard SysReq/Attention"},

    {0x9B, "Keyboard Cancel"},

    {0x9C, "Keyboard Clear"},

    {0x9D, "Keyboard Prior"},

    {0x9E, "Keyboard Return"},

    {0x9F, "Keyboard Separator"},

    {0xA0, "Keyboard Out"},

    {0xA1, "Keyboard Oper"},

    {0xA2, "Keyboard Clear/Again"},

    {0xA3, "Keyboard CrSel/Props"},

    {0xA4, "Keyboard ExSel"},

    {0xB0, "Keypad 00"},

    {0xB1, "Keypad 000"},

    {0xB2, "Thousands Separator"},

    {0xB3, "Decimal Separator"},

    {0xB4, "Currency Unit"},

    {0xB5, "Currency Sub-unit"},

    {0xB6, "Keypad ("},

    {0xB7, "Keypad )"},

    {0xB8, "Keypad {"},

    {0xB9, "Keypad }"},

    {0xBA, "Keypad Tab"},

    {0xBB, "Keypad Backspace"},

    {0xBC, "Keypad A"},

    {0xBD, "Keypad B"},

    {0xBE, "Keypad C"},

    {0xBF, "Keypad D"},

    {0xC0, "Keypad E"},

    {0xC1, "Keypad F"},

    {0xC2, "Keypad XOR"},

    {0xC3, "Keypad ^"},

    {0xC4, "Keypad %"},

    {0xC5, "Keypad <"},

    {0xC6, "Keypad >"},

    {0xC7, "Keypad &"},

    {0xC8, "Keypad &&"},

    {0xC9, "Keypad |"},

    {0xCA, "Keypad ||"},

    {0xCB, "Keypad :"},

    {0xCC, "Keypad #"},

    {0xCD, "Keypad Space"},

    {0xCE, "Keypad @"},

    {0xCF, "Keypad !"},

    {0xD0, "Keypad Memory Store"},

    {0xD1, "Keypad Memory Recall"},

    {0xD2, "Keypad Memory Clear"},

    {0xD3, "Keypad Memory Add"},

    {0xD4, "Keypad Memory Subtract"},

    {0xD5, "Keypad Memory Multiply"},

    {0xD6, "Keypad Memory Divide"},

    {0xD7, "Keypad +/-"},

    {0xD8, "Keypad Clear"},

    {0xD9, "Keypad Clear Entry"},

    {0xDA, "Keypad Binary"},

    {0xDB, "Keypad Octal"},

    {0xDC, "Keypad Decimal"},

    {0xDD, "Keypad Hexadecimal"},

    {0xE0, "Keyboard LeftControl"},

    {0xE1, "Keyboard LeftShift"},

    {0xE2, "Keyboard LeftAlt"},

    {0xE3, "Keyboard Left GUI"},

    {0xE4, "Keyboard RightControl"},

    {0xE5, "Keyboard RightShift"},

    {0xE6, "Keyboard RightAlt"},

    {0xE7, "Keyboard Right GUI"},

    {0, NULL}

};

static const value_string usb_hid_led_usage_page_vals[] = {

    {0x00, "Undefined"},

    {0x01, "Num Lock"},

    {0x02, "Caps Lock"},

    {0x03, "Scroll Lock"},

    {0x04, "Compose"},

    {0x05, "Kana"},

    {0x06, "Power"},

    {0x07, "Shift"},

    {0x08, "Do Not Disturb"},

    {0x09, "Mute"},

    {0x0A, "Tone Enable"},

    {0x0B, "High Cut Filter"},

    {0x0C, "Low Cut Filter"},

    {0x0D, "Equalizer Enable"},

    {0x0E, "Sound Field On"},

    {0x0F, "Surround On"},

    {0x10, "Repeat"},

    {0x11, "Stereo"},

    {0x12, "Sampling Rate Detect"},

    {0x13, "Spinning"},

    {0x14, "CAV"},

    {0x15, "CLV"},

    {0x16, "Recording Format Detect"},

    {0x17, "Off-Hook"},

    {0x18, "Ring"},

    {0x19, "Message Waiting"},

    {0x1A, "Data Mode"},

    {0x1B, "Battery Operation"},

    {0x1C, "Battery OK"},

    {0x1D, "Battery Low"},

    {0x1E, "Speaker"},

    {0x1F, "Head Set"},

    {0x20, "Hold"},

    {0x21, "Microphone"},

    {0x22, "Coverage"},

    {0x23, "Night Mode"},

    {0x24, "Send Calls"},

    {0x25, "Call Pickup"},

    {0x26, "Conference"},

    {0x27, "Stand-by"},

    {0x28, "Camera On"},

    {0x29, "Camera Off"},

    {0x2A, "On-Line"},

    {0x2B, "Off-Line"},

    {0x2C, "Busy"},

    {0x2D, "Ready"},

    {0x2E, "Paper-Out"},

    {0x2F, "Paper-Jam"},

    {0x30, "Remote"},

    {0x31, "Forward"},

    {0x32, "Reverse"},

    {0x33, "Stop"},

    {0x34, "Rewind"},

    {0x35, "Fast Forward"},

    {0x36, "Play"},

    {0x37, "Pause"},

    {0x38, "Record"},

    {0x39, "Error"},

    {0x3A, "Usage Selected Indicator"},

    {0x3B, "Usage In Use Indicator"},

    {0x3C, "Usage Multi Mode Indicator"},

    {0x3D, "Indicator On"},

    {0x3E, "Indicator Flash"},

    {0x3F, "Indicator Slow Blink"},

    {0x40, "Indicator Fast Blink"},

    {0x41, "Indicator Off"},

    {0x42, "Flash On Time"},

    {0x43, "Slow Blink On Time"},

    {0x44, "Slow Blink Off Time"},

    {0x45, "Fast Blink On Time"},

    {0x46, "Fast Blink Off Time"},

    {0x47, "Usage Indicator Color"},

    {0x48, "Indicator Red"},

    {0x49, "Indicator Green"},

    {0x4A, "Indicator Amber"},

    {0x4B, "Generic Indicator"},

    {0x4C, "System Suspend"},