path: root/src/flash/nor/stmqspi.c

/***************************************************************************
 *   Copyright (C) 2016 - 2019 by Andreas Bolsch                           *
 *   andreas.bolsch@mni.thm.de                                             *
 *                                                                         *
 *   Copyright (C) 2010 by Antonio Borneo                                  *
 *   borneo.antonio@gmail.com                                              *
 *                                                                         *
 *   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.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
 ***************************************************************************/

/* STM QuadSPI (QSPI) and OctoSPI (OCTOSPI) controller are SPI bus controllers
 * specifically designed for SPI memories.
 * Two working modes are available:
 * - indirect mode: the SPI is controlled by SW. Any custom commands can be sent
 *   on the bus.
 * - memory mapped mode: the SPI is under QSPI/OCTOSPI control. Memory content
 *   is directly accessible in CPU memory space. CPU can read and execute from
 *   memory (but not write to) */

/* ATTENTION:
 * To have flash mapped in CPU memory space, the QSPI/OCTOSPI controller
 * has to be in "memory mapped mode". This requires following constraints:
 * 1) The command "reset init" has to initialize QSPI/OCTOSPI controller and put
 *    it in memory mapped mode;
 * 2) every command in this file has to return to prompt in memory mapped mode. */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "imp.h"
#include <helper/bits.h>
#include <helper/time_support.h>
#include <target/algorithm.h>
#include <target/armv7m.h>
#include <target/image.h>
#include "stmqspi.h"
#include "sfdp.h"

/* deprecated */
#undef SPIFLASH_READ
#undef SPIFLASH_PAGE_PROGRAM

/* saved mode settings */
#define QSPI_MODE (stmqspi_info->saved_ccr & \
	(0xF0000000U | QSPI_DCYC_MASK | QSPI_4LINE_MODE | QSPI_ALTB_MODE | QSPI_ADDR4))

/* saved read mode settings but indirect read instead of memory mapped
 * in particular, use the dummy cycle setting from this saved setting */
#define	QSPI_CCR_READ (QSPI_READ_MODE | (stmqspi_info->saved_ccr & \
	(0xF0000000U | QSPI_DCYC_MASK | QSPI_4LINE_MODE | QSPI_ALTB_MODE | QSPI_ADDR4 | 0xFF)))

/* QSPI_CCR for various other commands, these never use dummy cycles nor alternate bytes */
#define	QSPI_CCR_READ_STATUS \
	((QSPI_MODE & ~QSPI_DCYC_MASK & QSPI_NO_ADDR & QSPI_NO_ALTB) | \
	(QSPI_READ_MODE | SPIFLASH_READ_STATUS))

#define	QSPI_CCR_READ_ID \
	((QSPI_MODE & ~QSPI_DCYC_MASK & QSPI_NO_ADDR & QSPI_NO_ALTB) | \
	(QSPI_READ_MODE | SPIFLASH_READ_ID))

#define	QSPI_CCR_READ_MID \
	((QSPI_MODE & ~QSPI_DCYC_MASK & QSPI_NO_ADDR & QSPI_NO_ALTB) | \
	(QSPI_READ_MODE | SPIFLASH_READ_MID))

/* always use 3-byte addresses for read SFDP */
#define	QSPI_CCR_READ_SFDP \
	((QSPI_MODE & ~QSPI_DCYC_MASK & ~QSPI_ADDR4 & QSPI_NO_ALTB) | \
	(QSPI_READ_MODE | QSPI_ADDR3 | SPIFLASH_READ_SFDP))

#define QSPI_CCR_WRITE_ENABLE \
	((QSPI_MODE & ~QSPI_DCYC_MASK & QSPI_NO_ADDR & QSPI_NO_ALTB & QSPI_NO_DATA) | \
	(QSPI_WRITE_MODE | SPIFLASH_WRITE_ENABLE))

#define QSPI_CCR_SECTOR_ERASE \
	((QSPI_MODE & ~QSPI_DCYC_MASK & QSPI_NO_ALTB & QSPI_NO_DATA) | \
	(QSPI_WRITE_MODE | stmqspi_info->dev.erase_cmd))

#define QSPI_CCR_MASS_ERASE \
	((QSPI_MODE & ~QSPI_DCYC_MASK & QSPI_NO_ADDR & QSPI_NO_ALTB & QSPI_NO_DATA) | \
	(QSPI_WRITE_MODE | stmqspi_info->dev.chip_erase_cmd))

#define QSPI_CCR_PAGE_PROG \
	((QSPI_MODE & ~QSPI_DCYC_MASK & QSPI_NO_ALTB) | \
	(QSPI_WRITE_MODE | stmqspi_info->dev.pprog_cmd))

/* saved mode settings */
#define OCTOSPI_MODE (stmqspi_info->saved_cr & 0xCFFFFFFF)

#define OPI_MODE ((stmqspi_info->saved_ccr & OCTOSPI_ISIZE_MASK) != 0)

#define OCTOSPI_MODE_CCR (stmqspi_info->saved_ccr & \
	(0xF0000000U | OCTOSPI_8LINE_MODE | OCTOSPI_ALTB_MODE | OCTOSPI_ADDR4))

/* use saved ccr for read */
#define OCTOSPI_CCR_READ OCTOSPI_MODE_CCR

/* OCTOSPI_CCR for various other commands, these never use alternate bytes	*
 * for READ_STATUS and READ_ID, 4-byte address 0							*
 * 4 dummy cycles must sent in OPI mode when DQS is disabled. However, when	*
 * DQS is enabled, some STM32 devices need at least 6 dummy cycles for		*
 * proper operation, but otherwise the actual number has no effect!			*
 * E.g. RM0432 Rev. 7 is incorrect regarding this: L4R9 works well with 4	*
 * dummy clocks whereas L4P5 not at all.									*
 */
#define OPI_DUMMY \
	((stmqspi_info->saved_ccr & OCTOSPI_DQSEN) ? 6U : 4U)

#define	OCTOSPI_CCR_READ_STATUS \
	((OCTOSPI_MODE_CCR & OCTOSPI_NO_DDTR & \
	(OPI_MODE ? ~0U : OCTOSPI_NO_ADDR) & OCTOSPI_NO_ALTB))

#define	OCTOSPI_CCR_READ_ID \
	((OCTOSPI_MODE_CCR & OCTOSPI_NO_DDTR & \
	(OPI_MODE ? ~0U : OCTOSPI_NO_ADDR) & OCTOSPI_NO_ALTB))

#define	OCTOSPI_CCR_READ_MID OCTOSPI_CCR_READ_ID

/* 4-byte address in octo mode, else 3-byte address for read SFDP */
#define	OCTOSPI_CCR_READ_SFDP(len) \
	((OCTOSPI_MODE_CCR & OCTOSPI_NO_DDTR & ~OCTOSPI_ADDR4 & OCTOSPI_NO_ALTB) | \
	(((len) < 4) ? OCTOSPI_ADDR3 : OCTOSPI_ADDR4))

#define OCTOSPI_CCR_WRITE_ENABLE \
	((OCTOSPI_MODE_CCR & OCTOSPI_NO_ADDR & OCTOSPI_NO_ALTB & OCTOSPI_NO_DATA))

#define OCTOSPI_CCR_SECTOR_ERASE \
	((OCTOSPI_MODE_CCR & OCTOSPI_NO_ALTB & OCTOSPI_NO_DATA))

#define OCTOSPI_CCR_MASS_ERASE \
	((OCTOSPI_MODE_CCR & OCTOSPI_NO_ADDR & OCTOSPI_NO_ALTB & OCTOSPI_NO_DATA))

#define OCTOSPI_CCR_PAGE_PROG \
	((OCTOSPI_MODE_CCR & QSPI_NO_ALTB))

#define SPI_ADSIZE (((stmqspi_info->saved_ccr >> SPI_ADSIZE_POS) & 0x3) + 1)

#define OPI_CMD(cmd) ((OPI_MODE ? ((((uint16_t)(cmd)) << 8) | (~(cmd) & 0xFFU)) : (cmd)))

/* convert uint32_t into 4 uint8_t in little endian byte order */
static inline uint32_t h_to_le_32(uint32_t val)
{
	uint32_t result;

	h_u32_to_le((uint8_t *)&result, val);
	return result;
}

/* Timeout in ms */
#define SPI_CMD_TIMEOUT			(100)
#define SPI_PROBE_TIMEOUT		(100)
#define SPI_MAX_TIMEOUT			(2000)
#define SPI_MASS_ERASE_TIMEOUT	(400000)

struct sector_info {
	uint32_t offset;
	uint32_t size;
	uint32_t result;
};

struct stmqspi_flash_bank {
	bool probed;
	char devname[32];
	bool octo;
	struct flash_device dev;
	uint32_t io_base;
	uint32_t saved_cr;	/* in particular FSEL, DFM bit mask in QUADSPI_CR *AND* OCTOSPI_CR */
	uint32_t saved_ccr; /* different meaning for QUADSPI and OCTOSPI */
	uint32_t saved_tcr;	/* only for OCTOSPI */
	uint32_t saved_ir;	/* only for OCTOSPI */
	unsigned int sfdp_dummy1;	/* number of dummy bytes for SFDP read for flash1 and octo */
	unsigned int sfdp_dummy2;	/* number of dummy bytes for SFDP read for flash2 */
};

static inline int octospi_cmd(struct flash_bank *bank, uint32_t mode,
		uint32_t ccr, uint32_t ir)
{
	struct target *target = bank->target;
	const struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	const uint32_t io_base = stmqspi_info->io_base;

	int retval = target_write_u32(target, io_base + OCTOSPI_CR,
		OCTOSPI_MODE | mode);

	if (retval != ERROR_OK)
		return retval;

	retval = target_write_u32(target, io_base + OCTOSPI_TCR,
		(stmqspi_info->saved_tcr & ~OCTOSPI_DCYC_MASK) |
		((OPI_MODE && (mode == OCTOSPI_READ_MODE)) ?
		(OPI_DUMMY << OCTOSPI_DCYC_POS) : 0));

	if (retval != ERROR_OK)
		return retval;

	retval = target_write_u32(target, io_base + OCTOSPI_CCR, ccr);

	if (retval != ERROR_OK)
		return retval;

	return target_write_u32(target, io_base + OCTOSPI_IR, OPI_CMD(ir));
}

FLASH_BANK_COMMAND_HANDLER(stmqspi_flash_bank_command)
{
	struct stmqspi_flash_bank *stmqspi_info;
	uint32_t io_base;

	LOG_DEBUG("%s", __func__);

	if (CMD_ARGC < 7)
		return ERROR_COMMAND_SYNTAX_ERROR;

	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[6], io_base);

	stmqspi_info = malloc(sizeof(struct stmqspi_flash_bank));
	if (stmqspi_info == NULL) {
		LOG_ERROR("not enough memory");
		return ERROR_FAIL;
	}

	bank->driver_priv = stmqspi_info;
	stmqspi_info->sfdp_dummy1 = 0;
	stmqspi_info->sfdp_dummy2 = 0;
	stmqspi_info->probed = false;
	stmqspi_info->io_base = io_base;

	return ERROR_OK;
}

/* Poll busy flag */
/* timeout in ms */
static int poll_busy(struct flash_bank *bank, int timeout)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	uint32_t io_base = stmqspi_info->io_base;
	long long endtime;

	endtime = timeval_ms() + timeout;
	do {
		uint32_t spi_sr;
		int retval = target_read_u32(target, io_base + SPI_SR, &spi_sr);

		if (retval != ERROR_OK)
			return retval;

		if ((spi_sr & BIT(SPI_BUSY)) == 0) {
			/* Clear transmit finished flag */
			return target_write_u32(target, io_base + SPI_FCR, BIT(SPI_TCF));
		} else
			LOG_DEBUG("busy: 0x%08X", spi_sr);
		alive_sleep(1);
	} while (timeval_ms() < endtime);

	LOG_ERROR("Timeout while polling BUSY");
	return ERROR_FLASH_OPERATION_FAILED;
}

static int stmqspi_abort(struct flash_bank *bank)
{
	struct target *target = bank->target;
	const struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	const uint32_t io_base = stmqspi_info->io_base;
	uint32_t cr;

	int retval = target_read_u32(target, io_base + SPI_CR, &cr);

	if (retval != ERROR_OK)
		cr = 0;

	return target_write_u32(target, io_base + SPI_CR, cr | BIT(SPI_ABORT));
}

