/* packet-silabs-dch.c

 * Routines for Silicon Labs Debug Channel dissection

 * Copyright 2023, Dhruv Chandwani <dhchandw@silabs.com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

/*

 * Silabs Debug Channel is a protocol that is used for PTI (Packet Trace) data

 * to flow from the Silicon Labs chips, via the adapter firmware into the PC of a developer.

 *

 * Packet Trace (PTI) is a functionality of Silicon Labs radio chips, which allows

 * for the information about radio operation to be transferred to the observing

 * hardware via a dedicated PTI pin (or two) on the Silicon Labs Radio Microcontroller.

 *

 * Silabs Debug Channel can also be used for other event-based data transfer, but PTI is the primary use case.

 *

 * Spec - https://github.com/SiliconLabsSoftware/java-pti/blob/main/doc/debug-channel.md

 */

/* Include files */

#include "config.h"

#define WS_LOG_DOMAIN "silabs_dch"

#include <wireshark.h>

#include <wiretap/wtap.h>

#include <wsutil/bitswap.h>

#include <epan/packet.h> /* Required dissection API header */

#include <epan/exceptions.h>

#include <epan/show_exception.h>

#include <epan/expert.h> /* Include only as needed */

#include <epan/prefs.h>  /* Include only as needed */

#include <epan/proto_data.h>

#include "packet-ieee802154.h"

#include "packet-btle.h"

/* Protocol identifier, populated by registration */

static int proto_silabs_dch;

// Field identifiers, populated by registration.

/* Debug Channel Header */

static int hf_dch_version;

static int hf_dch_timestamp;

static int hf_dch_type;

static int hf_dch_flags;

static int hf_dch_sequence;

/* EFR32 */

static int hf_efr32;

static int hf_efr32_hwstart;

static int hf_efr32_phr;

static int hf_efr32_phr_packetlen;

static int hf_efr32_2bytephr;

static int hf_efr32_4bytephr;

static int hf_efr32_hwend;

static int hf_efr32_rssi;

static int hf_efr32_syncword;

static int hf_efr32_radiocfg;

static int hf_efr32_phyid;

static int hf_efr32_radiocfg_addedbytes;

static int hf_efr32_radiocfg_blephyid;

static int hf_efr32_radiocfg_regionid;

static int hf_efr32_radiocfg_2bytephr;

static int hf_efr32_radiocfg_softmodem;

static int hf_efr32_radiocfg_external;

static int hf_efr32_radiocfg_id;

static int hf_efr32_radioinfo;

static int hf_efr32_radioinfo_antenna;

static int hf_efr32_radioinfo_syncword;

static int hf_efr32_radioinfo_channel;

static int hf_efr32_channel;

static int hf_efr32_status;

static int hf_efr32_status_errorcode;

static int hf_efr32_status_protocolid;

static int hf_efr32_appendedinfocfg;

static int hf_efr32_appendedinfocfg_txrx;

static int hf_efr32_appendedinfocfg_length;

static int hf_efr32_appendedinfocfg_version;

/* Wi-SUN PHY Header */

static int hf_phr_fsk;

static int hf_phr_wisun_fsk_ms;

static int hf_phr_ofdm;

static int hf_phr_fsk_ms;

static int hf_phr_fsk_fcs;

static int hf_phr_fsk_dw;

static int hf_phr_fsk_length;

static int hf_phr_fsk_ms_checksum;

static int hf_phr_fsk_ms_parity;

static int hf_phr_wisun_fsk_ms_reserved;

static int hf_phr_wisun_fsk_ms_phymodeid;

static int hf_phr_ofdm_rate;

static int hf_phr_ofdm_length;

static int hf_phr_ofdm_scrambler;

/* Expert info fields - used for warnings and notes*/

static expert_field ei_silabs_dch_unsupported_type;

static expert_field ei_silabs_dch_unsupported_protocol;

static expert_field ei_silabs_dch_invalid_appendedinfolen;

/* Bit-mask for the EFR32 phr field */

#define EFR32_PHR_PACKETLEN_MASK 0xFF

/* Bit-masks for the EFR32 radio-cfg field */

#define EFR32_RADIOCFG_ADDEDBYTES_MASK 0xF8

#define EFR32_RADIOCFG_BLEPHYID_MASK 0x03

#define EFR32_RADIOCFG_REGIONID_MASK 0x1F

#define EFR32_RADIOCFG_2BYTEPHR_MASK 0x80

#define EFR32_RADIOCFG_SOFTMODEM_MASK 0x40

#define EFR32_RADIOCFG_EXTERNAL_MASK 0x10

#define EFR32_RADIOCFG_ID_MASK 0x07

/* Bit-masks for the EFR32 radio-info field */

#define EFR32_RADIOINFO_ANTENNA_MASK 0x80

#define EFR32_RADIOINFO_SYNCWORD_MASK 0x40

#define EFR32_RADIOINFO_CHANNEL_MASK 0x3F

/* Bit-masks for the EFR32 status field */

#define EFR32_STATUS_ERRORCODE_MASK 0xF0

#define EFR32_STATUS_PROTOCOLID_MASK 0x0F

/* Bit-masks for the EFR32 appended info cfg field */

#define EFR32_APPENDEDINFOCFG_TXRX_MASK 0x40

#define EFR32_APPENDEDINFOCFG_LENGTH_MASK 0x38

