diff --git a/ft4222_spi.c b/ft4222_spi.c
new file mode 100644
index 0000000..46fa698
--- /dev/null
+++ b/ft4222_spi.c
@@ -0,0 +1,824 @@
+/*
+ * This file is part of the flashrom project.
+ *
+ * Copyright (C) 2024 Nico Huber <nico.h@gmx.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <libusb.h>
+
+#include "platform.h"
+#include "programmer.h"
+#include "flash.h"
+#include "spi_command.h"
+#include "spi.h"
+
+#define FT4222_RESET_REQUEST		0x00
+#define  FT4222_RESET_SIO		0x0000
+#define  FT4222_OUTPUT_FLUSH		0x0001
+#define  FT4222_INPUT_FLUSH		0x0002
+
+#define FT4222_INFO_REQUEST		0x20
+#define  FT4222_GET_VERSION		0x00
+#define  FT4222_GET_CONFIG		0x01
+
+#define FT4222_CONFIG_REQUEST		0x21
+#define  FT4222_SET_CLOCK		0x04
+#define  FT4222_SET_MODE		0x05
+#define   FT4222_I2C_MASTER		1
+#define   FT4222_I2C_SLAVE		2
+#define   FT4222_SPI_MASTER		3
+#define   FT4222_SPI_SLAVE		4
+#define  FT4222_SPI_SET_IO_LINES	0x42
+#define  FT4222_SPI_SET_CS_ACTIVE	0x43
+#define   FT4222_SPI_CS_ACTIVE_LOW	0
+#define   FT4222_SPI_CS_ACTIVE_HIGH	1
+#define  FT4222_SPI_SET_CLK_DIV		0x44
+#define  FT4222_SPI_SET_CLK_IDLE	0x45
+#define   FT4222_CLK_IDLE_LOW		0
+#define   FT4222_CLK_IDLE_HIGH		1
+#define  FT4222_SPI_SET_CAPTURE		0x46
+#define   FT4222_LEADING_CLK		0
+#define   FT4222_TRAILING_CLK		1
+#define  FT4222_SPI_SET_CS_MASK		0x48
+#define   FT4222_SPI_CS_MASK(cs)	(1 << (cs))
+#define  FT4222_SPI_RESET_TRANSACTION	0x49
+#define  FT4222_SPI_RESET		0x4a
+#define   FT4222_RESET_FULL		0
+#define   FT4222_RESET_LINE_NUM		1
+
+#define READ_BUFFER_SIZE		2048	/* Any power-of-2 >= 512 seems to work. */
+#define READ_MAX_XFERS			4	/* Should be >1 to avoid starvation. */
+
+#define USB_TIMEOUT			2000	/* In milliseconds. */
+
+#define FTDI_VID			0x0403
+#define FTDI_FT4222H_PID		0x601c
+
+static const struct dev_entry devs[] = {
+	{FTDI_VID, FTDI_FT4222H_PID, OK, "FTDI", "FT4222H"},
+	{0},
+};
+
+struct ft4222_clock {
+	unsigned short sys_idx;
+	unsigned short div_log2;
+};
+
+struct ft4222_write_info {
+	bool success;
+	bool done;
+};
+
+struct ft4222_read_info {
+	unsigned char xfer_buf[READ_MAX_XFERS * READ_BUFFER_SIZE];
+	unsigned char *target_buf;
+	unsigned int active;
+	size_t total;
+	size_t skip;
+	size_t done;
+};
+
+struct ft4222 {
+	struct libusb_context *usb_context;
+	struct libusb_device_handle *usb_handle;
+	struct ft4222_write_info write_info;
+	struct ft4222_write_info dummy_write_info;
+	struct ft4222_write_info deassert_cs_info;
+	struct ft4222_read_info read_info;
+	unsigned char control_index;
+	unsigned char in_ep, out_ep;
+	unsigned char io_lines;
+};
+
+static struct ft4222_clock ft4222_find_spi_clock(const struct ft4222 *ft4222, const unsigned int target_khz)
+{
+	const unsigned int sys_clks[] = { 60000, 24000, 48000, 80000 };
+	struct ft4222_clock found = { .sys_idx = 1, .div_log2 = 9 };
+	unsigned int found_khz = sys_clks[found.sys_idx] / (1 << found.div_log2);
+	unsigned int sys, div;
+
+	if (target_khz < found_khz) {
+		msg_pwarn("No compatible clock found, using minimum of %ukHz.\n", found_khz);
+		return found;
+	}
+
+	/* look for the highest clock below given target */
+	for (sys = 0; sys < ARRAY_SIZE(sys_clks); ++sys) {
+		for (div = 9; div > 0; --div) {
+			const unsigned int this_khz = sys_clks[sys] / (1 << div);
+			if (this_khz > target_khz)
+				break;
+			if (this_khz < found_khz) /* accept equal khz for higher sys clk */
+				continue;
+
+			found_khz = this_khz;
+			found.sys_idx = sys;
+			found.div_log2 = div;
+		}
+	}
+
+	msg_pinfo("Using %ukHz SPI clock.\n", found_khz);
+	return found;
+}
+
+static int receive_control(const struct ft4222 *ft4222, unsigned char *data, size_t len,
+			   uint8_t request, uint16_t value, uint16_t index)
+{
+	return libusb_control_transfer(
+		ft4222->usb_handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR,
+		request, value, index, data, len, USB_TIMEOUT);
+}
+
+static int ft4222_get_version(const struct ft4222 *ft4222, uint32_t *chip_version,
+			      uint32_t *version2, uint32_t *version3)
+{
+	unsigned char buf[12];
+
+	int ret = receive_control(ft4222, buf, sizeof(buf), FT4222_INFO_REQUEST,
+				  FT4222_GET_VERSION, ft4222->control_index);
+	if (ret < 0) {
+		msg_perr("Failed to query version: %s (%d)\n", libusb_strerror(ret), ret);
+		return SPI_PROGRAMMER_ERROR;
+	}
+
+	if (chip_version)
+		*chip_version = read_be32(buf, 0);
+	if (version2)
+		*version2 = read_be32(buf, 4);
+	if (version3)
+		*version3 = read_be32(buf, 8);
+
+	return 0;
+}
+
+static int ft4222_get_num_channels(const struct ft4222 *ft4222, unsigned int *channels)
+{
+	unsigned char buf[13];
+
+	int ret = receive_control(ft4222, buf, sizeof(buf), FT4222_INFO_REQUEST,
+				  FT4222_GET_CONFIG, ft4222->control_index);
+	if (ret < 0) {
+		msg_perr("Failed to query config: %s (%d)\n", libusb_strerror(ret), ret);
+		return SPI_PROGRAMMER_ERROR;
+	}
+
+	switch (buf[0]) {
+		case 0: *channels = 1; return 0;
+		case 1: *channels = 3; return 0;
+		case 2: *channels = 4; return 0;
+		case 3: *channels = 1; return 0;
+	}
+
+	msg_perr("Failed to determine number of channels. Mode byte: 0x%02x\n", buf[0]);
+	return SPI_PROGRAMMER_ERROR;
+}
+
+static int send_control(const struct ft4222 *ft4222,
+			uint8_t request, uint16_t value, uint16_t index)
+{
+	return libusb_control_transfer(
+		ft4222->usb_handle, LIBUSB_REQUEST_TYPE_VENDOR,
+		request, value, index, NULL, 0, USB_TIMEOUT);
+}
+
+static void ft4222_flush(const struct ft4222 *ft4222, const uint16_t index)
+{
+	int i, ret;
+
+	for (i = 0; i < 6; ++i) {
+		ret = send_control(ft4222, 0, FT4222_OUTPUT_FLUSH, index);
+		if (ret < 0) {
+			msg_pwarn("FT4222 output flush failed: %s (%d)\n",
+				  libusb_strerror(ret), ret);
+			break;
+		}
+	}
+
+	ret = send_control(ft4222, 0, FT4222_INPUT_FLUSH, index);
+	if (ret < 0)
+		msg_pwarn("FT4222 input flush failed: %s (%d)\n", libusb_strerror(ret), ret);
+}
+
+static void ft4222_reset(const struct ft4222 *ft4222)
+{
+	const int ret = send_control(ft4222, 0, FT4222_RESET_SIO, 0);
+	if (ret < 0)
+		msg_pwarn("FT4222 device reset failed: %s (%d)\n", libusb_strerror(ret), ret);
+
+	ft4222_flush(ft4222, ft4222->control_index);
+}
+
+static int ft4222_config_request(const struct ft4222 *ft4222, uint8_t cmd, uint8_t data)
+{
+	const int ret = send_control(ft4222, FT4222_CONFIG_REQUEST,
+				     (data << 8) | cmd, ft4222->control_index);
+	if (ret < 0) {
+		msg_perr("FT4222 config command 0x%02x failed: %s (%d)\n",
+			 cmd, libusb_strerror(ret), ret);
+		return SPI_PROGRAMMER_ERROR;
+	}
+
+	return 0;
+}
+
+static int ft4222_set_sys_clock(const struct ft4222 *ft4222, struct ft4222_clock clock)
+{
+	return ft4222_config_request(ft4222, FT4222_SET_CLOCK, clock.sys_idx);
+}
+
+static int ft4222_spi_set_io_lines(struct ft4222 *ft4222, const unsigned int lines)
+{
+	assert(lines == 1 || lines == 2 || lines == 4);
+
+	if (ft4222->io_lines == lines)
+		return 0;
+
+	int ret = ft4222_config_request(ft4222, FT4222_SPI_SET_IO_LINES, lines);
+	if (ret)
+		return ret;
+
+	ret = ft4222_config_request(ft4222, FT4222_SPI_RESET, FT4222_RESET_LINE_NUM);
+	if (!ret)
+		ft4222->io_lines = lines;
+
+	return ret;
+}
+
+static int ft4222_configure_spi_master(struct ft4222 *ft4222, struct ft4222_clock clock, unsigned int cs)
+{
+	assert(cs < 4);
+
+	/* LibFT4222 always does this for spiIdx 0. Assuming that's the
+	   interface channel tied to a CS pin, and given that I couldn't
+	   figure out how to make it use other channels, let's do this for
+	   the channel we are going to use: */
+	if (ft4222_config_request(ft4222, FT4222_SPI_RESET_TRANSACTION, /* idx => */cs))
+		return SPI_PROGRAMMER_ERROR;
+
+	if (ft4222_spi_set_io_lines(ft4222, 1) ||
+	    ft4222_config_request(ft4222, FT4222_SPI_SET_CLK_DIV, clock.div_log2) ||
+	    ft4222_config_request(ft4222, FT4222_SPI_SET_CLK_IDLE, FT4222_CLK_IDLE_LOW) ||
+	    ft4222_config_request(ft4222, FT4222_SPI_SET_CAPTURE, FT4222_LEADING_CLK) ||
+	    ft4222_config_request(ft4222, FT4222_SPI_SET_CS_ACTIVE, FT4222_SPI_CS_ACTIVE_LOW) ||
+	    ft4222_config_request(ft4222, FT4222_SPI_SET_CS_MASK, FT4222_SPI_CS_MASK(cs)) ||
+	    ft4222_config_request(ft4222, FT4222_SET_MODE, FT4222_SPI_MASTER))
+		return SPI_PROGRAMMER_ERROR;
+
+	return 0;
+}
+
+static void ft4222_async_write_callback(struct libusb_transfer *transfer)
+{
+	struct ft4222_write_info *const async_info = transfer->user_data;
+
+	async_info->success = transfer->status == LIBUSB_TRANSFER_COMPLETED;
+	async_info->done = true;
+}
+
+static int ft4222_async_write(const struct ft4222 *const ft4222,
+			      struct ft4222_write_info *const async_info,
+			      const unsigned char *const buf, const size_t len)
+{
+	unsigned char *const out_buf = buf ? (unsigned char *)buf : malloc(len);
+	struct libusb_transfer *const transfer = libusb_alloc_transfer(0);
+
+	if (!out_buf || !transfer) {
+		msg_perr("Out of memory!\n");
+		goto err_ret;
+	}
+
+	if (out_buf != buf)
+		memset(out_buf, 0xff, len);
+	async_info->done = false;
+
+	libusb_fill_bulk_transfer(
+			transfer, ft4222->usb_handle, ft4222->out_ep,
+			out_buf, len, ft4222_async_write_callback, async_info, 16*USB_TIMEOUT);
+	transfer->flags |= LIBUSB_TRANSFER_SHORT_NOT_OK | LIBUSB_TRANSFER_FREE_TRANSFER;
+	if (out_buf != buf)
+		transfer->flags |= LIBUSB_TRANSFER_FREE_BUFFER;
+
+	const int ret = libusb_submit_transfer(transfer);
+	if (ret != LIBUSB_SUCCESS) {
+		msg_perr("Failed to queue %zuB transfer: %s (%d)\n",
+			 len, libusb_strerror(ret), ret);
+		goto err_ret;
+	}
+
+	return 0;
+
+err_ret:
+	libusb_free_transfer(transfer);
+	if (out_buf != buf)
+		free(out_buf);
+
+	return SPI_GENERIC_ERROR;
+}
+
+static unsigned int ft4222_num_async_reads(const struct ft4222_read_info *info)
+{
+	return MIN(READ_MAX_XFERS,
+		(info->total - info->done + READ_BUFFER_SIZE - 1) / READ_BUFFER_SIZE);
+}
+
+static void ft4222_async_read_callback(struct libusb_transfer *const transfer)
+{
+	struct ft4222_read_info *const info = transfer->user_data;
+	bool warned_status = false;
+
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
+		msg_perr("Read failure: %s (%d)\n",
+			 libusb_strerror(transfer->status), transfer->status);
+		goto free_transfer;
+	}
+
+	/* A transfer contains multiple packages of up to 512B. Each one
+	   starts with a 2B status (libftdi calls it modem status). */
+	size_t actual_len = transfer->actual_length;
+	const unsigned char *packet = transfer->buffer;
+	while (actual_len > 0) {
+		const size_t packet_len = MIN(actual_len, 512);
+		msg_pspew("%s: packet of %zu bytes\n", __func__, packet_len);
+
+		if (packet_len < 2) {
+			msg_perr("Read failure: Broken packet\n");
+			goto free_transfer;
+		}
+
+		/* So far we always received the same status bytes.
+		   Libftdi ignores them, so only warn if we get some-
+		   thing different. */
+		if (!warned_status && (packet[0] != 0x02 || packet[1] != 0x00)) {
+			msg_pwarn("Unknown status code %02x %02x\n", packet[0], packet[1]);
+			warned_status = true;
+		}
+
+		if (packet_len == 2) {
+			msg_pdbg2("%s: Empty packet (%u active transfers)\n", __func__, info->active);
+			break;
+		}
+
+		const size_t done_here = MIN(packet_len - 2, info->total - info->done);
+		if (info->done + done_here > info->skip) {
+			size_t buffer_off, packet_off;
+			if (info->done < info->skip) {
+				buffer_off = 0;
+				packet_off = info->skip - info->done;
+			} else {
+				buffer_off = info->done - info->skip;
+				packet_off = 0;
+			}
+			const size_t copy = MIN(done_here - packet_off,
+						info->total - info->skip - buffer_off);
+			memcpy(info->target_buf + buffer_off, packet + 2 + packet_off, copy);
+		}
+		info->done += done_here;
+		msg_pspew("%s: Processed %zuB\n", __func__, done_here);
+
+		actual_len -= packet_len;
+		packet += packet_len;
+	}
+
+	if (info->active <= ft4222_num_async_reads(info)) {
+		const int ret = libusb_submit_transfer(transfer);
+		if (ret != LIBUSB_SUCCESS)
+			msg_perr("Failed to re-queue %dB transfer: %s (%d)\n",
+				 transfer->length, libusb_strerror(ret), ret);
+		else	/* do not free re-submitted transfer */
+			return;
+	}
+
+free_transfer:
+	libusb_free_transfer(transfer);
+	--info->active;
+}
+
+static int ft4222_async_read(const struct ft4222 *const ft4222,
+			     struct ft4222_read_info *const info,
+			     unsigned char *const dst, const size_t len, const size_t skip)
+{
+	info->target_buf = dst;
+	info->active = 0;
+	info->total = len + skip;
+	info->skip = skip;
+	info->done = 0;
+
+	unsigned int i;
+	for (i = 0; i < ft4222_num_async_reads(info); ++i) {
+		struct libusb_transfer *const transfer = libusb_alloc_transfer(0);
+		if (!transfer) {
+			msg_perr("Out of memory!\n");
+			return SPI_GENERIC_ERROR;
+		}
+
+		unsigned char *const buf = info->xfer_buf + i * READ_BUFFER_SIZE;
+		libusb_fill_bulk_transfer(
+			transfer, ft4222->usb_handle, ft4222->in_ep,
+			buf, READ_BUFFER_SIZE, ft4222_async_read_callback,
+			info, USB_TIMEOUT);
+
+		const int ret = libusb_submit_transfer(transfer);
+		if (ret != LIBUSB_SUCCESS) {
+			msg_perr("Failed to queue %dB transfer: %s (%d)\n",
+				 transfer->length, libusb_strerror(ret), ret);
+			libusb_free_transfer(transfer);
+			return SPI_GENERIC_ERROR;
+		}
+		++info->active;
+	}
+
+	return 0;
+}
+
+static void ft4222_async_init(struct ft4222 *ft4222)
+{
+	/* initialize such that ft4222_async_done() thinks we're done */
+	const struct ft4222_write_info success = { .success = true, .done = true };
+	ft4222->write_info = success;
+	ft4222->dummy_write_info = success;
+	ft4222->deassert_cs_info = success;
+	ft4222->read_info.active = ft4222->read_info.total = ft4222->read_info.done = 0;
+}
+
+static bool ft4222_async_done(const struct ft4222 *ft4222)
+{
+	return ft4222->write_info.done &&
+		ft4222->dummy_write_info.done &&
+		ft4222->deassert_cs_info.done &&
+		ft4222->read_info.active == 0;
+}
+
+static int ft4222_async_poll(const struct ft4222 *ft4222)
+{
+	while (!ft4222_async_done(ft4222)) {
+		struct timeval timeout = { 10, 0 };
+		const int ret = libusb_handle_events_timeout(ft4222->usb_context, &timeout);
+		if (ret != LIBUSB_SUCCESS) {
+			msg_perr("Polling transfers failed: %s!\n", libusb_error_name(ret));
+			return SPI_GENERIC_ERROR;
+		}
+	}
+
+	if (!ft4222->write_info.success ||
+	    !ft4222->dummy_write_info.success ||
+	    !ft4222->deassert_cs_info.success ||
+	    ft4222->read_info.done < ft4222->read_info.total)
+		return SPI_GENERIC_ERROR;
+
+	return 0;
+}
+
+static int ft4222_spi_send_command(
+		const struct flashctx *const flash,
+		const unsigned int writecnt, const unsigned int readcnt,
+		const unsigned char *const writearr, unsigned char *const readarr)
+{
+	struct ft4222 *const ft4222 = flash->mst.spi->data;
+	int ret, poll_ret;
+
+	ret = ft4222_spi_set_io_lines(ft4222, 1);
+	if (ret)
+		return ret;
+
+	/*
+	 * Single-i/o mode is full-duplex. So we send
+	 *   o `writecnt` real bytes,
+	 *   o `readcnt` dummy bytes, and
+	 *   o an empty packet to deassert CS.
+	 * Then we read but discard
+	 *   o `writecnt` dummy bytes, and read
+	 *   o `readcnt` real bytes.
+	 */
+
+	ft4222_async_init(ft4222);
+
+	ret = ft4222_async_write(ft4222, &ft4222->write_info, writearr, writecnt);
+	if (ret)
+		goto poll;
+
+	ret = ft4222_async_write(ft4222, &ft4222->dummy_write_info, NULL, readcnt);
+	if (ret)
+		goto poll;
+
+	ret = ft4222_async_write(ft4222, &ft4222->deassert_cs_info, NULL, 0);
+	if (ret)
+		goto poll;
+
+	ret = ft4222_async_read(ft4222, &ft4222->read_info, readarr,
+			        /* len => */readcnt, /* skip => */writecnt);
+
+poll:	/* we should always poll, in case we partially started transfers */
+	poll_ret = ft4222_async_poll(ft4222);
+	return ret ? ret : poll_ret;
+}
+
+static int ft4222_spi_send_multi_io(struct ft4222 *ft4222, const struct spi_command *cmd)
+{
+	const size_t read_total = cmd->high_z_len + cmd->read_len;
+	size_t write_single = 0, write_multi = 0;
+	unsigned int io_lines = 4;
+	int ret, poll_ret;
+
+	switch (cmd->io_mode) {
+	case DUAL_OUT_1_1_2:
+		io_lines = 2;
+		/* fall-through */
+	case QUAD_OUT_1_1_4:
+		write_single = cmd->opcode_len + cmd->address_len + cmd->write_len;
+		break;
+
+	case DUAL_IO_1_2_2:
+		io_lines = 2;
+		/* fall-through */
+	case QUAD_IO_1_4_4:
+		write_single = cmd->opcode_len;
+		write_multi = cmd->address_len + cmd->write_len;
+		break;
+
+	case QPI_4_4_4:
+		write_multi = cmd->opcode_len + cmd->address_len + cmd->write_len;
+		break;
+
+	default:
+		return SPI_FLASHPROG_BUG;
+	}
+
+	ret = ft4222_spi_set_io_lines(ft4222, io_lines);
+	if (ret)
+		return ret;
+
+	/*
+	 * Multi-i/o mode is half-duplex. We can send up to 15B ahead
+	 * as single-i/o. Then write and read up to 65535 bytes each
+	 * as multi-i/o. Looks suspiciously tailored to our use case. :)
+	 *
+	 * The lengths are controlled by a 5B header:
+	 * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+	 * | 4 bit |          4 bit |       2B big-endian |      2B big-endian |
+	 * +-------+----------------+---------------------+--------------------+
+	 * |  0x8  | single-i/o len | multi-i/o write len | multi-i/o read len |
+	 * +-------+----------------+---------------------+--------------------+
+	 */
+
+	if (write_single > 15 || write_multi > UINT16_MAX || read_total > UINT16_MAX)
+		return SPI_INVALID_LENGTH;
+
+	unsigned char *const write_buf = malloc(5 + write_single + write_multi);
+	if (!write_buf)
+		return SPI_GENERIC_ERROR;
+
+	write_buf[0] = 0x80 | write_single;
+	write_buf[1] = write_multi >> 8 & 0xff;
+	write_buf[2] = write_multi >> 0 & 0xff;
+	write_buf[3] = read_total  >> 8 & 0xff;
+	write_buf[4] = read_total  >> 0 & 0xff;
+	memcpy(write_buf + 5, cmd->writearr, write_single + write_multi);
+
+	ft4222_async_init(ft4222);
+
+	ret = ft4222_async_write(ft4222, &ft4222->write_info, write_buf, 5 + write_single + write_multi);
+	if (ret)
+		goto poll;
+
+	ret = ft4222_async_read(ft4222, &ft4222->read_info, cmd->readarr,
+				/* len => */cmd->read_len, /* skip => */cmd->high_z_len);
+
+poll:	/* we should always poll, in case we partially started transfers */
+	poll_ret = ft4222_async_poll(ft4222);
+
+	free(write_buf);
+
+	return ret ? ret : poll_ret;
+}
+
+static int ft4222_spi_send_multicommand(const struct flashctx *flash, struct spi_command *cmds)
+{
+	struct ft4222 *const ft4222 = flash->mst.spi->data;
+
+	for (; !spi_is_empty(cmds); ++cmds) {
+		int ret;
+		if (cmds->io_mode == SINGLE_IO_1_1_1) {
+			ret = ft4222_spi_send_command(flash, spi_write_len(cmds),
+					spi_read_len(cmds), cmds->writearr, cmds->readarr);
+		} else {
+			ret = ft4222_spi_send_multi_io(ft4222, cmds);
+		}
+		if (ret)
+			return ret;
+	}
+
+	return 0;
+}
+
+static int ft4222_shutdown(void *data)
+{
+	struct ft4222 *const ft4222 = data;
+	libusb_close(ft4222->usb_handle);
+	libusb_exit(ft4222->usb_context);
+	free(data);
+	return 0;
+}
+
+static const struct spi_master spi_master_ft4222 = {
+	.features	= SPI_MASTER_4BA | SPI_MASTER_DUAL,
+	.max_data_read	= 65530,
+	.max_data_write	= MAX_DATA_WRITE_UNLIMITED,
+	.command	= ft4222_spi_send_command,
+	.multicommand	= ft4222_spi_send_multicommand,
+	.read		= default_spi_read,
+	.write_256	= default_spi_write_256,
+	.shutdown	= ft4222_shutdown,
+	.probe_opcode	= default_spi_probe_opcode,
+};
+
+/* Returns 0 upon success, a negative number upon errors. */
+static int ft4222_spi_init(struct flashprog_programmer *const prog)
+{
+	struct spi_master master = spi_master_ft4222;
+	uint32_t chip_version, version2, version3;
+	unsigned long speed_khz = 10*1000;
+	unsigned long cs = 0;
+	unsigned int num_cs, i;
+	char *endp;
+
+	char *const cs_arg = extract_programmer_param("cs");
+	if (cs_arg) {
+		cs = strtoul(cs_arg, &endp, 10);
+		if (cs_arg == endp || cs > 3) {
+			msg_perr("Invalid cs setting: %s\n", cs_arg);
+			free(cs_arg);
+			return SPI_GENERIC_ERROR;
+		}
+	}
+	msg_pdbg("Using CS#%lu.\n", cs);
+	free(cs_arg);
+
+	char *const spispeed = extract_programmer_param("spispeed");
+	if (spispeed) {
+		speed_khz = strtoul(spispeed, &endp, 10);
+		if (spispeed == endp || speed_khz == 0 || speed_khz > UINT_MAX) {
+			msg_perr("Invalid spispeed setting: %s kHz\n", spispeed);
+			free(spispeed);
+			return SPI_GENERIC_ERROR;
+		}
+	} else {
+		msg_pinfo("Using default %lukHz clock. Use 'spispeed' parameter to override.\n",
+			  speed_khz);
+	}
+	free(spispeed);
+
+	char *const io_mode = extract_programmer_param("iomode");
+	if (io_mode) {
+		if (strcmp(io_mode, "single") == 0) {
+			master.features &= ~SPI_MASTER_DUAL;
+		} else if (strcmp(io_mode, "dual") == 0) {
+			/* dual-i/o mode is enabled by default */
+		} else if (strcmp(io_mode, "quad") == 0) {
+			master.features |= SPI_MASTER_QUAD | SPI_MASTER_QPI;
+		} else {
+			msg_perr("Invalid iomode setting: %s\n", io_mode);
+			return SPI_GENERIC_ERROR;
+		}
+	}
+	free(io_mode);
+
+	struct ft4222 *const ft4222 = calloc(1, sizeof(*ft4222));
+	if (!ft4222) {
+		msg_perr("Could not allocate space for FT4222 context\n");
+		return SPI_GENERIC_ERROR;
+	}
+
+	int ret = libusb_init(&ft4222->usb_context);
+	if (ret != LIBUSB_SUCCESS) {
+		msg_perr("Could not initialize libusb: %s\n", libusb_error_name(ret));
+		free(ft4222);
+		return SPI_GENERIC_ERROR;
+	}
+
+	/* Enable information, warning, and error messages (only). */
+	libusb_set_option(NULL, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_INFO);
+
+	const uint16_t vid = devs[0].vendor_id;
+	const uint16_t pid = devs[0].device_id;
+	ft4222->usb_handle = libusb_open_device_with_vid_pid(ft4222->usb_context, vid, pid);
+	if (ft4222->usb_handle == NULL) {
+		msg_perr("Couldn't open device %04x:%04x.\n", vid, pid);
+		libusb_exit(ft4222->usb_context);
+		free(ft4222);
+		return SPI_GENERIC_ERROR;
+	}
+
+	struct libusb_config_descriptor *config;
+	ret = libusb_get_active_config_descriptor(libusb_get_device(ft4222->usb_handle), &config);
+	if (ret != LIBUSB_SUCCESS) {
+		msg_perr("Couldn't get config descriptor: %s (%d)\n", libusb_strerror(ret), ret);
+		ret = SPI_GENERIC_ERROR;
+		goto shutdown;
+	}
+
+	if (config->bNumInterfaces > 1) {
+		/* LibFT4222 does this. So far it's
+		   not known to make a difference. */
+		ft4222->control_index = 1;
+	}
+
+	ret = ft4222_get_version(ft4222, &chip_version, &version2, &version3);
+	if (ret)
+		goto free_config_shutdown;
+	msg_pinfo("Found %s, chip version %08x (%08x %08x)\n",
+		  devs[0].device_name, chip_version, version2, version3);
+
+	ret = ft4222_get_num_channels(ft4222, &num_cs);
+	if (ret)
+		goto free_config_shutdown;
+	if (cs >= num_cs) {
+		msg_perr("Invalid cs setting: %lu, maximum is %u.\n", cs, num_cs - 1);
+		ret = SPI_GENERIC_ERROR;
+		goto free_config_shutdown;
+	}
+
+	if (cs >= config->bNumInterfaces) {
+		msg_perr("Error: Device supports less interfaces than expected.\n");
+		ret = SPI_GENERIC_ERROR;
+		goto free_config_shutdown;
+	}
+
+	ret = libusb_claim_interface(ft4222->usb_handle, cs);
+	if (ret != LIBUSB_SUCCESS) {
+		msg_perr("Couldn't claim interface %lu: %s (%d)\n", cs, libusb_strerror(ret), ret);
+		ret = SPI_GENERIC_ERROR;
+		goto free_config_shutdown;
+	}
+
+	const struct libusb_interface_descriptor *const interface =
+					config->interface[cs].altsetting;
+
+	/* Try first alternate setting if there are more than one. */
+	if (config->interface[cs].num_altsetting > 1) {
+		ret = libusb_set_interface_alt_setting(
+				ft4222->usb_handle, cs, interface->bAlternateSetting);
+		if (ret != LIBUSB_SUCCESS) {
+			msg_perr("Failed to select alternate interface: %s (%d)\n",
+				 libusb_strerror(ret), ret);
+			ret = SPI_GENERIC_ERROR;
+			goto free_config_shutdown;
+		}
+	}
+
+	for (i = 0; i < interface->bNumEndpoints; ++i) {
+		if (interface->endpoint[i].bEndpointAddress & LIBUSB_ENDPOINT_IN)
+			ft4222->in_ep = interface->endpoint[i].bEndpointAddress;
+		else
+			ft4222->out_ep = interface->endpoint[i].bEndpointAddress;
+		if (ft4222->in_ep && ft4222->out_ep)
+			break;
+	}
+	if (!ft4222->in_ep || !ft4222->out_ep) {
+		msg_perr("Error: Couldn't find compatible endpoints.\n");
+		ret = SPI_GENERIC_ERROR;
+		goto free_config_shutdown;
+	}
+
+	libusb_free_config_descriptor(config);
+
+	ft4222_reset(ft4222);
+
+	const struct ft4222_clock clock = ft4222_find_spi_clock(ft4222, speed_khz);
+	ret = ft4222_set_sys_clock(ft4222, clock);
+	if (ret)
+		goto shutdown;
+
+	ret = ft4222_configure_spi_master(ft4222, clock, cs);
+	if (ret)
+		goto shutdown;
+
+	return register_spi_master(&master, 0, ft4222);
+
+free_config_shutdown:
+	libusb_free_config_descriptor(config);
+shutdown:
+	ft4222_shutdown(ft4222);
+	return ret;
+}
+
+const struct programmer_entry programmer_ft4222_spi = {
+	.name			= "ft4222_spi",
+	.type			= USB,
+	.devs.dev		= devs,
+	.init			= ft4222_spi_init,
+};