/* Set to memory-mapped mode, e.g. after an error */
static int set_mm_mode(struct flash_bank *bank)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	uint32_t io_base = stmqspi_info->io_base;
	int retval;

	/* Reset Address register bits 0 and 1, see various errata sheets */
	retval = target_write_u32(target, io_base + SPI_AR, 0x0);
	if (retval != ERROR_OK)
		return retval;

	/* Abort any previous operation */
	retval = stmqspi_abort(bank);
	if (retval != ERROR_OK)
		return retval;

	/* Wait for busy to be cleared */
	retval = poll_busy(bank, SPI_PROBE_TIMEOUT);
	if (retval != ERROR_OK)
		return retval;

	/* Finally switch to memory mapped mode */
	if (IS_OCTOSPI) {
		retval = target_write_u32(target, io_base + OCTOSPI_CR,
			OCTOSPI_MODE | OCTOSPI_MM_MODE);
		if (retval == ERROR_OK)
			retval = target_write_u32(target, io_base + OCTOSPI_CCR,
				stmqspi_info->saved_ccr);
		if (retval == ERROR_OK)
			retval = target_write_u32(target, io_base + OCTOSPI_TCR,
				stmqspi_info->saved_tcr);
		if (retval == ERROR_OK)
			retval = target_write_u32(target, io_base + OCTOSPI_IR,
				stmqspi_info->saved_ir);
	} else {
		retval = target_write_u32(target, io_base + QSPI_CR,
			stmqspi_info->saved_cr);
		if (retval == ERROR_OK)
			retval = target_write_u32(target, io_base + QSPI_CCR,
				stmqspi_info->saved_ccr);
	}
	return retval;
}

/* Read the status register of the external SPI flash chip(s). */
static int read_status_reg(struct flash_bank *bank, uint16_t *status)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	uint32_t io_base = stmqspi_info->io_base;
	uint8_t data;
	int count, retval;

	/* Abort any previous operation */
	retval = stmqspi_abort(bank);
	if (retval != ERROR_OK)
		return retval;

	/* Wait for busy to be cleared */
	retval = poll_busy(bank, SPI_PROBE_TIMEOUT);
	if (retval != ERROR_OK)
		goto err;

	/* Read always two (for DTR mode) bytes per chip */
	count = 2;
	retval = target_write_u32(target, io_base + SPI_DLR,
		((stmqspi_info->saved_cr & BIT(SPI_DUAL_FLASH)) ? 2 * count : count) - 1);
	if (retval != ERROR_OK)
		goto err;

	/* Read status */
	if (IS_OCTOSPI) {
		retval = octospi_cmd(bank, OCTOSPI_READ_MODE, OCTOSPI_CCR_READ_STATUS,
			SPIFLASH_READ_STATUS);
		if (OPI_MODE) {
			/* Dummy address 0, only required for 8-line mode */
			retval = target_write_u32(target, io_base + SPI_AR, 0);
			if (retval != ERROR_OK)
				goto err;
		}
	} else
		retval = target_write_u32(target, io_base + QSPI_CCR, QSPI_CCR_READ_STATUS);
	if (retval != ERROR_OK)
		goto err;

	*status = 0;

	/* for debugging only */
	uint32_t dummy;
	(void)target_read_u32(target, io_base + SPI_SR, &dummy);

	for ( ; count > 0; --count) {
		if ((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) | BIT(SPI_FSEL_FLASH)))
			!= BIT(SPI_FSEL_FLASH)) {
			/* get status of flash 1 in dual mode or flash 1 only mode */
			retval = target_read_u8(target, io_base + SPI_DR, &data);
			if (retval != ERROR_OK)
				goto err;
			*status |= data;
		}

		if ((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) | BIT(SPI_FSEL_FLASH))) != 0) {
			/* get status of flash 2 in dual mode or flash 2 only mode */
			retval = target_read_u8(target, io_base + SPI_DR, &data);
			if (retval != ERROR_OK)
				goto err;
			*status |= ((uint16_t)data) << 8;
		}
	}

	LOG_DEBUG("flash status regs: 0x%04" PRIx16, *status);

err:
	return retval;
}

/* check for WIP (write in progress) bit(s) in status register(s) */
/* timeout in ms */
static int wait_till_ready(struct flash_bank *bank, int timeout)
{
	uint16_t status;
	int retval;
	long long endtime;

	endtime = timeval_ms() + timeout;
	do {
		/* Read flash status register(s) */
		retval = read_status_reg(bank, &status);
		if (retval != ERROR_OK)
			return retval;

		if ((status & ((SPIFLASH_BSY_BIT << 8) | SPIFLASH_BSY_BIT)) == 0)
			return retval;
		alive_sleep(25);
	} while (timeval_ms() < endtime);

	LOG_ERROR("timeout");
	return ERROR_FLASH_OPERATION_FAILED;
}

/* Send "write enable" command to SPI flash chip(s). */
static int qspi_write_enable(struct flash_bank *bank)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	uint32_t io_base = stmqspi_info->io_base;
	uint16_t status;
	int retval;

	/* Abort any previous operation */
	retval = stmqspi_abort(bank);
	if (retval != ERROR_OK)
		return retval;

	/* Wait for busy to be cleared */
	retval = poll_busy(bank, SPI_PROBE_TIMEOUT);
	if (retval != ERROR_OK)
		goto err;

	/* Send write enable command */
	if (IS_OCTOSPI) {
		retval = octospi_cmd(bank, OCTOSPI_WRITE_MODE, OCTOSPI_CCR_WRITE_ENABLE,
			SPIFLASH_WRITE_ENABLE);
		if (OPI_MODE) {
			/* Dummy address 0, only required for 8-line mode */
			retval = target_write_u32(target, io_base + SPI_AR, 0);
			if (retval != ERROR_OK)
				goto err;
		}
	} else
		retval = target_write_u32(target, io_base + QSPI_CCR, QSPI_CCR_WRITE_ENABLE);
	if (retval != ERROR_OK)
		goto err;


	/* Wait for transmit of command completed */
	poll_busy(bank, SPI_CMD_TIMEOUT);
	if (retval != ERROR_OK)
		goto err;

	/* Read flash status register */
	retval = read_status_reg(bank, &status);
	if (retval != ERROR_OK)
		goto err;

	/* Check write enabled for flash 1 */
	if ((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) | BIT(SPI_FSEL_FLASH)))
		!= BIT(SPI_FSEL_FLASH))
		if ((status & (SPIFLASH_WE_BIT | SPIFLASH_BSY_BIT)) != SPIFLASH_WE_BIT) {
			LOG_ERROR("Cannot write enable flash1. Status=0x%02x",
				status & 0xFFU);
			return ERROR_FLASH_OPERATION_FAILED;
		}

	/* Check write enabled for flash 2 */
	status >>= 8;
	if ((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) | BIT(SPI_FSEL_FLASH))) != 0)
		if ((status & (SPIFLASH_WE_BIT | SPIFLASH_BSY_BIT)) != SPIFLASH_WE_BIT) {
			LOG_ERROR("Cannot write enable flash2. Status=0x%02x",
				status & 0xFFU);
			return ERROR_FLASH_OPERATION_FAILED;
		}

err:
	return retval;
}

COMMAND_HANDLER(stmqspi_handle_mass_erase_command)
{
	struct target *target = NULL;
	struct flash_bank *bank;
	struct stmqspi_flash_bank *stmqspi_info;
	struct duration bench;
	uint32_t io_base;
	uint16_t status;
	unsigned int sector;
	int retval;

	LOG_DEBUG("%s", __func__);

	if (CMD_ARGC != 1)
		return ERROR_COMMAND_SYNTAX_ERROR;

	retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
	if (ERROR_OK != retval)
		return retval;

	stmqspi_info = bank->driver_priv;
	target = bank->target;

	if (target->state != TARGET_HALTED) {
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	if (!(stmqspi_info->probed)) {
		LOG_ERROR("Flash bank not probed");
		return ERROR_FLASH_BANK_NOT_PROBED;
	}

	if (stmqspi_info->dev.chip_erase_cmd == 0x00) {
		LOG_ERROR("Mass erase not available for this device");
		return ERROR_FLASH_OPER_UNSUPPORTED;
	}

	for (sector = 0; sector < bank->num_sectors; sector++) {
		if (bank->sectors[sector].is_protected) {
			LOG_ERROR("Flash sector %u protected", sector);
			return ERROR_FLASH_PROTECTED;
		}
	}

	io_base = stmqspi_info->io_base;
	duration_start(&bench);

	retval = qspi_write_enable(bank);
	if (retval != ERROR_OK)
		goto err;

	/* Send Mass Erase command */
	if (IS_OCTOSPI)
		retval = octospi_cmd(bank, OCTOSPI_WRITE_MODE, OCTOSPI_CCR_MASS_ERASE,
			stmqspi_info->dev.chip_erase_cmd);
	else
		retval = target_write_u32(target, io_base + QSPI_CCR, QSPI_CCR_MASS_ERASE);
	if (retval != ERROR_OK)
		goto err;

	/* Wait for transmit of command completed */
	poll_busy(bank, SPI_CMD_TIMEOUT);
	if (retval != ERROR_OK)
		goto err;

	/* Read flash status register(s) */
	retval = read_status_reg(bank, &status);
	if (retval != ERROR_OK)
		goto err;

	/* Check for command in progress for flash 1 */
	if (((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) | BIT(SPI_FSEL_FLASH)))
		!= BIT(SPI_FSEL_FLASH)) && ((status & SPIFLASH_BSY_BIT) == 0) &&
		((status & SPIFLASH_WE_BIT) != 0)) {
		LOG_ERROR("Mass erase command not accepted by flash1. Status=0x%02x",
			status & 0xFFU);
		retval = ERROR_FLASH_OPERATION_FAILED;
		goto err;
	}

	/* Check for command in progress for flash 2 */
	status >>= 8;
	if (((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) | BIT(SPI_FSEL_FLASH))) != 0) &&
		((status & SPIFLASH_BSY_BIT) == 0) &&
		((status & SPIFLASH_WE_BIT) != 0)) {
		LOG_ERROR("Mass erase command not accepted by flash2. Status=0x%02x",
			status & 0xFFU);
		retval = ERROR_FLASH_OPERATION_FAILED;
		goto err;
	}

	/* Poll WIP for end of self timed Sector Erase cycle */
	retval = wait_till_ready(bank, SPI_MASS_ERASE_TIMEOUT);

	duration_measure(&bench);
	if (retval == ERROR_OK) {
		/* set all sectors as erased */
		for (sector = 0; sector < bank->num_sectors; sector++)
			bank->sectors[sector].is_erased = 1;

		command_print(CMD, "stmqspi mass erase completed in %fs (%0.3f KiB/s)",
			duration_elapsed(&bench),
			duration_kbps(&bench, bank->size));
	} else {
		command_print(CMD, "stmqspi mass erase not completed even after %fs",
			duration_elapsed(&bench));
	}

err:
	/* Switch to memory mapped mode before return to prompt */
	set_mm_mode(bank);

	return retval;
}

static int log2u(uint32_t word)
{
	int result;

	for (result = 0; (unsigned int) result < sizeof(uint32_t) * CHAR_BIT; result++)
		if (word == BIT(result))
			return result;

	return -1;
}