#define EFR32_APPENDEDINFOCFG_VERSION_MASK 0x07

/* BLE advertising PDU types (BT Core Spec Vol 6, Part B, 2.3) */

#define BLE_ADV_PDU_TYPE_CONNECT_IND 0x05

/* Bit-masks for Wi-SUN PHY Header */

#define PHR_FSK_MS 0x8000

#define PHR_FSK_FCS 0x1000

#define PHR_FSK_DW 0x0800

#define PHR_FSK_LENGTH 0x07ff

#define PHR_FSK_MS_CHECKSUM 0x001E

#define PHR_FSK_MS_PARITY 0x0001

#define PHR_WISUN_FSK_MS_RESERVED 0x6000

#define PHR_WISUN_FSK_MS_PHYMODEID 0x1FE0

#define PHR_OFDM_RATE 0xF80000

#define PHR_OFDM_LENGTH 0x03FF80

#define PHR_OFDM_SCRAMBLER 0x000018

// --------------------

/* Subtree identifiers, populated by registration */

static int ett_silabs_dch;

static int ett_silabs_efr32;

static int ett_silabs_efr32_radiocfg;

static int ett_silabs_efr32_radioinfo;

static int ett_silabs_efr32_status;

static int ett_silabs_efr32_appendedinfo;

static int ett_silabs_efr32_phr;

static int *ett[] = {

    &ett_silabs_dch,

    &ett_silabs_efr32,

    &ett_silabs_efr32_radiocfg,

    &ett_silabs_efr32_radioinfo,

    &ett_silabs_efr32_status,

    &ett_silabs_efr32_appendedinfo,

    &ett_silabs_efr32_phr,

};

// Structs and other types

typedef struct

{

  const char *title;

  int8_t crcLen;

} ProtocolInfo;

typedef struct

{

  uint8_t length;

  uint8_t version;

  bool isRx;

  bool hasRssi;

  bool hasSyncword;

  bool hasRadioCfg;

  uint8_t rssiLen;

  uint8_t syncwordLen;

  uint8_t radioCfgLen;

  bool isInvalid;

} Efr32AppendedInfo;

typedef enum

{

  PHR_RAW = 0,

  PHR_SUN_FSK = 6,

  PHR_SUN_OFDM = 7,

  PHR_WISUN_FSK_MS = 18,

} phr_type_t;

// --------------------

/* Silabs Debug Channel Dissector Handle */

static dissector_handle_t silabs_dch_handle;

/* Handoff dissector handles */

static dissector_handle_t ieee802154fcs_handle;

static dissector_handle_t ieee802154nofcs_handle;

static dissector_handle_t btle_handle;

/* BLE connection tracking for direction inference */

typedef struct {

    uint8_t device_role;  /* BTLE_DIR_CENTRAL_PERIPHERAL or BTLE_DIR_PERIPHERAL_CENTRAL */

} silabs_ble_connection_info_t;

static wmem_tree_t *silabs_ble_connections;

static bool pref_ble_sniffer_mode;

// Function declarations

/* Prototypes for required functions. */

void proto_reg_handoff_silabs_dch(void);

void proto_register_silabs_dch(void);

/* Dissector functions */

static int dissect_silabs_dch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_);

static int dissect_silabs_efr32(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);

static void dissect_silabs_ieee802154_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset, int ota_payload_len, int crc_len);

static void dissect_silabs_ble_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset, int ota_payload_len, const Efr32AppendedInfo *appended_info);

static int dissect_silabs_wisun_phr(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset, uint8_t phr_len, uint8_t phy_mode_id, int ota_payload_len, int *crc_len);

/* Helper functions */

static const Efr32AppendedInfo *get_efr32_appended_info(wmem_allocator_t *scope, uint8_t appended_info_cfg);

static const ProtocolInfo *get_protocol_info(wmem_allocator_t *scope, uint8_t protocol_id);

static int decode_wisun_phr_type(tvbuff_t *tvb, unsigned offset, uint8_t phr_len, uint8_t phy_mode_id, int ota_payload_len);

static int decode_channel_number(tvbuff_t *tvb, proto_tree *tree, unsigned offset, uint8_t radioinfo_channel, uint8_t radiocfg_id, uint8_t protocol_id);

static uint16_t reverse_bits_uint16(uint16_t value);

static uint8_t get_phr_length(uint8_t protocol_id, tvbuff_t *tvb, int last_index, uint8_t radioCfgLen);

static uint8_t get_phy_mode_id(uint8_t protocol_id, tvbuff_t *tvb, int last_index, uint8_t radioCfgLen);

/* BLE direction tracking helpers */

static void store_ble_connection_role(packet_info *pinfo, uint32_t interface_id, uint32_t access_address, uint8_t device_role);

static uint8_t lookup_ble_connection_role(uint32_t interface_id, uint32_t access_address);

// --------------------

/* Debug channel message types*/

