diff options
Diffstat (limited to 'epan/dissectors/packet-btlmp.c')
| -rw-r--r-- | epan/dissectors/packet-btlmp.c | 2459 |
1 files changed, 2459 insertions, 0 deletions
diff --git a/epan/dissectors/packet-btlmp.c b/epan/dissectors/packet-btlmp.c new file mode 100644 index 00000000..9015088c --- /dev/null +++ b/epan/dissectors/packet-btlmp.c @@ -0,0 +1,2459 @@ +/* packet-btlmp.c + * Routines for the Bluetooth Link Manager Protocol + * + * Copyright 2020, Thomas Sailer <t.sailer@alumni.ethz.ch> + * + * Wireshark - Network traffic analyzer + * By Gerald Combs <gerald@wireshark.org> + * Copyright 1998 Gerald Combs + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + +#include "config.h" + +#include <epan/packet.h> +#include <epan/expert.h> + + +#include "packet-bluetooth.h" +#include "packet-btbredr_rf.h" + +static int proto_btlmp = -1; + +static int hf_opcode[3] = { -1, -1, -1 }; +static int hf_escopcode[4] = { -1, -1, -1, -1 }; +static int hf_accept_opcode = -1; +static int hf_accept_escopcode[4] = { -1, -1, -1, -1 }; +static int hf_errorcode = -1; +static int hf_param_feature_page0_byte0[9] = { -1, -1, -1, -1, -1, -1, -1, -1, -1 }; +static int hf_param_feature_page0_byte1[9] = { -1, -1, -1, -1, -1, -1, -1, -1, -1 }; +static int hf_param_feature_page0_byte2[7] = { -1, -1, -1, -1, -1, -1, -1 }; +static int hf_param_feature_page0_byte3[9] = { -1, -1, -1, -1, -1, -1, -1, -1, -1 }; +static int hf_param_feature_page0_byte4[9] = { -1, -1, -1, -1, -1, -1, -1, -1, -1 }; +static int hf_param_feature_page0_byte5[9] = { -1, -1, -1, -1, -1, -1, -1, -1, -1 }; +static int hf_param_feature_page0_byte6[9] = { -1, -1, -1, -1, -1, -1, -1, -1, -1 }; +static int hf_param_feature_page0_byte7[6] = { -1, -1, -1, -1, -1, -1 }; +static int hf_param_feature_page1_byte0[6] = { -1, -1, -1, -1, -1, -1 }; +static int hf_param_feature_page2_byte0[9] = { -1, -1, -1, -1, -1, -1, -1, -1, -1 }; +static int hf_param_feature_page2_byte1[6] = { -1, -1, -1, -1, -1, -1 }; +static int hf_param_features_page = -1; +static int hf_param_max_supported_page = -1; +static int hf_param_versnr = -1; +static int hf_param_compid = -1; +static int hf_param_subversnr = -1; +static int hf_param_namelength = -1; +static int hf_param_nameoffset = -1; +static int hf_param_namefragment = -1; +static int hf_param_afh_mode = -1; +static int hf_param_afh_instant = -1; +static int hf_param_afh_channelmap[10] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; +static int hf_param_afh_reportingmode = -1; +static int hf_param_afh_mininterval = -1; +static int hf_param_afh_maxinterval = -1; +static int hf_param_afh_channelclass[10][4] = { { -1, -1, -1, -1 }, { -1, -1, -1, -1 }, { -1, -1, -1, -1 }, { -1, -1, -1, -1 }, { -1, -1, -1, -1 }, + { -1, -1, -1, -1 }, { -1, -1, -1, -1 }, { -1, -1, -1, -1 }, { -1, -1, -1, -1 }, { -1, -1, -1, -1 } }; +static int hf_param_rand = -1; +static int hf_param_key = -1; +static int hf_param_clockoffset = -1; +static int hf_param_authresp = -1; +static int hf_param_encryptionmode = -1; +static int hf_param_encryptionkeysize = -1; +static int hf_param_switchinstant = -1; +static int hf_param_holdtime = -1; +static int hf_param_holdinstant = -1; +static int hf_param_dsniff = -1; +static int hf_param_tsniff = -1; +static int hf_param_sniffattempt = -1; +static int hf_param_snifftimeout = -1; +static int hf_param_timingcontrolflags[5] = { -1, -1, -1, -1, -1 }; +static int hf_param_futureuse1 = -1; +static int hf_param_datarate[6] = { -1, -1, -1, -1, -1, -1 }; +static int hf_param_pollinterval = -1; +static int hf_param_nbc = -1; +static int hf_param_scohandle = -1; +static int hf_param_dsco = -1; +static int hf_param_tsco = -1; +static int hf_param_scopacket = -1; +static int hf_param_airmode = -1; +static int hf_param_slots = -1; +static int hf_param_tmgacc_drift = -1; +static int hf_param_tmgacc_jitter = -1; +static int hf_param_slotoffset = -1; +static int hf_param_bdaddr = -1; +static int hf_param_pagingscheme = -1; +static int hf_param_pagingschemesettings = -1; +static int hf_param_supervisiontimeout = -1; +static int hf_param_testscenario = -1; +static int hf_param_testhoppingmode = -1; +static int hf_param_testtxfrequency = -1; +static int hf_param_testrxfrequency = -1; +static int hf_param_testpowercontrolmode = -1; +static int hf_param_testpollperiod = -1; +static int hf_param_testpackettype = -1; +static int hf_param_testdatalength = -1; +static int hf_param_keysizemask = -1; +static int hf_param_encapsulatedmajor = -1; +static int hf_param_encapsulatedminor = -1; +static int hf_param_encapsulatedlength = -1; +static int hf_param_encapsulateddata = -1; +static int hf_param_simplepaircommit = -1; +static int hf_param_simplepairnonce = -1; +static int hf_param_dhkeyconfirm = -1; +static int hf_param_clkadjid = -1; +static int hf_param_clkadjinstant = -1; +static int hf_param_clkadjus = -1; +static int hf_param_clkadjslots = -1; +static int hf_param_clkadjmode = -1; +static int hf_param_clkadjclk = -1; +static int hf_param_clkadjperiod = -1; +static int hf_param_packettypetable = -1; +static int hf_param_escohandle = -1; +static int hf_param_escoltaddr = -1; +static int hf_param_escod = -1; +static int hf_param_escot = -1; +static int hf_param_escow = -1; +static int hf_param_escopackettypems = -1; +static int hf_param_escopackettypesm = -1; +static int hf_param_escopacketlengthms = -1; +static int hf_param_escopacketlengthsm = -1; +static int hf_param_negostate = -1; +static int hf_param_maxsniffsubrate = -1; +static int hf_param_minsniffmodetimeout = -1; +static int hf_param_sniffsubratinginstant = -1; +static int hf_param_iocapcap = -1; +static int hf_param_iocapoobauthdata = -1; +static int hf_param_iocapauthreq = -1; +static int hf_param_keypressnotificationtype = -1; +static int hf_param_poweradjreq = -1; +static int hf_param_poweradjresp[5] = { -1, -1, -1, -1, -1 }; +static int hf_param_samindex = -1; +static int hf_param_samtsm = -1; +static int hf_param_samnsm = -1; +static int hf_param_samsubmaps = -1; +static int hf_param_samupdatemode = -1; +static int hf_param_samtype0submap = -1; +static int hf_param_samd = -1; +static int hf_param_saminstant = -1; +static int hf_params = -1; + +static gint ett_btlmp = -1; + +static dissector_handle_t btlmp_handle; + +static const value_string opcode_vals[] = { + { 1, "LMP_name_req" }, + { 2, "LMP_name_res" }, + { 3, "LMP_accepted" }, + { 4, "LMP_not_accepted" }, + { 5, "LMP_clkoffset_req" }, + { 6, "LMP_clkoffset_res" }, + { 7, "LMP_detach" }, + { 8, "LMP_in_rand" }, + { 9, "LMP_comb_key" }, + { 10, "LMP_unit_key" }, + { 11, "LMP_au_rand" }, + { 12, "LMP_sres" }, + { 13, "LMP_temp_rand" }, + { 14, "LMP_temp_key" }, + { 15, "LMP_encryption_mode_req" }, + { 16, "LMP_encryption_key_size_req" }, + { 17, "LMP_start_encryption_req" }, + { 18, "LMP_stop_encryption_req" }, + { 19, "LMP_switch_req" }, + { 20, "LMP_hold" }, + { 21, "LMP_hold_req" }, + { 23, "LMP_sniff_req" }, + { 24, "LMP_unsniff_req" }, + { 31, "LMP_incr_power_req" }, + { 32, "LMP_decr_power_req" }, + { 33, "LMP_max_power" }, + { 34, "LMP_min_power" }, + { 35, "LMP_auto_rate" }, + { 36, "LMP_preferred_rate" }, + { 37, "LMP_version_req" }, + { 38, "LMP_version_res" }, + { 39, "LMP_features_req" }, + { 40, "LMP_features_res" }, + { 41, "LMP_quality_of_service" }, + { 42, "LMP_quality_of_service_req" }, + { 43, "LMP_SCO_link_req" }, + { 44, "LMP_remove_SCO_link_req" }, + { 45, "LMP_max_slot" }, + { 46, "LMP_max_slot_req" }, + { 47, "LMP_timing_accuracy_req" }, + { 48, "LMP_timing_accuracy_res" }, + { 49, "LMP_setup_complete" }, + { 50, "LMP_use_semi_permanent_key" }, + { 51, "LMP_host_connection_req" }, + { 52, "LMP_slot_offset" }, + { 53, "LMP_page_mode_req" }, + { 54, "LMP_page_scan_mode_req" }, + { 55, "LMP_supervision_timeout" }, + { 56, "LMP_test_activate" }, + { 57, "LMP_test_control" }, + { 58, "LMP_encryption_key_size_mask_req" }, + { 59, "LMP_encryption_key_size_mask_res" }, + { 60, "LMP_set_AFH" }, + { 61, "LMP_encapsulated_header" }, + { 62, "LMP_encapsulated_payload" }, + { 63, "LMP_Simple_Pairing_Confirm" }, + { 64, "LMP_Simple_Pairing_Number" }, + { 65, "LMP_DHkey_Check" }, + { 66, "LMP_pause_encryption_aes_req" }, + { 124, "Escape 1" }, + { 125, "Escape 2" }, + { 126, "Escape 3" }, + { 127, "Escape 4" }, + { 0, NULL } +}; + +static const value_string escape1_opcode_vals[] = { + { 0x00, "Mandatory Scan Mode" }, + { 0, NULL } +}; + +static const value_string escape2_opcode_vals[] = { + { 0x00, "Mandatory Scan Mode" }, + { 0, NULL } +}; + +static const value_string escape3_opcode_vals[] = { + { 0x00, "Mandatory Scan Mode" }, + { 0, NULL } +}; + +static const value_string escape4_opcode_vals[] = { + { 1, "LMP_accepted_ext" }, + { 2, "LMP_not_accepted_ext" }, + { 3, "LMP_features_req_ext" }, + { 4, "LMP_features_res_ext" }, + { 5, "LMP_clk_adj" }, + { 6, "LMP_clk_adj_ack" }, + { 7, "LMP_clk_adj_req" }, + { 11, "LMP_packet_type_table_req" }, + { 12, "LMP_eSCO_link_req" }, + { 13, "LMP_remove_eSCO_link_req" }, + { 16, "LMP_channel_classification_req" }, + { 17, "LMP_channel_classification" }, + { 21, "LMP_sniff_subrating_req" }, + { 22, "LMP_sniff_subrating_res" }, + { 23, "LMP_pause_encryption_req" }, + { 24, "LMP_resume_encryption_req" }, + { 25, "LMP_IO_Capability_req" }, + { 26, "LMP_IO_Capability_res" }, + { 27, "LMP_numeric_comparison_failed" }, + { 28, "LMP_passkey_failed" }, + { 29, "LMP_oob_failed" }, + { 30, "LMP_keypress_notification" }, + { 31, "LMP_power_control_req" }, + { 32, "LMP_power_control_res" }, + { 33, "LMP_ping_req" }, + { 34, "LMP_ping_res" }, + { 35, "LMP_SAM_set_type0" }, + { 36, "LMP_SAM_define_map" }, + { 37, "LMP_SAM_switch" }, + { 0, NULL } +}; + +static const value_string errorcode_vals[] = { + { 0x00, "Success" }, + { 0x01, "Unknown HCI Command" }, + { 0x02, "Unknown Connection Identifier" }, + { 0x03, "Hardware Failure" }, + { 0x04, "Page Timeout" }, + { 0x05, "Authentication Failure" }, + { 0x06, "PIN or Key Missing" }, + { 0x07, "Memory Capacity Exceeded" }, + { 0x08, "Connection Timeout" }, + { 0x09, "Connection Limit Exceeded" }, + { 0x0A, "Synchronous Connection Limit To A Device Exceeded" }, + { 0x0B, "Connection Already Exists" }, + { 0x0C, "Command Disallowed" }, + { 0x0D, "Connection Rejected due to Limited Resources" }, + { 0x0E, "Connection Rejected Due To Security Reasons" }, + { 0x0F, "Connection Rejected due to Unacceptable BD_ADDR" }, + { 0x10, "Connection Accept Timeout Exceeded" }, + { 0x11, "Unsupported Feature or Parameter Value" }, + { 0x12, "Invalid HCI Command Parameters" }, + { 0x13, "Remote User Terminated Connection" }, + { 0x14, "Remote Device Terminated Connection due to Low Resources" }, + { 0x15, "Remote Device Terminated Connection due to Power Off" }, + { 0x16, "Connection Terminated By Local Host" }, + { 0x17, "Repeated Attempts" }, + { 0x18, "Pairing Not Allowed" }, + { 0x19, "Unknown LMP PDU" }, + { 0x1A, "Unsupported Remote Feature / Unsupported LMP Feature" }, + { 0x1B, "SCO Offset Rejected" }, + { 0x1C, "SCO Interval Rejected" }, + { 0x1D, "SCO Air Mode Rejected" }, + { 0x1E, "Invalid LMP Parameters / Invalid LL Parameters" }, + { 0x1F, "Unspecified Error" }, + { 0x20, "Unsupported LMP Parameter Value / Unsupported LL Parameter Value" }, + { 0x21, "Role Change Not Allowed" }, + { 0x22, "LMP Response Timeout / LL Response Timeout" }, + { 0x23, "LMP Error Transaction Collision / LL Procedure Collision" }, + { 0x24, "LMP PDU Not Allowed" }, + { 0x25, "Encryption Mode Not Acceptable" }, + { 0x26, "Link Key cannot be Changed" }, + { 0x27, "Requested QoS Not Supported" }, + { 0x28, "Instant Passed" }, + { 0x29, "Pairing With Unit Key Not Supported" }, + { 0x2A, "Different Transaction Collision" }, + { 0x2B, "Reserved for future use" }, + { 0x2C, "QoS Unacceptable Parameter" }, + { 0x2D, "QoS Rejected" }, + { 0x2E, "Channel Classification Not Supported" }, + { 0x2F, "Insufficient Security" }, + { 0x30, "Parameter Out Of Mandatory Range" }, + { 0x31, "Reserved for future use" }, + { 0x32, "Role Switch Pending" }, + { 0x33, "Reserved for future use" }, + { 0x34, "Reserved Slot Violation" }, + { 0x35, "Role Switch Failed" }, + { 0x36, "Extended Inquiry Response Too Large" }, + { 0x37, "Secure Simple Pairing Not Supported By Host" }, + { 0x38, "Host Busy - Pairing" }, + { 0x39, "Connection Rejected due to No Suitable Channel Found" }, + { 0x3A, "Controller Busy" }, + { 0x3B, "Unacceptable Connection Parameters" }, + { 0x3C, "Advertising Timeout" }, + { 0x3D, "Connection Terminated due to MIC Failure" }, + { 0x3E, "Connection Failed to be Established / Synchronization Timeout" }, + { 0x3F, "MAC Connection Failed" }, + { 0x40, "Coarse Clock Adjustment Rejected but Will Try to Adjust Using Clock" }, + { 0x41, "Type0 Submap Not Defined" }, + { 0x42, "Unknown Advertising Identifier" }, + { 0x43, "Limit Reached" }, + { 0x44, "Operation Cancelled by Host" }, + { 0x45, "Packet Too Long" }, + { 0x00, NULL } +}; + +static const value_string afh_mode_vals[] = { + { 0x00, "AFH disabled" }, + { 0x01, "AFH enabled" }, + { 0x00, NULL } +}; + +static const value_string afh_reportingmode_vals[] = { + { 0x00, "AFH reporting disabled" }, + { 0x01, "AFH reporting enabled" }, + { 0x00, NULL } +}; + +static const value_string afh_channelclass_vals[] = { + { 0x00, "unknown" }, + { 0x01, "good" }, + { 0x02, "reserved" }, + { 0x03, "bad" }, + { 0x00, NULL } +}; + +static const value_string encryptionmode_vals[] = { + { 0x00, "no encryption" }, + { 0x01, "encryption" }, + { 0x02, "encryption" }, + { 0x00, NULL } +}; + +static const value_string timingcontrol_timingchange_vals[] = { + { 0x00, "no timing change" }, + { 0x01, "timing change" }, + { 0x00, NULL } +}; + +static const value_string timingcontrol_useinit2[] = { + { 0x00, "use initialization 1" }, + { 0x01, "use initialization 2" }, + { 0x00, NULL } +}; + +static const value_string timingcontrol_noaccesswindow[] = { + { 0x00, "access window" }, + { 0x01, "no access window" }, + { 0x00, NULL } +}; + +static const value_string dataratenofec_vals[] = { + { 0x00, "use FEC" }, + { 0x01, "do not use FEC" }, + { 0x00, NULL } +}; + +static const value_string dataratepacketsizepreference_vals[] = { + { 0x00, "no packet size preference" }, + { 0x01, "use 1-slot packets" }, + { 0x02, "use 3-slot packets" }, + { 0x03, "use 5-slot packets" }, + { 0x00, NULL } +}; + +static const value_string dataratedrpreference_vals[] = { + { 0x00, "use DM1 packets" }, + { 0x01, "use 2Mb/s packets" }, + { 0x02, "use 3Mb/s packets" }, + { 0x00, NULL } +}; + +static const value_string scopacket_vals[] = { + { 0x00, "HV1" }, + { 0x01, "HV2" }, + { 0x02, "HV3" }, + { 0x00, NULL } +}; + +static const value_string airmode_vals[] = { + { 0x00, "ulaw log" }, + { 0x01, "Alaw log" }, + { 0x02, "CVSD" }, + { 0x03, "transparent data" }, + { 0x00, NULL } +}; + +static const value_string pagingscheme_vals[] = { + { 0x00, "mandatory scheme" }, + { 0x00, NULL } +}; + +static const value_string pagingschemesettings_vals[] = { + { 0x00, "R0" }, + { 0x01, "R1" }, + { 0x02, "R2" }, + { 0x00, NULL } +}; + +static const value_string encapsulatedmajor_vals[] = { + { 0x01, "public key" }, + { 0x00, NULL } +}; + +static const value_string encapsulatedminor_vals[] = { + { 0x01, "P-192 public key" }, + { 0x02, "P-256 public key" }, + { 0x00, NULL } +}; + +static const value_string clkadjmode_vals[] = { + { 0x00, "before instant" }, + { 0x01, "after instant" }, + { 0x00, NULL } +}; + +static const value_string packettypetable_vals[] = { + { 0x00, "1Mb/s only" }, + { 0x01, "2/3Mb/s" }, + { 0x00, NULL } +}; + +static const value_string escopackettypems_vals[] = { + { 0x00, "POLL" }, + { 0x07, "EV3" }, + { 0x0c, "EV4" }, + { 0x0d, "EV5" }, + { 0x26, "2-EV3" }, + { 0x2c, "2-EV5" }, + { 0x37, "3-EV3" }, + { 0x3d, "3-EV5" }, + { 0x00, NULL } +}; + +static const value_string escopackettypesm_vals[] = { + { 0x00, "NULL" }, + { 0x07, "EV3" }, + { 0x0c, "EV4" }, + { 0x0d, "EV5" }, + { 0x26, "2-EV3" }, + { 0x2c, "2-EV5" }, + { 0x37, "3-EV3" }, + { 0x3d, "3-EV5" }, + { 0x00, NULL } +}; + +static const value_string negostate_vals[] = { + { 0, "initiate negotiation" }, + { 1, "the latest received set of negotiable parameters were possible but these parameters are preferred" }, + { 2, "the latest received set of negotiable parameters would cause a reserved slot violation" }, + { 3, "the latest received set of negotiable parameters would cause a latency violation" }, + { 4, "the latest received set of negotiable parameters are not supported" }, + { 0, NULL } +}; + +static const value_string iocapcap_vals[] = { + { 0x00, "Display Only" }, + { 0x01, "Display Yes/No" }, + { 0x02, "Keyboard Only" }, + { 0x03, "No Input No Output" }, + { 0x00, NULL } +}; + +static const value_string iocapoobauthdata_vals[] = { + { 0x00, "No OOB Authentication Data received" }, + { 0x01, "OOB Authentication Data received" }, + { 0x00, NULL } +}; + +static const value_string iocapauthreq_vals[] = { + { 0x00, "MITM Protection Not Required - No Bonding" }, + { 0x01, "MITM Protection Required - No Bonding" }, + { 0x02, "MITM Protection Not Required - Dedicated Bonding" }, + { 0x03, "MITM Protection Required - Dedicated Bonding" }, + { 0x04, "MITM Protection Not Required - General Bonding" }, + { 0x05, "MITM Protection Required - General Bonding" }, + { 0x00, NULL } +}; + +static const value_string keypressnotificationtype_vals[] = { + { 0x00, "passkey entry started" }, + { 0x01, "passkey digit entered" }, + { 0x02, "passkey digit erased" }, + { 0x03, "passkey cleared" }, + { 0x04, "passkey entry completed" }, + { 0x00, NULL } +}; + +static const value_string poweradjreq_vals[] = { + { 0x00, "decrement power one step" }, + { 0x01, "increment power one step" }, + { 0x02, "increase to maximum power" }, + { 0x00, NULL } +}; + +static const value_string poweradjresp_vals[] = { + { 0x00, "not supported" }, + { 0x01, "changed one step" }, + { 0x02, "max power" }, + { 0x03, "min power" }, + { 0x00, NULL } +}; + +static const value_string samupdatemode_vals[] = { + { 0, "Existing SAM slot maps containing any type 0 submaps are invalidated" }, + { 1, "The defined type 0 submap takes effect immediately" }, + { 2, "The defined type 0 submap takes effect at the start of the next sub-interval" }, + { 0, NULL } +}; + +static const unit_name_string units_ppm = { " ppm", NULL }; + +static const unit_name_string units_slots = { " slot", " slots" }; + +static const unit_name_string units_slotpairs = { " slot pair", " slot pairs" }; + + + + +static void decode_uint8_binary(gchar *s, guint8 value) +{ + for (guint i = 0; i < 8 && i + 1 < ITEM_LABEL_LENGTH; ++i, value <<= 1) + *s++ = '0' + ((value >> 7) & 1); + *s = 0; +} + +void proto_register_btlmp(void); +void proto_reg_handoff_btlmp(void); + +static gint +dissect_btlmp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data) +{ + proto_item *btlmp_item; + proto_tree *btlmp_tree; + gint offset = 0; + guint16 opcode; + connection_info_t *connection_info = (connection_info_t *)data; + + btlmp_item = proto_tree_add_item(tree, proto_btlmp, tvb, offset, -1, ENC_NA); + btlmp_tree = proto_item_add_subtree(btlmp_item, ett_btlmp); + + col_set_str(pinfo->cinfo, COL_PROTOCOL, "BT LMP"); + + for (guint i = 0; i < array_length(hf_opcode); ++i) + proto_tree_add_item(btlmp_tree, hf_opcode[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + opcode = tvb_get_guint8(tvb, offset) >> 1; + offset += 1; + if (opcode >= 0x7c) { + opcode &= 3; + proto_tree_add_item(btlmp_tree, hf_escopcode[opcode], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++opcode; + opcode <<= 8; + opcode |= tvb_get_guint8(tvb, offset); + offset += 1; + } + switch (opcode) { + case 0x001: // LMP_name_req + break; + + case 0x002: // LMP_name_res + proto_tree_add_item(btlmp_tree, hf_param_nameoffset, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_namelength, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + if (tvb_captured_length_remaining(tvb, offset) <= 0) + break; + proto_tree_add_item(btlmp_tree, hf_param_namefragment, tvb, offset, tvb_captured_length_remaining(tvb, offset), ENC_NA); + offset = tvb_reported_length(tvb); + break; + + case 0x003: // LMP_accepted + proto_tree_add_item(btlmp_tree, hf_accept_opcode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x004: // LMP_not_accepted + proto_tree_add_item(btlmp_tree, hf_accept_opcode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_errorcode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x005: // LMP_clkoffset_req + break; + + case 0x006: // LMP_clkoffset_res + proto_tree_add_item(btlmp_tree, hf_param_clockoffset, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + break; + + case 0x007: // LMP_detach + proto_tree_add_item(btlmp_tree, hf_errorcode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x008: // LMP_in_rand + case 0x009: // LMP_comb_key + case 0x00b: // LMP_au_rand + case 0x00d: // LMP_temp_rand + case 0x011: // LMP_start_encryption_req + case 0x042: // LMP_pause_encryption_aes_req + proto_tree_add_item(btlmp_tree, hf_param_rand, tvb, offset, 16, ENC_NA); + offset += 16; + break; + + case 0x00a: // LMP_unit_key + case 0x00e: // LMP_temp_key + proto_tree_add_item(btlmp_tree, hf_param_key, tvb, offset, 16, ENC_NA); + offset += 16; + break; + + case 0x00c: // LMP_sres + proto_tree_add_item(btlmp_tree, hf_param_authresp, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + break; + + case 0x00f: // LMP_encryption_mode_req + proto_tree_add_item(btlmp_tree, hf_param_encryptionmode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x010: // LMP_encryption_key_size_req + proto_tree_add_item(btlmp_tree, hf_param_encryptionkeysize, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x012: // LMP_stop_encryption_req + break; + + case 0x013: // LMP_switch_req + proto_tree_add_item(btlmp_tree, hf_param_switchinstant, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + break; + + case 0x014: // LMP_hold + case 0x015: // LMP_hold_req + proto_tree_add_item(btlmp_tree, hf_param_holdtime, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_holdinstant, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + break; + + case 0x017: // LMP_sniff_req + for (guint i = 0; i < array_length(hf_param_timingcontrolflags); ++i) + proto_tree_add_item(btlmp_tree, hf_param_timingcontrolflags[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_dsniff, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_tsniff, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_sniffattempt, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_snifftimeout, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + break; + + case 0x018: // LMP_unsniff_req + break; + + case 0x01f: // LMP_incr_power_req + case 0x020: // LMP_decr_power_req + proto_tree_add_item(btlmp_tree, hf_param_futureuse1, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x021: // LMP_max_power + case 0x022: // LMP_min_power + case 0x023: // LMP_auto_rate + break; + + case 0x024: // LMP_preferred_rate + for (guint i = 0; i < array_length(hf_param_datarate); ++i) + proto_tree_add_item(btlmp_tree, hf_param_datarate[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + break; + + case 0x025: // LMP_version_req + case 0x026: // LMP_version_res + proto_tree_add_item(btlmp_tree, hf_param_versnr, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_compid, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_subversnr, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + break; + + case 0x027: // LMP_features_req + case 0x028: // LMP_features_res + for (guint i = 0; i < array_length(hf_param_feature_page0_byte0); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte0[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte1); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte1[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte2); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte2[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte3); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte3[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte4); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte4[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte5); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte5[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte6); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte6[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte7); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte7[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x029: // LMP_quality_of_service + case 0x02a: // LMP_quality_of_service_req + proto_tree_add_item(btlmp_tree, hf_param_pollinterval, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_nbc, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x02b: // LMP_SCO_link_req + proto_tree_add_item(btlmp_tree, hf_param_scohandle, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_timingcontrolflags); ++i) + proto_tree_add_item(btlmp_tree, hf_param_timingcontrolflags[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_dsco, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_tsco, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_scopacket, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_airmode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x02c: // LMP_remove_SCO_link_req + proto_tree_add_item(btlmp_tree, hf_param_scohandle, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_errorcode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x02d: // LMP_max_slot + case 0x02e: // LMP_max_slot_req + proto_tree_add_item(btlmp_tree, hf_param_slots, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x02f: // LMP_timing_accuracy_req + break; + + case 0x030: // LMP_timing_accuracy_res + proto_tree_add_item(btlmp_tree, hf_param_tmgacc_drift, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_tmgacc_jitter, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x031: // LMP_setup_complete + case 0x032: // LMP_use_semi_permanent_key + case 0x033: // LMP_host_connection_req + break; + + case 0x034: // LMP_slot_offset + proto_tree_add_item(btlmp_tree, hf_param_slotoffset, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_bdaddr, tvb, offset, 6, ENC_NA); + offset += 6; + break; + + case 0x035: // LMP_page_mode_req + case 0x036: // LMP_page_scan_mode_req + proto_tree_add_item(btlmp_tree, hf_param_pagingscheme, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_pagingschemesettings, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x037: // LMP_supervision_timeout + proto_tree_add_item(btlmp_tree, hf_param_supervisiontimeout, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + break; + + case 0x038: // LMP_test_activate + break; + + case 0x039: // LMP_test_control + proto_tree_add_item(btlmp_tree, hf_param_testscenario, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_testhoppingmode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_testtxfrequency, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_testrxfrequency, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_testpowercontrolmode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_testpollperiod, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_testpackettype, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_testdatalength, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x03a: // LMP_encryption_key_size_mask_req + break; + + case 0x03b: // LMP_encryption_key_size_mask_res + proto_tree_add_item(btlmp_tree, hf_param_keysizemask, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + break; + + case 0x03c: // LMP_set_AFH + proto_tree_add_item(btlmp_tree, hf_param_afh_instant, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + proto_tree_add_item(btlmp_tree, hf_param_afh_mode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_afh_channelmap); ++i, ++offset) + proto_tree_add_item(btlmp_tree, hf_param_afh_channelmap[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + break; + + case 0x03d: // LMP_encapsulated_header + proto_tree_add_item(btlmp_tree, hf_param_encapsulatedmajor, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_encapsulatedminor, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_encapsulatedlength, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x03e: // LMP_encapsulated_payload + proto_tree_add_item(btlmp_tree, hf_param_encapsulateddata, tvb, offset, 16, ENC_NA); + offset += 16; + break; + + case 0x03f: // LMP_Simple_Pairing_Confirm + proto_tree_add_item(btlmp_tree, hf_param_simplepaircommit, tvb, offset, 16, ENC_NA); + offset += 16; + break; + + case 0x040: // LMP_Simple_Pairing_Number + proto_tree_add_item(btlmp_tree, hf_param_simplepairnonce, tvb, offset, 16, ENC_NA); + offset += 16; + break; + + case 0x041: // LMP_DHkey_Check + proto_tree_add_item(btlmp_tree, hf_param_dhkeyconfirm, tvb, offset, 16, ENC_NA); + offset += 16; + break; + + case 0x401: // LMP_accepted_ext + proto_tree_add_item(btlmp_tree, hf_accept_opcode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_accept_escopcode[tvb_get_guint8(tvb, offset - 1) & 3], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x402: // LMP_not_accepted_ext + proto_tree_add_item(btlmp_tree, hf_accept_opcode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_accept_escopcode[tvb_get_guint8(tvb, offset - 1) & 3], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_errorcode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x403: // LMP_features_req_ext + case 0x404: // LMP_features_res_ext + proto_tree_add_item(btlmp_tree, hf_param_features_page, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_max_supported_page, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + switch (tvb_get_guint8(tvb, offset - 2)) { + case 0: + for (guint i = 0; i < array_length(hf_param_feature_page0_byte0); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte0[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte1); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte1[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte2); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte2[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte3); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte3[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte4); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte4[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte5); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte5[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte6); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte6[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page0_byte7); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page0_byte7[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 1: + for (guint i = 0; i < array_length(hf_param_feature_page1_byte0); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page1_byte0[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 2: + for (guint i = 0; i < array_length(hf_param_feature_page2_byte0); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page2_byte0[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_feature_page2_byte1); ++i) + proto_tree_add_item(btlmp_tree, hf_param_feature_page2_byte1[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + default: + break; + } + break; + + case 0x405: // LMP_clk_adj + proto_tree_add_item(btlmp_tree, hf_param_clkadjid, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_clkadjinstant, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + proto_tree_add_item(btlmp_tree, hf_param_clkadjus, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_clkadjslots, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_clkadjmode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_clkadjclk, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + break; + + case 0x406: // LMP_clk_adj_ack + proto_tree_add_item(btlmp_tree, hf_param_clkadjid, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x407: // LMP_clk_adj_req + proto_tree_add_item(btlmp_tree, hf_param_clkadjus, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_clkadjslots, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_clkadjperiod, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x40b: // LMP_packet_type_table_req + proto_tree_add_item(btlmp_tree, hf_param_packettypetable, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x40c: // LMP_eSCO_link_req + btbredr_rf_add_esco_link(connection_info, pinfo, tvb_get_guint8(tvb, offset), tvb_get_guint8(tvb, offset + 1), + tvb_get_guint16(tvb, offset + 8, ENC_LITTLE_ENDIAN), tvb_get_guint16(tvb, offset + 10, ENC_LITTLE_ENDIAN)); + proto_tree_add_item(btlmp_tree, hf_param_escohandle, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_escoltaddr, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_timingcontrolflags); ++i) + proto_tree_add_item(btlmp_tree, hf_param_timingcontrolflags[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_escod, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_escot, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_escow, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_escopackettypems, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_escopackettypesm, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_escopacketlengthms, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_escopacketlengthsm, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_airmode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_negostate, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x40d: // LMP_remove_eSCO_link_req + btbredr_rf_remove_esco_link(connection_info, pinfo, tvb_get_guint8(tvb, offset)); + proto_tree_add_item(btlmp_tree, hf_param_escohandle, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_errorcode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x410: // LMP_channel_classification_req + proto_tree_add_item(btlmp_tree, hf_param_afh_reportingmode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_afh_mininterval, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_afh_maxinterval, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + break; + + case 0x411: // LMP_channel_classification + for (guint i = 0; i < array_length(hf_param_afh_channelclass); ++i) + for (guint j = 0; j < array_length(hf_param_afh_channelclass[0]); ++j) + proto_tree_add_item(btlmp_tree, hf_param_afh_channelclass[i][j], tvb, offset + i, 1, ENC_LITTLE_ENDIAN); + offset += array_length(hf_param_afh_channelclass); + break; + + case 0x415: // LMP_sniff_subrating_req + case 0x416: // LMP_sniff_subrating_res + proto_tree_add_item(btlmp_tree, hf_param_maxsniffsubrate, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_minsniffmodetimeout, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + proto_tree_add_item(btlmp_tree, hf_param_sniffsubratinginstant, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + break; + + case 0x417: // LMP_pause_encryption_req + case 0x418: // LMP_resume_encryption_req + break; + + case 0x419: // LMP_IO_Capability_req + case 0x41a: // LMP_IO_Capability_res + proto_tree_add_item(btlmp_tree, hf_param_iocapcap, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_iocapoobauthdata, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_iocapauthreq, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x41b: // LMP_numeric_comparison_failed + case 0x41c: // LMP_passkey_failed + case 0x41d: // LMP_oob_failed + break; + + case 0x41e: // LMP_keypress_notification + proto_tree_add_item(btlmp_tree, hf_param_keypressnotificationtype, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x41f: // LMP_power_control_req + proto_tree_add_item(btlmp_tree, hf_param_poweradjreq, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x420: // LMP_power_control_res + for (guint i = 0; i < array_length(hf_param_poweradjresp); ++i) + proto_tree_add_item(btlmp_tree, hf_param_poweradjresp[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + break; + + case 0x421: // LMP_ping_req + case 0x422: // LMP_ping_res + break; + + case 0x423: // LMP_SAM_set_type0 + proto_tree_add_item(btlmp_tree, hf_param_samupdatemode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_samtype0submap, tvb, offset, 14, ENC_NA); + offset += 14; + break; + + case 0x424: // LMP_SAM_define_map + proto_tree_add_item(btlmp_tree, hf_param_samindex, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_samtsm, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_samnsm, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_samsubmaps, tvb, offset, 12, ENC_NA); + offset += 12; + break; + + case 0x425: // LMP_SAM_switch + proto_tree_add_item(btlmp_tree, hf_param_samindex, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + for (guint i = 0; i < array_length(hf_param_timingcontrolflags); ++i) + proto_tree_add_item(btlmp_tree, hf_param_timingcontrolflags[i], tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_samd, tvb, offset, 1, ENC_LITTLE_ENDIAN); + ++offset; + proto_tree_add_item(btlmp_tree, hf_param_saminstant, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + break; + + default: + break; + } + if (tvb_captured_length_remaining(tvb, offset) > 0) { + proto_tree_add_item(btlmp_tree, hf_params, tvb, offset, tvb_captured_length_remaining(tvb, offset), ENC_NA); + offset = tvb_reported_length(tvb); + } + return offset; +} + +void +proto_register_btlmp(void) +{ + static hf_register_info hf[] = { + { &hf_opcode[0], + { "Opcode", "btlmp.opcode.byte0", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_opcode[1], + { "TID", "btlmp.opcode.tid", + FT_UINT8, BASE_HEX, NULL, 0x01, + NULL, HFILL } + }, + { &hf_opcode[2], + { "Opcode", "btlmp.opcode.opcode", + FT_UINT8, BASE_DEC_HEX, VALS(opcode_vals), 0xfe, + NULL, HFILL } + }, + { &hf_escopcode[0], + { "Escape 1 Opcode", "btlmp.opcode.escaped", + FT_UINT16, BASE_DEC_HEX, VALS(escape1_opcode_vals), 0x00, + NULL, HFILL } + }, + { &hf_escopcode[1], + { "Escape 2 Opcode", "btlmp.opcode.escaped", + FT_UINT16, BASE_DEC_HEX, VALS(escape2_opcode_vals), 0x00, + NULL, HFILL } + }, + { &hf_escopcode[2], + { "Escape 3 Opcode", "btlmp.opcode.escaped", + FT_UINT16, BASE_DEC_HEX, VALS(escape3_opcode_vals), 0x00, + NULL, HFILL } + }, + { &hf_escopcode[3], + { "Escape 4 Opcode", "btlmp.opcode.escaped", + FT_UINT16, BASE_DEC_HEX, VALS(escape4_opcode_vals), 0x00, + NULL, HFILL } + }, + { &hf_accept_opcode, + { "Opcode", "btlmp.accept_opcode", + FT_UINT8, BASE_DEC_HEX, VALS(opcode_vals), 0x00, + NULL, HFILL } + }, + { &hf_accept_escopcode[0], + { "Escape 1 Opcode", "btlmp.accept_opcode1", + FT_UINT16, BASE_DEC_HEX, VALS(escape1_opcode_vals), 0x00, + NULL, HFILL } + }, + { &hf_accept_escopcode[1], + { "Escape 2 Opcode", "btlmp.accept_opcode2", + FT_UINT16, BASE_DEC_HEX, VALS(escape2_opcode_vals), 0x00, + NULL, HFILL } + }, + { &hf_accept_escopcode[2], + { "Escape 3 Opcode", "btlmp.accept_opcode3", + FT_UINT16, BASE_DEC_HEX, VALS(escape3_opcode_vals), 0x00, + NULL, HFILL } + }, + { &hf_accept_escopcode[3], + { "Escape 4 Opcode", "btlmp.accept_opcode4", + FT_UINT16, BASE_DEC_HEX, VALS(escape4_opcode_vals), 0x00, + NULL, HFILL } + }, + { &hf_errorcode, + { "Error Code", "btlmp.errorcode", + FT_UINT8, BASE_DEC_HEX, VALS(errorcode_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte0[0], + { "Feature Page 0 Byte 0", "btlmp.feature.page0.byte0", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte0[1], + { "3 slot packets", "btlmp.feature.page0.3slotpackets", + FT_UINT8, BASE_DEC, NULL, 0x01, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte0[2], + { "5 slot packets", "btlmp.feature.page0.5slotpackets", + FT_UINT8, BASE_DEC, NULL, 0x02, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte0[3], + { "Encryption", "btlmp.feature.page0.encryption", + FT_UINT8, BASE_DEC, NULL, 0x04, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte0[4], + { "Slot offset", "btlmp.feature.page0.slotoffset", + FT_UINT8, BASE_DEC, NULL, 0x08, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte0[5], + { "Timing accuracy", "btlmp.feature.page0.timingaccuracy", + FT_UINT8, BASE_DEC, NULL, 0x10, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte0[6], + { "Role switch", "btlmp.feature.page0.roleswitch", + FT_UINT8, BASE_DEC, NULL, 0x20, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte0[7], + { "Hold mode", "btlmp.feature.page0.holdmode", + FT_UINT8, BASE_DEC, NULL, 0x40, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte0[8], + { "Sniff mode", "btlmp.feature.page0.sniffmode", + FT_UINT8, BASE_DEC, NULL, 0x80, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte1[0], + { "Feature Page 0 Byte 1", "btlmp.feature.page0.byte1", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte1[1], + { "Reserved", "btlmp.feature.page0.reserved1", + FT_UINT8, BASE_DEC, NULL, 0x01, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte1[2], + { "Power control requests", "btlmp.feature.page0.powercontrolrequests", + FT_UINT8, BASE_DEC, NULL, 0x02, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte1[3], + { "Channel quality driven data rate (CQDDR)", "btlmp.feature.page0.cqddr", + FT_UINT8, BASE_DEC, NULL, 0x04, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte1[4], + { "SCO link", "btlmp.feature.page0.scolink", + FT_UINT8, BASE_DEC, NULL, 0x08, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte1[5], + { "HV2 packets", "btlmp.feature.page0.hv2packets", + FT_UINT8, BASE_DEC, NULL, 0x10, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte1[6], + { "HV3 packets", "btlmp.feature.page0.hv3packets", + FT_UINT8, BASE_DEC, NULL, 0x20, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte1[7], + { "u-law log synchronous data", "btlmp.feature.page0.ulaw", + FT_UINT8, BASE_DEC, NULL, 0x40, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte1[8], + { "A-law log synchronous data", "btlmp.feature.page0.alaw", + FT_UINT8, BASE_DEC, NULL, 0x80, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte2[0], + { "Feature Page 0 Byte 2", "btlmp.feature.page0.byte2", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte2[1], + { "CVSD synchronous data", "btlmp.feature.page0.cvsd", + FT_UINT8, BASE_DEC, NULL, 0x01, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte2[2], + { "Paging parameter negotiation", "btlmp.feature.page0.pagingparameter", + FT_UINT8, BASE_DEC, NULL, 0x02, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte2[3], + { "Power control", "btlmp.feature.page0.powercontrol", + FT_UINT8, BASE_DEC, NULL, 0x04, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte2[4], + { "Transparent synchronous data", "btlmp.feature.page0.transparentsynchronous", + FT_UINT8, BASE_DEC, NULL, 0x08, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte2[5], + { "Flow control lag (least significant bit)", "btlmp.feature.page0.flowcontrollag", + FT_UINT8, BASE_DEC, NULL, 0x70, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte2[6], + { "Broadcast Encryption", "btlmp.feature.page0.broadcastencryption", + FT_UINT8, BASE_DEC, NULL, 0x80, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte3[0], + { "Feature Page 0 Byte 3", "btlmp.feature.page0.byte3", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte3[1], + { "Reserved", "btlmp.feature.page0.reserved2", + FT_UINT8, BASE_DEC, NULL, 0x01, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte3[2], + { "Enhanced Data Rate ACL 2 Mb/s mode", "btlmp.feature.page0.edracl2", + FT_UINT8, BASE_DEC, NULL, 0x02, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte3[3], + { "Enhanced Data Rate ACL 3 Mb/s mode", "btlmp.feature.page0.edracl3", + FT_UINT8, BASE_DEC, NULL, 0x04, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte3[4], + { "Enhanced inquiry scan", "btlmp.feature.page0.enhinqscan", + FT_UINT8, BASE_DEC, NULL, 0x08, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte3[5], + { "Interlaced inquiry scan", "btlmp.feature.page0.interlacedinqscan", + FT_UINT8, BASE_DEC, NULL, 0x10, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte3[6], + { "Interlaced page scan", "btlmp.feature.page0.interlacedpgscan", + FT_UINT8, BASE_DEC, NULL, 0x20, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte3[7], + { "RSSI with inquiry results", "btlmp.feature.page0.inqrssi", + FT_UINT8, BASE_DEC, NULL, 0x40, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte3[8], + { "Extended SCO link (EV3 packets)", "btlmp.feature.page0.escolink", + FT_UINT8, BASE_DEC, NULL, 0x80, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte4[0], + { "Feature Page 0 Byte 4", "btlmp.feature.page0.byte4", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte4[1], + { "EV4 packets", "btlmp.feature.page0.ev4", + FT_UINT8, BASE_DEC, NULL, 0x01, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte4[2], + { "EV5 packets", "btlmp.feature.page0.ev5", + FT_UINT8, BASE_DEC, NULL, 0x02, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte4[3], + { "Reserved", "btlmp.feature.page0.reserved3", + FT_UINT8, BASE_DEC, NULL, 0x04, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte4[4], + { "AFH capable slave", "btlmp.feature.page0.afhcapableslave", + FT_UINT8, BASE_DEC, NULL, 0x08, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte4[5], + { "AFH classification slave", "btlmp.feature.page0.afhclassificationslave", + FT_UINT8, BASE_DEC, NULL, 0x10, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte4[6], + { "BR/EDR Not Supported", "btlmp.feature.page0.bredrnotsupp", + FT_UINT8, BASE_DEC, NULL, 0x20, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte4[7], + { "LE Supported (Controller)", "btlmp.feature.page0.lesuppcontroller", + FT_UINT8, BASE_DEC, NULL, 0x40, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte4[8], + { "3-slot Enhanced Data Rate ACL packets", "btlmp.feature.page0.3slotedracl", + FT_UINT8, BASE_DEC, NULL, 0x80, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte5[0], + { "Feature Page 0 Byte 5", "btlmp.feature.page0.byte5", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte5[1], + { "5-slot Enhanced Data Rate ACL packets", "btlmp.feature.page0.5slotedracl", + FT_UINT8, BASE_DEC, NULL, 0x01, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte5[2], + { "Sniff subrating", "btlmp.feature.page0.sniffsubrating", + FT_UINT8, BASE_DEC, NULL, 0x02, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte5[3], + { "Pause encryption", "btlmp.feature.page0.pauseencrypt", + FT_UINT8, BASE_DEC, NULL, 0x04, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte5[4], + { "AFH capable master", "btlmp.feature.page0.afhcapablemaster", + FT_UINT8, BASE_DEC, NULL, 0x08, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte5[5], + { "AFH classification master", "btlmp.feature.page0.afhclassificationmaster", + FT_UINT8, BASE_DEC, NULL, 0x10, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte5[6], + { "Enhanced Data Rate eSCO 2 Mb/s mode", "btlmp.feature.page0.edresco2", + FT_UINT8, BASE_DEC, NULL, 0x20, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte5[7], + { "Enhanced Data Rate eSCO 3 Mb/s mode", "btlmp.feature.page0.edresco3", + FT_UINT8, BASE_DEC, NULL, 0x40, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte5[8], + { "3-slot Enhanced Data Rate eSCO packets", "btlmp.feature.page0.3slotedresco", + FT_UINT8, BASE_DEC, NULL, 0x80, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte6[0], + { "Feature Page 0 Byte 6", "btlmp.feature.page0.byte6", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte6[1], + { "Extended Inquiry Response", "btlmp.feature.page0.extinqresp", + FT_UINT8, BASE_DEC, NULL, 0x01, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte6[2], + { "Simultaneous LE and BR/EDR to Same Device Capable (Controller)", "btlmp.feature.page0.simullebredrcontroller", + FT_UINT8, BASE_DEC, NULL, 0x02, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte6[3], + { "Reserved", "btlmp.feature.page0.reserved4", + FT_UINT8, BASE_DEC, NULL, 0x04, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte6[4], + { "Secure Simple Pairing (Controller Support)", "btlmp.feature.page0.securesimplepaircontroller", + FT_UINT8, BASE_DEC, NULL, 0x08, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte6[5], + { "Encapsulated PDU", "btlmp.feature.page0.encpdu", + FT_UINT8, BASE_DEC, NULL, 0x10, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte6[6], + { "Erroneous Data Reporting", "btlmp.feature.page0.errdatareport", + FT_UINT8, BASE_DEC, NULL, 0x20, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte6[7], + { "Non-flushable Packet Boundary Flag", "btlmp.feature.page0.nonflushboundary", + FT_UINT8, BASE_DEC, NULL, 0x40, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte6[8], + { "Reserved", "btlmp.feature.page0.reserved5", + FT_UINT8, BASE_DEC, NULL, 0x80, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte7[0], + { "Feature Page 0 Byte 1", "btlmp.feature.page0.byte7", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte7[1], + { "HCI Link Supervision Timeout Changed event", "btlmp.feature.page0.hcilinksupervisiontimeoutchgevt", + FT_UINT8, BASE_DEC, NULL, 0x01, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte7[2], + { "Variable Inquiry TX Power Level", "btlmp.feature.page0.varinqtxpwr", + FT_UINT8, BASE_DEC, NULL, 0x02, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte7[3], + { "Enhanced Power Control", "btlmp.feature.page0.enhpowercontrol", + FT_UINT8, BASE_DEC, NULL, 0x04, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte7[4], + { "Reserved", "btlmp.feature.page0.reserved6", + FT_UINT8, BASE_DEC, NULL, 0x78, + NULL, HFILL } + }, + { &hf_param_feature_page0_byte7[5], + { "Extended features", "btlmp.feature.page0.extftr", + FT_UINT8, BASE_DEC, NULL, 0x80, + NULL, HFILL } + }, + { &hf_param_feature_page1_byte0[0], + { "Feature Page 1 Byte 0", "btlmp.feature.page1.byte0", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_feature_page1_byte0[1], + { "Secure Simple Pairing (Host Support)", "btlmp.feature.page1.securesimplepairhost", + FT_UINT8, BASE_DEC, NULL, 0x01, + NULL, HFILL } + }, + { &hf_param_feature_page1_byte0[2], + { "LE Supported (Host)", "btlmp.feature.page1.lesupphost", + FT_UINT8, BASE_DEC, NULL, 0x02, + NULL, HFILL } + }, + { &hf_param_feature_page1_byte0[3], + { "Simultaneous LE and BR/EDR to Same Device Capable (Host)", "btlmp.feature.page1.simullebredrhost", + FT_UINT8, BASE_DEC, NULL, 0x04, + NULL, HFILL } + }, + { &hf_param_feature_page1_byte0[4], + { "Secure Connections (Host Support)", "btlmp.feature.page1.secureconnhost", + FT_UINT8, BASE_DEC, NULL, 0x08, + NULL, HFILL } + }, + { &hf_param_feature_page1_byte0[5], + { "Reserved", "btlmp.feature.page1.reserved1", + FT_UINT8, BASE_DEC, NULL, 0xf0, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte0[0], + { "Feature Page 2 Byte 0", "btlmp.feature.page2.byte0", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte0[1], + { "Connectionless Slave Broadcast - Master", "btlmp.feature.page2.csbmaster", + FT_UINT8, BASE_DEC, NULL, 0x01, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte0[2], + { "Connectionless Slave Broadcast - Slave", "btlmp.feature.page2.csbslave", + FT_UINT8, BASE_DEC, NULL, 0x02, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte0[3], + { "Synchronization Train", "btlmp.feature.page2.synctrain", + FT_UINT8, BASE_DEC, NULL, 0x04, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte0[4], + { "Synchronization Scan", "btlmp.feature.page2.syncscan", + FT_UINT8, BASE_DEC, NULL, 0x08, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte0[5], + { "HCI_Inquiry_Response_Notification event", "btlmp.feature.page2.hciinqrespnotifevt", + FT_UINT8, BASE_DEC, NULL, 0x10, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte0[6], + { "Generalized interlaced scan", "btlmp.feature.page2.generalinterlacedscan", + FT_UINT8, BASE_DEC, NULL, 0x20, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte0[7], + { "Coarse Clock Adjustment", "btlmp.feature.page2.coarseclockadj", + FT_UINT8, BASE_DEC, NULL, 0x40, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte0[8], + { "Reserved", "btlmp.feature.page2.reserved1", + FT_UINT8, BASE_DEC, NULL, 0x80, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte1[0], + { "Feature Page 2 Byte 1", "btlmp.feature.page2.byte1", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte1[1], + { "Secure Connections (Controller Support)", "btlmp.feature.page2.secureconncontroller", + FT_UINT8, BASE_DEC, NULL, 0x01, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte1[2], + { "Ping", "btlmp.feature.page2.ping", + FT_UINT8, BASE_DEC, NULL, 0x02, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte1[3], + { "Slot Availability Mask", "btlmp.feature.page2.slotavailabilitymask", + FT_UINT8, BASE_DEC, NULL, 0x04, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte1[4], + { "Train nudging", "btlmp.feature.page2.trainnudging", + FT_UINT8, BASE_DEC, NULL, 0x08, + NULL, HFILL } + }, + { &hf_param_feature_page2_byte1[5], + { "Reserved", "btlmp.feature.page2.reserved2", + FT_UINT8, BASE_DEC, NULL, 0xf0, + NULL, HFILL } + }, + { &hf_param_features_page, + { "Feature Page", "btlmp.feature.features_page", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_max_supported_page, + { "Max Supported Page", "btlmp.feature.max_supported_page", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_versnr, + { "VersNr", "btlmp.version.versnr", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_compid, + { "CompId", "btlmp.version.CompId", + FT_UINT16, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_subversnr, + { "SubVersNr", "btlmp.version.SubVersNr", + FT_UINT16, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_namelength, + { "Name Length", "btlmp.name.length", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_nameoffset, + { "Name Offset", "btlmp.name.offset", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_namefragment, + { "Name Fragment", "btlmp.name.fragment", + FT_STRINGZPAD, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_afh_mode, + { "AFH Mode", "btlmp.afh.mode", + FT_UINT8, BASE_HEX, VALS(afh_mode_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_afh_instant, + { "AFH Instant", "btlmp.afh.instant", + FT_UINT32, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_afh_channelmap[0], + { "AFH Channel Map 0", "btlmp.afh.channelmap0", + FT_UINT32, BASE_CUSTOM, CF_FUNC(decode_uint8_binary), 0x00, + NULL, HFILL } + }, + { &hf_param_afh_channelmap[1], + { "AFH Channel Map 1", "btlmp.afh.channelmap1", + FT_UINT32, BASE_CUSTOM, CF_FUNC(decode_uint8_binary), 0x00, + NULL, HFILL } + }, + { &hf_param_afh_channelmap[2], + { "AFH Channel Map 2", "btlmp.afh.channelmap2", + FT_UINT32, BASE_CUSTOM, CF_FUNC(decode_uint8_binary), 0x00, + NULL, HFILL } + }, + { &hf_param_afh_channelmap[3], + { "AFH Channel Map 3", "btlmp.afh.channelmap3", + FT_UINT32, BASE_CUSTOM, CF_FUNC(decode_uint8_binary), 0x00, + NULL, HFILL } + }, + { &hf_param_afh_channelmap[4], + { "AFH Channel Map 4", "btlmp.afh.channelmap4", + FT_UINT32, BASE_CUSTOM, CF_FUNC(decode_uint8_binary), 0x00, + NULL, HFILL } + }, + { &hf_param_afh_channelmap[5], + { "AFH Channel Map 5", "btlmp.afh.channelmap5", + FT_UINT32, BASE_CUSTOM, CF_FUNC(decode_uint8_binary), 0x00, + NULL, HFILL } + }, + { &hf_param_afh_channelmap[6], + { "AFH Channel Map 6", "btlmp.afh.channelmap6", + FT_UINT32, BASE_CUSTOM, CF_FUNC(decode_uint8_binary), 0x00, + NULL, HFILL } + }, + { &hf_param_afh_channelmap[7], + { "AFH Channel Map 7", "btlmp.afh.channelmap7", + FT_UINT32, BASE_CUSTOM, CF_FUNC(decode_uint8_binary), 0x00, + NULL, HFILL } + }, + { &hf_param_afh_channelmap[8], + { "AFH Channel Map 8", "btlmp.afh.channelmap8", + FT_UINT32, BASE_CUSTOM, CF_FUNC(decode_uint8_binary), 0x00, + NULL, HFILL } + }, + { &hf_param_afh_channelmap[9], + { "AFH Channel Map 9", "btlmp.afh.channelmap9", + FT_UINT32, BASE_CUSTOM, CF_FUNC(decode_uint8_binary), 0x00, + NULL, HFILL } + }, + { &hf_param_afh_reportingmode, + { "AFH Reporting Mode", "btlmp.afh.reportingmode", + FT_UINT8, BASE_HEX, VALS(afh_reportingmode_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_afh_mininterval, + { "AFH Min Interval", "btlmp.afh.mininterval", + FT_UINT16, BASE_HEX_DEC | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_afh_maxinterval, + { "AFH Max Interval", "btlmp.afh.maxinterval", + FT_UINT16, BASE_HEX_DEC | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[0][0], + { "AFH Channel 0-1 Classification", "btlmp.afh.channelclass0", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x03, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[0][1], + { "AFH Channel 2-3 Classification", "btlmp.afh.channelclass2", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x0C, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[0][2], + { "AFH Channel 4-5 Classification", "btlmp.afh.channelclass4", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x30, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[0][3], + { "AFH Channel 6-7 Classification", "btlmp.afh.channelclass6", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0xC0, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[1][0], + { "AFH Channel 8-9 Classification", "btlmp.afh.channelclass8", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x03, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[1][1], + { "AFH Channel 10-11 Classification", "btlmp.afh.channelclass10", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x0C, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[1][2], + { "AFH Channel 12-13 Classification", "btlmp.afh.channelclass12", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x30, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[1][3], + { "AFH Channel 14-15 Classification", "btlmp.afh.channelclass14", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0xC0, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[2][0], + { "AFH Channel 16-17 Classification", "btlmp.afh.channelclass16", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x03, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[2][1], + { "AFH Channel 18-19 Classification", "btlmp.afh.channelclass18", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x0C, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[2][2], + { "AFH Channel 20-21 Classification", "btlmp.afh.channelclass20", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x30, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[2][3], + { "AFH Channel 22-23 Classification", "btlmp.afh.channelclass22", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0xC0, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[3][0], + { "AFH Channel 24-25 Classification", "btlmp.afh.channelclass24", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x03, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[3][1], + { "AFH Channel 26-27 Classification", "btlmp.afh.channelclass26", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x0C, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[3][2], + { "AFH Channel 28-29 Classification", "btlmp.afh.channelclass28", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x30, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[3][3], + { "AFH Channel 30-31 Classification", "btlmp.afh.channelclass30", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0xC0, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[4][0], + { "AFH Channel 32-33 Classification", "btlmp.afh.channelclass32", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x03, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[4][1], + { "AFH Channel 34-35 Classification", "btlmp.afh.channelclass34", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x0C, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[4][2], + { "AFH Channel 36-37 Classification", "btlmp.afh.channelclass36", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x30, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[4][3], + { "AFH Channel 38-39 Classification", "btlmp.afh.channelclass38", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0xC0, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[5][0], + { "AFH Channel 40-41 Classification", "btlmp.afh.channelclass40", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x03, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[5][1], + { "AFH Channel 42-43 Classification", "btlmp.afh.channelclass42", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x0C, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[5][2], + { "AFH Channel 44-45 Classification", "btlmp.afh.channelclass44", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x30, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[5][3], + { "AFH Channel 46-47 Classification", "btlmp.afh.channelclass46", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0xC0, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[6][0], + { "AFH Channel 48-49 Classification", "btlmp.afh.channelclass48", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x03, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[6][1], + { "AFH Channel 50-51 Classification", "btlmp.afh.channelclass50", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x0C, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[6][2], + { "AFH Channel 52-53 Classification", "btlmp.afh.channelclass52", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x30, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[6][3], + { "AFH Channel 54-55 Classification", "btlmp.afh.channelclass54", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0xC0, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[7][0], + { "AFH Channel 56-57 Classification", "btlmp.afh.channelclass56", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x03, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[7][1], + { "AFH Channel 58-59 Classification", "btlmp.afh.channelclass58", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x0C, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[7][2], + { "AFH Channel 60-61 Classification", "btlmp.afh.channelclass60", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x30, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[7][3], + { "AFH Channel 62-63 Classification", "btlmp.afh.channelclass62", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0xC0, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[8][0], + { "AFH Channel 64-65 Classification", "btlmp.afh.channelclass64", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x03, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[8][1], + { "AFH Channel 66-67 Classification", "btlmp.afh.channelclass66", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x0C, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[8][2], + { "AFH Channel 68-69 Classification", "btlmp.afh.channelclass68", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x30, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[8][3], + { "AFH Channel 70-71 Classification", "btlmp.afh.channelclass70", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0xC0, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[9][0], + { "AFH Channel 72-73 Classification", "btlmp.afh.channelclass72", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x03, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[9][1], + { "AFH Channel 74-75 Classification", "btlmp.afh.channelclass74", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x0C, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[9][2], + { "AFH Channel 76-77 Classification", "btlmp.afh.channelclass76", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0x30, + NULL, HFILL } + }, + { &hf_param_afh_channelclass[9][3], + { "AFH Channel 78 Classification", "btlmp.afh.channelclass78", + FT_UINT8, BASE_HEX, VALS(afh_channelclass_vals), 0xC0, + NULL, HFILL } + }, + { &hf_param_rand, + { "Random Number", "btlmp.randomnumber", + FT_BYTES, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_key, + { "Key", "btlmp.key", + FT_BYTES, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_clockoffset, + { "Clock Offset", "btlmp.clockoffset", + FT_UINT16, BASE_HEX | BASE_UNIT_STRING, &units_slotpairs, 0x00, + NULL, HFILL } + }, + { &hf_param_authresp, + { "Authentication Response", "btlmp.authenticationresponse", + FT_UINT32, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_encryptionmode, + { "Encryption Mode", "btlmp.encryptionmode", + FT_UINT8, BASE_HEX, VALS(encryptionmode_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_encryptionkeysize, + { "Encryption Key Size", "btlmp.encryptionkeysize", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_switchinstant, + { "Switch Instant", "btlmp.switchinstant", + FT_UINT32, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_holdtime, + { "Hold Time", "btlmp.holdtime", + FT_UINT16, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_holdinstant, + { "Hold Instant", "btlmp.holdinstant", + FT_UINT32, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_dsniff, + { "Dsniff", "btlmp.sniff.d", + FT_UINT16, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_tsniff, + { "Tsniff", "btlmp.sniff.t", + FT_UINT16, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_sniffattempt, + { "Sniff Attempt", "btlmp.sniff.attempt", + FT_UINT16, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_snifftimeout, + { "Sniff Timeout", "btlmp.sniff.timeout", + FT_UINT16, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_timingcontrolflags[0], + { "Timing Control Flags", "btlmp.timingcontrol.flags", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_timingcontrolflags[1], + { "Timing Change", "btlmp.timingcontrol.timingchange", + FT_UINT8, BASE_DEC, VALS(timingcontrol_timingchange_vals), 0x01, + NULL, HFILL } + }, + { &hf_param_timingcontrolflags[2], + { "Use Initialization 2", "btlmp.timingcontrol.useinit2", + FT_UINT8, BASE_DEC, VALS(timingcontrol_useinit2), 0x02, + NULL, HFILL } + }, + { &hf_param_timingcontrolflags[3], + { "No Access Window", "btlmp.timingcontrol.noaccesswindow", + FT_UINT8, BASE_DEC, VALS(timingcontrol_noaccesswindow), 0x04, + NULL, HFILL } + }, + { &hf_param_timingcontrolflags[4], + { "Reserved", "btlmp.timingcontrol.reserved", + FT_UINT8, BASE_HEX, NULL, 0xf8, + NULL, HFILL } + }, + { &hf_param_futureuse1, + { "Future Use", "btlmp.futureuse1", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_datarate[0], + { "Datarate", "btlmp.datarate.flags", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_datarate[1], + { "Do not use FEC", "btlmp.datarate.nofec", + FT_UINT8, BASE_DEC, VALS(dataratenofec_vals), 0x01, + NULL, HFILL } + }, + { &hf_param_datarate[2], + { "Basic Rate Packet Size Preference", "btlmp.datarate.brpacketsizepreference", + FT_UINT8, BASE_DEC, VALS(dataratepacketsizepreference_vals), 0x06, + NULL, HFILL } + }, + { &hf_param_datarate[3], + { "Enhanced Data Rate Datarate Preference", "btlmp.datarate.edrdataratepreference", + FT_UINT8, BASE_DEC, VALS(dataratedrpreference_vals), 0x18, + NULL, HFILL } + }, + { &hf_param_datarate[4], + { "Enhanced Data Rate Packet Size Preference", "btlmp.datarate.edrpacketsizepreference", + FT_UINT8, BASE_DEC, VALS(dataratepacketsizepreference_vals), 0x60, + NULL, HFILL } + }, + { &hf_param_datarate[5], + { "Reserved", "btlmp.datarate.reserved", + FT_UINT8, BASE_DEC, NULL, 0x80, + NULL, HFILL } + }, + { &hf_param_pollinterval, + { "Poll Interval", "btlmp.qos.pollinterval", + FT_UINT16, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_nbc, + { "NBC", "btlmp.qos.nbc", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_scohandle, + { "SCO Handle", "btlmp.sco.handle", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_dsco, + { "Dsco", "btlmp.sco.d", + FT_UINT8, BASE_DEC | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_tsco, + { "Tsco", "btlmp.sco.t", + FT_UINT8, BASE_DEC | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_scopacket, + { "SCO packet", "btlmp.sco.packet", + FT_UINT8, BASE_HEX, VALS(scopacket_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_airmode, + { "Air Mode", "btlmp.sco.airmode", + FT_UINT8, BASE_HEX, VALS(airmode_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_slots, + { "Slots", "btlmp.slots", + FT_UINT8, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_tmgacc_drift, + { "Drift", "btlmp.timingaccuracy.drift", + FT_UINT8, BASE_DEC | BASE_UNIT_STRING, &units_ppm, 0x00, + NULL, HFILL } + }, + { &hf_param_tmgacc_jitter, + { "Jitter", "btlmp.timingaccuracy.jitter", + FT_UINT8, BASE_DEC | BASE_UNIT_STRING, &units_microsecond_microseconds, 0x00, + NULL, HFILL } + }, + { &hf_param_slotoffset, + { "Slot Offset", "btlmp.slotoffset", + FT_UINT16, BASE_DEC | BASE_UNIT_STRING, &units_microsecond_microseconds, 0x00, + NULL, HFILL } + }, + { &hf_param_bdaddr, + { "Address", "btlmp.bd_addr", + FT_ETHER, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_pagingscheme, + { "Paging Scheme", "btlmp.paging.scheme", + FT_UINT8, BASE_HEX, VALS(pagingscheme_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_pagingschemesettings, + { "Paging Scheme Settings", "btlmp.paging.schemesettings", + FT_UINT8, BASE_HEX, VALS(pagingschemesettings_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_supervisiontimeout, + { "Supervision Timeout", "btlmp.supervisiontimeout", + FT_UINT16, BASE_DEC | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_testscenario, + { "Scenario", "btlmp.test.scenario", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_testhoppingmode, + { "Hopping Mode", "btlmp.test.hoppingmode", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_testtxfrequency, + { "TX frequency", "btlmp.test.txfrequency", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_testrxfrequency, + { "RX frequency", "btlmp.test.rxfrequency", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_testpowercontrolmode, + { "Power Control Mode", "btlmp.test.powercontrolmode", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_testpollperiod, + { "Poll Period", "btlmp.test.pollperiod", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_testpackettype, + { "Packet Type", "btlmp.test.packettype", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_testdatalength, + { "Length of Test Data", "btlmp.test.datalength", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_keysizemask, + { "Key Size Mask", "btlmp.keysizemask", + FT_UINT16, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_encapsulatedmajor, + { "Encapsulated Major Type", "btlmp.encapsulated.major", + FT_UINT8, BASE_HEX, VALS(encapsulatedmajor_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_encapsulatedminor, + { "Encapsulated Minor Type", "btlmp.encapsulated.minor", + FT_UINT8, BASE_HEX, VALS(encapsulatedminor_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_encapsulatedlength, + { "Encapsulated Payload Length", "btlmp.encapsulated.payloadlength", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_encapsulateddata, + { "Encapsulated Data", "btlmp.encapsulated.data", + FT_BYTES, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_simplepaircommit, + { "Commitment Value", "btlmp.simplepair.commit", + FT_BYTES, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_simplepairnonce, + { "Nonce Value", "btlmp.simplepair.nonce", + FT_BYTES, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_dhkeyconfirm, + { "Confirmation Value", "btlmp.dhkey.confirm", + FT_BYTES, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_clkadjid, + { "Clock Adjust ID", "btlmp.clkadj.id", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_clkadjinstant, + { "Clock Adjust Instant", "btlmp.clkadj.instant", + FT_UINT32, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_clkadjus, + { "Clock Adjust Microseconds", "btlmp.clkadj.us", + FT_INT16, BASE_DEC | BASE_UNIT_STRING, &units_microsecond_microseconds, 0x00, + NULL, HFILL } + }, + { &hf_param_clkadjslots, + { "Clock Adjust Slots", "btlmp.clkadj.slots", + FT_UINT8, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_clkadjmode, + { "Clock Adjust Mode", "btlmp.clkadj.mode", + FT_UINT8, BASE_HEX, VALS(clkadjmode_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_clkadjclk, + { "Clock Adjust Clock", "btlmp.clkadj.clk", + FT_UINT32, BASE_HEX | BASE_UNIT_STRING, &units_slotpairs, 0x00, + NULL, HFILL } + }, + { &hf_param_clkadjperiod, + { "Clock Adjust Period", "btlmp.clkadj.period", + FT_UINT8, BASE_DEC | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_packettypetable, + { "Packet Type Table", "btlmp.packettypetable", + FT_UINT8, BASE_HEX, VALS(packettypetable_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_escohandle, + { "eSCO Handle", "btlmp.esco.handle", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_escoltaddr, + { "eSCO LT_ADDR", "btlmp.esco.ltaddr", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_escod, + { "Desco", "btlmp.esco.d", + FT_UINT8, BASE_DEC | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_escot, + { "Tesco", "btlmp.esco.t", + FT_UINT8, BASE_DEC | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_escow, + { "Wesco", "btlmp.esco.w", + FT_UINT8, BASE_DEC | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_escopackettypems, + { "eSCO Packet Type M->S", "btlmp.esco.packettypems", + FT_UINT8, BASE_HEX, VALS(escopackettypems_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_escopackettypesm, + { "eSCO Packet Type S->M", "btlmp.esco.packettypesm", + FT_UINT8, BASE_HEX, VALS(escopackettypesm_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_escopacketlengthms, + { "eSCO Packet Length M->S", "btlmp.esco.packetlengthms", + FT_UINT16, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_escopacketlengthsm, + { "eSCO Packet Length S->M", "btlmp.esco.packetlengthsm", + FT_UINT16, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_negostate, + { "Negotiation State", "btlmp.negotiationstate", + FT_UINT8, BASE_HEX, VALS(negostate_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_maxsniffsubrate, + { "Max Sniff Subrate", "btlmp.sniffsubrate.max", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_minsniffmodetimeout, + { "Min Sniff Mode Timeout", "btlmp.sniffsubrate.minmodetimeout", + FT_UINT16, BASE_DEC | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_sniffsubratinginstant, + { "Sniff Subrating Instant", "btlmp.sniffsubrate.instant", + FT_UINT32, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_iocapcap, + { "IO Capabilities", "btlmp.iocap.cap", + FT_UINT8, BASE_HEX, VALS(iocapcap_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_iocapoobauthdata, + { "OOB Authentication Data", "btlmp.iocap.oobauthdata", + FT_UINT8, BASE_HEX, VALS(iocapoobauthdata_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_iocapauthreq, + { "Authentication Requirement", "btlmp.iocap.authreq", + FT_UINT8, BASE_HEX, VALS(iocapauthreq_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_keypressnotificationtype, + { "Notification Type", "btlmp.keypress.notificationtype", + FT_UINT8, BASE_HEX, VALS(keypressnotificationtype_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_poweradjreq, + { "Power Adjustment Request", "btlmp.poweradj.request", + FT_UINT8, BASE_HEX, VALS(poweradjreq_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_poweradjresp[0], + { "Power Adjustment Response", "btlmp.poweradj.response", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_poweradjresp[1], + { "GFSK", "btlmp.poweradj.gfsk", + FT_UINT8, BASE_HEX, VALS(poweradjresp_vals), 0x03, + NULL, HFILL } + }, + { &hf_param_poweradjresp[2], + { "Pi/4-DQPSK", "btlmp.poweradj.pi4dqsk", + FT_UINT8, BASE_HEX, VALS(poweradjresp_vals), 0x0C, + NULL, HFILL } + }, + { &hf_param_poweradjresp[3], + { "8DPSK", "btlmp.poweradj.8dpsk", + FT_UINT8, BASE_HEX, VALS(poweradjresp_vals), 0x30, + NULL, HFILL } + }, + { &hf_param_poweradjresp[4], + { "Reserved", "btlmp.poweradj.reserved", + FT_UINT8, BASE_HEX, NULL, 0xC0, + NULL, HFILL } + }, + { &hf_param_samindex, + { "SAM Index", "btlmp.sam.index", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_samtsm, + { "Tsam-sm", "btlmp.sam.tsm", + FT_UINT8, BASE_DEC | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_param_samnsm, + { "Nsam-sm", "btlmp.sam.nsm", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_samsubmaps, + { "SAM Submaps", "btlmp.sam.submaps", + FT_BYTES, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_samupdatemode, + { "Update Mode", "btlmp.sam.updatemode", + FT_UINT8, BASE_HEX, VALS(samupdatemode_vals), 0x00, + NULL, HFILL } + }, + { &hf_param_samtype0submap, + { "SAM Type 0 Submap", "btlmp.sam.type0submap", + FT_BYTES, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_samd, + { "Dsam", "btlmp.sam.d", + FT_UINT8, BASE_HEX, NULL, 0x00, + NULL, HFILL } + }, + { &hf_param_saminstant, + { "SAM Instant", "btlmp.sam.instant", + FT_UINT32, BASE_HEX | BASE_UNIT_STRING, &units_slots, 0x00, + NULL, HFILL } + }, + { &hf_params, + { "Parameters", "btlmp.parameters", + FT_NONE, BASE_NONE, NULL, 0x00, + NULL, HFILL } + } + }; + + static gint *ett[] = { + &ett_btlmp + }; + + proto_btlmp = proto_register_protocol("Bluetooth Link Manager Protocol", "BT LMP", "btlmp"); + proto_register_field_array(proto_btlmp, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + btlmp_handle = register_dissector("btlmp", dissect_btlmp, proto_btlmp); +} + +void +proto_reg_handoff_btlmp(void) +{ +} + +/* + * Editor modelines - https://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 8 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=8 expandtab: + * :indentSize=4:tabSize=8:noTabs=true: + */ |