COMMAND_HANDLER(stmqspi_handle_set)
{
	struct flash_bank *bank = NULL;
	struct target *target = NULL;
	struct stmqspi_flash_bank *stmqspi_info = NULL;
	struct flash_sector *sectors = NULL;
	uint32_t io_base;
	unsigned int index = 0, dual, fsize;
	int retval;

	LOG_DEBUG("%s", __func__);

	dual = (stmqspi_info->saved_cr & BIT(SPI_DUAL_FLASH)) ? 1 : 0;

	/* chip_erase_cmd, sectorsize and erase_cmd are optional */
	if ((CMD_ARGC < 7) || (CMD_ARGC > 10))
		return ERROR_COMMAND_SYNTAX_ERROR;

	retval = CALL_COMMAND_HANDLER(flash_command_get_bank, index++, &bank);
	if (ERROR_OK != retval)
		return retval;

	target = bank->target;
	stmqspi_info = bank->driver_priv;

	/* invalidate all old info */
	if (stmqspi_info->probed)
		free(bank->sectors);
	bank->size = 0;
	bank->num_sectors = 0;
	bank->sectors = NULL;
	stmqspi_info->sfdp_dummy1 = 0;
	stmqspi_info->sfdp_dummy2 = 0;
	stmqspi_info->probed = false;
	memset(&stmqspi_info->dev, 0, sizeof(stmqspi_info->dev));
	stmqspi_info->dev.name = "unknown";

	strncpy(stmqspi_info->devname, CMD_ARGV[index++], sizeof(stmqspi_info->devname) - 1);
	stmqspi_info->devname[sizeof(stmqspi_info->devname) - 1] = '\0';

	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[index++], stmqspi_info->dev.size_in_bytes);
	if (log2u(stmqspi_info->dev.size_in_bytes) < 8) {
		command_print(CMD, "stmqspi: device size must be 2^n with n >= 8");
		return ERROR_COMMAND_SYNTAX_ERROR;
	}

	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[index++], stmqspi_info->dev.pagesize);
	if (stmqspi_info->dev.pagesize > stmqspi_info->dev.size_in_bytes ||
		(log2u(stmqspi_info->dev.pagesize) < 0)) {
		command_print(CMD, "stmqspi: page size must be 2^n and <= device size");
		return ERROR_COMMAND_SYNTAX_ERROR;
	}

	COMMAND_PARSE_NUMBER(u8, CMD_ARGV[index++], stmqspi_info->dev.read_cmd);
	if ((stmqspi_info->dev.read_cmd != 0x03) &&
		(stmqspi_info->dev.read_cmd != 0x13)) {
		command_print(CMD, "stmqspi: only 0x03/0x13 READ cmd allowed");
		return ERROR_COMMAND_SYNTAX_ERROR;
	}

	COMMAND_PARSE_NUMBER(u8, CMD_ARGV[index++], stmqspi_info->dev.qread_cmd);
	if ((stmqspi_info->dev.qread_cmd != 0x00) &&
		(stmqspi_info->dev.qread_cmd != 0x0B) &&
		(stmqspi_info->dev.qread_cmd != 0x0C) &&
		(stmqspi_info->dev.qread_cmd != 0x3B) &&
		(stmqspi_info->dev.qread_cmd != 0x3C) &&
		(stmqspi_info->dev.qread_cmd != 0x6B) &&
		(stmqspi_info->dev.qread_cmd != 0x6C) &&
		(stmqspi_info->dev.qread_cmd != 0xBB) &&
		(stmqspi_info->dev.qread_cmd != 0xBC) &&
		(stmqspi_info->dev.qread_cmd != 0xEB) &&
		(stmqspi_info->dev.qread_cmd != 0xEC) &&
		(stmqspi_info->dev.qread_cmd != 0xEE)) {
		command_print(CMD, "stmqspi: only 0x0B/0x0C/0x3B/0x3C/"
			"0x6B/0x6C/0xBB/0xBC/0xEB/0xEC/0xEE QREAD allowed");
		return ERROR_COMMAND_SYNTAX_ERROR;
	}

	COMMAND_PARSE_NUMBER(u8, CMD_ARGV[index++], stmqspi_info->dev.pprog_cmd);
	if ((stmqspi_info->dev.pprog_cmd != 0x02) &&
		(stmqspi_info->dev.pprog_cmd != 0x12) &&
		(stmqspi_info->dev.pprog_cmd != 0x32)) {
		command_print(CMD, "stmqspi: only 0x02/0x12/0x32 PPRG cmd allowed");
		return ERROR_COMMAND_SYNTAX_ERROR;
	}

	if (index < CMD_ARGC)
		COMMAND_PARSE_NUMBER(u8, CMD_ARGV[index++], stmqspi_info->dev.chip_erase_cmd);
	else
		stmqspi_info->dev.chip_erase_cmd = 0x00;

	if (index < CMD_ARGC) {
		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[index++], stmqspi_info->dev.sectorsize);
		if ((stmqspi_info->dev.sectorsize > stmqspi_info->dev.size_in_bytes) ||
			(stmqspi_info->dev.sectorsize < stmqspi_info->dev.pagesize) ||
			(log2u(stmqspi_info->dev.sectorsize) < 0)) {
			command_print(CMD, "stmqspi: sector size must be 2^n and <= device size");
			return ERROR_COMMAND_SYNTAX_ERROR;
		}

		if (index < CMD_ARGC)
			COMMAND_PARSE_NUMBER(u8, CMD_ARGV[index++], stmqspi_info->dev.erase_cmd);
		else
			return ERROR_COMMAND_SYNTAX_ERROR;
	} else {
		/* no sector size / sector erase cmd given, treat whole bank as a single sector */
		stmqspi_info->dev.erase_cmd = 0x00;
		stmqspi_info->dev.sectorsize = stmqspi_info->dev.size_in_bytes;
	}

	/* set correct size value */
	bank->size = stmqspi_info->dev.size_in_bytes << dual;

	io_base = stmqspi_info->io_base;

	uint32_t dcr;
	retval = target_read_u32(target, io_base + SPI_DCR, &dcr);

	if (retval != ERROR_OK)
		return retval;

	fsize = (dcr >> SPI_FSIZE_POS) & (BIT(SPI_FSIZE_LEN) - 1);

	LOG_DEBUG("FSIZE = 0x%04x", fsize);
	if (bank->size == BIT(fsize + 1))
		LOG_DEBUG("FSIZE in DCR(1) matches actual capacity. Beware of silicon bug in H7, L4+, MP1.");
	else if (bank->size == BIT(fsize + 0))
		LOG_DEBUG("FSIZE in DCR(1) is off by one regarding actual capacity. Fix for silicon bug?");
	else
		LOG_ERROR("FSIZE in DCR(1) doesn't match actual capacity.");

	/* create and fill sectors array */
	bank->num_sectors =
		stmqspi_info->dev.size_in_bytes / stmqspi_info->dev.sectorsize;
	sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
	if (sectors == NULL) {
		LOG_ERROR("not enough memory");
		return ERROR_FAIL;
	}

	for (unsigned int sector = 0; sector < bank->num_sectors; sector++) {
		sectors[sector].offset = sector * (stmqspi_info->dev.sectorsize << dual);
		sectors[sector].size = (stmqspi_info->dev.sectorsize << dual);
		sectors[sector].is_erased = -1;
		sectors[sector].is_protected = 0;
	}

	bank->sectors = sectors;
	stmqspi_info->dev.name = stmqspi_info->devname;
	if (stmqspi_info->dev.size_in_bytes / 4096)
		LOG_INFO("flash \'%s\' id = unknown\nchip size = %" PRIu32 "kbytes,"
			" bank size = %" PRIu32 "kbytes", stmqspi_info->dev.name,
			stmqspi_info->dev.size_in_bytes / 1024,
			(stmqspi_info->dev.size_in_bytes / 1024) << dual);
	else
		LOG_INFO("flash \'%s\' id = unknown\nchip size = %" PRIu32 "bytes,"
			" bank size = %" PRIu32 "bytes", stmqspi_info->dev.name,
			stmqspi_info->dev.size_in_bytes,
			stmqspi_info->dev.size_in_bytes << dual);

	stmqspi_info->probed = true;

	return ERROR_OK;
}

COMMAND_HANDLER(stmqspi_handle_cmd)
{
	struct target *target = NULL;
	struct flash_bank *bank;
	struct stmqspi_flash_bank *stmqspi_info = NULL;
	uint32_t io_base, addr;
	uint8_t num_write, num_read, cmd_byte, data;
	unsigned int count;
	const int max = 21;
	char temp[4], output[(2 + max + 256) * 3 + 8];
	int retval;

	LOG_DEBUG("%s", __func__);

	if (CMD_ARGC < 3)
		return ERROR_COMMAND_SYNTAX_ERROR;

	num_write = CMD_ARGC - 2;
	if (num_write > max) {
		LOG_ERROR("at most %d bytes may be sent", max);
		return ERROR_COMMAND_SYNTAX_ERROR;
	}

	retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
	if (ERROR_OK != retval)
		return retval;

	target = bank->target;
	stmqspi_info = bank->driver_priv;
	io_base = stmqspi_info->io_base;

	if (target->state != TARGET_HALTED) {
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	COMMAND_PARSE_NUMBER(u8, CMD_ARGV[1], num_read);
	COMMAND_PARSE_NUMBER(u8, CMD_ARGV[2], cmd_byte);

	if (num_read == 0) {
		/* nothing to read, then one command byte and for dual flash
		 * an *even* number of data bytes to follow */
		if (stmqspi_info->saved_cr & BIT(SPI_DUAL_FLASH)) {
			if ((num_write & 1) == 0) {
				LOG_ERROR("number of data bytes to write must be even in dual mode");
				return ERROR_COMMAND_SYNTAX_ERROR;
			}
		}
	} else {
		/* read mode, one command byte and up to four following address bytes */
		if (stmqspi_info->saved_cr & BIT(SPI_DUAL_FLASH)) {
			if ((num_read & 1) != 0) {
				LOG_ERROR("number of bytes to read must be even in dual mode");
				return ERROR_COMMAND_SYNTAX_ERROR;
			}
		}
		if ((num_write < 1) || (num_write > 5)) {
			LOG_ERROR("one cmd and up to four addr bytes must be send when reading");
			return ERROR_COMMAND_SYNTAX_ERROR;
		}
	}

	/* Abort any previous operation */
	retval = stmqspi_abort(bank);
	if (retval != ERROR_OK)
		return retval;

	/* Wait for busy to be cleared */
	retval = poll_busy(bank, SPI_PROBE_TIMEOUT);
	if (retval != ERROR_OK)
		return retval;

	/* send command byte */
	snprintf(output, sizeof(output), "spi: %02x ", cmd_byte);
	if (num_read == 0) {
		/* write, send cmd byte */
		retval = target_write_u32(target, io_base + SPI_DLR, ((uint32_t)num_write) - 2);
		if (retval != ERROR_OK)
			goto err;

		if (IS_OCTOSPI)
			retval = octospi_cmd(bank, OCTOSPI_WRITE_MODE,
				(OCTOSPI_MODE_CCR & OCTOSPI_NO_ALTB & OCTOSPI_NO_ADDR &
				((num_write == 1) ? OCTOSPI_NO_DATA : ~0U)), cmd_byte);
		else
			retval = target_write_u32(target, io_base + QSPI_CCR,
				(QSPI_MODE & ~QSPI_DCYC_MASK & QSPI_NO_ALTB & QSPI_NO_ADDR &
				((num_write == 1) ? QSPI_NO_DATA : ~0U)) |
				(QSPI_WRITE_MODE | cmd_byte));
		if (retval != ERROR_OK)
			goto err;

		/* send additional data bytes */
		for (count = 3; count < CMD_ARGC; count++) {
			COMMAND_PARSE_NUMBER(u8, CMD_ARGV[count], data);
			snprintf(temp, sizeof(temp), "%02" PRIx8 " ", data);
			retval = target_write_u8(target, io_base + SPI_DR, data);
			if (retval != ERROR_OK)
				goto err;
			strncat(output, temp, sizeof(output) - strlen(output) - 1);
		}
		strncat(output, "-> ", sizeof(output) - strlen(output) - 1);
	} else {
		/* read, pack additional bytes into address */
		addr = 0;
		for (count = 3; count < CMD_ARGC; count++) {
			COMMAND_PARSE_NUMBER(u8, CMD_ARGV[count], data);
			snprintf(temp, sizeof(temp), "%02" PRIx8 " ", data);
			addr = (addr << 8) | data;
			strncat(output, temp, sizeof(output) - strlen(output) - 1);
		}
		strncat(output, "-> ", sizeof(output) - strlen(output) - 1);

		/* send cmd byte, if ADMODE indicates no address, this already triggers command */
		retval = target_write_u32(target, io_base + SPI_DLR, ((uint32_t)num_read) - 1);
		if (retval != ERROR_OK)
			goto err;
		if (IS_OCTOSPI)
			retval = octospi_cmd(bank, OCTOSPI_READ_MODE,
				(OCTOSPI_MODE_CCR & OCTOSPI_NO_DDTR & OCTOSPI_NO_ALTB & ~OCTOSPI_ADDR4 &
					((num_write == 1) ? OCTOSPI_NO_ADDR : ~0U)) |
				(((num_write - 2) & 0x3U) << SPI_ADSIZE_POS), cmd_byte);
		else
			retval = target_write_u32(target, io_base + QSPI_CCR,
				(QSPI_MODE & ~QSPI_DCYC_MASK & QSPI_NO_ALTB & ~QSPI_ADDR4 &
					((num_write == 1) ? QSPI_NO_ADDR : ~0U)) |
				((QSPI_READ_MODE | (((num_write - 2) & 0x3U) << SPI_ADSIZE_POS) | cmd_byte)));
		if (retval != ERROR_OK)
			goto err;

		if (num_write > 1) {
			/* if ADMODE indicates address required, only the write to AR triggers command */
			retval = target_write_u32(target, io_base + SPI_AR, addr);
			if (retval != ERROR_OK)
				goto err;
		}

		/* read response bytes */
		for ( ; num_read > 0; num_read--) {
			retval = target_read_u8(target, io_base + SPI_DR, &data);
			if (retval != ERROR_OK)
				goto err;
			snprintf(temp, sizeof(temp), "%02" PRIx8 " ", data);
			strncat(output, temp, sizeof(output) - strlen(output) - 1);
		}
	}
	command_print(CMD, "%s", output);

err:
	/* Switch to memory mapped mode before return to prompt */
	set_mm_mode(bank);

	return retval;
}

static int qspi_erase_sector(struct flash_bank *bank, unsigned int sector)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	uint32_t io_base = stmqspi_info->io_base;
	uint16_t status;
	int retval;

	retval = qspi_write_enable(bank);
	if (retval != ERROR_OK)
		goto err;

	/* Send Sector Erase command */
	if (IS_OCTOSPI)
		retval = octospi_cmd(bank, OCTOSPI_WRITE_MODE, OCTOSPI_CCR_SECTOR_ERASE,
			stmqspi_info->dev.erase_cmd);
	else
		retval = target_write_u32(target, io_base + QSPI_CCR, QSPI_CCR_SECTOR_ERASE);
	if (retval != ERROR_OK)
		goto err;

	/* Address is sector offset, this write initiates command transmission */
	retval = target_write_u32(target, io_base + SPI_AR, bank->sectors[sector].offset);
	if (retval != ERROR_OK)
		goto err;

	/* Wait for transmit of command completed */
	poll_busy(bank, SPI_CMD_TIMEOUT);
	if (retval != ERROR_OK)
		goto err;

	/* Read flash status register(s) */
	retval = read_status_reg(bank, &status);
	if (retval != ERROR_OK)
		goto err;

	LOG_DEBUG("erase status regs: 0x%04" PRIx16, status);

	/* Check for command in progress for flash 1 */
	/* If BSY and WE are already cleared the erase did probably complete already */
	if (((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) | BIT(SPI_FSEL_FLASH)))
		!= BIT(SPI_FSEL_FLASH)) && ((status & SPIFLASH_BSY_BIT) == 0) &&
		((status & SPIFLASH_WE_BIT) != 0)) {
		LOG_ERROR("Sector erase command not accepted by flash1. Status=0x%02x",
			status & 0xFFU);
		retval = ERROR_FLASH_OPERATION_FAILED;
		goto err;
	}

	/* Check for command in progress for flash 2 */
	/* If BSY and WE are already cleared the erase did probably complete already */
	status >>= 8;
	if (((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) | BIT(SPI_FSEL_FLASH))) != 0) &&
		((status & SPIFLASH_BSY_BIT) == 0) &&
		((status & SPIFLASH_WE_BIT) != 0)) {
		LOG_ERROR("Sector erase command not accepted by flash2. Status=0x%02x",
			status & 0xFFU);
		retval = ERROR_FLASH_OPERATION_FAILED;
		goto err;
	}

	/* Erase takes a long time, so some sort of progress message is a good idea */
	LOG_DEBUG("erasing sector %4u", sector);

	/* Poll WIP for end of self timed Sector Erase cycle */
	retval = wait_till_ready(bank, SPI_MAX_TIMEOUT);

