path: root/epan/dissectors/packet-ftdi-ft.c

/* packet-ftdi-ft.c
 * Routines for FTDI FTxxxx USB converters dissection
 *
 * Copyright 2019 Tomasz Mon
 *
 * 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/prefs.h>
#include <epan/expert.h>
#include <epan/reassemble.h>
#include "packet-usb.h"
#include "packet-ftdi-ft.h"

static int proto_ftdi_ft = -1;

static gint hf_setup_brequest = -1;
static gint hf_setup_lvalue = -1;
static gint hf_setup_lvalue_purge = -1;
static gint hf_setup_lvalue_dtr = -1;
static gint hf_setup_lvalue_rts = -1;
static gint hf_setup_lvalue_xon_char = -1;
static gint hf_setup_lvalue_baud_low = -1;
static gint hf_setup_lvalue_data_size = -1;
static gint hf_setup_lvalue_event_char = -1;
static gint hf_setup_lvalue_error_char = -1;
static gint hf_setup_lvalue_latency_time = -1;
static gint hf_setup_lvalue_bitmask = -1;
static gint hf_setup_hvalue = -1;
static gint hf_setup_hvalue_dtr = -1;
static gint hf_setup_hvalue_rts = -1;
static gint hf_setup_hvalue_xoff_char = -1;
static gint hf_setup_hvalue_baud_mid = -1;
static gint hf_setup_hvalue_parity = -1;
static gint hf_setup_hvalue_stop_bits = -1;
static gint hf_setup_hvalue_break_bit = -1;
static gint hf_setup_hvalue_trigger = -1;
static gint hf_setup_hvalue_error_replacement = -1;
static gint hf_setup_hvalue_bitmode = -1;
static gint hf_setup_lindex = -1;
static gint hf_setup_lindex_port_ab = -1;
static gint hf_setup_lindex_port_abcd = -1;
static gint hf_setup_lindex_baud_high = -1;
static gint hf_setup_hindex = -1;
static gint hf_setup_hindex_rts_cts = -1;
static gint hf_setup_hindex_dtr_dsr = -1;
static gint hf_setup_hindex_xon_xoff = -1;
static gint hf_setup_hindex_baud_high = -1;
static gint hf_setup_hindex_baud_clock_divide = -1;
static gint hf_setup_wlength = -1;
static gint hf_response_lat_timer = -1;
static gint hf_modem_status = -1;
static gint hf_modem_status_fs_max_packet = -1;
static gint hf_modem_status_hs_max_packet = -1;
static gint hf_modem_status_cts = -1;
static gint hf_modem_status_dsr = -1;
static gint hf_modem_status_ri = -1;
static gint hf_modem_status_dcd = -1;
static gint hf_line_status = -1;
static gint hf_line_status_receive_overflow = -1;
static gint hf_line_status_parity_error = -1;
static gint hf_line_status_framing_error = -1;
static gint hf_line_status_break_received = -1;
static gint hf_line_status_tx_holding_reg_empty = -1;
static gint hf_line_status_tx_empty = -1;
static gint hf_if_a_rx_payload = -1;
static gint hf_if_a_tx_payload = -1;
static gint hf_if_b_rx_payload = -1;
static gint hf_if_b_tx_payload = -1;
static gint hf_if_c_rx_payload = -1;
static gint hf_if_c_tx_payload = -1;
static gint hf_if_d_rx_payload = -1;
static gint hf_if_d_tx_payload = -1;
static gint hf_ftdi_fragments = -1;
static gint hf_ftdi_fragment = -1;
static gint hf_ftdi_fragment_overlap = -1;
static gint hf_ftdi_fragment_overlap_conflicts = -1;
static gint hf_ftdi_fragment_multiple_tails = -1;
static gint hf_ftdi_fragment_too_long_fragment = -1;
static gint hf_ftdi_fragment_error = -1;
static gint hf_ftdi_fragment_count = -1;
static gint hf_ftdi_reassembled_in = -1;
static gint hf_ftdi_reassembled_length = -1;

static gint ett_ftdi_ft = -1;
static gint ett_modem_ctrl_lvalue = -1;
static gint ett_modem_ctrl_hvalue = -1;
static gint ett_flow_ctrl_hindex = -1;
static gint ett_baudrate_lindex = -1;
static gint ett_baudrate_hindex = -1;
static gint ett_setdata_hvalue = -1;
static gint ett_modem_status = -1;
static gint ett_line_status = -1;
static gint ett_ftdi_fragment = -1;
static gint ett_ftdi_fragments = -1;

static const fragment_items ftdi_frag_items = {
    /* Fragment subtrees */
    &ett_ftdi_fragment,
    &ett_ftdi_fragments,
    /* Fragment Fields */
    &hf_ftdi_fragments,
    &hf_ftdi_fragment,
    &hf_ftdi_fragment_overlap,
    &hf_ftdi_fragment_overlap_conflicts,
    &hf_ftdi_fragment_multiple_tails,
    &hf_ftdi_fragment_too_long_fragment,
    &hf_ftdi_fragment_error,
    &hf_ftdi_fragment_count,
    /* Reassembled in field */
    &hf_ftdi_reassembled_in,
    /* Reassembled length field */
    &hf_ftdi_reassembled_length,
    /* Reassembled data field */
    NULL,
    /* Tag */
    "FTDI FT fragments"
};

static dissector_handle_t ftdi_mpsse_handle;

static expert_field ei_undecoded = EI_INIT;

static dissector_handle_t ftdi_ft_handle;

static reassembly_table ftdi_reassembly_table;

static wmem_tree_t *request_info = NULL;
static wmem_tree_t *bitmode_info = NULL;
static wmem_tree_t *desegment_info = NULL;

typedef struct _request_data {
    guint32  bus_id;
    guint32  device_address;
    guint8   request;
    guint8   hvalue;
    guint8   lindex;
} request_data_t;

typedef struct _bitmode_data {
    guint32        bus_id;
    guint32        device_address;
    FTDI_INTERFACE interface;
    guint8         bitmode;
} bitmode_data_t;

typedef struct _desegment_data desegment_data_t;
struct _desegment_data {
    guint32           bus_id;
    guint32           device_address;
    FTDI_INTERFACE    interface;
    guint8            bitmode;
    gint              p2p_dir;
    /* First frame where the segmented data starts (reassembly key) */
    guint32           first_frame;
    guint32           last_frame;
    gint              first_frame_offset;
    /* Points to desegment data if the previous desegment data ends
     * in last_frame that is equal to this desegment data first_frame.
     */
    desegment_data_t *previous;
};

typedef struct _ftdi_fragment_key {
    guint32           bus_id;
    guint32           device_address;
    FTDI_INTERFACE    interface;
    guint8            bitmode;
    gint              p2p_dir;
    guint32           id;
} ftdi_fragment_key_t;

#define REQUEST_RESET           0x00
#define REQUEST_MODEM_CTRL      0x01
#define REQUEST_SET_FLOW_CTRL   0x02
#define REQUEST_SET_BAUD_RATE   0x03
#define REQUEST_SET_DATA        0x04
#define REQUEST_GET_MODEM_STAT  0x05
#define REQUEST_SET_EVENT_CHAR  0x06
#define REQUEST_SET_ERROR_CHAR  0x07
#define REQUEST_SET_LAT_TIMER   0x09
#define REQUEST_GET_LAT_TIMER   0x0A
#define REQUEST_SET_BITMODE     0x0B

static const value_string request_vals[] = {
    {REQUEST_RESET,           "Reset"},
    {REQUEST_MODEM_CTRL,      "ModemCtrl"},
    {REQUEST_SET_FLOW_CTRL,   "SetFlowCtrl"},
    {REQUEST_SET_BAUD_RATE,   "SetBaudRate"},
    {REQUEST_SET_DATA,        "SetData"},
    {REQUEST_GET_MODEM_STAT,  "GetModemStat"},
    {REQUEST_SET_EVENT_CHAR,  "SetEventChar"},
    {REQUEST_SET_ERROR_CHAR,  "SetErrorChar"},
    {REQUEST_SET_LAT_TIMER,   "SetLatTimer"},
    {REQUEST_GET_LAT_TIMER,   "GetLatTimer"},
    {REQUEST_SET_BITMODE,     "SetBitMode"},
    {0, NULL}
};
static value_string_ext request_vals_ext  = VALUE_STRING_EXT_INIT(request_vals);