static const value_string silabs_dch_message_types[] = {

    {0x0000, "Time synchronization notice"},

    {0x0001, "Reset notice"},

    {0x0002, "Application printf"},

    {0x0003, "API trace"},

    {0x0004, "Assertion notice"},

    {0x0005, "Core dump"},

    {0x0006, "Phy Rx"},

    {0x0007, "API Rx"},

    {0x0008, "Phy Tx"},

    {0x0009, "API Tx"},

    {0x000A, "Sniffer packet"},

    {0x000B, "Adapter error"},

    {0x000C, "Statistics"},

    {0x000D, "Time sync test"},

    {0x000E, "Radio reboot count"},

    {0x0011, "Virtual UART Tx"},

    {0x0012, "Virtual UART Rx"},

    {0x0020, "2420 Tx packet"},

    {0x0021, "2420 Rx packet"},

    {0x0022, "250 Tx packet"},

    {0x0023, "250 Rx packet"},

    {0x0024, "350 Tx packet"},

    {0x0025, "350 Rx packet"},

    {0x0026, "Pro2+ Tx packet"},

    {0x0027, "Pro2+ Rx packet"},

    {0x0028, "Pro2+ debug packet"},

    {0x0029, "EFR Tx packet"},

    {0x002A, "EFR Rx packet"},

    {0x002B, "EFR additional PTI data"},

    {0x0030, "Flash read request"},

    {0x0031, "Flash read response"},

    {0x0032, "EEPROM read request"},

    {0x0033, "EEPROM read response"},

    {0x0034, "EEPROM write request"},

    {0x0035, "EEPROM write response"},

    {0x0036, "RAM read request"},

    {0x0037, "RAM read response"},

    {0x0038, "RAM write request"},

    {0x0039, "RAM write response"},

    {0x003A, "Info request"},

    {0x003B, "Node information"},

    {0x003C, "EmberZNet serial protocol"},

    {0x003D, "ASH protocol"},

    {0x003E, "DAG trace"},

    {0x003F, "Simulated NCP callback ready"},

    {0x0040, "Simulated wakeup signal to NCP"},

    {0x0041, "Simulated signal to host that NCP is awake"},

    {0x0042, "Ember ZNet stack version"},

    {0x0043, "Ember IP stack version"},

    {0x0044, "Current time information"},

    {0x0045, "Memory use information"},

    {0x0046, "Mustang API message"},

    {0x0047, "Latency"},

    {0x0048, "TMSP"},

    {0x0050, "AEM sample"},

    {0x0051, "AEM counters snapshot"},

    {0x0060, "AEM request"},

    {0x0061, "AEM response"},

    {0x0062, "AEM current packet"},

    {0x0063, "AEM current packet v2"},

    {0x0064, "PC sample packet"},

    {0x0065, "Exception packet"},

    {0x0066, "Logic analyzer data"},

    {0x0070, "CPU usage"},

    {0x0080, "Configuration over SWO"},

    {0xFFFE, "User command"},

    {0xFFFF, "User response"},

    {0, NULL}};

/* Efr32 HW start values*/

static const value_string silabs_efr32_hwstart_values[] = {

    {0xF8, "Rx Start"},

    {0xFC, "Tx Start"},

    {0xF0, "DMP Protocol Switch"},

    {0, NULL}};

/* Efr32 HW end values*/

static const value_string silabs_efr32_hwend_values[] = {

    {0xF9, "Rx Success"},

    {0xFA, "Rx Abort"},

    {0xFD, "Tx Success"},

    {0xFE, "Tx Abort"},

    {0, NULL}};

/* Efr32 protocol id values*/

static const value_string silabs_efr32_status_protcolid_values[] = {

    {0x00, "Custom"},

    {0x01, "EmberPHY (Zigbee/Thread)"},

    {0x02, "Thread on RAIL"},

    {0x03, "BLE"},

    {0x04, "Connect on RAIL"},

    {0x05, "Zigbee on RAIL"},

    {0x06, "Z-Wave on RAIL"},

    {0x07, "Wi-SUN on RAIL"},

    {0x08, "Custom on 802.15.4 built-in PHY"},

    {0x09, "Amazon SideWalk"},

    {0x0A, "Bluetooth Classic"},

    {0, NULL}};

/* Efr32 tx/rx values*/

static const value_string silabs_efr32_appendedinfocfg_txrx_values[] = {

    {0x00, "Tx"},

    {0x01, "Rx"},

    {0, NULL}};

/* Wi-SUN PHR Values*/

static const value_string phr_wisun_phymodeid_values[] = {

    {1, "FSK #1a 50ksym/s mod-index 0.5"},

    {2, "FSK #1b 50ksym/s mod-index 1.0"},

    {3, "FSK #2a 100ksym/s mod-index 0.5"},

    {4, "FSK #2b 100ksym/s mod-index 1.0"},

    {5, "FSK #3 150ksym/s mod-index 0.5"},

    {6, "FSK #4a 200ksym/s mod-index 0.5"},

    {7, "FSK #4b 200ksym/s mod-index 1.0"},

    {8, "FSK #5 300ksym/s mod-index 0.5"},

    {17, "FSK with FEC #1a 50ksym/s mod-index 0.5"},

    {18, "FSK with FEC #1b 50ksym/s mod-index 1.0"},

    {19, "FSK with FEC #2a 100ksym/s mod-index 0.5"},

    {20, "FSK with FEC #2b 100ksym/s mod-index 1.0"},

    {21, "FSK with FEC #3 150ksym/s mod-index 0.5"},

    {22, "FSK with FEC #4a 200ksym/s mod-index 0.5"},

    {23, "FSK with FEC #4b 200ksym/s mod-index 1.0"},

    {24, "FSK with FEC #5 300ksym/s mod-index 0.5"},

    {34, "OFDM Option 1 MCS 2 400kbps"},

    {35, "OFDM Option 1 MCS 3 800kbps"},

    {36, "OFDM Option 1 MCS 4 1200kbps"},

    {37, "OFDM Option 1 MCS 5 1600kbps"},

    {38, "OFDM Option 1 MCS 6 2400kbps"},

    {51, "OFDM Option 2 MCS 3 400kbps"},

    {52, "OFDM Option 2 MCS 4 600kbps"},

    {53, "OFDM Option 2 MCS 5 800kbps"},

    {54, "OFDM Option 2 MCS 6 1200kbps"},

    {68, "OFDM Option 3 MCS 4 300kbps"},

    {69, "OFDM Option 3 MCS 5 400kbps"},

    {70, "OFDM Option 3 MCS 6 600kbps"},

    {84, "OFDM Option 4 MCS 4 150kbps"},

    {85, "OFDM Option 4 MCS 5 200kbps"},

    {86, "OFDM Option 4 MCS 6 300kbps"},

    {0, NULL}};