err:
	return retval;
}

static int stmqspi_erase(struct flash_bank *bank, unsigned int first, unsigned int last)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	unsigned int sector;
	int retval = ERROR_OK;

	LOG_DEBUG("%s: from sector %u to sector %u", __func__, first, last);

	if (target->state != TARGET_HALTED) {
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	if (!(stmqspi_info->probed)) {
		LOG_ERROR("Flash bank not probed");
		return ERROR_FLASH_BANK_NOT_PROBED;
	}

	if (stmqspi_info->dev.erase_cmd == 0x00) {
		LOG_ERROR("Sector erase not available for this device");
		return ERROR_FLASH_OPER_UNSUPPORTED;
	}

	if ((last < first) || (last >= bank->num_sectors)) {
		LOG_ERROR("Flash sector invalid");
		return ERROR_FLASH_SECTOR_INVALID;
	}

	for (sector = first; sector <= last; sector++) {
		if (bank->sectors[sector].is_protected) {
			LOG_ERROR("Flash sector %u protected", sector);
			return ERROR_FLASH_PROTECTED;
		}
	}

	for (sector = first; sector <= last; sector++) {
		retval = qspi_erase_sector(bank, sector);
		if (retval != ERROR_OK)
			break;
		alive_sleep(10);
		keep_alive();
	}

	if (retval != ERROR_OK)
		LOG_ERROR("Flash sector_erase failed on sector %u", sector);

	/* Switch to memory mapped mode before return to prompt */
	set_mm_mode(bank);

	return retval;
}

static int stmqspi_protect(struct flash_bank *bank, int set,
	unsigned int first, unsigned int last)
{
	unsigned int sector;

	for (sector = first; sector <= last; sector++)
		bank->sectors[sector].is_protected = set;

	if (set)
		LOG_WARNING("setting soft protection only, not related to flash's hardware write protection");

	return ERROR_OK;
}

/* Check whether flash is blank */
static int stmqspi_blank_check(struct flash_bank *bank)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	struct duration bench;
	struct reg_param reg_params[2];
	struct armv7m_algorithm armv7m_info;
	struct working_area *algorithm;
	const uint8_t *code;
	struct sector_info erase_check_info;
	uint32_t codesize, maxsize, result, exit_point;
	unsigned int count, index, num_sectors, sector;
	int retval;
	const uint32_t erased = 0x00FF;

	if (target->state != TARGET_HALTED) {
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	if (!(stmqspi_info->probed)) {
		LOG_ERROR("Flash bank not probed");
		return ERROR_FLASH_BANK_NOT_PROBED;
	}

	/* Abort any previous operation */
	retval = stmqspi_abort(bank);
	if (retval != ERROR_OK)
		return retval;

	/* Wait for busy to be cleared */
	retval = poll_busy(bank, SPI_PROBE_TIMEOUT);
	if (retval != ERROR_OK)
		return retval;

	/* see contrib/loaders/flash/stmqspi/stmqspi_erase_check.S for src */
	static const uint8_t stmqspi_erase_check_code[] = {
		#include "../../../contrib/loaders/flash/stmqspi/stmqspi_erase_check.inc"
	};

	/* see contrib/loaders/flash/stmqspi/stmoctospi_erase_check.S for src */
	static const uint8_t stmoctospi_erase_check_code[] = {
		#include "../../../contrib/loaders/flash/stmqspi/stmoctospi_erase_check.inc"
	};

	if (IS_OCTOSPI) {
		code = stmoctospi_erase_check_code;
		codesize = sizeof(stmoctospi_erase_check_code);
	} else {
		code = stmqspi_erase_check_code;
		codesize = sizeof(stmqspi_erase_check_code);
	}

	/* This will overlay the last 4 words of stmqspi/stmoctospi_erase_check_code in target */
	/* for read use the saved settings (memory mapped mode) but indirect read mode */
	uint32_t ccr_buffer[][4] = {
		/* cr  (not used for QSPI)			*
		 * ccr (for both QSPI and OCTOSPI)	*
		 * tcr (not used for QSPI)			*
		 * ir  (not used for QSPI)			*/
		{
			h_to_le_32(OCTOSPI_MODE | OCTOSPI_READ_MODE),
			h_to_le_32(IS_OCTOSPI ? OCTOSPI_CCR_READ : QSPI_CCR_READ),
			h_to_le_32(stmqspi_info->saved_tcr),
			h_to_le_32(stmqspi_info->saved_ir),
		},
	};

	maxsize = target_get_working_area_avail(target);
	if (maxsize < codesize + sizeof(erase_check_info)) {
		LOG_ERROR("Not enough working area, can't do QSPI blank check");
		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
	}

	num_sectors = (maxsize - codesize) / sizeof(erase_check_info);
	num_sectors = (bank->num_sectors < num_sectors) ? bank->num_sectors : num_sectors;

	if (target_alloc_working_area_try(target,
			codesize + num_sectors * sizeof(erase_check_info), &algorithm) != ERROR_OK) {
		LOG_ERROR("allocating working area failed");
		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
	};

	/* prepare blank check code, excluding ccr_buffer */
	retval = target_write_buffer(target, algorithm->address,
		codesize - sizeof(ccr_buffer), code);
	if (retval != ERROR_OK)
		goto err;

	/* prepare QSPI/OCTOSPI_CCR register values */
	retval = target_write_buffer(target, algorithm->address
		+ codesize - sizeof(ccr_buffer),
		sizeof(ccr_buffer), (uint8_t *)ccr_buffer);
	if (retval != ERROR_OK)
		goto err;

	duration_start(&bench);

	/* after breakpoint instruction (halfword), one nop (halfword) and
	 * port_buffer till end of code */
	exit_point = algorithm->address + codesize - sizeof(uint32_t) - sizeof(ccr_buffer);

	init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);	/* sector count */
	init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);	/* QSPI/OCTOSPI io_base */

	sector = 0;
	while (sector < bank->num_sectors) {
		/* at most num_sectors sectors to handle in one run */
		count = bank->num_sectors - sector;
		if (count > num_sectors)
			count = num_sectors;

		for (index = 0; index < count; index++) {
			erase_check_info.offset = h_to_le_32(bank->sectors[sector + index].offset);
			erase_check_info.size = h_to_le_32(bank->sectors[sector + index].size);
			erase_check_info.result = h_to_le_32(erased);

			retval = target_write_buffer(target, algorithm->address
				+ codesize + index * sizeof(erase_check_info),
					sizeof(erase_check_info), (uint8_t *)&erase_check_info);
			if (retval != ERROR_OK)
				goto err;
		}

		buf_set_u32(reg_params[0].value, 0, 32, count);
		buf_set_u32(reg_params[1].value, 0, 32, stmqspi_info->io_base);

		armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
		armv7m_info.core_mode = ARM_MODE_THREAD;

		LOG_DEBUG("checking sectors %u to %u", sector, sector + count - 1);
		/* check a block of sectors */
		retval = target_run_algorithm(target,
			0, NULL,
			ARRAY_SIZE(reg_params), reg_params,
			algorithm->address, exit_point,
			count * ((bank->sectors[sector].size >> 6) + 1) + 1000,
			&armv7m_info);
		if (retval != ERROR_OK)
			break;

		for (index = 0; index < count; index++) {
			retval = target_read_buffer(target, algorithm->address
				+ codesize + index * sizeof(erase_check_info),
					sizeof(erase_check_info), (uint8_t *)&erase_check_info);
			if (retval != ERROR_OK)
				goto err;

			if ((erase_check_info.offset != h_to_le_32(bank->sectors[sector + index].offset)) ||
				(erase_check_info.size != 0)) {
				LOG_ERROR("corrupted blank check info");
				goto err;
			}

			/* we need le_32_to_h, but that's the same as h_to_le_32 */
			result = h_to_le_32(erase_check_info.result);
			bank->sectors[sector + index].is_erased = ((result & 0xFF) == 0xFF);
			LOG_DEBUG("Flash sector %u checked: 0x%04x", sector + index, result & 0xFFFFU);
		}
		keep_alive();
		sector += count;
	}

	destroy_reg_param(&reg_params[0]);
	destroy_reg_param(&reg_params[1]);

	duration_measure(&bench);
	LOG_INFO("stmqspi blank checked in %fs (%0.3f KiB/s)", duration_elapsed(&bench),
		duration_kbps(&bench, bank->size));