static const value_string reset_purge_vals[] = {
    {0x00, "Purge RX and TX"},
    {0x01, "Purge RX"},
    {0x02, "Purge TX"},
    {0, NULL}
};

static const value_string index_port_ab_vals[] = {
    {0x00, "Port A"},
    {0x01, "Port A"},
    {0x02, "Port B"},
    {0, NULL}
};

static const value_string index_port_abcd_vals[] = {
    {0x00, "Port A"},
    {0x01, "Port A"},
    {0x02, "Port B"},
    {0x03, "Port C"},
    {0x04, "Port D"},
    {0, NULL}
};

static const value_string data_size_vals[] = {
    {0x07, "7 bit data"},
    {0x08, "8 bit data"},
    {0, NULL}
};

static const value_string parity_vals[] = {
    {0x0, "None"},
    {0x1, "Odd"},
    {0x2, "Even"},
    {0x3, "Mark"},
    {0x4, "Space"},
    {0, NULL}
};

static const value_string stop_bits_vals[] = {
    {0, "1 stop bit"},
    {1, "2 stop bits"},
    {0, NULL}
};

static const value_string break_bit_vals[] = {
    {0, "No Break"},
    {1, "Set Break"},
    {0, NULL}
};

static const value_string event_char_trigger_vals[] = {
    {0x00, "No trigger"},
    {0x01, "Trigger IN on Event Char"},
    {0, NULL}
};

static const value_string error_replacement_vals[] = {
    {0x00, "No Error Replacement"},
    {0x01, "Error Replacement On"},
    {0, NULL}
};

#define BITMODE_RESET   0x00
#define BITMODE_BITBANG 0x01
#define BITMODE_MPSSE   0x02
#define BITMODE_SYNCBB  0x04
#define BITMODE_MCU     0x08
#define BITMODE_OPTO    0x10
#define BITMODE_CBUS    0x20
#define BITMODE_SYNCFF  0x40
#define BITMODE_FT1284  0x80


static const value_string bitmode_vals[] = {
    {BITMODE_RESET,   "switch off bitbang mode, back to regular serial / FIFO"},
    {BITMODE_BITBANG, "classical asynchronous bitbang mode, introduced with B-type chips"},
    {BITMODE_MPSSE,   "MPSSE mode, available on 2232x chips"},
    {BITMODE_SYNCBB,  "synchronous bitbang mode, available on 2232x and R-type chips"},
    {BITMODE_MCU,     "MCU Host Bus Emulation mode, available on 2232x chips"},
    {BITMODE_OPTO,    "Fast Opto-Isolated Serial Interface Mode, available on 2232x chips"},
    {BITMODE_CBUS,    "Bitbang on CBUS pins of R-type chips, configure in EEPROM before"},
    {BITMODE_SYNCFF,  "Single Channel Synchronous FIFO mode, available on 2232H chips"},
    {BITMODE_FT1284,  "FT1284 mode, available on 232H chips"},
    {0, NULL}
};

#define MODEM_STATUS_BIT_FS_64_MAX_PACKET  (1 << 0)
#define MODEM_STATUS_BIT_HS_512_MAX_PACKET (1 << 1)

void proto_register_ftdi_ft(void);
void proto_reg_handoff_ftdi_ft(void);

/* It is assumed that this function is called only when the device is known
 * to be FTDI FT chip and thus the VID and PID is not checked here.
 * This function determines chip based on bcdDevice version which cannot be
 * altered by the hardware vendor.
 */
static FTDI_CHIP
identify_chip(usb_conv_info_t *usb_conv_info)
{
    switch (usb_conv_info->deviceVersion)
    {
    case 0x0200:
        if (usb_conv_info->iSerialNumber)
        {
            /* Serial number enabled - it is FT8U232AM */
            return FTDI_CHIP_FT8U232AM;
        }
        /* No serial number - FT232B without (or with blank) EEPROM fitted */
        return FTDI_CHIP_FT232B;
    case 0x0400:
        return FTDI_CHIP_FT232B;
    case 0x0500:
        return FTDI_CHIP_FT2232D;
    case 0x0600:
        return FTDI_CHIP_FT232R;
    case 0x0700:
        return FTDI_CHIP_FT2232H;
    case 0x0800:
        return FTDI_CHIP_FT4232H;
    case 0x0900:
        return FTDI_CHIP_FT232H;
    case 0x1000:
        return FTDI_CHIP_X_SERIES;
    default:
        return FTDI_CHIP_UNKNOWN;
    }
}

static FTDI_INTERFACE
endpoint_to_interface(usb_conv_info_t *usb_conv_info)
{
    switch (usb_conv_info->endpoint)
    {
    case 0x01: /* A OUT */
    case 0x02: /* A IN */
        return FTDI_INTERFACE_A;
    case 0x03: /* B OUT */
    case 0x04: /* B IN */
        return FTDI_INTERFACE_B;
    case 0x05: /* C OUT */
    case 0x06: /* C IN */
        return FTDI_INTERFACE_C;
    case 0x07: /* D OUT */
    case 0x08: /* D IN */
        return FTDI_INTERFACE_D;
    default:
        return FTDI_INTERFACE_UNKNOWN;
    }
}

static FTDI_INTERFACE
lindex_to_interface(guint8 lindex)
{
    switch (lindex)
    {
    case 0: /* ANY, default to A */
    case 1:
        return FTDI_INTERFACE_A;
    case 2:
        return FTDI_INTERFACE_B;
    case 3:
        return FTDI_INTERFACE_C;
    case 4:
        return FTDI_INTERFACE_D;
    default:
        return FTDI_INTERFACE_UNKNOWN;
    }
}