static const value_string phr_ofdm_rate_values[] = {

    {0, "MCS0"},

    {1, "MCS1"},

    {2, "MCS2"},

    {3, "MCS3"},

    {4, "MCS4"},

    {5, "MCS5"},

    {6, "MCS6"},

    {7, "MCS7"},

    {0, NULL}};

static const value_string phr_ofdm_scrambler_values[] = {

    {0, "000010111"},

    {1, "000011100"},

    {2, "101110111"},

    {3, "101111100"},

    {0, NULL}};

/**

 * Top-level dissector - dissects the debug channel header.

 *

 * @param tvb pointer to buffer containing raw packet.

 * @param pinfo pointer to packet information fields

 * @param tree pointer to data tree wireshark uses to display packet.

 * @param data data passed (unused)

 * @return offset after dissection

 *

 */

static int dissect_silabs_dch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)

{

  proto_item *dch_root = NULL;

  proto_tree *dch_tree = NULL;

  tvbuff_t *next_tvb;

  unsigned offset = 0;

  uint32_t dch_version, dch_message_type;

  const char *dch_message_type_str;

  // Create the top-level DCH subtree.

  dch_root = proto_tree_add_item(tree, proto_silabs_dch, tvb, offset, -1, ENC_NA);

  dch_tree = proto_item_add_subtree(dch_root, ett_silabs_dch);

  // Decode version, add it to DCH subtree.

  proto_tree_add_item_ret_uint(dch_tree, hf_dch_version, tvb, offset, 2, ENC_LITTLE_ENDIAN, &dch_version);

  offset += 2;

  // Decode timestamp, add it to DCH subtree. Timestamp is 8 bytes in later versions, but only 6 in version 2.

  if (dch_version > 2)

  {

    proto_tree_add_item(dch_tree, hf_dch_timestamp, tvb, offset, 8, ENC_TIME_NSECS | ENC_LITTLE_ENDIAN);

    offset += 8;

  }

  else

  {

    proto_tree_add_item(dch_tree, hf_dch_timestamp, tvb, offset, 6, ENC_TIME_USECS | ENC_LITTLE_ENDIAN);

    offset += 6;

  }

  // Decode message type, add it to DCH subtree. Use the message type descriptions

  // from the array above.

  proto_tree_add_item_ret_uint(dch_tree, hf_dch_type, tvb, offset, 2, ENC_LITTLE_ENDIAN, &dch_message_type);

  dch_message_type_str = val_to_str_const(dch_message_type, silabs_dch_message_types, "Unknown");

  offset += 2;

  col_add_fstr(pinfo->cinfo, COL_INFO, "Debug Message Type: %s", dch_message_type_str);

  // Decode flags (if exists) and sequence, honor differences between version 2 and version 3.

  if (dch_version > 2)

  {

    proto_tree_add_item(dch_tree, hf_dch_flags, tvb, offset, 4, ENC_LITTLE_ENDIAN);

    offset += 4;

    proto_tree_add_item(dch_tree, hf_dch_sequence, tvb, offset, 2, ENC_LITTLE_ENDIAN);

    offset += 2;

  }

  else

  {

    proto_tree_add_item(dch_tree, hf_dch_sequence, tvb, offset, 1, ENC_LITTLE_ENDIAN);

    offset++;

  }

  // get debug message payload

  next_tvb = tvb_new_subset_remaining(tvb, offset);

  // Decode dch payload by dch message type

  switch (dch_message_type)

  {

  case 0x02A:

  case 0x029:

    // hand debug message payload to EFR32 dissector

    offset = dissect_silabs_efr32(next_tvb, pinfo, tree);

    break;

  default:

    proto_tree_add_expert_format_remaining(dch_tree, pinfo, &ei_silabs_dch_unsupported_type, tvb, offset, "Debug message type - %s not supported yet", dch_message_type_str);

    break;

  }

  return offset;

}

/**

 * Dissector for Efr32 radio info

 *

 * @param tvb pointer to buffer containing raw packet.

 * @param pinfo pointer to packet information fields

 * @param tree pointer to data tree wireshark uses to display packet.

 * @return offset after dissection

 *

 */

static int dissect_silabs_efr32(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)

