FT2232H and FT4232H

The fifth generation of fixed-function D2xx devices, an upgrade to FT2232D. There are two base devices:

• FT2232H: has two channels with 16 IO pins each and a large selection of operating modes
• FT4232H: has four channels with 8 IO pins each and a smaller selection of operating modes

Both of these devices are actually the same silicon, and are thus highly similar. Whether a device is FT2232H or FT4232H is determined by a fuse programmed at the factory. Note that the FT232H is not another variant of the same silicon, but a completely distinct device with different capabilities.

The devices have automotive variants, known as FT2232HA and FT4232HA. It is not known what their functional differences are, if any.

The devices also have USB-PD variants, which integrate a power delivery core into the same die. The D2xx function and the power delivery function are largely separate and operate independently, but they do share the same configuration EEPROM. The USB-PD variants are:

• FT2233HP and FT4233HP: two USB-PD ports
• FT2232HP and FT4232HP: one USB-PD port (actually identical to FTx233HP with the extra port unbonded)

All USB-PD variants are the same silicon (which is distinct from the "base" FT2232H silicon).

This document will use the name FT2232H to refer to FT2232HA/FT2232HP/FT2233HP as well, unless otherwise specified. The same applies for FT4232H.

Features:

• is a high-speed USB 2.0 peripherial
  • supports higher UART baud rates and bitbang/FIFO/MPSSE speeds thanks to the extra oomph
  • integrated D+ pullup resistor
• dual-channel (FT2232H) or quad-channel (FT4232H) D2xx device
• each channel can be independently configured to one of several supported modes:
  • FT232B-like UART mode (default)
  • FT245B-like FIFO mode (selected in EEPROM; FT2232H only)
  • new synchronous FIFO mode (dynamically selected variant of FIFO mode; FT2232H only)
    • available on channel A only
    • NOTE: channel B cannot be used while this mode is active, as it reuses channel B's buffer resources
  • FT2232D-like CPU FIFO mode (selected in EEPROM; FT2232H only)
  • FT2xxB-like async bitbang mode (dynamically selected)
  • FT2232C-like sync bitbang mode (dynamically selected)
  • FT2232C-like MPSSE mode (dynamically selected)
    • on FT2232H, supported on both channels (an improvement from FT2232C)
    • on FT4232H, supported on channels A and B only
  • FT2232C-like fast opto-isolated serial mode (selected in EEPROM; FT2232H only)
  • FT2232C-like MCU bus controller mode (dynamically selected; FT2232H only, uses both channels)
• FT2232H: 4kiB IN FIFO and 4kiB OUT FIFO for each channel
• FT4232H: 2kiB IN FIFO and 2kiB OUT FIFO for each channel
• 120MHz internal base clock, generated from 12MHz crystal
• internal 3.3V to 1.8V LDO
• 1.8V VCORE power supply for internal logic; can be connected to internal LDO
• 3.3V VCCIO power supply for business-end IO
• 3.3V VPHY power supply for USB PHY
• 3.3V separate AGND and VPLL power supply for PHY PLL
• internal power-on reset circuit
• required external support circuitry:
  • precision resistor for PHY current reference
  • VBUS to 3.3V LDO (or other 3.3V power source)
  • decoupling capacitor for internal LDO
  • 12MHz crystal
  • optionally, a 93LC46 (64×16-bit), 93LC56 (128×16-bit), or 93LC66 (256×16-bit) EEPROM

For USB-PD devices, the USB-PD function is described on the USB-PD page.

The full list of devices is:

Note: while FT2232HA is supported by the drivers, there is no datasheet available, thus packaging options are unknown. However, "same as FT4232HA" is probably a good bet.

Pinout — base and automotive devices

Pinout — USB-PD devices

Pin functions per mode — FT2232H

NOTE: The pin mapping is changed from FT2232C/D for many modes.

PWRSAV# is a device input that, if enabled in EEPROM, will force the device into suspend mode when low. It can be connected to VBUS/GND via a resistor ladder to force-suspend a self-powered device when not connected to USB.

Pin functions per mode — FT4232H

EEPROM data format

The device will accept 64-word, 128-word, and 256-word EEPROMs. In case of 256-word EEPROMs, only first half is covered by the checksum. The other half can still be used to store user data.

For USB-PD devices, a 256-word EEPROM is required for the USB-PD part of the device to function. The second half of the EEPROM is used to store the USB-PD configuration data, and it has its own, separate checksum. It is described on the USB-PD page.