static gint
dissect_request_reset(tvbuff_t *tvb, packet_info *pinfo _U_, gint offset, proto_tree *tree)
{
    gint offset_start = offset;

    proto_tree_add_item(tree, hf_setup_lvalue_purge, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hvalue, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_lindex_port_abcd, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hindex, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    return offset - offset_start;
}

static gint
dissect_request_modem_ctrl(tvbuff_t *tvb, packet_info *pinfo _U_, gint offset, proto_tree *tree)
{
    static int * const lvalue_bits[] = {
        &hf_setup_lvalue_dtr,
        &hf_setup_lvalue_rts,
        NULL
    };
    static int * const hvalue_bits[] = {
        &hf_setup_hvalue_dtr,
        &hf_setup_hvalue_rts,
        NULL
    };
    gint offset_start = offset;

    proto_tree_add_bitmask(tree, tvb, offset, hf_setup_lvalue,
        ett_modem_ctrl_lvalue, lvalue_bits, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_bitmask(tree, tvb, offset, hf_setup_hvalue,
        ett_modem_ctrl_hvalue, hvalue_bits, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_lindex_port_abcd, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hindex, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    return offset - offset_start;
}

static gint
dissect_request_set_flow_ctrl(tvbuff_t *tvb, packet_info *pinfo _U_, gint offset, proto_tree *tree)
{
    static int * const hindex_bits[] = {
        &hf_setup_hindex_rts_cts,
        &hf_setup_hindex_dtr_dsr,
        &hf_setup_hindex_xon_xoff,
        NULL
    };
    gint offset_start = offset;

    proto_tree_add_item(tree, hf_setup_lvalue_xon_char, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hvalue_xoff_char, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_lindex_port_abcd, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_bitmask(tree, tvb, offset, hf_setup_hindex,
        ett_flow_ctrl_hindex, hindex_bits, ENC_LITTLE_ENDIAN);
    offset++;

    return offset - offset_start;
}

static gint
dissect_request_set_baud_rate(tvbuff_t *tvb, packet_info *pinfo, gint offset, proto_tree *tree, FTDI_CHIP chip)
{
    static int * const lindex_bits[] = {
        &hf_setup_lindex_baud_high,
        NULL
    };
    static int * const hindex_bits[] = {
        &hf_setup_hindex_baud_high,
        NULL
    };
    static int * const hindex_bits_hispeed[] = {
        &hf_setup_hindex_baud_high,
        &hf_setup_hindex_baud_clock_divide,
        NULL
    };

    gint offset_start = offset;

    proto_tree_add_item(tree, hf_setup_lvalue_baud_low, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hvalue_baud_mid, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    switch (chip)
    {
    case FTDI_CHIP_FT8U232AM:
        proto_tree_add_item(tree, hf_setup_lindex, tvb, offset, 1, ENC_LITTLE_ENDIAN);
        offset++;

        proto_tree_add_item(tree, hf_setup_hindex, tvb, offset, 1, ENC_LITTLE_ENDIAN);
        offset++;
        break;
    case FTDI_CHIP_FT232B:
    case FTDI_CHIP_FT232R:
        proto_tree_add_bitmask(tree, tvb, offset, hf_setup_lindex,
            ett_baudrate_lindex, lindex_bits, ENC_LITTLE_ENDIAN);
        offset++;

        proto_tree_add_item(tree, hf_setup_hindex, tvb, offset, 1, ENC_LITTLE_ENDIAN);
        offset++;
        break;
    case FTDI_CHIP_FT2232D:
    case FTDI_CHIP_X_SERIES:
        proto_tree_add_item(tree, hf_setup_lindex_port_ab, tvb, offset, 1, ENC_LITTLE_ENDIAN);
        offset++;

        proto_tree_add_bitmask(tree, tvb, offset, hf_setup_hindex,
            ett_baudrate_hindex, hindex_bits, ENC_LITTLE_ENDIAN);
        offset++;
        break;
    case FTDI_CHIP_FT2232H:
    case FTDI_CHIP_FT4232H:
    case FTDI_CHIP_FT232H:
        proto_tree_add_item(tree, hf_setup_lindex_port_abcd, tvb, offset, 1, ENC_LITTLE_ENDIAN);
        offset++;

        proto_tree_add_bitmask(tree, tvb, offset, hf_setup_hindex,
            ett_baudrate_hindex, hindex_bits_hispeed, ENC_LITTLE_ENDIAN);
        offset++;
        break;
    case FTDI_CHIP_UNKNOWN:
    default:
        proto_tree_add_expert(tree, pinfo, &ei_undecoded, tvb, offset, 2);
        offset += 2;
        break;
    }
    return offset - offset_start;
}

static gint
dissect_request_set_data(tvbuff_t *tvb, packet_info *pinfo _U_, gint offset, proto_tree *tree)
{
    static int * const hvalue_bits[] = {
        &hf_setup_hvalue_parity,
        &hf_setup_hvalue_stop_bits,
        &hf_setup_hvalue_break_bit,
        NULL
    };
    gint offset_start = offset;

    proto_tree_add_item(tree, hf_setup_lvalue_data_size, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_bitmask(tree, tvb, offset, hf_setup_hvalue,
        ett_setdata_hvalue, hvalue_bits, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_lindex_port_abcd, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hindex, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    return offset - offset_start;
}

static gint
dissect_request_get_modem_stat(tvbuff_t *tvb, packet_info *pinfo _U_, gint offset, proto_tree *tree)
{
    gint offset_start = offset;

    proto_tree_add_item(tree, hf_setup_lvalue, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hvalue, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_lindex_port_abcd, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hindex, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    return offset - offset_start;
}

static gint
dissect_request_set_event_char(tvbuff_t *tvb, packet_info *pinfo _U_, gint offset, proto_tree *tree)
{
    gint offset_start = offset;

    proto_tree_add_item(tree, hf_setup_lvalue_event_char, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hvalue_trigger, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_lindex_port_abcd, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hindex, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    return offset - offset_start;
}

static gint
dissect_request_set_error_char(tvbuff_t *tvb, packet_info *pinfo _U_, gint offset, proto_tree *tree)
{
    gint offset_start = offset;

    proto_tree_add_item(tree, hf_setup_lvalue_error_char, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hvalue_error_replacement, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_lindex_port_abcd, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hindex, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;


    return offset - offset_start;
}

static gint
dissect_request_set_lat_timer(tvbuff_t *tvb, packet_info *pinfo _U_, gint offset, proto_tree *tree)
{
    gint offset_start = offset;

    proto_tree_add_item(tree, hf_setup_lvalue_latency_time, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hvalue, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_lindex_port_abcd, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hindex, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    return offset - offset_start;
}

static gint
dissect_request_get_lat_timer(tvbuff_t *tvb, packet_info *pinfo _U_, gint offset, proto_tree *tree)
{
    gint offset_start = offset;

    proto_tree_add_item(tree, hf_setup_lvalue, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hvalue, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_lindex_port_abcd, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hindex, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    return offset - offset_start;
}

static gint
dissect_response_get_lat_timer(tvbuff_t *tvb, packet_info *pinfo _U_, gint offset, proto_tree *tree)
{
    gint offset_start = offset;

    proto_tree_add_item(tree, hf_response_lat_timer, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    return offset - offset_start;
}

static gint
dissect_request_set_bitmode(tvbuff_t *tvb, packet_info *pinfo _U_, gint offset, proto_tree *tree)
{
    gint offset_start = offset;

    proto_tree_add_item(tree, hf_setup_lvalue_bitmask, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hvalue_bitmode, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_lindex_port_abcd, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    proto_tree_add_item(tree, hf_setup_hindex, tvb, offset, 1, ENC_LITTLE_ENDIAN);
    offset++;

    return offset - offset_start;
}

static gint
dissect_modem_status_bytes(tvbuff_t *tvb, packet_info *pinfo _U_, gint offset, proto_tree *tree, gint *out_rx_len)
{
    static int * const modem_status_bits[] = {
        &hf_modem_status_fs_max_packet,
        &hf_modem_status_hs_max_packet,
        &hf_modem_status_cts,
        &hf_modem_status_dsr,
        &hf_modem_status_ri,
        &hf_modem_status_dcd,
        NULL
    };
    static int * const line_status_bits[] = {
        &hf_line_status_receive_overflow,
        &hf_line_status_parity_error,
        &hf_line_status_framing_error,
        &hf_line_status_break_received,
        &hf_line_status_tx_holding_reg_empty,
        &hf_line_status_tx_empty,
        NULL
    };
    guint64 modem_status;

    proto_tree_add_bitmask_ret_uint64(tree, tvb, offset, hf_modem_status,
        ett_modem_status, modem_status_bits, ENC_LITTLE_ENDIAN, &modem_status);
    offset++;

    proto_tree_add_bitmask(tree, tvb, offset, hf_line_status,
        ett_line_status, line_status_bits, ENC_LITTLE_ENDIAN);
    offset++;

    if (out_rx_len)
    {
        *out_rx_len = tvb_reported_length_remaining(tvb, offset);
        if (modem_status & MODEM_STATUS_BIT_FS_64_MAX_PACKET)
        {
            /* 2 bytes modem status, 62 bytes payload */
            *out_rx_len = MIN(*out_rx_len, 62);
        }
        else if (modem_status & MODEM_STATUS_BIT_HS_512_MAX_PACKET)
        {
            /* 2 bytes modem status, 510 bytes payload */
            *out_rx_len = MIN(*out_rx_len, 510);
        }
    }

    return 2;
}

static void
record_interface_mode(packet_info *pinfo, usb_conv_info_t *usb_conv_info, FTDI_INTERFACE interface, guint8 bitmode)
{
    guint32         k_bus_id = usb_conv_info->bus_id;
    guint32         k_device_address = usb_conv_info->device_address;
    guint32         k_interface = (guint32)interface;
    wmem_tree_key_t key[] = {
        {1, &k_bus_id},
        {1, &k_device_address},
        {1, &k_interface},
        {1, &pinfo->num},
        {0, NULL}
    };
    bitmode_data_t *bitmode_data = NULL;

    bitmode_data = wmem_new(wmem_file_scope(), bitmode_data_t);
    bitmode_data->bus_id = usb_conv_info->bus_id;
    bitmode_data->device_address = usb_conv_info->device_address;
    bitmode_data->interface = interface;
    bitmode_data->bitmode = bitmode;
    wmem_tree_insert32_array(bitmode_info, key, bitmode_data);
}

static guint8
get_recorded_interface_mode(packet_info *pinfo, usb_conv_info_t *usb_conv_info, FTDI_INTERFACE interface)
{
    guint32         k_bus_id = usb_conv_info->bus_id;
    guint32         k_device_address = usb_conv_info->device_address;
    guint32         k_interface = (guint32)interface;
    wmem_tree_key_t key[] = {
        {1, &k_bus_id},
        {1, &k_device_address},
        {1, &k_interface},
        {1, &pinfo->num},
        {0, NULL}
    };

    bitmode_data_t *bitmode_data = NULL;
    bitmode_data = (bitmode_data_t *)wmem_tree_lookup32_array_le(bitmode_info, key);
    if (bitmode_data && bitmode_data->bus_id == k_bus_id && bitmode_data->device_address == k_device_address &&
        bitmode_data->interface == interface)
    {
        return bitmode_data->bitmode;
    }

    return 0; /* Default to 0, which is plain serial data */
}

static desegment_data_t *
record_desegment_data(packet_info *pinfo, usb_conv_info_t *usb_conv_info,
                      FTDI_INTERFACE interface, guint8 bitmode)
{
    guint32         k_bus_id = usb_conv_info->bus_id;
    guint32         k_device_address = usb_conv_info->device_address;
    guint32         k_interface = (guint32)interface;
    guint32         k_p2p_dir = (guint32)pinfo->p2p_dir;
    wmem_tree_key_t key[] = {
        {1, &k_bus_id},
        {1, &k_device_address},
        {1, &k_interface},
        {1, &k_p2p_dir},
        {1, &pinfo->num},
        {0, NULL}
    };
    desegment_data_t *desegment_data = NULL;

    desegment_data = wmem_new(wmem_file_scope(), desegment_data_t);
    desegment_data->bus_id = usb_conv_info->bus_id;
    desegment_data->device_address = usb_conv_info->device_address;
    desegment_data->interface = interface;
    desegment_data->bitmode = bitmode;
    desegment_data->p2p_dir = pinfo->p2p_dir;
    desegment_data->first_frame = pinfo->num;
    /* Last frame is currently unknown */
    desegment_data->last_frame = 0;
    desegment_data->first_frame_offset = 0;
    desegment_data->previous = NULL;

    wmem_tree_insert32_array(desegment_info, key, desegment_data);
    return desegment_data;
}

static desegment_data_t *
get_recorded_desegment_data(packet_info *pinfo, usb_conv_info_t *usb_conv_info,
                            FTDI_INTERFACE interface, guint8 bitmode)
{
    guint32         k_bus_id = usb_conv_info->bus_id;
    guint32         k_device_address = usb_conv_info->device_address;
    guint32         k_interface = (guint32)interface;
    guint32         k_p2p_dir = (guint32)pinfo->p2p_dir;
    wmem_tree_key_t key[] = {
        {1, &k_bus_id},
        {1, &k_device_address},
        {1, &k_interface},
        {1, &k_p2p_dir},
        {1, &pinfo->num},
        {0, NULL}
    };

    desegment_data_t *desegment_data = NULL;
    desegment_data = (desegment_data_t*)wmem_tree_lookup32_array_le(desegment_info, key);
    if (desegment_data && desegment_data->bus_id == k_bus_id && desegment_data->device_address == k_device_address &&
        desegment_data->interface == interface && desegment_data->bitmode == bitmode &&
        desegment_data->p2p_dir == pinfo->p2p_dir)
    {
        /* Return desegment data only if it is relevant to current packet */
        if ((desegment_data->last_frame == 0) || (desegment_data->last_frame >= pinfo->num))
        {
            return desegment_data;
        }
    }

    return NULL;
}

static guint ftdi_fragment_key_hash(gconstpointer k)
{
    const ftdi_fragment_key_t *key = (const ftdi_fragment_key_t *)k;
    return key->id;
}

static gint ftdi_fragment_key_equal(gconstpointer k1, gconstpointer k2)
{
    const ftdi_fragment_key_t *key1 = (const ftdi_fragment_key_t *)k1;
    const ftdi_fragment_key_t *key2 = (const ftdi_fragment_key_t *)k2;

    /* id is most likely to differ and thus should be checked first */
    return (key1->id == key2->id) &&
           (key1->bus_id == key2->bus_id) &&
           (key1->device_address == key2->device_address) &&
           (key1->interface == key2->interface) &&
           (key1->bitmode == key2->bitmode) &&
           (key1->p2p_dir == key2->p2p_dir);
}

static gpointer ftdi_fragment_key(const packet_info *pinfo _U_, const guint32 id, const void *data)
{
    desegment_data_t *desegment_data = (desegment_data_t *)data;
    ftdi_fragment_key_t *key = g_slice_new(ftdi_fragment_key_t);

    key->bus_id = desegment_data->bus_id;
    key->device_address = desegment_data->device_address;
    key->interface = desegment_data->interface;
    key->bitmode = desegment_data->bitmode;
    key->p2p_dir = desegment_data->p2p_dir;
    key->id = id;

    return (gpointer)key;
}

static void ftdi_fragment_free_key(gpointer ptr)
{
    ftdi_fragment_key_t *key = (ftdi_fragment_key_t *)ptr;
    g_slice_free(ftdi_fragment_key_t, key);
}

static const reassembly_table_functions ftdi_reassembly_table_functions = {
    .hash_func = ftdi_fragment_key_hash,
    .equal_func = ftdi_fragment_key_equal,
    .temporary_key_func = ftdi_fragment_key,
    .persistent_key_func = ftdi_fragment_key,
    .free_temporary_key_func = ftdi_fragment_free_key,
    .free_persistent_key_func = ftdi_fragment_free_key,
};

static void
dissect_payload(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, usb_conv_info_t *usb_conv_info,
                FTDI_INTERFACE interface, guint8 bitmode)
{
    guint32           k_bus_id;
    guint32           k_device_address;

    k_bus_id = usb_conv_info->bus_id;
    k_device_address = usb_conv_info->device_address;

    if (tvb && ((bitmode == BITMODE_MPSSE) || (bitmode == BITMODE_MCU)))
    {
        ftdi_mpsse_info_t mpsse_info = {
            .bus_id = k_bus_id,
            .device_address = k_device_address,
            .chip = identify_chip(usb_conv_info),
            .iface = interface,
            .mcu_mode = (bitmode == BITMODE_MCU),
        };
        call_dissector_with_data(ftdi_mpsse_handle, tvb, pinfo, tree, &mpsse_info);
    }
}

static gint
dissect_serial_payload(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, proto_tree *ftdi_tree,
                       usb_conv_info_t *usb_conv_info, FTDI_INTERFACE interface)
{
    guint16           save_can_desegment;
    int               save_desegment_offset;
    guint32           save_desegment_len;
    desegment_data_t *desegment_data;
    guint32           bytes;

    save_can_desegment = pinfo->can_desegment;
    save_desegment_offset = pinfo->desegment_offset;
    save_desegment_len = pinfo->desegment_len;

    bytes = tvb_reported_length(tvb);
    if (bytes > 0)
    {
        tvbuff_t *payload_tvb = NULL;
        guint32   reassembled_bytes = 0;
        guint8    bitmode;
        guint8    curr_layer_num = pinfo->curr_layer_num;

        bitmode = get_recorded_interface_mode(pinfo, usb_conv_info, interface);

        pinfo->can_desegment = 2;
        pinfo->desegment_offset = 0;
        pinfo->desegment_len = 0;

        desegment_data = get_recorded_desegment_data(pinfo, usb_conv_info, interface, bitmode);
        if (desegment_data)
        {
            fragment_head    *fd_head;
            desegment_data_t *next_desegment_data = NULL;

            if ((desegment_data->previous) && (desegment_data->first_frame == pinfo->num))
            {
                DISSECTOR_ASSERT(desegment_data->previous->last_frame == pinfo->num);

                next_desegment_data = desegment_data;
                desegment_data = desegment_data->previous;
            }

            if (!PINFO_FD_VISITED(pinfo))
            {
                /* Combine data reassembled so far with current tvb and check if this is last fragment or not */
                fragment_item *item;
                fd_head = fragment_get(&ftdi_reassembly_table, pinfo, desegment_data->first_frame, desegment_data);
                DISSECTOR_ASSERT(fd_head && !(fd_head->flags & FD_DEFRAGMENTED) && fd_head->next);
                payload_tvb = tvb_new_composite();
                for (item = fd_head->next; item; item = item->next)
                {
                    DISSECTOR_ASSERT(reassembled_bytes == item->offset);
                    tvb_composite_append(payload_tvb, item->tvb_data);
                    reassembled_bytes += item->len;
                }
                tvb_composite_append(payload_tvb, tvb);
                tvb_composite_finalize(payload_tvb);
            }
            else
            {
                fd_head = fragment_get_reassembled_id(&ftdi_reassembly_table, pinfo, desegment_data->first_frame);
                payload_tvb = process_reassembled_data(tvb, 0, pinfo, "Reassembled", fd_head,
                                                       &ftdi_frag_items, NULL, ftdi_tree);
            }

            if (next_desegment_data)
            {
                fragment_head *next_head;
                next_head = fragment_get_reassembled_id(&ftdi_reassembly_table, pinfo, next_desegment_data->first_frame);
                process_reassembled_data(tvb, 0, pinfo, "Reassembled", next_head, &ftdi_frag_items, NULL, ftdi_tree);
            }

            if ((desegment_data->first_frame == pinfo->num) && (desegment_data->first_frame_offset > 0))
            {
                payload_tvb = tvb_new_subset_length(tvb, 0, desegment_data->first_frame_offset);
            }
        }
        else
        {
            /* Packet is not part of reassembly sequence, simply use it without modifications */
            payload_tvb = tvb;
        }

        dissect_payload(payload_tvb, pinfo, tree, usb_conv_info, interface, bitmode);

        if (!PINFO_FD_VISITED(pinfo))
        {
            /* FTDI FT dissector doesn't know if the last fragment is really the last one unless it passes
             * the data to the next dissector. There is absolutely no metadata that could help with it as
             * FTDI FT is pretty much a direct replacement to UART (COM port) and is pretty much transparent
             * to the actual serial protocol used.
             *
             * Passing the data to next dissector results in curr_layer_num being increased if it dissected
             * the data (when it is the last fragment). This would prevent the process_reassembled_data()
             * (after the first pass) from returning the reassembled tvb in FTFI FT which in turn prevents
             * the data from being passed to the next dissector.
             *
             * Override pinfo->curr_layer_num value when the fragments are being added to reassembly table.
             * This is ugly hack. Is there any better approach?
             *
             * There doesn't seem to be a mechanism to "back-track" just added fragments to reassembly table,
             * or any way to "shorten" the last added fragment. The most problematic case is when current
             * packet is both last packet for previous reassembly and a first packet for next reassembly.
             */
            guint8 save_curr_layer_num = pinfo->curr_layer_num;
            pinfo->curr_layer_num = curr_layer_num;

            if (!pinfo->desegment_len)
            {
                if (desegment_data)
                {
                    /* Current tvb is really the last fragment */
                    fragment_add_check(&ftdi_reassembly_table, tvb, 0, pinfo, desegment_data->first_frame,
                                       desegment_data, reassembled_bytes, bytes, FALSE);
                    desegment_data->last_frame = pinfo->num;
                }
            }
            else
            {
                DISSECTOR_ASSERT_HINT(pinfo->desegment_len == DESEGMENT_ONE_MORE_SEGMENT,
                                      "FTDI FT supports only DESEGMENT_ONE_MORE_SEGMENT");
                if (!desegment_data)
                {
                    /* Start desegmenting */
                    gint fragment_length = tvb_reported_length_remaining(tvb, pinfo->desegment_offset);
                    desegment_data = record_desegment_data(pinfo, usb_conv_info, interface, bitmode);
                    desegment_data->first_frame_offset = pinfo->desegment_offset;
                    fragment_add_check(&ftdi_reassembly_table, tvb, pinfo->desegment_offset, pinfo,
                                       desegment_data->first_frame, desegment_data, 0, fragment_length, TRUE);
                }
                else if (pinfo->desegment_offset == 0)
                {
                    /* Continue reassembling */
                    fragment_add_check(&ftdi_reassembly_table, tvb, 0, pinfo, desegment_data->first_frame,
                                       desegment_data, reassembled_bytes, bytes, TRUE);
                }
                else
                {
                    gint fragment_length;
                    gint previous_bytes;
                    desegment_data_t *previous_desegment_data;

                    /* This packet contains both an end from a previous reassembly and start of a new one */
                    DISSECTOR_ASSERT((guint32)pinfo->desegment_offset > reassembled_bytes);
                    previous_bytes = pinfo->desegment_offset - reassembled_bytes;
                    fragment_add_check(&ftdi_reassembly_table, tvb, 0, pinfo, desegment_data->first_frame,
                                       desegment_data, reassembled_bytes, previous_bytes, FALSE);
                    desegment_data->last_frame = pinfo->num;

                    previous_desegment_data = desegment_data;
                    fragment_length = bytes - previous_bytes;
                    desegment_data = record_desegment_data(pinfo, usb_conv_info, interface, bitmode);
                    desegment_data->first_frame_offset = previous_bytes;
                    desegment_data->previous = previous_desegment_data;
                    fragment_add_check(&ftdi_reassembly_table, tvb, previous_bytes, pinfo, desegment_data->first_frame,
                                       desegment_data, 0, fragment_length, TRUE);
                }
            }

            pinfo->curr_layer_num = save_curr_layer_num;
        }
    }

    pinfo->can_desegment = save_can_desegment;
    pinfo->desegment_offset = save_desegment_offset;
    pinfo->desegment_len = save_desegment_len;

    return bytes;
}

static gint
dissect_ftdi_ft(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
{
    proto_item       *main_item;
    proto_tree       *main_tree;
    gint              offset = 0;
    usb_conv_info_t  *usb_conv_info = (usb_conv_info_t *)data;
    request_data_t   *request_data = NULL;
    wmem_tree_key_t   key[4];
    guint32           k_bus_id;
    guint32           k_device_address;

    if (!usb_conv_info)
    {
        return offset;
    }

    if (usb_conv_info->is_setup)
    {
        /* This dissector can only process device Vendor specific setup data */
        if ((USB_TYPE(usb_conv_info->setup_requesttype) != RQT_SETUP_TYPE_VENDOR) ||
            (USB_RECIPIENT(usb_conv_info->setup_requesttype) != RQT_SETUP_RECIPIENT_DEVICE))
        {
            return offset;
        }
    }

    k_bus_id = usb_conv_info->bus_id;
    k_device_address = usb_conv_info->device_address;

    key[0].length = 1;
    key[0].key = &k_bus_id;
    key[1].length = 1;
    key[1].key = &k_device_address;
    key[2].length = 1;
    key[2].key = &pinfo->num;
    key[3].length = 0;
    key[3].key = NULL;

    main_item = proto_tree_add_item(tree, proto_ftdi_ft, tvb, offset, -1, ENC_NA);
    main_tree = proto_item_add_subtree(main_item, ett_ftdi_ft);

    if (usb_conv_info->transfer_type == URB_CONTROL)
    {
        col_set_str(pinfo->cinfo, COL_PROTOCOL, "FTDI FT");
        col_set_str(pinfo->cinfo, COL_INFO, "FTDI FT ");
        col_append_str(pinfo->cinfo, COL_INFO, usb_conv_info->is_request ? "Request" : "Response");

        if (usb_conv_info->is_setup)
        {
            gint         bytes_dissected;
            guint8       brequest;
            guint8       hvalue;
            guint8       lindex;

            brequest = tvb_get_guint8(tvb, offset);
            col_append_fstr(pinfo->cinfo, COL_INFO, ": %s",
                val_to_str_ext_const(brequest, &request_vals_ext, "Unknown"));
            proto_tree_add_item(main_tree, hf_setup_brequest, tvb, offset, 1, ENC_LITTLE_ENDIAN);
            offset++;

            hvalue = tvb_get_guint8(tvb, offset + 1);
            lindex = tvb_get_guint8(tvb, offset + 2);

            switch (brequest)
            {
            case REQUEST_RESET:
                bytes_dissected = dissect_request_reset(tvb, pinfo, offset, main_tree);
                break;
            case REQUEST_MODEM_CTRL:
                bytes_dissected = dissect_request_modem_ctrl(tvb, pinfo, offset, main_tree);
                break;
            case REQUEST_SET_FLOW_CTRL:
                bytes_dissected = dissect_request_set_flow_ctrl(tvb, pinfo, offset, main_tree);
                break;
            case REQUEST_SET_BAUD_RATE:
            {
                FTDI_CHIP chip = identify_chip(usb_conv_info);
                bytes_dissected = dissect_request_set_baud_rate(tvb, pinfo, offset, main_tree, chip);
                break;
            }
            case REQUEST_SET_DATA:
                bytes_dissected = dissect_request_set_data(tvb, pinfo, offset, main_tree);
                break;
            case REQUEST_GET_MODEM_STAT:
                bytes_dissected = dissect_request_get_modem_stat(tvb, pinfo, offset, main_tree);
                break;
            case REQUEST_SET_EVENT_CHAR:
                bytes_dissected = dissect_request_set_event_char(tvb, pinfo, offset, main_tree);
                break;
            case REQUEST_SET_ERROR_CHAR:
                bytes_dissected = dissect_request_set_error_char(tvb, pinfo, offset, main_tree);
                break;
            case REQUEST_SET_LAT_TIMER:
                bytes_dissected = dissect_request_set_lat_timer(tvb, pinfo, offset, main_tree);
                break;
            case REQUEST_GET_LAT_TIMER:
                bytes_dissected = dissect_request_get_lat_timer(tvb, pinfo, offset, main_tree);
                break;
            case REQUEST_SET_BITMODE:
                bytes_dissected = dissect_request_set_bitmode(tvb, pinfo, offset, main_tree);
                break;
            default:
                bytes_dissected = 0;
                break;
            }

            offset += bytes_dissected;
            if (bytes_dissected < 4)
            {
                proto_tree_add_expert(main_tree, pinfo, &ei_undecoded, tvb, offset, 4 - bytes_dissected);
                offset += 4 - bytes_dissected;
            }

            proto_tree_add_item(main_tree, hf_setup_wlength, tvb, offset, 2, ENC_LITTLE_ENDIAN);
            offset += 2;

            /* Record the request type so we can find it when dissecting response */
            request_data = wmem_new(wmem_file_scope(), request_data_t);
            request_data->bus_id = usb_conv_info->bus_id;
            request_data->device_address = usb_conv_info->device_address;
            request_data->request = brequest;
            request_data->hvalue = hvalue;
            request_data->lindex = lindex;
            wmem_tree_insert32_array(request_info, key, request_data);
        }
        else
        {
            /* Retrieve request type */
            request_data = (request_data_t *)wmem_tree_lookup32_array_le(request_info, key);
            if (request_data && request_data->bus_id == k_bus_id && request_data->device_address == k_device_address)
            {
                col_append_fstr(pinfo->cinfo, COL_INFO, ": %s",
                    val_to_str_ext_const(request_data->request, &request_vals_ext, "Unknown"));

                switch (request_data->request)
                {
                case REQUEST_GET_MODEM_STAT:
                    offset += dissect_modem_status_bytes(tvb, pinfo, offset, main_tree, NULL);
                    break;
                case REQUEST_GET_LAT_TIMER:
                    offset += dissect_response_get_lat_timer(tvb, pinfo, offset, main_tree);
                    break;
                case REQUEST_SET_BITMODE:
                    /* TODO: Record interface mode only if the control request has succeeded */
                    record_interface_mode(pinfo, usb_conv_info, lindex_to_interface(request_data->lindex), request_data->hvalue);
                    break;
                default:
                    break;
                }
            }
            else
            {
                col_append_str(pinfo->cinfo, COL_INFO, ": Unknown");
            }

            /* Report any potentially undissected response data */
            if (tvb_reported_length_remaining(tvb, offset) > 0)
            {
                proto_tree_add_expert(main_tree, pinfo, &ei_undecoded, tvb, offset, -1);
            }
        }
    }
    else
    {
        const char *interface_str;
        FTDI_INTERFACE interface;
        gint rx_hf, tx_hf;

        interface = endpoint_to_interface(usb_conv_info);
        switch (interface)
        {
        case FTDI_INTERFACE_A:
            interface_str = "A";
            rx_hf = hf_if_a_rx_payload;
            tx_hf = hf_if_a_tx_payload;
            break;
        case FTDI_INTERFACE_B:
            interface_str = "B";
            rx_hf = hf_if_b_rx_payload;
            tx_hf = hf_if_b_tx_payload;
            break;
        case FTDI_INTERFACE_C:
            interface_str = "C";
            rx_hf = hf_if_c_rx_payload;
            tx_hf = hf_if_c_tx_payload;
            break;
        case FTDI_INTERFACE_D:
            interface_str = "D";
            rx_hf = hf_if_d_rx_payload;
            tx_hf = hf_if_d_tx_payload;
            break;
        default:
            return offset;
        }

        col_set_str(pinfo->cinfo, COL_PROTOCOL, "FTDI FT");
        if (pinfo->p2p_dir == P2P_DIR_RECV)
        {
            gint total_rx_len = 0;
            gint rx_len;
            tvbuff_t *rx_tvb = tvb_new_composite();

            col_add_fstr(pinfo->cinfo, COL_INFO, "INTERFACE %s RX", interface_str);

            do
            {
                /* First two bytes are status */
                offset += dissect_modem_status_bytes(tvb, pinfo, offset, main_tree, &rx_len);
                total_rx_len += rx_len;

                if (rx_len > 0)
                {
                    tvbuff_t *rx_tvb_fragment = tvb_new_subset_length(tvb, offset, rx_len);
                    tvb_composite_append(rx_tvb, rx_tvb_fragment);
                    proto_tree_add_item(main_tree, rx_hf, tvb, offset, rx_len, ENC_NA);
                    offset += rx_len;
                }
            }
            while (tvb_reported_length_remaining(tvb, offset) > 0);

            if (total_rx_len > 0)
            {
                tvb_composite_finalize(rx_tvb);
                col_append_fstr(pinfo->cinfo, COL_INFO, " %d bytes", total_rx_len);
                add_new_data_source(pinfo, rx_tvb, "RX Payload");
                dissect_serial_payload(rx_tvb, pinfo, tree, main_tree, usb_conv_info, interface);
            }
            else
            {
                tvb_free_chain(rx_tvb);
            }
        }
        else
        {
            gint bytes;

            col_add_fstr(pinfo->cinfo, COL_INFO, "INTERFACE %s TX", interface_str);
            bytes = tvb_reported_length_remaining(tvb, offset);

            if (bytes > 0)
            {
                tvbuff_t *tx_tvb;

                col_append_fstr(pinfo->cinfo, COL_INFO, " %d bytes", bytes);
                proto_tree_add_item(main_tree, tx_hf, tvb, offset, bytes, ENC_NA);

                tx_tvb = tvb_new_subset_length(tvb, offset, bytes);
                add_new_data_source(pinfo, tx_tvb, "TX Payload");
                dissect_serial_payload(tx_tvb, pinfo, tree, main_tree, usb_conv_info, interface);
                offset += bytes;
            }
        }
    }

    return offset;
}

void
proto_register_ftdi_ft(void)
{
    expert_module_t  *expert_module;

    static hf_register_info hf[] = {
        { &hf_setup_brequest,
          { "Request", "ftdi-ft.bRequest",
            FT_UINT8, BASE_DEC | BASE_EXT_STRING, &request_vals_ext, 0x0,
            NULL, HFILL }
        },
        { &hf_setup_lvalue,
          { "lValue", "ftdi-ft.lValue",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_setup_lvalue_purge,
          { "lValue", "ftdi-ft.lValue",
            FT_UINT8, BASE_HEX, VALS(reset_purge_vals), 0x0,
            NULL, HFILL }
        },
        { &hf_setup_lvalue_dtr,
          { "DTR Active", "ftdi-ft.lValue.b0",
            FT_BOOLEAN, 8, NULL, (1 << 0),
            NULL, HFILL }
        },
        { &hf_setup_lvalue_rts,
          { "RTS Active", "ftdi-ft.lValue.b1",
            FT_BOOLEAN, 8, NULL, (1 << 1),
            NULL, HFILL }
        },
        { &hf_setup_lvalue_xon_char,
          { "XON Char", "ftdi-ft.lValue",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_setup_lvalue_baud_low,
          { "Baud low", "ftdi-ft.lValue",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_setup_lvalue_data_size,
          { "Data Size", "ftdi-ft.lValue",
            FT_UINT8, BASE_HEX, VALS(data_size_vals), 0x0,
            NULL, HFILL }
        },
        { &hf_setup_lvalue_event_char,
          { "Event Char", "ftdi-ft.lValue",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_setup_lvalue_error_char,
          { "Parity Error Char", "ftdi-ft.lValue",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_setup_lvalue_latency_time,
          { "Latency Time", "ftdi-ft.lValue",
            FT_UINT8, BASE_DEC, NULL, 0x0,
            "Latency time in milliseconds", HFILL }
        },
        { &hf_setup_lvalue_bitmask,
          { "Bit Mask", "ftdi-ft.lValue",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_setup_hvalue,
          { "hValue", "ftdi-ft.hValue",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_setup_hvalue_dtr,
          { "en DTR for writing", "ftdi-ft.hValue.b0",
            FT_BOOLEAN, 8, NULL, (1 << 0),
            NULL, HFILL }
        },
        { &hf_setup_hvalue_rts,
          { "en RTS for writing", "ftdi-ft.hValue.b1",
            FT_BOOLEAN, 8, NULL, (1 << 1),
            NULL, HFILL }
        },
        { &hf_setup_hvalue_xoff_char,
          { "XOFF Char", "ftdi-ft.hValue",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_setup_hvalue_baud_mid,
          { "Baud mid", "ftdi-ft.hValue",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_setup_hvalue_parity,
          { "Parity", "ftdi-ft.hValue.parity",
            FT_UINT8, BASE_HEX, VALS(parity_vals), (0x7 << 0),
            NULL, HFILL }
        },
        { &hf_setup_hvalue_stop_bits,
          { "Stop Bits", "ftdi-ft.hValue.b4",
            FT_UINT8, BASE_HEX, VALS(stop_bits_vals), (1 << 4),
            NULL, HFILL }
        },
        { &hf_setup_hvalue_break_bit,
          { "Break Bit", "ftdi-ft.hValue.b6",
            FT_UINT8, BASE_HEX, VALS(break_bit_vals), (1 << 6),
            NULL, HFILL }
        },
        { &hf_setup_hvalue_trigger,
          { "hValue", "ftdi-ft.hValue",
            FT_UINT8, BASE_HEX, VALS(event_char_trigger_vals), 0x0,
            NULL, HFILL }
        },
        { &hf_setup_hvalue_error_replacement,
          { "hValue", "ftdi-ft.hValue",
            FT_UINT8, BASE_HEX, VALS(error_replacement_vals), 0x0,
            NULL, HFILL }
        },
        { &hf_setup_hvalue_bitmode,
          { "Bit Mode", "ftdi-ft.hValue",
            FT_UINT8, BASE_HEX, VALS(bitmode_vals), 0x0,
            NULL, HFILL }
        },
        { &hf_setup_lindex,
          { "lIndex", "ftdi-ft.lIndex",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_setup_lindex_port_ab,
          { "lIndex", "ftdi-ft.lIndex",
            FT_UINT8, BASE_HEX, VALS(index_port_ab_vals), 0x0,
            NULL, HFILL }
        },
        { &hf_setup_lindex_port_abcd,
          { "lIndex", "ftdi-ft.lIndex",
            FT_UINT8, BASE_HEX, VALS(index_port_abcd_vals), 0x0,
            NULL, HFILL }
        },
        { &hf_setup_lindex_baud_high,
          { "Baud High", "ftdi-ft.lIndex.b0",
            FT_UINT8, BASE_HEX, NULL, (1 << 0),
            NULL, HFILL }
        },
        { &hf_setup_hindex,
          { "hIndex", "ftdi-ft.hIndex",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_setup_hindex_rts_cts,
          { "RTS/CTS Flow Control", "ftdi-ft.hIndex.b0",
            FT_BOOLEAN, 8, NULL, (1 << 0),
            NULL, HFILL }
        },
        { &hf_setup_hindex_dtr_dsr,
          { "DTR/DSR Flow Control", "ftdi-ft.hIndex.b1",
            FT_BOOLEAN, 8, NULL, (1 << 1),
            NULL, HFILL }
        },
        { &hf_setup_hindex_xon_xoff,
          { "XON/XOFF Flow Control", "ftdi-ft.hIndex.b2",
            FT_BOOLEAN, 8, NULL, (1 << 2),
            NULL, HFILL }
        },
        { &hf_setup_hindex_baud_high,
          { "Baud High", "ftdi-ft.baud_high.b0",
            FT_UINT8, BASE_HEX, NULL, (1 << 0),
            NULL, HFILL }
        },
        { &hf_setup_hindex_baud_clock_divide,
          { "Baud Clock Divide off", "ftdi-ft.baud_clock_divide.b1",
            FT_BOOLEAN, 8, NULL, (1 << 1),
            "When active 120 MHz is max frequency instead of 48 MHz", HFILL }
        },
        { &hf_setup_wlength,
          { "wLength", "ftdi-ft.wLength",
            FT_UINT16, BASE_DEC, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_response_lat_timer,
          { "Latency Time", "ftdi-ft.latency_time",
            FT_UINT8, BASE_DEC, NULL, 0x0,
            "Latency time in milliseconds", HFILL }
        },
        { &hf_modem_status,
          { "Modem Status", "ftdi-ft.modem_status",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_modem_status_fs_max_packet,
          { "Full Speed 64 byte MAX packet", "ftdi-ft.modem_status.b0",
            FT_BOOLEAN, 8, NULL, (1 << 0),
            NULL, HFILL }
        },
        { &hf_modem_status_hs_max_packet,
          { "High Speed 512 byte MAX packet", "ftdi-ft.modem_status.b1",
            FT_BOOLEAN, 8, NULL, (1 << 1),
            NULL, HFILL }
        },
        { &hf_modem_status_cts,
          { "CTS", "ftdi-ft.modem_status.b4",
            FT_BOOLEAN, 8, NULL, (1 << 4),
            NULL, HFILL }
        },
        { &hf_modem_status_dsr,
          { "DSR", "ftdi-ft.modem_status.b5",
            FT_BOOLEAN, 8, NULL, (1 << 5),
            NULL, HFILL }
        },
        { &hf_modem_status_ri,
          { "RI", "ftdi-ft.modem_status.b6",
            FT_BOOLEAN, 8, NULL, (1 << 6),
            NULL, HFILL }
        },
        { &hf_modem_status_dcd,
          { "DCD", "ftdi-ft.modem_status.b7",
            FT_BOOLEAN, 8, NULL, (1 << 7),
            NULL, HFILL }
        },
        { &hf_line_status,
          { "Line Status", "ftdi-ft.line_status",
            FT_UINT8, BASE_HEX, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_line_status_receive_overflow,
          { "Receive Overflow Error", "ftdi-ft.line_status.b1",
            FT_BOOLEAN, 8, NULL, (1 << 1),
            NULL, HFILL }
        },
        { &hf_line_status_parity_error,
          { "Parity Error", "ftdi-ft.line_status.b2",
            FT_BOOLEAN, 8, NULL, (1 << 2),
            NULL, HFILL }
        },
        { &hf_line_status_framing_error,
          { "Framing Error", "ftdi-ft.line_status.b3",
            FT_BOOLEAN, 8, NULL, (1 << 3),
            NULL, HFILL }
        },
        { &hf_line_status_break_received,
          { "Break Received", "ftdi-ft.line_status.b4",
            FT_BOOLEAN, 8, NULL, (1 << 4),
            NULL, HFILL }
        },
        { &hf_line_status_tx_holding_reg_empty,
          { "Transmitter Holding Register Empty", "ftdi-ft.line_status.b5",
            FT_BOOLEAN, 8, NULL, (1 << 5),
            NULL, HFILL }
        },
        { &hf_line_status_tx_empty,
          { "Transmitter Empty", "ftdi-ft.line_status.b6",
            FT_BOOLEAN, 8, NULL, (1 << 6),
            NULL, HFILL }
        },
        { &hf_if_a_rx_payload,
          { "A RX payload", "ftdi-ft.if_a_rx_payload",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            "Data received on interface A", HFILL }
        },
        { &hf_if_a_tx_payload,
          { "A TX payload", "ftdi-ft.if_a_tx_payload",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            "Data to transmit on interface A", HFILL }
        },
        { &hf_if_b_rx_payload,
          { "B RX payload", "ftdi-ft.if_b_rx_payload",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            "Data received on interface B", HFILL }
        },
        { &hf_if_b_tx_payload,
          { "B TX payload", "ftdi-ft.if_b_tx_payload",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            "Data to transmit on interface B", HFILL }
        },
        { &hf_if_c_rx_payload,
          { "C RX payload", "ftdi-ft.if_c_rx_payload",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            "Data received on interface C", HFILL }
        },
        { &hf_if_c_tx_payload,
          { "C TX payload", "ftdi-ft.if_c_tx_payload",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            "Data to transmit on interface C", HFILL }
        },
        { &hf_if_d_rx_payload,
          { "D RX payload", "ftdi-ft.if_d_rx_payload",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            "Data received on interface D", HFILL }
        },
        { &hf_if_d_tx_payload,
          { "D TX payload", "ftdi-ft.if_d_tx_payload",
            FT_BYTES, BASE_NONE, NULL, 0x0,
            "Data to transmit on interface D", HFILL }
        },
        { &hf_ftdi_fragments,
          { "Payload fragments", "ftdi-ft.fragments",
            FT_NONE, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_ftdi_fragment,
          { "Payload fragment", "ftdi-ft.fragment",
            FT_FRAMENUM, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_ftdi_fragment_overlap,
          { "Payload fragment overlap", "ftdi-ft.fragment.overlap",
            FT_BOOLEAN, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_ftdi_fragment_overlap_conflicts,
          { "Payload fragment overlapping with conflicting data", "ftdi-ft.fragment.overlap.conflicts",
            FT_BOOLEAN, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_ftdi_fragment_multiple_tails,
          { "Payload has multiple tails", "ftdi-ft.fragment.multiple_tails",
            FT_BOOLEAN, BASE_NONE, NULL, 0x0,
            NULL, HFILL}
        },
        { &hf_ftdi_fragment_too_long_fragment,
          { "Payload fragment too long", "ftdi-ft.fragment.too_long_fragment",
            FT_BOOLEAN, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_ftdi_fragment_error,
          { "Payload defragmentation error", "ftdi-ft.fragment.error",
            FT_FRAMENUM, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_ftdi_fragment_count,
          { "Payload fragment count", "ftdi-ft.fragment.count",
            FT_UINT32, BASE_DEC, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_ftdi_reassembled_in,
          { "Payload reassembled in", "ftdi-ft.reassembled.in",
            FT_FRAMENUM, BASE_NONE, NULL, 0x0,
            NULL, HFILL }
        },
        { &hf_ftdi_reassembled_length,
          { "Payload reassembled length", "ftdi-ft.reassembled.length",
            FT_UINT32, BASE_DEC, NULL, 0x0,
            NULL, HFILL }
        },
    };

    static ei_register_info ei[] = {
        { &ei_undecoded, { "ftdi-ft.undecoded", PI_UNDECODED, PI_WARN, "Not dissected yet (report to wireshark.org)", EXPFILL }},
    };

    static gint *ett[] = {
        &ett_ftdi_ft,
        &ett_modem_ctrl_lvalue,
        &ett_modem_ctrl_hvalue,
        &ett_flow_ctrl_hindex,
        &ett_baudrate_lindex,
        &ett_baudrate_hindex,
        &ett_setdata_hvalue,
        &ett_modem_status,
        &ett_line_status,
        &ett_ftdi_fragment,
        &ett_ftdi_fragments,
    };

    request_info = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
    bitmode_info = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
    desegment_info = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());

    proto_ftdi_ft = proto_register_protocol("FTDI FT USB", "FTDI FT", "ftdi-ft");
    proto_register_field_array(proto_ftdi_ft, hf, array_length(hf));
    proto_register_subtree_array(ett, array_length(ett));
    ftdi_ft_handle = register_dissector("ftdi-ft", dissect_ftdi_ft, proto_ftdi_ft);

    expert_module = expert_register_protocol(proto_ftdi_ft);
    expert_register_field_array(expert_module, ei, array_length(ei));

    reassembly_table_register(&ftdi_reassembly_table, &ftdi_reassembly_table_functions);
}

void
proto_reg_handoff_ftdi_ft(void)
{
    /* TODO: Add configuration option to specify VID and PID.
     * The values below denote default VID/PID of FT converters (as of 2019)
     * The VID and PID can be changed by hardware vendor.
     */
    dissector_add_uint("usb.product", (0x0403 << 16) | 0x6001, ftdi_ft_handle);
    dissector_add_uint("usb.product", (0x0403 << 16) | 0x6010, ftdi_ft_handle);
    dissector_add_uint("usb.product", (0x0403 << 16) | 0x6011, ftdi_ft_handle);
    dissector_add_uint("usb.product", (0x0403 << 16) | 0x6014, ftdi_ft_handle);
    dissector_add_uint("usb.product", (0x0403 << 16) | 0x6015, ftdi_ft_handle);

    /* Devices that use FTDI FT converter with changed Vendor ID and/or Product ID */
    dissector_add_uint("usb.product", (0x0403 << 16) | 0xcff8, ftdi_ft_handle); /* Amontec JTAGkey */
    dissector_add_uint("usb.product", (0x15ba << 16) | 0x0003, ftdi_ft_handle); /* Olimex ARM-USB-OCD */
    dissector_add_uint("usb.product", (0x15ba << 16) | 0x0004, ftdi_ft_handle); /* Olimex ARM-USB-TINY */
    dissector_add_uint("usb.product", (0x15ba << 16) | 0x002a, ftdi_ft_handle); /* Olimex ARM-USB-TINY-H */
    dissector_add_uint("usb.product", (0x15ba << 16) | 0x002b, ftdi_ft_handle); /* Olimex ARM-USB-OCD-H */
    dissector_add_uint("usb.product", (0x1d50 << 16) | 0x607c, ftdi_ft_handle); /* OpenVizsla USB sniffer/analyzer */

    dissector_add_for_decode_as("usb.device", ftdi_ft_handle);

    ftdi_mpsse_handle = find_dissector_add_dependency("ftdi-mpsse", proto_ftdi_ft);
}

/*
 * 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:
 */