{

  proto_item *efr32_root;

  proto_tree *efr32_tree;

  unsigned offset = 0;

  // create the EFR32 subtree

  efr32_root = proto_tree_add_item(tree, hf_efr32, tvb, offset, -1, ENC_NA);

  efr32_tree = proto_item_add_subtree(efr32_root, ett_silabs_efr32);

  // decode hw start, add to subtree

  proto_tree_add_item(efr32_tree, hf_efr32_hwstart, tvb, offset, 1, ENC_LITTLE_ENDIAN);

  offset += 1;

  int last_index;

  uint8_t protocol_id;

  uint8_t appended_info_cfg;

  uint8_t status_byte;

  uint8_t phr_len;

  const ProtocolInfo *protocol;

  const Efr32AppendedInfo *appended_info;

  // decode radio appended info details

  last_index = offset + tvb_reported_length_remaining(tvb, offset) - 1;

  appended_info_cfg = tvb_get_uint8(tvb, last_index);

  appended_info = get_efr32_appended_info(pinfo->pool, appended_info_cfg);

  // check if appended info len is invalid

  if (appended_info->isInvalid)

  {

    proto_tree_add_expert_format_remaining(efr32_tree, pinfo, &ei_silabs_dch_invalid_appendedinfolen, tvb, offset, "Invalid Appended Info Length");

    return offset;

  }

  // decode protocol

  status_byte = tvb_get_uint8(tvb, last_index - 1);

  protocol_id = 0x0000000F & status_byte;

  protocol = get_protocol_info(pinfo->pool, protocol_id);

  // determine OTA Payload -> (PHR + Payload + CRC)

  int crc_len = (protocol->crcLen != -1) ? protocol->crcLen : 2; // Dynamic crc length (indicated by -1) not supported yet, default to 2

  int ota_payload_len = last_index + 1 - offset - appended_info->length - 1;

  // decode PHR Length and PHR

  phr_len = get_phr_length(protocol_id, tvb, last_index, appended_info->radioCfgLen);

  switch (protocol_id)

  {

  case 7:

  { // Further dissect Wi-SUN PHR

    uint8_t phy_mode_id = get_phy_mode_id(protocol_id, tvb, last_index, appended_info->radioCfgLen);

    phr_len = dissect_silabs_wisun_phr(tvb, pinfo, efr32_tree, offset, phr_len, phy_mode_id, ota_payload_len, &crc_len);

    // Adjust offset and ota_payload_len after PHR

    offset += phr_len;

    ota_payload_len -= phr_len;

    break;

  }

  case 2: // Thread on RAIL

  case 5: // Zigbee on RAIL

  case 8: // Custom on 802.15.4 built-in PHY

  {

    static int *const efr32_phr_fields[] = {

        &hf_efr32_phr_packetlen,

        NULL};

    switch (phr_len)

    {

    case 1:

      proto_tree_add_bitmask(efr32_tree, tvb, offset, hf_efr32_phr, ett_silabs_efr32_phr, efr32_phr_fields, ENC_LITTLE_ENDIAN);

      break;

    case 2:

      proto_tree_add_item(efr32_tree, hf_efr32_2bytephr, tvb, offset, 2, ENC_LITTLE_ENDIAN);

      break;

    case 4:

      proto_tree_add_item(efr32_tree, hf_efr32_4bytephr, tvb, offset, 4, ENC_LITTLE_ENDIAN);

      break;

    default:

      break;

    }

    // Adjust offset and ota_payload_len after PHR

    offset += phr_len;

    ota_payload_len -= phr_len;

  }

  }

  // hand ota payload to protocol dissector

  if (ota_payload_len > 0)

  {

    switch (protocol_id)

    {

    case 2: // Thread on RAIL

    case 5: // Zigbee on RAIL

    case 7: // Wi-SUN on RAIL

    case 8: // Custom on 802.15.4 built-in PHY

      dissect_silabs_ieee802154_pdu(tvb, pinfo, tree, offset, ota_payload_len, crc_len);

      break;

    case 3: // BLE

      dissect_silabs_ble_pdu(tvb, pinfo, tree, offset, ota_payload_len, appended_info);

      break;

    default:

      proto_tree_add_expert_format_remaining(efr32_tree, pinfo, &ei_silabs_dch_unsupported_protocol, tvb, offset, "Protocol - %s not supported yet", protocol->title);

      // TODO: add support for the following protocols

      // case 1: // EFR32 EmberPHY (Zigbee/Thread)

      // case 4: // Connect on RAIL

      // case 6: // Z-Wave on RAIL

      // case 9: // Amazon SideWalk

      break;

    }

    offset += ota_payload_len;

  }

  // decode hw end, add to subtree

  proto_tree_add_item(efr32_tree, hf_efr32_hwend, tvb, offset, 1, ENC_LITTLE_ENDIAN);

  offset += 1;

  // decode rssi, add to subtree

  if (appended_info->hasRssi)

  {

    int8_t rssi = tvb_get_uint8(tvb, offset);

    rssi = (appended_info->version == 1) ? (rssi - 0x32) : rssi;

    proto_tree_add_int_format_value(efr32_tree, hf_efr32_rssi, tvb, offset, appended_info->rssiLen, rssi, "%d dBm", rssi);

    offset += appended_info->rssiLen;

  }

  // decode syncword, add to subtree

  if (appended_info->hasSyncword)

  {

    proto_tree_add_item(efr32_tree, hf_efr32_syncword, tvb, offset, appended_info->syncwordLen, ENC_LITTLE_ENDIAN);

    offset += appended_info->syncwordLen;

  }

  // decode radio cfg, add to subtree

  static int *const efr32_radiocfg_ble_fields[] = {

      &hf_efr32_radiocfg_addedbytes,

      &hf_efr32_radiocfg_blephyid,

      NULL};

  static int *const efr32_radiocfg_zwave_fields[] = {

      &hf_efr32_radiocfg_regionid,

      NULL};

  static int *const efr32_radiocfg_154_fields[] = {

      &hf_efr32_radiocfg_2bytephr,

      &hf_efr32_radiocfg_softmodem,

      &hf_efr32_radiocfg_external,

      &hf_efr32_radiocfg_id,

      NULL};

  uint8_t radiocfg_id = 0;

  if (appended_info->hasRadioCfg)

  {

    switch (protocol_id)

    {

    case 3: // BLE

      proto_tree_add_bitmask(efr32_tree, tvb, offset, hf_efr32_radiocfg, ett_silabs_efr32_radiocfg, efr32_radiocfg_ble_fields, ENC_LITTLE_ENDIAN);

      break;

    case 6: // Z-Wave on RAIL

      proto_tree_add_bitmask(efr32_tree, tvb, offset, hf_efr32_radiocfg, ett_silabs_efr32_radiocfg, efr32_radiocfg_zwave_fields, ENC_LITTLE_ENDIAN);

      break;

    case 1:

    case 2:

    case 5:

    case 7:

    case 8:

    {

      radiocfg_id = tvb_get_uint8(tvb, offset) & EFR32_RADIOCFG_ID_MASK;

      proto_tree_add_bitmask(efr32_tree, tvb, offset, hf_efr32_radiocfg, ett_silabs_efr32_radiocfg, efr32_radiocfg_154_fields, ENC_LITTLE_ENDIAN);

      break;

    }

    default:

      proto_tree_add_item(efr32_tree, hf_efr32_radiocfg, tvb, offset, appended_info->radioCfgLen, ENC_LITTLE_ENDIAN);

      break;

    }

    offset += 1;

    if (appended_info->radioCfgLen == 2)

    {

      proto_tree_add_item(efr32_tree, hf_efr32_phyid, tvb, offset, 1, ENC_LITTLE_ENDIAN);

      offset += 1;

    }

  }

  // decode radio info, add to subtree

  static int *const efr32_radioinfo_fields[] = {

      &hf_efr32_radioinfo_antenna,

      &hf_efr32_radioinfo_syncword,

      &hf_efr32_radioinfo_channel,

      NULL};

  uint8_t radioinfo_channel = tvb_get_uint8(tvb, offset) & EFR32_RADIOINFO_CHANNEL_MASK;

  proto_tree_add_bitmask(efr32_tree, tvb, offset, hf_efr32_radioinfo, ett_silabs_efr32_radioinfo, efr32_radioinfo_fields, ENC_LITTLE_ENDIAN);

  // decode computed channel

  decode_channel_number(tvb, efr32_tree, offset, radioinfo_channel, radiocfg_id, protocol_id);

  offset += 1;

  // decode status, add to subtree

  static int *const efr32_status_fields[] = {

      &hf_efr32_status_errorcode,

      &hf_efr32_status_protocolid,

      NULL};

  proto_tree_add_bitmask(efr32_tree, tvb, offset, hf_efr32_status, ett_silabs_efr32_status, efr32_status_fields, ENC_LITTLE_ENDIAN);

  offset += 1;

  // decode appended info cfg, add to subtree

  static int *const efr32_appendedinfocfg_fields[] = {

      &hf_efr32_appendedinfocfg_txrx,

      &hf_efr32_appendedinfocfg_length,

      &hf_efr32_appendedinfocfg_version,

      NULL};

  proto_tree_add_bitmask(efr32_tree, tvb, offset, hf_efr32_appendedinfocfg, ett_silabs_efr32_appendedinfo, efr32_appendedinfocfg_fields, ENC_LITTLE_ENDIAN);

  offset += 1;

  return offset;

}