err:
	target_free_working_area(target, algorithm);

	/* Switch to memory mapped mode before return to prompt */
	set_mm_mode(bank);

	return retval;
}

/* Verify checksum */
static int qspi_verify(struct flash_bank *bank, uint8_t *buffer,
	uint32_t offset, uint32_t count)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	struct reg_param reg_params[4];
	struct armv7m_algorithm armv7m_info;
	struct working_area *algorithm;
	const uint8_t *code;
	uint32_t pagesize, codesize, crc32, result, exit_point;
	int retval;

	/* see contrib/loaders/flash/stmqspi/stmqspi_crc32.S for src */
	static const uint8_t stmqspi_crc32_code[] = {
		#include "../../../contrib/loaders/flash/stmqspi/stmqspi_crc32.inc"
	};

	/* see contrib/loaders/flash/stmqspi/stmoctospi_crc32.S for src */
	static const uint8_t stmoctospi_crc32_code[] = {
		#include "../../../contrib/loaders/flash/stmqspi/stmoctospi_crc32.inc"
	};

	if (IS_OCTOSPI) {
		code = stmoctospi_crc32_code;
		codesize = sizeof(stmoctospi_crc32_code);
	} else {
		code = stmqspi_crc32_code;
		codesize = sizeof(stmqspi_crc32_code);
	}

	/* block size doesn't matter that much here */
	pagesize = stmqspi_info->dev.sectorsize;
	if (pagesize == 0)
		pagesize = stmqspi_info->dev.pagesize;
	if (pagesize == 0)
		pagesize = SPIFLASH_DEF_PAGESIZE;

	/* adjust size according to dual flash mode */
	pagesize = (stmqspi_info->saved_cr & BIT(SPI_DUAL_FLASH)) ? pagesize << 1 : pagesize;

	/* This will overlay the last 4 words of stmqspi/stmoctospi_crc32_code in target */
	/* for read use the saved settings (memory mapped mode) but indirect read mode */
	uint32_t ccr_buffer[][4] = {
		/* cr  (not used for QSPI)			*
		 * ccr (for both QSPI and OCTOSPI)	*
		 * tcr (not used for QSPI)			*
		 * ir  (not used for QSPI)			*/
		{
			h_to_le_32(OCTOSPI_MODE | OCTOSPI_READ_MODE),
			h_to_le_32(IS_OCTOSPI ? OCTOSPI_CCR_READ : QSPI_CCR_READ),
			h_to_le_32(stmqspi_info->saved_tcr),
			h_to_le_32(stmqspi_info->saved_ir),
		},
	};

	if (target_alloc_working_area_try(target, codesize, &algorithm) != ERROR_OK) {
		LOG_ERROR("Not enough working area, can't do QSPI verify");
		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
	};

	/* prepare verify code, excluding ccr_buffer */
	retval = target_write_buffer(target, algorithm->address,
		codesize - sizeof(ccr_buffer), code);
	if (retval != ERROR_OK)
		goto err;

	/* prepare QSPI/OCTOSPI_CCR register values */
	retval = target_write_buffer(target, algorithm->address
		+ codesize - sizeof(ccr_buffer),
		sizeof(ccr_buffer), (uint8_t *)ccr_buffer);
	if (retval != ERROR_OK)
		goto err;

	/* after breakpoint instruction (halfword), one nop (halfword) and
	 * port_buffer till end of code */
	exit_point = algorithm->address + codesize - sizeof(uint32_t) - sizeof(ccr_buffer);

	init_reg_param(&reg_params[0], "r0", 32, PARAM_IN_OUT); /* count (in), crc32 (out) */
	init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);	/* pagesize */
	init_reg_param(&reg_params[2], "r2", 32, PARAM_OUT);	/* offset into flash address */
	init_reg_param(&reg_params[3], "r3", 32, PARAM_OUT);	/* QSPI/OCTOSPI io_base */

	buf_set_u32(reg_params[0].value, 0, 32, count);
	buf_set_u32(reg_params[1].value, 0, 32, pagesize);
	buf_set_u32(reg_params[2].value, 0, 32, offset);
	buf_set_u32(reg_params[3].value, 0, 32, stmqspi_info->io_base);


	armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
	armv7m_info.core_mode = ARM_MODE_THREAD;

	retval = target_run_algorithm(target,
		0, NULL,
		ARRAY_SIZE(reg_params), reg_params,
		algorithm->address, exit_point,
		(count >> 5) + 1000,
		&armv7m_info);
	keep_alive();

	image_calculate_checksum(buffer, count, &crc32);

	if (retval == ERROR_OK) {
		result = buf_get_u32(reg_params[0].value, 0, 32);
		LOG_DEBUG("addr " TARGET_ADDR_FMT ", len 0x%08" PRIx32 ", crc 0x%08" PRIx32 " 0x%08" PRIx32,
			offset + bank->base, count, ~crc32, result);
		if (~crc32 != result)
			retval = ERROR_FAIL;
	}

	destroy_reg_param(&reg_params[0]);
	destroy_reg_param(&reg_params[1]);
	destroy_reg_param(&reg_params[2]);
	destroy_reg_param(&reg_params[3]);

err:
	target_free_working_area(target, algorithm);

	/* Switch to memory mapped mode before return to prompt */
	set_mm_mode(bank);

	return retval;
}

static int qspi_read_write_block(struct flash_bank *bank, uint8_t *buffer,
	uint32_t offset, uint32_t count, bool write)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	uint32_t io_base = stmqspi_info->io_base;
	struct reg_param reg_params[6];
	struct armv7m_algorithm armv7m_info;
	struct working_area *algorithm;
	uint32_t pagesize, fifo_start, fifosize, remaining;
	uint32_t maxsize, codesize, exit_point;
	const uint8_t *code = NULL;
	unsigned int dual;
	int retval;

	LOG_DEBUG("%s: offset=0x%08" PRIx32 " len=0x%08" PRIx32,
		__func__, offset, count);

	dual = (stmqspi_info->saved_cr & BIT(SPI_DUAL_FLASH)) ? 1 : 0;

	/* see contrib/loaders/flash/stmqspi/stmqspi_read.S for src */
	static const uint8_t stmqspi_read_code[] = {
#include "../../../contrib/loaders/flash/stmqspi/stmqspi_read.inc"
	};

	/* see contrib/loaders/flash/stmqspi/stmoctospi_read.S for src */
	static const uint8_t stmoctospi_read_code[] = {
#include "../../../contrib/loaders/flash/stmqspi/stmoctospi_read.inc"
	};

	/* see contrib/loaders/flash/stmqspi/stmqspi_write.S for src */
	static const uint8_t stmqspi_write_code[] = {
#include "../../../contrib/loaders/flash/stmqspi/stmqspi_write.inc"
	};

	/* see contrib/loaders/flash/stmqspi/stmoctospi_write.S for src */
	static const uint8_t stmoctospi_write_code[] = {
#include "../../../contrib/loaders/flash/stmqspi/stmoctospi_write.inc"
	};

	/* This will overlay the last 12 words of stmqspi/stmoctospi_read/write_code in target */
	/* for read use the saved settings (memory mapped mode) but indirect read mode */
	uint32_t ccr_buffer[][4] = {
		/* cr  (not used for QSPI)			*
		 * ccr (for both QSPI and OCTOSPI)	*
		 * tcr (not used for QSPI)			*
		 * ir  (not used for QSPI)			*/
		{
			h_to_le_32(OCTOSPI_MODE | OCTOSPI_READ_MODE),
			h_to_le_32(IS_OCTOSPI ? OCTOSPI_CCR_READ_STATUS : QSPI_CCR_READ_STATUS),
			h_to_le_32((stmqspi_info->saved_tcr & ~OCTOSPI_DCYC_MASK) |
						(OPI_MODE ? (OPI_DUMMY << OCTOSPI_DCYC_POS) : 0)),
			h_to_le_32(OPI_CMD(SPIFLASH_READ_STATUS)),
		},
		{
			h_to_le_32(OCTOSPI_MODE | OCTOSPI_WRITE_MODE),
			h_to_le_32(IS_OCTOSPI ? OCTOSPI_CCR_WRITE_ENABLE : QSPI_CCR_WRITE_ENABLE),
			h_to_le_32(stmqspi_info->saved_tcr & ~OCTOSPI_DCYC_MASK),
			h_to_le_32(OPI_CMD(SPIFLASH_WRITE_ENABLE)),
		},
		{
			h_to_le_32(OCTOSPI_MODE | (write ? OCTOSPI_WRITE_MODE : OCTOSPI_READ_MODE)),
			h_to_le_32(write ? (IS_OCTOSPI ? OCTOSPI_CCR_PAGE_PROG : QSPI_CCR_PAGE_PROG) :
				(IS_OCTOSPI ? OCTOSPI_CCR_READ : QSPI_CCR_READ)),
			h_to_le_32(write ? (stmqspi_info->saved_tcr & ~OCTOSPI_DCYC_MASK) :
				stmqspi_info->saved_tcr),
			h_to_le_32(write ? OPI_CMD(stmqspi_info->dev.pprog_cmd) : stmqspi_info->saved_ir),
		},
	};

	/* force reasonable defaults */
	fifosize = stmqspi_info->dev.sectorsize ?
		stmqspi_info->dev.sectorsize : stmqspi_info->dev.size_in_bytes;

	if (write) {
		if (IS_OCTOSPI) {
			code = stmoctospi_write_code;
			codesize = sizeof(stmoctospi_write_code);
		} else {
			code = stmqspi_write_code;
			codesize = sizeof(stmqspi_write_code);
		}
	} else {
		if (IS_OCTOSPI) {
			code = stmoctospi_read_code;
			codesize = sizeof(stmoctospi_read_code);
		} else {
			code = stmqspi_read_code;
			codesize = sizeof(stmqspi_read_code);
		}
	}

	/* for write, pagesize must be taken into account */
	/* for read, the page size doesn't matter that much */
	pagesize = stmqspi_info->dev.pagesize;
	if (pagesize == 0)
		pagesize = (fifosize <= SPIFLASH_DEF_PAGESIZE) ?
			fifosize : SPIFLASH_DEF_PAGESIZE;

	/* adjust sizes according to dual flash mode */
	pagesize <<= dual;
	fifosize <<= dual;

	/* memory buffer, we assume sectorsize to be a power of 2 times pagesize */
	maxsize = target_get_working_area_avail(target);
	if (maxsize < codesize + 2 * sizeof(uint32_t) + pagesize) {
		LOG_ERROR("not enough working area, can't do QSPI page reads/writes");
		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
	}

	/* fifo size at most sector size, and multiple of page size */
	maxsize -= (codesize + 2 * sizeof(uint32_t));
	fifosize = ((maxsize < fifosize) ? maxsize : fifosize) & ~(pagesize - 1);

	if (target_alloc_working_area_try(target,
		codesize + 2 * sizeof(uint32_t) + fifosize, &algorithm) != ERROR_OK) {
		LOG_ERROR("allocating working area failed");
		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
	};

	/* prepare flash write code, excluding ccr_buffer */
	retval = target_write_buffer(target, algorithm->address,
		codesize - sizeof(ccr_buffer), code);
	if (retval != ERROR_OK)
		goto err;

	/* prepare QSPI/OCTOSPI_CCR register values */
	retval = target_write_buffer(target, algorithm->address
		+ codesize - sizeof(ccr_buffer),
		sizeof(ccr_buffer), (uint8_t *)ccr_buffer);
	if (retval != ERROR_OK)
		goto err;

	/* target buffer starts right after flash_write_code, i.e.
	 * wp and rp are implicitly included in buffer!!! */
	fifo_start = algorithm->address + codesize + 2 * sizeof(uint32_t);

	init_reg_param(&reg_params[0], "r0", 32, PARAM_IN_OUT); /* count (in), status (out) */
	init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);	/* pagesize */
	init_reg_param(&reg_params[2], "r2", 32, PARAM_IN_OUT);	/* offset into flash address */
	init_reg_param(&reg_params[3], "r3", 32, PARAM_OUT);	/* QSPI/OCTOSPI io_base */
	init_reg_param(&reg_params[4], "r8", 32, PARAM_OUT);	/* fifo start */
	init_reg_param(&reg_params[5], "r9", 32, PARAM_OUT);	/* fifo end + 1 */

	buf_set_u32(reg_params[0].value, 0, 32, count);
	buf_set_u32(reg_params[1].value, 0, 32, pagesize);
	buf_set_u32(reg_params[2].value, 0, 32, offset);
	buf_set_u32(reg_params[3].value, 0, 32, io_base);
	buf_set_u32(reg_params[4].value, 0, 32, fifo_start);
	buf_set_u32(reg_params[5].value, 0, 32, fifo_start + fifosize);

	armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
	armv7m_info.core_mode = ARM_MODE_THREAD;

	/* after breakpoint instruction (halfword), one nop (halfword) and
	 * ccr_buffer follow till end of code */
	exit_point = algorithm->address + codesize
		- (sizeof(ccr_buffer) + sizeof(uint32_t));

	if (write) {
		retval = target_run_flash_async_algorithm(target, buffer, count, 1,
				0, NULL,
				ARRAY_SIZE(reg_params), reg_params,
				algorithm->address + codesize,
				fifosize + 2 * sizeof(uint32_t),
				algorithm->address, exit_point,
				&armv7m_info);
	} else {
		retval = target_run_read_async_algorithm(target, buffer, count, 1,
				0, NULL,
				ARRAY_SIZE(reg_params), reg_params,
				algorithm->address + codesize,
				fifosize + 2 * sizeof(uint32_t),
				algorithm->address, exit_point,
				&armv7m_info);
	}

	remaining = buf_get_u32(reg_params[0].value, 0, 32);
	if ((retval == ERROR_OK) && remaining)
		retval = ERROR_FLASH_OPERATION_FAILED;

	if (retval != ERROR_OK) {
		offset = buf_get_u32(reg_params[2].value, 0, 32);
		LOG_ERROR("flash %s failed at address 0x%" PRIx32 ", remaining 0x%" PRIx32,
			write ? "write" : "read", offset, remaining);
	}

	destroy_reg_param(&reg_params[0]);
	destroy_reg_param(&reg_params[1]);
	destroy_reg_param(&reg_params[2]);
	destroy_reg_param(&reg_params[3]);
	destroy_reg_param(&reg_params[4]);
	destroy_reg_param(&reg_params[5]);