• word 0x00 (FT2232H):
  • bits 0-2: channel A mode
    • 0: UART
    • 1: 245-style FIFO
    • 2: CPU FIFO
    • 4: fast opto-isolated serial
  • bit 3: channel A enable bind to VCP driver
  • bits 8-10: channel B mode (see above)
  • bit 11: channel B enable bind to VCP driver
  • bit 15: enable PWRSAV# function on BCBUS7
• word 0x00 (FT4232H):
  • bit 3: channel A enable bind to VCP driver
  • bit 7: channel C enable bind to VCP driver
  • bit 11: channel B enable bind to VCP driver
  • bit 15: channel D enable bind to VCP driver
• word 0x01: idVendor (USB VID)
• word 0x02: idProduct (USB PID)
• word 0x03: bcdDevice (see table)
• word 0x04: USB config (goes straight to configuration descriptor)
  • bits 0-7: bmAttributes
    • bit 5: remote wakeup enabled
    • bit 6: self-powered
    • bit 7: always set to 1
  • bits 8-15: bMaxPower (max power in units of 2mA)
• word 0x05: device control
  • bit 2: IO pulldown in suspend
  • bit 3: serial number enabled
  • bit 12 (FT4232H only): ADBUS7 function in UART mode
    • 0: RI
    • 1: TXDEN
  • bit 13 (FT4232H only): BDBUS7 function in UART mode
  • bit 14 (FT4232H only): CDBUS7 function in UART mode
  • bit 15 (FT4232H only): DDBUS7 function in UART mode
• word 0x06: controls electrical characteristics of channel IO pins; the IO-* names match the pin categories in the pinout table above. on FT4232H, they correspond directly to channels, while on FT2232H, CBUS and DBUS of each channel can be controlled independently
  • bits 0-1: IO-A pin drive strength
    • 0: 4mA
    • 1: 8mA
    • 2: 12mA
    • 3: 16mA
  • bit 2: IO-A pin slow slew rate
  • bit 3: IO-A pin schmitt trigger
  • bits 4-5: IO-B drive strength
  • bit 6: IO-B slow slew rate
  • bit 7: IO-B schmitt trigger
  • bits 8-9: IO-C drive strength
  • bit 10: IO-C slow slew rate
  • bit 11: IO-C schmitt trigger
  • bits 12-13: IO-D drive strength
  • bit 14: IO-D slow slew rate
  • bit 15: IO-D schmitt trigger
• word 0x07: manufacturer string pointer
• word 0x08: product description string pointer
• word 0x09: serial number string pointer
• word 0x0a: always 0
• word 0x0b:
  • bits 3-4: TPRDRV (an obscure undocumented trim parameter for the USB HS PHY)
• word 0x0c: EEPROM type
  • 0x46: 93LC46 (64-word)
  • 0x56: 93LC56 (128-word)
  • 0x66: 93LC66 (256-word)
• for 64-word EEPROM:
  • words 0x0d..0x3f: string / user area
  • word 0x3f: checksum
• for 128-word and 256-word EEPROM:
  • words 0xd..0x4d: user area
    • word 0x2b: for some reason, set to 0x302 by default (concidentally or not, this corresponds to a header of an empty string descriptor)
  • words 0x4d..0x7f: string / user area
  • word 0x7f: checksum

String pointers are formatted as follows:

• for 64-word EEPROM:
  • bits 0-6: pointer to descriptor within EEPROM (counted in bytes)
  • bit 7: always set to 1
• for 128-word or 256-word EEPROM:
  • bits 0-7: pointer to descriptor within EEPROM (counted in bytes); note that FTDI tools will only store string descriptors in the area starting at word 0x4d, ensuring the high bit is always set
• bits 8-15: total length of descriptor in bytes

TODO: figure out wtf it is with the always-set high bit

The string descriptors are stored in ROM with the descriptor header included, as follows:

• word 0: header
  • bits 0-7: total length of descriptor in bytes (includes header)
  • bits 8-15: descriptor type (always 3 — string)
• words 1 and up: string in UTF-16

The checksum can be computed as follows:

#![allow(unused)]
fn main() {
fn checksum(eeprom: &[u16]) -> u16 {
    let checksum_word = match eeprom.len() {
        0x40 => 0x3f,
        0x80 | 0x100 => 0x7f,
    };
    let mut res: u16 = 0xaaaa;
    for pos in 0..checksum_word { // checksum word is NOT included — we're calculating it
        res ^= eeprom[pos];
        res = res.rotate_left(1);
    }
    res
}
}