/**

 * Dissect IEEE 802.15.4 OTA payload and hand off to the 802.15.4 dissector.

 *

 * @param tvb pointer to buffer containing raw packet.

 * @param pinfo pointer to packet information fields

 * @param tree pointer to data tree wireshark uses to display packet.

 * @param offset offset into tvb where the payload begins

 * @param ota_payload_len length of the OTA payload

 * @param crc_len length of the CRC (0 = no FCS, 2 = 16-bit, 4 = 32-bit)

 *

 */

static void

dissect_silabs_ieee802154_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                             unsigned offset, int ota_payload_len, int crc_len)

{

  tvbuff_t *next_tvb = tvb_new_subset_length(tvb, offset, ota_payload_len);

  TRY

  {

    if (crc_len > 0)

    {

      int fcs_type = crc_len == 2 ? IEEE802154_FCS_16_BIT : IEEE802154_FCS_32_BIT;

      call_dissector_with_data(ieee802154fcs_handle, next_tvb, pinfo, tree, &fcs_type);

    }

    else

    {

      call_dissector(ieee802154nofcs_handle, next_tvb, pinfo, tree);

    }

  }

  CATCH_NONFATAL_ERRORS

  {

    show_exception(next_tvb, pinfo, tree, EXCEPT_CODE, GET_MESSAGE);

  }

  ENDTRY;

}