err:
	target_free_working_area(target, algorithm);

	/* Switch to memory mapped mode before return to prompt */
	set_mm_mode(bank);

	return retval;
}

static int stmqspi_read(struct flash_bank *bank, uint8_t *buffer,
	uint32_t offset, uint32_t count)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	int retval;

	LOG_DEBUG("%s: offset=0x%08" PRIx32 " count=0x%08" PRIx32,
		__func__, offset, count);

	if (target->state != TARGET_HALTED) {
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	if (!(stmqspi_info->probed)) {
		LOG_ERROR("Flash bank not probed");
		return ERROR_FLASH_BANK_NOT_PROBED;
	}

	if (offset + count > bank->size) {
		LOG_WARNING("Read beyond end of flash. Extra data to be ignored.");
		count = bank->size - offset;
	}

	/* Abort any previous operation */
	retval = stmqspi_abort(bank);
	if (retval != ERROR_OK)
		return retval;

	/* Wait for busy to be cleared */
	retval = poll_busy(bank, SPI_PROBE_TIMEOUT);
	if (retval != ERROR_OK)
		return retval;

	return qspi_read_write_block(bank, buffer, offset, count, false);
}

static int stmqspi_write(struct flash_bank *bank, const uint8_t *buffer,
	uint32_t offset, uint32_t count)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	unsigned int dual, sector;
	bool octal_dtr;
	int retval;

	LOG_DEBUG("%s: offset=0x%08" PRIx32 " count=0x%08" PRIx32,
		__func__, offset, count);

	dual = (stmqspi_info->saved_cr & BIT(SPI_DUAL_FLASH)) ? 1 : 0;
	octal_dtr = IS_OCTOSPI && (stmqspi_info->saved_ccr & BIT(OCTOSPI_DDTR));

	if (target->state != TARGET_HALTED) {
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	if (!(stmqspi_info->probed)) {
		LOG_ERROR("Flash bank not probed");
		return ERROR_FLASH_BANK_NOT_PROBED;
	}

	if (offset + count > bank->size) {
		LOG_WARNING("Write beyond end of flash. Extra data discarded.");
		count = bank->size - offset;
	}

	/* Check sector protection */
	for (sector = 0; sector < bank->num_sectors; sector++) {
		/* Start offset in or before this sector? */
		/* End offset in or behind this sector? */
		if ((offset < (bank->sectors[sector].offset + bank->sectors[sector].size)) &&
			((offset + count - 1) >= bank->sectors[sector].offset) &&
			bank->sectors[sector].is_protected) {
			LOG_ERROR("Flash sector %u protected", sector);
			return ERROR_FLASH_PROTECTED;
		}
	}

	if ((dual || octal_dtr) && ((offset & 1) != 0 || (count & 1) != 0)) {
		LOG_ERROR("In dual-QSPI and octal-DTR modes writes must be two byte aligned: "
			"%s: address=0x%08" PRIx32 " len=0x%08" PRIx32, __func__, offset, count);
		return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
	}

	/* Abort any previous operation */
	retval = stmqspi_abort(bank);
	if (retval != ERROR_OK)
		return retval;

	/* Wait for busy to be cleared */
	retval = poll_busy(bank, SPI_PROBE_TIMEOUT);
	if (retval != ERROR_OK)
		return retval;

	return qspi_read_write_block(bank, (uint8_t *)buffer, offset, count, true);
}

static int stmqspi_verify(struct flash_bank *bank, const uint8_t *buffer,
	uint32_t offset, uint32_t count)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	unsigned int dual;
	bool octal_dtr;
	int retval;

	LOG_DEBUG("%s: offset=0x%08" PRIx32 " count=0x%08" PRIx32,
		__func__, offset, count);

	dual = (stmqspi_info->saved_cr & BIT(SPI_DUAL_FLASH)) ? 1 : 0;
	octal_dtr = IS_OCTOSPI && (stmqspi_info->saved_ccr & BIT(OCTOSPI_DDTR));

	if (target->state != TARGET_HALTED) {
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	if (!(stmqspi_info->probed)) {
		LOG_ERROR("Flash bank not probed");
		return ERROR_FLASH_BANK_NOT_PROBED;
	}

	if (offset + count > bank->size) {
		LOG_WARNING("Verify beyond end of flash. Extra data ignored.");
		count = bank->size - offset;
	}

	if ((dual || octal_dtr) && ((offset & 1) != 0 || (count & 1) != 0)) {
		LOG_ERROR("In dual-QSPI and octal-DTR modes reads must be two byte aligned: "
			"%s: address=0x%08" PRIx32 " len=0x%08" PRIx32, __func__, offset, count);
		return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
	}

	/* Abort any previous operation */
	retval = stmqspi_abort(bank);
	if (retval != ERROR_OK)
		return retval;

	/* Wait for busy to be cleared */
	retval = poll_busy(bank, SPI_PROBE_TIMEOUT);
	if (retval != ERROR_OK)
		return retval;

	return qspi_verify(bank, (uint8_t *)buffer, offset, count);
}

/* Find appropriate dummy setting, in particular octo mode */
static int find_sfdp_dummy(struct flash_bank *bank, int len)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	uint32_t io_base = stmqspi_info->io_base;
	uint8_t data;
	unsigned int dual, count;
	bool flash1 = !(stmqspi_info->saved_cr & BIT(SPI_FSEL_FLASH));
	int retval;
	const unsigned int max_bytes = 64;

	dual = (stmqspi_info->saved_cr & BIT(SPI_DUAL_FLASH)) ? 1 : 0;

	LOG_DEBUG("%s: len=%d, dual=%u, flash1=%d",
		__func__, len, dual, flash1);

	/* Abort any previous operation */
	retval = target_write_u32(target, io_base + SPI_CR,
		stmqspi_info->saved_cr | BIT(SPI_ABORT));
	if (retval != ERROR_OK)
		goto err;

	/* Wait for busy to be cleared */
	retval = poll_busy(bank, SPI_PROBE_TIMEOUT);
	if (retval != ERROR_OK)
		goto err;

	/* Switch to saved_cr (had to be set accordingly before this call) */
	retval = target_write_u32(target, io_base + SPI_CR, stmqspi_info->saved_cr);
	if (retval != ERROR_OK)
		goto err;

	/* Read at most that many bytes */
	retval = target_write_u32(target, io_base + SPI_DLR, (max_bytes << dual) - 1);
	if (retval != ERROR_OK)
		return retval;

	/* Read SFDP block */
	if (IS_OCTOSPI)
		retval = octospi_cmd(bank, OCTOSPI_READ_MODE,
			OCTOSPI_CCR_READ_SFDP(len), SPIFLASH_READ_SFDP);
	else
		retval = target_write_u32(target, io_base + QSPI_CCR, QSPI_CCR_READ_SFDP);
	if (retval != ERROR_OK)
		goto err;

	/* Read from start of sfdp block */
	retval = target_write_u32(target, io_base + SPI_AR, 0);
	if (retval != ERROR_OK)
		goto err;

	for (count = 0 ; count < max_bytes; count++) {
		if ((dual != 0) && !flash1) {
			/* discard even byte in dual flash-mode if flash2 */
			retval = target_read_u8(target, io_base + SPI_DR, &data);
			if (retval != ERROR_OK)
				goto err;
		}

		retval = target_read_u8(target, io_base + SPI_DR, &data);
		if (retval != ERROR_OK)
			goto err;

		if (data == 0x53) {
			LOG_DEBUG("start of SFDP header for flash%c after %u dummy bytes",
				flash1 ? '1' : '2', count);
			if (flash1)
				stmqspi_info->sfdp_dummy1 = count;
			else
				stmqspi_info->sfdp_dummy2 = count;
			return ERROR_OK;
		}

		if ((dual != 0) && flash1) {
			/* discard odd byte in dual flash-mode if flash1 */
			retval = target_read_u8(target, io_base + SPI_DR, &data);
			if (retval != ERROR_OK)
				goto err;
		}
	}

	retval = ERROR_FAIL;
	LOG_DEBUG("no start of SFDP header even after %u dummy bytes", count);

err:
	/* Abort operation */
	retval = stmqspi_abort(bank);

	return retval;
}