/**

 * Dissect BLE OTA payload and hand off to the BTLE dissector.

 *

 * Builds a composite tvb from the syncword (in appended info) and the OTA

 * payload, infers BLE direction from connection tracking, and passes to

 * the BTLE dissector.

 *

 * @param tvb pointer to buffer containing raw packet.

 * @param pinfo pointer to packet information fields

 * @param tree pointer to data tree wireshark uses to display packet.

 * @param offset offset into tvb where the payload begins

 * @param ota_payload_len length of the OTA payload

 * @param appended_info pointer to appended info struct

 *

 */

static void

dissect_silabs_ble_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                       unsigned offset, int ota_payload_len,

                       const Efr32AppendedInfo *appended_info)

{

  if (!appended_info->hasSyncword)

    return;

  bool is_tx = !appended_info->isRx;

  // syncword offset: after OTA payload, hwend (1 byte), and RSSI

  int syncword_offset = offset + ota_payload_len + 1 + appended_info->rssiLen;

  uint32_t access_address = tvb_get_letohl(tvb, syncword_offset);

  uint32_t interface_id = (pinfo->rec->presence_flags & WTAP_HAS_INTERFACE_ID) ?

                          pinfo->rec->rec_header.packet_header.interface_id : 0;

  // build composite tvb: syncword + payload (BTLE dissector expects this)

  tvbuff_t *composite_tvb = tvb_new_composite();

  tvb_composite_append(composite_tvb, tvb_new_subset_length(tvb, syncword_offset, appended_info->syncwordLen));

  tvb_composite_append(composite_tvb, tvb_new_subset_length(tvb, offset, ota_payload_len));

  tvb_composite_finalize(composite_tvb);

  void *volatile dissector_data = NULL;

  btle_context_t context_storage;

  if (!pref_ble_sniffer_mode)

  {

    // track device role from CONNECT_IND for direction inference

    if (access_address == ACCESS_ADDRESS_ADVERTISING)

    {

      uint8_t pdu_type = tvb_get_uint8(composite_tvb, 4) & 0x0F;

      if (pdu_type == BLE_ADV_PDU_TYPE_CONNECT_IND)

      {

        // conn access addr at AA(4)+hdr(2)+InitA(6)+AdvA(6)=18, need +4 to read

        if (tvb_captured_length(composite_tvb) >= 22)

        {

          uint32_t conn_access_addr = tvb_get_letohl(composite_tvb, 18);

          uint8_t device_role = is_tx ? BTLE_DIR_CENTRAL_PERIPHERAL : BTLE_DIR_PERIPHERAL_CENTRAL;

          store_ble_connection_role(pinfo, interface_id, conn_access_addr, device_role);

        }

      }

    }

    // pass NULL context for ADV so BTLE uses its default path;

    // a zero-init context triggers wrong value-table lookups

    if (access_address != ACCESS_ADDRESS_ADVERTISING)

    {

      memset(&context_storage, 0, sizeof(context_storage));

      uint8_t device_role;

      /* Keep the role found on the first pass for this frame, so that

         later passes do not see roles learned from later frames. */

      uint8_t *stored_role = (uint8_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_silabs_dch, 0);

      if (stored_role) {

        device_role = *stored_role;

      } else {

        device_role = lookup_ble_connection_role(interface_id, access_address);

        if (!PINFO_FD_VISITED(pinfo)) {

          stored_role = wmem_new(wmem_file_scope(), uint8_t);

          *stored_role = device_role;

          p_add_proto_data(wmem_file_scope(), pinfo, proto_silabs_dch, 0, stored_role);

        }

      }

      if (device_role != BTLE_DIR_UNKNOWN)

      {

        if (is_tx)

        {

          context_storage.direction = device_role;

          pinfo->p2p_dir = (device_role == BTLE_DIR_CENTRAL_PERIPHERAL) ? P2P_DIR_SENT : P2P_DIR_RECV;

        }

        else

        {

          context_storage.direction = (device_role == BTLE_DIR_CENTRAL_PERIPHERAL) ?

                                     BTLE_DIR_PERIPHERAL_CENTRAL : BTLE_DIR_CENTRAL_PERIPHERAL;

          pinfo->p2p_dir = (device_role == BTLE_DIR_CENTRAL_PERIPHERAL) ? P2P_DIR_RECV : P2P_DIR_SENT;

        }

      }

      dissector_data = &context_storage;

    }

  }

  add_new_data_source(pinfo, composite_tvb, "BLE Packet");

  TRY

  {

    call_dissector_with_data(btle_handle, composite_tvb, pinfo, tree, dissector_data);

  }

  CATCH_NONFATAL_ERRORS

  {

    show_exception(composite_tvb, pinfo, tree, EXCEPT_CODE, GET_MESSAGE);

  }

  ENDTRY;

}

/**

 * Dissect Wi-SUN PHY Header

 *

 * @param tvb pointer to buffer containing raw packet.

 * @param pinfo pointer to packet information fields

 * @param tree pointer to data tree wireshark uses to display packet.

 * @param offset offset in tvb

 * @param phr_len length of PHY Header

 * @param ota_payload_len length of OTA payload

 * @param crc_len pointer to length of CRC (updated by function)

 * @return offset after dissection

 *

 */

static int dissect_silabs_wisun_phr(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, unsigned offset, uint8_t phr_len, uint8_t phy_mode_id, int ota_payload_len, int *crc_len)