/* Read SFDP parameter block */
static int read_sfdp_block(struct flash_bank *bank, uint32_t addr,
	uint32_t words, uint32_t *buffer)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	uint32_t io_base = stmqspi_info->io_base;
	bool flash1 = !(stmqspi_info->saved_cr & BIT(SPI_FSEL_FLASH));
	unsigned int dual, count, len, *dummy;
	int retval;

	dual = (stmqspi_info->saved_cr & BIT(SPI_DUAL_FLASH)) ? 1 : 0;

	if (IS_OCTOSPI && (((stmqspi_info->saved_ccr >> SPI_DMODE_POS) & 0x7) > 3)) {
		/* in OCTO mode 4-byte address and (yet) unknown number of dummy clocks */
		len = 4;

		/* in octo mode, use sfdp_dummy1 only */
		dummy = &stmqspi_info->sfdp_dummy1;
		if (*dummy == 0) {
			retval = find_sfdp_dummy(bank, len);
			if (retval != ERROR_OK)
				return retval;
		}
	} else {
		/* in all other modes 3-byte-address and 8(?) dummy clocks */
		len = 3;

		/* use sfdp_dummy1/2 according to currently selected flash */
		dummy = (stmqspi_info->saved_cr & BIT(SPI_FSEL_FLASH)) ?
			&stmqspi_info->sfdp_dummy2 : &stmqspi_info->sfdp_dummy1;

		/* according to SFDP standard, there should always be 8 dummy *CLOCKS*
		 * giving 1, 2 or 4 dummy *BYTES*, however, this is apparently not
		 * always implemented correctly, so determine the number of dummy bytes
		 * dynamically */
		if (*dummy == 0) {
			retval = find_sfdp_dummy(bank, len);
			if (retval != ERROR_OK)
				return retval;
		}
	}

	LOG_DEBUG("%s: addr=0x%08" PRIx32 " words=0x%08" PRIx32 " dummy=%u",
		__func__, addr, words, *dummy);

	/* Abort any previous operation */
	retval = target_write_u32(target, io_base + SPI_CR,
		stmqspi_info->saved_cr | BIT(SPI_ABORT));
	if (retval != ERROR_OK)
		goto err;

	/* Wait for busy to be cleared */
	retval = poll_busy(bank, SPI_PROBE_TIMEOUT);
	if (retval != ERROR_OK)
		goto err;

	/* Switch to one flash only */
	retval = target_write_u32(target, io_base + SPI_CR, stmqspi_info->saved_cr);
	if (retval != ERROR_OK)
		goto err;

	/* Read that many words plus dummy bytes */
	retval = target_write_u32(target, io_base + SPI_DLR,
		((*dummy + words * sizeof(uint32_t)) << dual) - 1);
	if (retval != ERROR_OK)
		goto err;

	/* Read SFDP block */
	if (IS_OCTOSPI)
		retval = octospi_cmd(bank, OCTOSPI_READ_MODE,
			OCTOSPI_CCR_READ_SFDP(len), SPIFLASH_READ_SFDP);
	else
		retval = target_write_u32(target, io_base + QSPI_CCR, QSPI_CCR_READ_SFDP);
	if (retval != ERROR_OK)
		goto err;

	retval = target_write_u32(target, io_base + SPI_AR, addr << dual);
	if (retval != ERROR_OK)
		goto err;

	/* dummy clocks */
	for (count = *dummy << dual; count > 0; --count) {
		retval = target_read_u8(target, io_base + SPI_DR, (uint8_t *)buffer);
		if (retval != ERROR_OK)
			goto err;
	}

	for ( ; words > 0; words--) {
		if (dual != 0) {
			uint32_t word1, word2;

			retval = target_read_u32(target, io_base + SPI_DR, &word1);
			if (retval != ERROR_OK)
				goto err;
			retval = target_read_u32(target, io_base + SPI_DR, &word2);
			if (retval != ERROR_OK)
				goto err;

			if (!flash1) {
				/* shift odd numbered bytes into even numbered ones */
				word1 >>= 8;
				word2 >>= 8;
			}

			/* pack even numbered bytes into one word */
			*buffer = (word1 & 0xFFU) | ((word1 & 0xFF0000U) >> 8) |
				((word2 & 0xFFU) << 16) | ((word2 & 0xFF0000U) << 8);


		} else {
			retval = target_read_u32(target, io_base + SPI_DR, buffer);
			if (retval != ERROR_OK)
				goto err;
		}
		LOG_DEBUG("raw SFDP data 0x%08" PRIx32, *buffer);

		/* endian correction, sfdp data is always le uint32_t based */
		*buffer = le_to_h_u32((uint8_t *)buffer);
		buffer++;
	}

err:
	return retval;
}

/* Return ID of flash device(s) */
/* On exit, indirect mode is kept */
static int read_flash_id(struct flash_bank *bank, uint32_t *id1, uint32_t *id2)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	uint32_t io_base = stmqspi_info->io_base;
	uint8_t byte;
	unsigned int type, count, len1, len2;
	int retval = ERROR_OK;

	/* invalidate both ids */
	*id1 = 0;
	*id2 = 0;

	if (target->state != TARGET_HALTED) {
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	/* SPIFLASH_READ_MID causes device in octal mode to go berserk, so don't use in this case */
	for (type = (IS_OCTOSPI && OPI_MODE) ? 1 : 0; type < 2 ; type++) {
		/* Abort any previous operation */
		retval = stmqspi_abort(bank);
		if (retval != ERROR_OK)
			goto err;

		/* Poll WIP */
		retval = wait_till_ready(bank, SPI_PROBE_TIMEOUT);
		if (retval != ERROR_OK)
			goto err;

		/* Wait for busy to be cleared */
		retval = poll_busy(bank, SPI_PROBE_TIMEOUT);
		if (retval != ERROR_OK)
			goto err;

		/* Read at most 16 bytes per chip */
		count = 16;
		retval = target_write_u32(target, io_base + SPI_DLR,
			(stmqspi_info->saved_cr & BIT(SPI_DUAL_FLASH) ? count * 2 : count) - 1);
		if (retval != ERROR_OK)
			goto err;

		/* Read id: one particular flash chip (N25Q128) switches back to SPI mode when receiving
		 * SPI_FLASH_READ_ID in QPI mode, hence try SPIFLASH_READ_MID first */
		switch (type) {
			case 0:
				if (IS_OCTOSPI)
					retval = octospi_cmd(bank, OCTOSPI_READ_MODE,
						OCTOSPI_CCR_READ_MID, SPIFLASH_READ_MID);
				else
					retval = target_write_u32(target, io_base + QSPI_CCR, QSPI_CCR_READ_MID);
				break;

			case 1:
				if (IS_OCTOSPI)
					retval = octospi_cmd(bank, OCTOSPI_READ_MODE,
						OCTOSPI_CCR_READ_ID, SPIFLASH_READ_ID);
				else
					retval = target_write_u32(target, io_base + QSPI_CCR, QSPI_CCR_READ_ID);
				break;

			default:
				return ERROR_FAIL;
		}

		if (retval != ERROR_OK)
			goto err;

		/* Dummy address 0, only required for 8-line mode */
		if (IS_OCTOSPI && OPI_MODE) {
			retval = target_write_u32(target, io_base + SPI_AR, 0);
			if (retval != ERROR_OK)
				goto err;
		}

		/* for debugging only */
		uint32_t dummy;
		(void)target_read_u32(target, io_base + SPI_SR, &dummy);

		/* Read ID from Data Register */
		for (len1 = 0, len2 = 0; count > 0; --count) {
			if ((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) |
				BIT(SPI_FSEL_FLASH))) != BIT(SPI_FSEL_FLASH)) {
				retval = target_read_u8(target, io_base + SPI_DR, &byte);
				if (retval != ERROR_OK)
					goto err;
				/* collect 3 bytes without continuation codes */
				if ((byte != 0x7F) && (len1 < 3)) {
					*id1 = (*id1 >> 8) | ((uint32_t)byte) << 16;
					len1++;
				}
			}
			if ((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) |
				BIT(SPI_FSEL_FLASH))) != 0) {
				retval = target_read_u8(target, io_base + SPI_DR, &byte);
				if (retval != ERROR_OK)
					goto err;
				/* collect 3 bytes without continuation codes */
				if ((byte != 0x7F) && (len2 < 3)) {
					*id2 = (*id2 >> 8) | ((uint32_t)byte) << 16;
					len2++;
				}
			}
		}

		if (((*id1 != 0x000000) && (*id1 != 0xFFFFFF)) ||
			((*id2 != 0x000000) && (*id2 != 0xFFFFFF)))
			break;
	}

	if ((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) |
		BIT(SPI_FSEL_FLASH))) != BIT(SPI_FSEL_FLASH)) {
		if ((*id1 == 0x000000) || (*id1 == 0xFFFFFF)) {
			/* no id retrieved, so id must be set manually */
			LOG_INFO("No id from flash1");
			retval = ERROR_FLASH_BANK_NOT_PROBED;
		}
	}

	if ((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) | BIT(SPI_FSEL_FLASH))) != 0) {
		if ((*id2 == 0x000000) || (*id2 == 0xFFFFFF)) {
			/* no id retrieved, so id must be set manually */
			LOG_INFO("No id from flash2");
			retval = ERROR_FLASH_BANK_NOT_PROBED;
		}
	}

err:
	return retval;
}

static int stmqspi_probe(struct flash_bank *bank)
{
	struct target *target = bank->target;
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
	struct flash_sector *sectors = NULL;
	uint32_t io_base = stmqspi_info->io_base;
	uint32_t id1 = 0, id2 = 0, data = 0;
	const struct flash_device *p;
	const uint32_t magic = 0xAEF1510E;
	unsigned int dual, fsize;
	bool octal_dtr;
	int retval;

	if (stmqspi_info->probed) {
		bank->size = 0;
		bank->num_sectors = 0;
		free(bank->sectors);
		bank->sectors = NULL;
		memset(&stmqspi_info->dev, 0, sizeof(stmqspi_info->dev));
		stmqspi_info->sfdp_dummy1 = 0;
		stmqspi_info->sfdp_dummy2 = 0;
		stmqspi_info->probed = false;
	}

	/* Abort any previous operation */
	retval = stmqspi_abort(bank);
	if (retval != ERROR_OK)
		return retval;

	/* Wait for busy to be cleared */
	retval = poll_busy(bank, SPI_PROBE_TIMEOUT);
	if (retval != ERROR_OK)
		return retval;

	/* check whether QSPI_ABR is writeable and readback returns the value written */
	retval = target_write_u32(target, io_base + QSPI_ABR, magic);
	if (retval == ERROR_OK) {
		retval = target_read_u32(target, io_base + QSPI_ABR, &data);
		retval = target_write_u32(target, io_base + QSPI_ABR, 0);
	}

	if (data == magic) {
		LOG_DEBUG("QSPI_ABR register present");
		stmqspi_info->octo = false;
	} else {
		uint32_t magic_id;

		retval = target_read_u32(target, io_base + OCTOSPI_MAGIC, &magic_id);

		if (retval == ERROR_OK && magic_id == OCTO_MAGIC_ID) {
			LOG_DEBUG("OCTOSPI_MAGIC present");
			stmqspi_info->octo = true;
		} else {
			LOG_ERROR("No QSPI, no OCTOSPI at 0x%08" PRIx32, io_base);
			stmqspi_info->probed = false;
			stmqspi_info->dev.name = "none";
			return ERROR_FAIL;
		}
	}

	/* save current FSEL and DFM bits in QSPI/OCTOSPI_CR, current QSPI/OCTOSPI_CCR value */
	retval = target_read_u32(target, io_base + SPI_CR, &stmqspi_info->saved_cr);
	if (retval == ERROR_OK)
		retval = target_read_u32(target, io_base + SPI_CCR, &stmqspi_info->saved_ccr);

	if (IS_OCTOSPI) {
		uint32_t dcr1;

		retval = target_read_u32(target, io_base + OCTOSPI_DCR1, &dcr1);

		if (retval == ERROR_OK)
			retval = target_read_u32(target, io_base + OCTOSPI_TCR,
				&stmqspi_info->saved_tcr);

		if (retval == ERROR_OK)
			retval = target_read_u32(target, io_base + OCTOSPI_IR,
				&stmqspi_info->saved_ir);

		if (retval != ERROR_OK) {
			LOG_ERROR("No OCTOSPI at io_base 0x%08" PRIx32, io_base);
			stmqspi_info->probed = false;
			stmqspi_info->dev.name = "none";
			return ERROR_FAIL;
		}

		const uint32_t mtyp = (dcr1 & OCTOSPI_MTYP_MASK) >> OCTOSPI_MTYP_POS;

		if ((mtyp != 0x0) && (mtyp != 0x1)) {
			LOG_ERROR("Only regular SPI protocol supported in OCTOSPI");
			stmqspi_info->probed = false;
			stmqspi_info->dev.name = "none";
			return ERROR_FAIL;
		}

		LOG_DEBUG("OCTOSPI at 0x%08" PRIx64 ", io_base at 0x%08" PRIx32 ", OCTOSPI_CR 0x%08"
			PRIx32 ", OCTOSPI_CCR 0x%08" PRIx32 ", %d-byte addr", bank->base, io_base,
			stmqspi_info->saved_cr, stmqspi_info->saved_ccr, SPI_ADSIZE);
	} else {
		if (retval == ERROR_OK) {
			LOG_DEBUG("QSPI at 0x%08" PRIx64 ", io_base at 0x%08" PRIx32 ", QSPI_CR 0x%08"
				PRIx32 ", QSPI_CCR 0x%08" PRIx32 ", %d-byte addr", bank->base, io_base,
				stmqspi_info->saved_cr, stmqspi_info->saved_ccr, SPI_ADSIZE);
				if (stmqspi_info->saved_ccr & (1U << QSPI_DDRM))
					LOG_WARNING("DDR mode is untested and suffers from some silicon bugs");
		} else {
			LOG_ERROR("No QSPI at io_base 0x%08" PRIx32, io_base);
			stmqspi_info->probed = false;
			stmqspi_info->dev.name = "none";
			return ERROR_FAIL;
		}
	}

	dual = (stmqspi_info->saved_cr & BIT(SPI_DUAL_FLASH)) ? 1 : 0;
	octal_dtr = IS_OCTOSPI && (stmqspi_info->saved_ccr & BIT(OCTOSPI_DDTR));
	if (dual || octal_dtr)
		bank->write_start_alignment = bank->write_end_alignment = 2;
	else
		bank->write_start_alignment = bank->write_end_alignment = 1;

	/* read and decode flash ID; returns in indirect mode */
	retval = read_flash_id(bank, &id1, &id2);
	LOG_DEBUG("id1 0x%06" PRIx32 ", id2 0x%06" PRIx32, id1, id2);
	if (retval == ERROR_FLASH_BANK_NOT_PROBED) {
		/* no id retrieved, so id must be set manually */
		LOG_INFO("No id - set flash parameters manually");
		retval = ERROR_OK;
		goto err;
	}

	if (retval != ERROR_OK)
		goto err;

	/* identify flash1 */
	for (p = flash_devices; id1 && p->name ; p++) {
		if (p->device_id == id1) {
			memcpy(&stmqspi_info->dev, p, sizeof(stmqspi_info->dev));
			if (p->size_in_bytes / 4096)
				LOG_INFO("flash1 \'%s\' id = 0x%06" PRIx32 " size = %" PRIu32
					"kbytes", p->name, id1, p->size_in_bytes / 1024);
			else
				LOG_INFO("flash1 \'%s\' id = 0x%06" PRIx32 " size = %" PRIu32
					"bytes", p->name, id1, p->size_in_bytes);
			break;
		}
	}

	if (id1 && !p->name) {
		/* chip not been identified by id, then try SFDP */
		struct flash_device temp;
		uint32_t saved_cr = stmqspi_info->saved_cr;

		/* select flash1 */
		stmqspi_info->saved_cr = stmqspi_info->saved_cr & ~BIT(SPI_FSEL_FLASH);
		retval = spi_sfdp(bank, &temp, &read_sfdp_block);

		/* restore saved_cr */
		stmqspi_info->saved_cr = saved_cr;

		if (retval == ERROR_OK) {
			LOG_INFO("flash1 \'%s\' id = 0x%06" PRIx32 " size = %" PRIu32
				"kbytes", temp.name, id1, temp.size_in_bytes / 1024);
			/* save info and retrieved *good* id as spi_sfdp clears all info */
			memcpy(&stmqspi_info->dev, &temp, sizeof(stmqspi_info->dev));
			stmqspi_info->dev.device_id = id1;
		} else {
			/* even not identified by SFDP, then give up */
			LOG_WARNING("Unknown flash1 device id = 0x%06" PRIx32
				" - set flash parameters manually", id1);
			retval = ERROR_OK;
			goto err;
		}
	}

	/* identify flash2 */
	for (p = flash_devices; id2 && p->name ; p++) {
		if (p->device_id == id2) {
			if (p->size_in_bytes / 4096)
				LOG_INFO("flash2 \'%s\' id = 0x%06" PRIx32 " size = %" PRIu32
					"kbytes", p->name, id2, p->size_in_bytes / 1024);
			else
				LOG_INFO("flash2 \'%s\' id = 0x%06" PRIx32 " size = %" PRIu32
					"bytes", p->name, id2, p->size_in_bytes);

			if (!id1)
				memcpy(&stmqspi_info->dev, p, sizeof(stmqspi_info->dev));
			else {
				if ((stmqspi_info->dev.read_cmd != p->read_cmd) ||
					(stmqspi_info->dev.qread_cmd != p->qread_cmd) ||
					(stmqspi_info->dev.pprog_cmd != p->pprog_cmd) ||
					(stmqspi_info->dev.erase_cmd != p->erase_cmd) ||
					(stmqspi_info->dev.chip_erase_cmd != p->chip_erase_cmd) ||
					(stmqspi_info->dev.sectorsize != p->sectorsize) ||
					(stmqspi_info->dev.size_in_bytes != p->size_in_bytes)) {
					LOG_ERROR("Incompatible flash1/flash2 devices");
					goto err;
				}
				/* page size is optional in SFDP, so accept smallest value */
				if (p->pagesize < stmqspi_info->dev.pagesize)
					stmqspi_info->dev.pagesize = p->pagesize;
			}
			break;
		}
	}

	if (id2 && !p->name) {
		/* chip not been identified by id, then try SFDP */
		struct flash_device temp;
		uint32_t saved_cr = stmqspi_info->saved_cr;

		/* select flash2 */
		stmqspi_info->saved_cr = stmqspi_info->saved_cr | BIT(SPI_FSEL_FLASH);
		retval = spi_sfdp(bank, &temp, &read_sfdp_block);

		/* restore saved_cr */
		stmqspi_info->saved_cr = saved_cr;

		if (retval == ERROR_OK)
			LOG_INFO("flash2 \'%s\' id = 0x%06" PRIx32 " size = %" PRIu32
				"kbytes", temp.name, id2, temp.size_in_bytes / 1024);
		else {
			/* even not identified by SFDP, then give up */
			LOG_WARNING("Unknown flash2 device id = 0x%06" PRIx32
				" - set flash parameters manually", id2);
			retval = ERROR_OK;
			goto err;
		}

		if (!id1)
			memcpy(&stmqspi_info->dev, &temp, sizeof(stmqspi_info->dev));
		else {
			if ((stmqspi_info->dev.read_cmd != temp.read_cmd) ||
				(stmqspi_info->dev.qread_cmd != temp.qread_cmd) ||
				(stmqspi_info->dev.pprog_cmd != temp.pprog_cmd) ||
				(stmqspi_info->dev.erase_cmd != temp.erase_cmd) ||
				(stmqspi_info->dev.chip_erase_cmd != temp.chip_erase_cmd) ||
				(stmqspi_info->dev.sectorsize != temp.sectorsize) ||
				(stmqspi_info->dev.size_in_bytes != temp.size_in_bytes)) {
				LOG_ERROR("Incompatible flash1/flash2 devices");
				goto err;
			}
			/* page size is optional in SFDP, so accept smallest value */
			if (temp.pagesize < stmqspi_info->dev.pagesize)
				stmqspi_info->dev.pagesize = temp.pagesize;
		}
	}

	/* Set correct size value */
	bank->size = stmqspi_info->dev.size_in_bytes << dual;

	uint32_t dcr;
	retval = target_read_u32(target, io_base + SPI_DCR, &dcr);

	if (retval != ERROR_OK)
		goto err;

	fsize = (dcr >> SPI_FSIZE_POS) & (BIT(SPI_FSIZE_LEN) - 1);

	LOG_DEBUG("FSIZE = 0x%04x", fsize);
	if (bank->size == BIT((fsize + 1)))
		LOG_DEBUG("FSIZE in DCR(1) matches actual capacity. Beware of silicon bug in H7, L4+, MP1.");
	else if (bank->size == BIT((fsize + 0)))
		LOG_DEBUG("FSIZE in DCR(1) is off by one regarding actual capacity. Fix for silicon bug?");
	else
		LOG_ERROR("FSIZE in DCR(1) doesn't match actual capacity.");

	/* if no sectors, then treat whole flash as single sector */
	if (stmqspi_info->dev.sectorsize == 0)
		stmqspi_info->dev.sectorsize = stmqspi_info->dev.size_in_bytes;
	/* if no page_size, then use sectorsize as page_size */
	if (stmqspi_info->dev.pagesize == 0)
		stmqspi_info->dev.pagesize = stmqspi_info->dev.sectorsize;

	/* create and fill sectors array */
	bank->num_sectors = stmqspi_info->dev.size_in_bytes / stmqspi_info->dev.sectorsize;
	sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
	if (sectors == NULL) {
		LOG_ERROR("not enough memory");
		retval = ERROR_FAIL;
		goto err;
	}

	for (unsigned int sector = 0; sector < bank->num_sectors; sector++) {
		sectors[sector].offset = sector * (stmqspi_info->dev.sectorsize << dual);
		sectors[sector].size = (stmqspi_info->dev.sectorsize << dual);
		sectors[sector].is_erased = -1;
		sectors[sector].is_protected = 0;
	}

	bank->sectors = sectors;
	stmqspi_info->probed = true;

err:
	/* Switch to memory mapped mode before return to prompt */
	set_mm_mode(bank);

	return retval;
}

static int stmqspi_auto_probe(struct flash_bank *bank)
{
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;

	if (stmqspi_info->probed)
		return ERROR_OK;
	stmqspi_probe(bank);
	return ERROR_OK;
}

static int stmqspi_protect_check(struct flash_bank *bank)
{
	/* Nothing to do. Protection is only handled in SW. */
	return ERROR_OK;
}

static int get_stmqspi_info(struct flash_bank *bank, struct command_invocation *cmd)
{
	struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;

	if (!(stmqspi_info->probed)) {
		command_print_sameline(cmd, "\nQSPI flash bank not probed yet\n");
		return ERROR_FLASH_BANK_NOT_PROBED;
	}

	command_print_sameline(cmd, "flash%s%s \'%s\', device id = 0x%06" PRIx32
			", flash size = %" PRIu32 "%sbytes\n(page size = %" PRIu32
			", read = 0x%02" PRIx8 ", qread = 0x%02" PRIx8
			", pprog = 0x%02" PRIx8 ", mass_erase = 0x%02" PRIx8
			", sector size = %" PRIu32 "%sbytes, sector_erase = 0x%02" PRIx8 ")",
			((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) |
			BIT(SPI_FSEL_FLASH))) != BIT(SPI_FSEL_FLASH)) ? "1" : "",
			((stmqspi_info->saved_cr & (BIT(SPI_DUAL_FLASH) |
			BIT(SPI_FSEL_FLASH))) != 0) ? "2" : "",
			stmqspi_info->dev.name, stmqspi_info->dev.device_id,
			bank->size / 4096 ? bank->size / 1024 : bank->size,
			bank->size / 4096 ? "k" : "", stmqspi_info->dev.pagesize,
			stmqspi_info->dev.read_cmd, stmqspi_info->dev.qread_cmd,
			stmqspi_info->dev.pprog_cmd, stmqspi_info->dev.chip_erase_cmd,
			stmqspi_info->dev.sectorsize / 4096 ?
				stmqspi_info->dev.sectorsize / 1024 : stmqspi_info->dev.sectorsize,
			stmqspi_info->dev.sectorsize / 4096 ? "k" : "",
			stmqspi_info->dev.erase_cmd);

	return ERROR_OK;
}

static const struct command_registration stmqspi_exec_command_handlers[] = {
	{
		.name = "mass_erase",
		.handler = stmqspi_handle_mass_erase_command,
		.mode = COMMAND_EXEC,
		.usage = "bank_id",
		.help = "Mass erase entire flash device.",
	},
	{
		.name = "set",
		.handler = stmqspi_handle_set,
		.mode = COMMAND_EXEC,
		.usage = "bank_id name chip_size page_size read_cmd qread_cmd pprg_cmd "
			"[ mass_erase_cmd ] [ sector_size sector_erase_cmd ]",
		.help = "Set params of single flash chip",
	},
	{
		.name = "cmd",
		.handler = stmqspi_handle_cmd,
		.mode = COMMAND_EXEC,
		.usage = "bank_id num_resp cmd_byte ...",
		.help = "Send low-level command cmd_byte and following bytes or read num_resp.",
	},
	COMMAND_REGISTRATION_DONE
};

static const struct command_registration stmqspi_command_handlers[] = {
	{
		.name = "stmqspi",
		.mode = COMMAND_ANY,
		.help = "stmqspi flash command group",
		.usage = "",
		.chain = stmqspi_exec_command_handlers,
	},
	COMMAND_REGISTRATION_DONE
};

struct flash_driver stmqspi_flash = {
	.name = "stmqspi",
	.commands = stmqspi_command_handlers,
	.flash_bank_command = stmqspi_flash_bank_command,
	.erase = stmqspi_erase,
	.protect = stmqspi_protect,
	.write = stmqspi_write,
	.read = stmqspi_read,
	.verify = stmqspi_verify,
	.probe = stmqspi_probe,
	.auto_probe = stmqspi_auto_probe,
	.erase_check = stmqspi_blank_check,
	.protect_check = stmqspi_protect_check,
	.info = get_stmqspi_info,
	.free_driver_priv = default_flash_free_driver_priv,
};