{

  // First byte after HW Start can be a garbage 0x0b or 0x00 byte

  bool can_be_garbage = (tvb_get_uint8(tvb, offset) == 0x0b) || (tvb_get_uint8(tvb, offset) == 0x00);

  // Get PHR Type

  uint8_t garbage_byte_len = 0;

  uint8_t phr_type = decode_wisun_phr_type(tvb, offset, phr_len, phy_mode_id, ota_payload_len);

  // if possible garbage byte is present, try skipping it

  if ((phr_type == PHR_RAW) & can_be_garbage)

  {

    phr_type = decode_wisun_phr_type(tvb, offset + 1, phr_len, phy_mode_id, ota_payload_len - 1);

    if (phr_type != PHR_RAW)

    {

      offset += 1;

      garbage_byte_len = 1;

    }

  }

  // Dissect PHR based of Type

  if (phr_type == PHR_SUN_FSK || phr_type == PHR_WISUN_FSK_MS)

  {

    uint8_t *datax = (uint8_t *)tvb_memdup(pinfo->pool, tvb, offset, 2);

    bitswap_buf_inplace(datax, 2);

    tvbuff_t *reversed_tvb = tvb_new_child_real_data(tvb, datax, 2, 2);

    /* Add the reversed data to the data source list. */

    add_new_data_source(pinfo, reversed_tvb, "decoded_phr");

    if (phr_type == PHR_WISUN_FSK_MS)

    {

      static int *const phr_wisun_fsk_ms_fields[] = {

          &hf_phr_fsk_ms,

          &hf_phr_wisun_fsk_ms_reserved,

          &hf_phr_wisun_fsk_ms_phymodeid,

          &hf_phr_fsk_ms_checksum,

          &hf_phr_fsk_ms_parity,

          NULL};

      proto_tree_add_bitmask(tree, reversed_tvb, 0, hf_phr_wisun_fsk_ms, ett_silabs_efr32_phr, phr_wisun_fsk_ms_fields, ENC_BIG_ENDIAN);

      col_clear(pinfo->cinfo, COL_INFO);

      col_set_str(pinfo->cinfo, COL_INFO, "Wi-SUN FSK Mode Switch PHR");

      *crc_len = 0; // No CRC for Wi-SUN FSK MS since no payload

    }

    else

    {

      static int *const phr_fsk_fields[] = {

          &hf_phr_fsk_ms,

          &hf_phr_fsk_fcs,

          &hf_phr_fsk_dw,

          &hf_phr_fsk_length,

          NULL};

      proto_tree_add_bitmask(tree, reversed_tvb, 0, hf_phr_fsk, ett_silabs_efr32_phr, phr_fsk_fields, ENC_BIG_ENDIAN);

    }

  }

  else if (phr_type == PHR_SUN_OFDM)

  {

    offset += 1;

    *crc_len = 0; // No CRC for OFDM

    uint8_t *datax = (uint8_t *)tvb_memdup(pinfo->pool, tvb, offset, 3);

    bitswap_buf_inplace(datax, 3);

    tvbuff_t *reversed_tvb = tvb_new_child_real_data(tvb, datax, 3, 3);

    /* Add the reversed data to the data source list. */

    add_new_data_source(pinfo, reversed_tvb, "decoded_phr");

    static int *const phr_ofdm_fields[] = {

        &hf_phr_ofdm_rate,

        &hf_phr_ofdm_length,

        &hf_phr_ofdm_scrambler,

        NULL};

    proto_tree_add_bitmask(tree, reversed_tvb, 0, hf_phr_ofdm, ett_silabs_efr32_phr, phr_ofdm_fields, ENC_BIG_ENDIAN);

  }

  else

  {

    proto_tree_add_item(tree, hf_efr32_phr, tvb, offset, phr_len, ENC_LITTLE_ENDIAN);

  }

  return phr_len + garbage_byte_len;

}

/**

 * Get Wi-SUN PHY Header Type

 *

 * @param tvb pointer to buffer containing raw packet.

 * @param offset offset in tvb

 * @param phr_len length of PHY Header

 * @param phy_mode_id PHY Mode ID

 * @param ota_payload_len length of OTA payload

 * @return Wi-SUN PHY Header Type

 *

 */

static int decode_wisun_phr_type(tvbuff_t *tvb, unsigned offset, uint8_t phr_len, uint8_t phy_mode_id, int ota_payload_len)

{

  uint8_t phr_type = PHR_RAW;

  if (phr_len == 2)

  {

    /* If PHR length is 2, PHR is either SUN FSK or WISUN FSK MS based on Mode Switch bit*/

    uint16_t phr = tvb_get_uint16(tvb, offset, ENC_LITTLE_ENDIAN);

    if ((phr & 0x01) && (ota_payload_len == phr_len))

    {

      phr_type = PHR_WISUN_FSK_MS;

    }

    if ((ota_payload_len - phr_len) == reverse_bits_uint16(phr & 0xFFE0))

    {

      phr_type = PHR_SUN_FSK;

    }

  }

  if ((phr_len == 4) && (phy_mode_id >= 0x20))

  {

    uint32_t phr = tvb_get_uint24(tvb, offset + 1, ENC_LITTLE_ENDIAN);

    uint16_t frame_length = (uint16_t)((phr & 0x0001FFC0) >> 6);

    frame_length = reverse_bits_uint16(frame_length) >> 5;

    if ((ota_payload_len) == frame_length)

    {

      phr_type = PHR_SUN_OFDM;

    }

  }