STM32H750B-DK TouchGFX Project: "Cannot access memory at address 0x90000000" During Debug

[ksale.1]

Board: STM32H750B-DK (DK32H750B$AT1)
IDE: STM32CubeIDE 1.14.1
CubeMX: 6.11.1
TouchGFX: 4.23.1
Firmware: STM32Cube FW_H7 V1.12.1

Problem Description:

I created a new TouchGFX project for the STM32H750B-DK board. The project builds successfully (0 errors, 1 warning), but I cannot debug it. When starting a debug session, I get the error: "Cannot access memory at address 0x90000000".

The project is configured to use external QSPI flash (0x90000000) for code execution (XIP) since the code size (424KB) exceeds the H750's internal flash (128KB).

What Works:

• Project builds successfully

• Simple non-TouchGFX blinky projects debug successfully

What Fails:

• Debug session fails with memory access errors at 0x90000000

• Attempts to set SP/PC from external flash vector table fail

As found

 

STMicroelectronics ST-LINK GDB server. Version 7.12.0

Copyright (c) 2025, STMicroelectronics. All rights reserved.

 

Starting server with the following options:

Persistent Mode : Disabled

Logging Level : 1

Listen Port Number : 61234

Status Refresh Delay : 15s

Verbose Mode : Disabled

SWD Debug : Enabled

InitWhile : Enabled

 

Waiting for debugger connection...

Debugger connected

Waiting for debugger connection...

Debugger connected

Waiting for debugger connection...

-------------------------------------------------------------------

STM32CubeProgrammer v2.21.0

-------------------------------------------------------------------

 

Log output file: C:\Users\asus\AppData\Local\Temp\STM32CubeProgrammer_a20920.log

ST-LINK SN : 004D00213137510C33333639

ST-LINK FW : V3J16M9

Board : STM32H750B-DK

Voltage : 3.28V

SWD freq : 8000 KHz

Connect mode: Under Reset

Reset mode : Hardware reset

Device ID : 0x450

Revision ID : Rev V

Device name : STM32H7xx

Flash size : 128 KBytes

Device type : MCU

Device CPU : Cortex-M7

BL Version : 0x90

 

Opening and parsing file: ST-LINK_GDB_server_a20920.srec

 

Memory Programming ...

File : ST-LINK_GDB_server_a20920.srec

Size : 437.95 KB

Address : 0x90000000

 

 

Erasing memory corresponding to segment 0:

Erasing external memory sectors [0 1]

Erasing memory corresponding to segment 1:

Erasing external memory sectors [16 17]

Download in Progress:

 

 

File download complete

Time elapsed during download operation: 00:00:02.260

 

Verifying...

 

Time elapsed during verifying operation: 00:00:01.786

Download verified successfully

 

Any guidance on proper debug configuration for external flash execution would be greatly appreciated!

 

NOTE: Shouldn'e external loader be found, where?

 

[ksale.1]

Attachment 1: main.c

/* USER CODE BEGIN Header */
/**
 ******************************************************************************
 * @file : main.c
 * @brief : Main program body
 ******************************************************************************
 * @attention
 *
 * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
 * All rights reserved.</center></h2>
 *
 * This software component is licensed by ST under Ultimate Liberty license
 * SLA0044, the "License"; You may not use this file except in compliance with
 * the License. You may obtain a copy of the License at:
 * www.st.com/SLA0044
 *
 ******************************************************************************
 */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "cmsis_os.h"
#include "libjpeg.h"
#include "app_touchgfx.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stm32h750b_discovery_qspi.h"
#include "stm32h750b_discovery_sdram.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

CRC_HandleTypeDef hcrc;

DMA2D_HandleTypeDef hdma2d;

JPEG_HandleTypeDef hjpeg;
MDMA_HandleTypeDef hmdma_jpeg_infifo_th;
MDMA_HandleTypeDef hmdma_jpeg_outfifo_th;

LTDC_HandleTypeDef hltdc;

QSPI_HandleTypeDef hqspi;

RTC_HandleTypeDef hrtc;

SDRAM_HandleTypeDef hsdram2;

/* Definitions for defaultTask */
osThreadId_t defaultTaskHandle;
const osThreadAttr_t defaultTask_attributes = {
 .name = "defaultTask",
 .stack_size = 128 * 4,
 .priority = (osPriority_t) osPriorityNormal,
};
/* Definitions for GUITask */
osThreadId_t GUITaskHandle;
const osThreadAttr_t GUITask_attributes = {
 .name = "GUITask",
 .stack_size = 8192 * 4,
 .priority = (osPriority_t) osPriorityNormal,
};
/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MPU_Config(void);
static void MX_GPIO_Init(void);
static void MX_MDMA_Init(void);
static void MX_LTDC_Init(void);
static void MX_DMA2D_Init(void);
static void MX_QUADSPI_Init(void);
static void MX_FMC_Init(void);
static void MX_JPEG_Init(void);
static void MX_CRC_Init(void);
static void MX_RTC_Init(void);
void StartDefaultTask(void *argument);
extern void TouchGFX_Task(void *argument);

/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
 * @brief The application entry point.
 * @retval int
 */
int main(void)
{

 /* USER CODE BEGIN 1 */

 /* USER CODE END 1 */

 /* MPU Configuration--------------------------------------------------------*/
 MPU_Config();

 /* Enable the CPU Cache */

 /* Enable I-Cache---------------------------------------------------------*/
 SCB_EnableICache();

 /* Enable D-Cache---------------------------------------------------------*/
 SCB_EnableDCache();

 /* MCU Configuration--------------------------------------------------------*/

 /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
 HAL_Init();

 /* USER CODE BEGIN Init */

 /* USER CODE END Init */

 /* Configure the system clock */
 SystemClock_Config();

 /* USER CODE BEGIN SysInit */
 /* Explicit enabling interrupt to support debugging in STM32CubeIDE when using external flash loader */
 __enable_irq();
 /* USER CODE END SysInit */

 /* Initialize all configured peripherals */
 MX_GPIO_Init();
 MX_MDMA_Init();
 MX_LTDC_Init();
 MX_DMA2D_Init();
 MX_FMC_Init();
 MX_LIBJPEG_Init();
 MX_JPEG_Init();
 MX_CRC_Init();
 MX_RTC_Init();
 MX_TouchGFX_Init();
 /* Call PreOsInit function */
 MX_TouchGFX_PreOSInit();
 /* USER CODE BEGIN 2 */

 /* USER CODE END 2 */

 /* Init scheduler */
 osKernelInitialize();

 /* USER CODE BEGIN RTOS_MUTEX */
 /* add mutexes, ... */
 /* USER CODE END RTOS_MUTEX */

 /* USER CODE BEGIN RTOS_SEMAPHORES */
 /* add semaphores, ... */
 /* USER CODE END RTOS_SEMAPHORES */

 /* USER CODE BEGIN RTOS_TIMERS */
 /* start timers, add new ones, ... */
 /* USER CODE END RTOS_TIMERS */

 /* USER CODE BEGIN RTOS_QUEUES */
 /* add queues, ... */
 /* USER CODE END RTOS_QUEUES */

 /* Create the thread(s) */
 /* creation of defaultTask */
 defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes);

 /* creation of GUITask */
 GUITaskHandle = osThreadNew(TouchGFX_Task, NULL, &GUITask_attributes);

 /* USER CODE BEGIN RTOS_THREADS */
 /* add threads, ... */
 /* USER CODE END RTOS_THREADS */

 /* USER CODE BEGIN RTOS_EVENTS */
 /* add events, ... */
 /* USER CODE END RTOS_EVENTS */

 /* Start scheduler */
 osKernelStart();

 /* We should never get here as control is now taken by the scheduler */

 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
 /* USER CODE END WHILE */

 /* USER CODE BEGIN 3 */
 }
 /* USER CODE END 3 */
}

/**
 * @brief System Clock Configuration
 * @retval None
 */
void SystemClock_Config(void)
{
 RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

 /** Supply configuration update enable
 */
 HAL_PWREx_ConfigSupply(PWR_LDO_SUPPLY);

 /** Configure the main internal regulator output voltage
 */
 __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE0);

 while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}

 /** Configure LSE Drive Capability
 */
 HAL_PWR_EnableBkUpAccess();
 __HAL_RCC_LSEDRIVE_CONFIG(RCC_LSEDRIVE_LOW);

 /** Initializes the RCC Oscillators according to the specified parameters
 * in the RCC_OscInitTypeDef structure.
 */
 RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE|RCC_OSCILLATORTYPE_LSE;
 RCC_OscInitStruct.HSEState = RCC_HSE_ON;
 RCC_OscInitStruct.LSEState = RCC_LSE_ON;
 RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
 RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
 RCC_OscInitStruct.PLL.PLLM = 5;
 RCC_OscInitStruct.PLL.PLLN = 192;
 RCC_OscInitStruct.PLL.PLLP = 2;
 RCC_OscInitStruct.PLL.PLLQ = 4;
 RCC_OscInitStruct.PLL.PLLR = 2;
 RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_2;
 RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
 RCC_OscInitStruct.PLL.PLLFRACN = 0;
 if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
 {
 Error_Handler();
 }

 /** Initializes the CPU, AHB and APB buses clocks
 */
 RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
 |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2
 |RCC_CLOCKTYPE_D3PCLK1|RCC_CLOCKTYPE_D1PCLK1;
 RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
 RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
 RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
 RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
 RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
 RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
 RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;

 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
 {
 Error_Handler();
 }
}

/**
 * @brief CRC Initialization Function
 * @PAram None
 * @retval None
 */
static void MX_CRC_Init(void)
{

 /* USER CODE BEGIN CRC_Init 0 */

 /* USER CODE END CRC_Init 0 */

 /* USER CODE BEGIN CRC_Init 1 */

 /* USER CODE END CRC_Init 1 */
 hcrc.Instance = CRC;
 hcrc.Init.DefaultPolynomialUse = DEFAULT_POLYNOMIAL_ENABLE;
 hcrc.Init.DefaultInitValueUse = DEFAULT_INIT_VALUE_ENABLE;
 hcrc.Init.InputDataInversionMode = CRC_INPUTDATA_INVERSION_NONE;
 hcrc.Init.OutputDataInversionMode = CRC_OUTPUTDATA_INVERSION_DISABLE;
 hcrc.InputDataFormat = CRC_INPUTDATA_FORMAT_BYTES;
 if (HAL_CRC_Init(&hcrc) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN CRC_Init 2 */

 /* USER CODE END CRC_Init 2 */

}

/**
 * @brief DMA2D Initialization Function
 * @PAram None
 * @retval None
 */
static void MX_DMA2D_Init(void)
{

 /* USER CODE BEGIN DMA2D_Init 0 */

 /* USER CODE END DMA2D_Init 0 */

 /* USER CODE BEGIN DMA2D_Init 1 */

 /* USER CODE END DMA2D_Init 1 */
 hdma2d.Instance = DMA2D;
 hdma2d.Init.Mode = DMA2D_M2M;
 hdma2d.Init.ColorMode = DMA2D_OUTPUT_RGB565;
 hdma2d.Init.OutputOffset = 0;
 hdma2d.LayerCfg[1].InputOffset = 0;
 hdma2d.LayerCfg[1].InputColorMode = DMA2D_INPUT_RGB565;
 hdma2d.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
 hdma2d.LayerCfg[1].InputAlpha = 0;
 hdma2d.LayerCfg[1].AlphaInverted = DMA2D_REGULAR_ALPHA;
 hdma2d.LayerCfg[1].RedBlueSwap = DMA2D_RB_REGULAR;
 hdma2d.LayerCfg[1].ChromaSubSampling = DMA2D_NO_CSS;
 if (HAL_DMA2D_Init(&hdma2d) != HAL_OK)
 {
 Error_Handler();
 }
 if (HAL_DMA2D_ConfigLayer(&hdma2d, 1) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN DMA2D_Init 2 */

 /* USER CODE END DMA2D_Init 2 */

}

/**
 * @brief JPEG Initialization Function
 * @PAram None
 * @retval None
 */
static void MX_JPEG_Init(void)
{

 /* USER CODE BEGIN JPEG_Init 0 */

 /* USER CODE END JPEG_Init 0 */

 /* USER CODE BEGIN JPEG_Init 1 */

 /* USER CODE END JPEG_Init 1 */
 hjpeg.Instance = JPEG;
 if (HAL_JPEG_Init(&hjpeg) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN JPEG_Init 2 */

 /* USER CODE END JPEG_Init 2 */

}

/**
 * @brief LTDC Initialization Function
 * @PAram None
 * @retval None
 */
static void MX_LTDC_Init(void)
{

 /* USER CODE BEGIN LTDC_Init 0 */

 /* USER CODE END LTDC_Init 0 */

 LTDC_LayerCfgTypeDef pLayerCfg = {0};

 /* USER CODE BEGIN LTDC_Init 1 */

 /* USER CODE END LTDC_Init 1 */
 hltdc.Instance = LTDC;
 hltdc.Init.HSPolarity = LTDC_HSPOLARITY_AL;
 hltdc.Init.VSPolarity = LTDC_VSPOLARITY_AL;
 hltdc.Init.DEPolarity = LTDC_DEPOLARITY_AL;
 hltdc.Init.PCPolarity = LTDC_PCPOLARITY_IPC;
 hltdc.Init.HorizontalSync = 39;
 hltdc.Init.VerticalSync = 8;
 hltdc.Init.AccumulatedHBP = 42;
 hltdc.Init.AccumulatedVBP = 11;
 hltdc.Init.AccumulatedActiveW = 522;
 hltdc.Init.AccumulatedActiveH = 283;
 hltdc.Init.TotalWidth = 528;
 hltdc.Init.TotalHeigh = 285;
 hltdc.Init.Backcolor.Blue = 0;
 hltdc.Init.Backcolor.Green = 0;
 hltdc.Init.Backcolor.Red = 0;
 if (HAL_LTDC_Init(&hltdc) != HAL_OK)
 {
 Error_Handler();
 }
 pLayerCfg.WindowX0 = 0;
 pLayerCfg.WindowX1 = 480;
 pLayerCfg.WindowY0 = 0;
 pLayerCfg.WindowY1 = 272;
 pLayerCfg.PixelFormat = LTDC_PIXEL_FORMAT_RGB565;
 pLayerCfg.Alpha = 255;
 pLayerCfg.Alpha0 = 0;
 pLayerCfg.BlendingFactor1 = LTDC_BLENDING_FACTOR1_CA;
 pLayerCfg.BlendingFactor2 = LTDC_BLENDING_FACTOR2_CA;
 pLayerCfg.FBStartAdress = 0;
 pLayerCfg.ImageWidth = 480;
 pLayerCfg.ImageHeight = 272;
 pLayerCfg.Backcolor.Blue = 0;
 pLayerCfg.Backcolor.Green = 0;
 pLayerCfg.Backcolor.Red = 0;
 if (HAL_LTDC_ConfigLayer(&hltdc, &pLayerCfg, 0) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN LTDC_Init 2 */

 /* USER CODE END LTDC_Init 2 */

}

/**
 * @brief QUADSPI Initialization Function
 * @PAram None
 * @retval None
 */
static void MX_QUADSPI_Init(void)
{

 /* USER CODE BEGIN QUADSPI_Init 0 */
 BSP_QSPI_Init_t qspi_initParams ;
 /* USER CODE END QUADSPI_Init 0 */

 /* USER CODE BEGIN QUADSPI_Init 1 */

 /* USER CODE END QUADSPI_Init 1 */
 /* QUADSPI parameter configuration*/
 hqspi.Instance = QUADSPI;
 hqspi.Init.ClockPrescaler = 3;
 hqspi.Init.FifoThreshold = 1;
 hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_NONE;
 hqspi.Init.FlashSize = 26;
 hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_4_CYCLE;
 hqspi.Init.ClockMode = QSPI_CLOCK_MODE_0;
 hqspi.Init.DualFlash = QSPI_DUALFLASH_ENABLE;
 if (HAL_QSPI_Init(&hqspi) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN QUADSPI_Init 2 */
 qspi_initParams.InterfaceMode = MT25TL01G_QPI_MODE;
 qspi_initParams.TransferRate = MT25TL01G_DTR_TRANSFER ;
 qspi_initParams.DualFlashMode = MT25TL01G_DUALFLASH_ENABLE;
 BSP_QSPI_DeInit(0);
 if (BSP_QSPI_Init(0, &qspi_initParams) != BSP_ERROR_NONE)
 {
 Error_Handler( );
 }
 if(BSP_QSPI_EnableMemoryMappedMode(0) != BSP_ERROR_NONE)
 {
 Error_Handler( );
 }
 /* USER CODE END QUADSPI_Init 2 */

}

/**
 * @brief RTC Initialization Function
 * @PAram None
 * @retval None
 */
static void MX_RTC_Init(void)
{

 /* USER CODE BEGIN RTC_Init 0 */

 /* USER CODE END RTC_Init 0 */

 /* USER CODE BEGIN RTC_Init 1 */

 /* USER CODE END RTC_Init 1 */

 /** Initialize RTC Only
 */
 hrtc.Instance = RTC;
 hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
 hrtc.Init.AsynchPrediv = 127;
 hrtc.Init.SynchPrediv = 255;
 hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
 hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
 hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
 hrtc.Init.OutPutRemap = RTC_OUTPUT_REMAP_NONE;
 if (HAL_RTC_Init(&hrtc) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN RTC_Init 2 */

 /* USER CODE END RTC_Init 2 */

}

/**
 * Enable MDMA controller clock
 */
static void MX_MDMA_Init(void)
{

 /* MDMA controller clock enable */
 __HAL_RCC_MDMA_CLK_ENABLE();
 /* Local variables */

 /* MDMA interrupt initialization */
 /* MDMA_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(MDMA_IRQn, 5, 0);
 HAL_NVIC_EnableIRQ(MDMA_IRQn);

}

/* FMC initialization function */
static void MX_FMC_Init(void)
{

 /* USER CODE BEGIN FMC_Init 0 */

 /* USER CODE END FMC_Init 0 */

 FMC_SDRAM_TimingTypeDef SdramTiming = {0};

 /* USER CODE BEGIN FMC_Init 1 */

 /* USER CODE END FMC_Init 1 */

 /** Perform the SDRAM2 memory initialization sequence
 */
 hsdram2.Instance = FMC_SDRAM_DEVICE;
 /* hsdram2.Init */
 hsdram2.Init.SDBank = FMC_SDRAM_BANK2;
 hsdram2.Init.ColumnBitsNumber = FMC_SDRAM_COLUMN_BITS_NUM_8;
 hsdram2.Init.RowBitsNumber = FMC_SDRAM_ROW_BITS_NUM_12;
 hsdram2.Init.MemoryDataWidth = FMC_SDRAM_MEM_BUS_WIDTH_16;
 hsdram2.Init.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_4;
 hsdram2.Init.CASLatency = FMC_SDRAM_CAS_LATENCY_3;
 hsdram2.Init.WriteProtection = FMC_SDRAM_WRITE_PROTECTION_DISABLE;
 hsdram2.Init.SDClockPeriod = FMC_SDRAM_CLOCK_PERIOD_2;
 hsdram2.Init.ReadBurst = FMC_SDRAM_RBURST_ENABLE;
 hsdram2.Init.ReadPipeDelay = FMC_SDRAM_RPIPE_DELAY_0;
 /* SdramTiming */
 SdramTiming.LoadToActiveDelay = 2;
 SdramTiming.ExitSelfRefreshDelay = 7;
 SdramTiming.SelfRefreshTime = 4;
 SdramTiming.RowCycleDelay = 7;
 SdramTiming.WriteRecoveryTime = 5;
 SdramTiming.RPDelay = 2;
 SdramTiming.RCDDelay = 2;

 if (HAL_SDRAM_Init(&hsdram2, &SdramTiming) != HAL_OK)
 {
 Error_Handler( );
 }

 /* USER CODE BEGIN FMC_Init 2 */
 /* Disable FMC Bank1 to avoid speculative/cache accesses */
 FMC_Bank1_R->BTCR[0] &= ~FMC_BCRx_MBKEN;

 BSP_SDRAM_DeInit(0);
 if(BSP_SDRAM_Init(0) != BSP_ERROR_NONE)
 {
 Error_Handler( );
 }
 /* USER CODE END FMC_Init 2 */
}

/**
 * @brief GPIO Initialization Function
 * @PAram None
 * @retval None
 */
static void MX_GPIO_Init(void)
{
 GPIO_InitTypeDef GPIO_InitStruct = {0};
 /* USER CODE BEGIN MX_GPIO_Init_1 */
 /* USER CODE END MX_GPIO_Init_1 */

 /* GPIO Ports Clock Enable */
 __HAL_RCC_GPIOK_CLK_ENABLE();
 __HAL_RCC_GPIOG_CLK_ENABLE();
 __HAL_RCC_GPIOI_CLK_ENABLE();
 __HAL_RCC_GPIOE_CLK_ENABLE();
 __HAL_RCC_GPIOB_CLK_ENABLE();
 __HAL_RCC_GPIOJ_CLK_ENABLE();
 __HAL_RCC_GPIOC_CLK_ENABLE();
 __HAL_RCC_GPIOD_CLK_ENABLE();
 __HAL_RCC_GPIOF_CLK_ENABLE();
 __HAL_RCC_GPIOH_CLK_ENABLE();
 __HAL_RCC_GPIOA_CLK_ENABLE();

 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(GPIOB, FRAME_RATE_Pin|RENDER_TIME_Pin, GPIO_PIN_RESET);

 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(LCD_DE_GPIO_Port, LCD_DE_Pin, GPIO_PIN_RESET);

 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(VSYNC_FREQ_GPIO_Port, VSYNC_FREQ_Pin, GPIO_PIN_RESET);

 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(LCD_BL_CTRL_GPIO_Port, LCD_BL_CTRL_Pin, GPIO_PIN_SET);

 /*Configure GPIO pin Output Level */
 HAL_GPIO_WritePin(MCU_ACTIVE_GPIO_Port, MCU_ACTIVE_Pin, GPIO_PIN_RESET);

 /*Configure GPIO pins : FRAME_RATE_Pin RENDER_TIME_Pin */
 GPIO_InitStruct.Pin = FRAME_RATE_Pin|RENDER_TIME_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

 /*Configure GPIO pin : LCD_DE_Pin */
 GPIO_InitStruct.Pin = LCD_DE_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 HAL_GPIO_Init(LCD_DE_GPIO_Port, &GPIO_InitStruct);

 /*Configure GPIO pin : VSYNC_FREQ_Pin */
 GPIO_InitStruct.Pin = VSYNC_FREQ_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 HAL_GPIO_Init(VSYNC_FREQ_GPIO_Port, &GPIO_InitStruct);

 /*Configure GPIO pin : LCD_BL_CTRL_Pin */
 GPIO_InitStruct.Pin = LCD_BL_CTRL_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 HAL_GPIO_Init(LCD_BL_CTRL_GPIO_Port, &GPIO_InitStruct);

 /*Configure GPIO pin : MCU_ACTIVE_Pin */
 GPIO_InitStruct.Pin = MCU_ACTIVE_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 HAL_GPIO_Init(MCU_ACTIVE_GPIO_Port, &GPIO_InitStruct);

 /* USER CODE BEGIN MX_GPIO_Init_2 */
 /* USER CODE END MX_GPIO_Init_2 */
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/* USER CODE BEGIN Header_StartDefaultTask */
/**
 * @brief Function implementing the defaultTask thread.
 * @PAram argument: Not used
 * @retval None
 */
/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void *argument)
{
 /* USER CODE BEGIN 5 */
 /* Infinite loop */
 for(;;)
 {
 osDelay(100);
 }
 /* USER CODE END 5 */
}

 /* MPU Configuration */

void MPU_Config(void)
{
 MPU_Region_InitTypeDef MPU_InitStruct = {0};

 /* Disables the MPU */
 HAL_MPU_Disable();

 /** Initializes and configures the Region and the memory to be protected
 */
 MPU_InitStruct.Enable = MPU_REGION_ENABLE;
 MPU_InitStruct.Number = MPU_REGION_NUMBER0;
 MPU_InitStruct.BaseAddress = 0x24000000;
 MPU_InitStruct.Size = MPU_REGION_SIZE_512KB;
 MPU_InitStruct.SubRegionDisable = 0x0;
 MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
 MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
 MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_DISABLE;
 MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
 MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
 MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;

 HAL_MPU_ConfigRegion(&MPU_InitStruct);

 /** Initializes and configures the Region and the memory to be protected
 */
 MPU_InitStruct.Number = MPU_REGION_NUMBER1;
 MPU_InitStruct.BaseAddress = 0x90000000;
 MPU_InitStruct.Size = MPU_REGION_SIZE_256MB;
 MPU_InitStruct.AccessPermission = MPU_REGION_NO_ACCESS;
 MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
 MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;

 HAL_MPU_ConfigRegion(&MPU_InitStruct);

 /** Initializes and configures the Region and the memory to be protected
 */
 MPU_InitStruct.Number = MPU_REGION_NUMBER2;
 MPU_InitStruct.Size = MPU_REGION_SIZE_128MB;
 MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
 MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
 MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
 MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;

 HAL_MPU_ConfigRegion(&MPU_InitStruct);

 /** Initializes and configures the Region and the memory to be protected
 */
 MPU_InitStruct.Number = MPU_REGION_NUMBER3;
 MPU_InitStruct.BaseAddress = 0xD0000000;
 MPU_InitStruct.Size = MPU_REGION_SIZE_256MB;
 MPU_InitStruct.AccessPermission = MPU_REGION_NO_ACCESS;
 MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_DISABLE;
 MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
 MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;

 HAL_MPU_ConfigRegion(&MPU_InitStruct);

 /** Initializes and configures the Region and the memory to be protected
 */
 MPU_InitStruct.Number = MPU_REGION_NUMBER4;
 MPU_InitStruct.Size = MPU_REGION_SIZE_32MB;
 MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
 MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;

 HAL_MPU_ConfigRegion(&MPU_InitStruct);
 /* Enables the MPU */
 HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);

}

/**
 * @brief Period elapsed callback in non blocking mode
 * @note This function is called when TIM6 interrupt took place, inside
 * HAL_TIM_IRQHandler(). It makes a direct call to HAL_IncTick() to increment
 * a global variable "uwTick" used as application time base.
 * @PAram htim : TIM handle
 * @retval None
 */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
 /* USER CODE BEGIN Callback 0 */

 /* USER CODE END Callback 0 */
 if (htim->Instance == TIM6)
 {
 HAL_IncTick();
 }
 /* USER CODE BEGIN Callback 1 */

 /* USER CODE END Callback 1 */
}

/**
 * @brief This function is executed in case of error occurrence.
 * @retval None
 */
void Error_Handler(void)
{
 /* USER CODE BEGIN Error_Handler_Debug */
 /* User can add his own implementation to report the HAL error return state */

 /* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
 * @brief Reports the name of the source file and the source line number
 * where the assert_param error has occurred.
 * @PAram file: pointer to the source file name
 * @PAram line: assert_param error line source number
 * @retval None
 */
void assert_failed(uint8_t *file, uint32_t line)
{
 /* USER CODE BEGIN 6 */
 /* User can add his own implementation to report the file name and line number,
 tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
 /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

 

[ksale.1]

attachment 2: linker script

/*
******************************************************************************
**

** File : LinkerScript.ld
**
** Author		: STM32CubeMX
**
** Abstract : Linker script for STM32H750XBHx series
** 128Kbytes FLASH and 1056Kbytes RAM
**
** Set heap size, stack size and stack location according
** to application requirements.
**
** Set memory bank area and size if external memory is used.
**
** Target : STMicroelectronics STM32
**
** Distribution: The file is distributed “as is,” without any warranty
** of any kind.
**
*****************************************************************************
** @attention
**
** <h2><center>&copy; COPYRIGHT(c) 2025 STMicroelectronics</center></h2>
**
** Redistribution and use in source and binary forms, with or without modification,
** are permitted provided that the following conditions are met:
** 1. Redistributions of source code must retain the above copyright notice,
** this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright notice,
** this list of conditions and the following disclaimer in the documentation
** and/or other materials provided with the distribution.
** 3. Neither the name of STMicroelectronics nor the names of its contributors
** may be used to endorse or promote products derived from this software
** without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
** DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**
*****************************************************************************
*/

/* Entry Point */
ENTRY(Reset_Handler)

/* Specify the memory areas */
MEMORY
{
 DTCMRAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
 ITCMRAM (xrw) : ORIGIN = 0x00000000, LENGTH = 64K
 RAM_D1 (xrw) : ORIGIN = 0x24000000, LENGTH = 512K
 RAM_D2 (xrw) : ORIGIN = 0x30000000, LENGTH = 288K
 RAM_D3 (xrw) : ORIGIN = 0x38000000, LENGTH = 64K
 SDRAM (xrw) : ORIGIN = 0xD0000000, LENGTH = 8M
 FLASH (rx) : ORIGIN = 0x90000000, LENGTH = 2048K
 ASSETS_FLASH (r) : ORIGIN = 0x90200000, LENGTH = 126M
 BOOTLOADER (xrw) : ORIGIN = 0x08000000, LENGTH = 128k
}

/* Highest address of the user mode stack */
_estack = ORIGIN(DTCMRAM) + LENGTH(DTCMRAM); /* end of RAM */
/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0x1000; /* required amount of heap */
_Min_Stack_Size = 0x1000; /* required amount of stack */

/* Link ISR vectors */
SECTIONS
{
 /* The startup code into "FLASH" Rom type memory */
 .isr_vector :
 {
 __ICFEDIT_intvec_start__ = .;
 . = ALIGN(4);
 KEEP(*(.isr_vector)) /* Startup code */
 . = ALIGN(4);
 } >FLASH
}

/* Define specific placement of memory areas */
SECTIONS
{
 TextFlashSection :
 {
 *(TextFlashSection TextFlashSection.*)
 *(.gnu.linkonce.r.*)
 . = ALIGN(0x4);
 } >ASSETS_FLASH

 FontFlashSection :
 {
 *(FontFlashSection FontFlashSection.*)
 *(.gnu.linkonce.r.*)
 . = ALIGN(0x4);
 } >ASSETS_FLASH

 ExtFlashSection :
 {
 *(ExtFlashSection ExtFlashSection.*)
 *(.gnu.linkonce.r.*)
 . = ALIGN(0x4);
 } >ASSETS_FLASH
}

/* Define output sections */
SECTIONS
{
 .bootloader :
 {
 . = ALIGN(4);
 ExtMem_Boot/bootloader.o(*)
 } >BOOTLOADER

 /* The program code and other data goes into FLASH */
 .text :
 {
 . = ALIGN(4);
 *(.text) /* .text sections (code) */
 *(.text*) /* .text* sections (code) */
 *(.glue_7) /* glue arm to thumb code */
 *(.glue_7t) /* glue thumb to arm code */
 *(.eh_frame)

 KEEP (*(.init))
 KEEP (*(.fini))

 . = ALIGN(4);
 _etext = .; /* define a global symbols at end of code */
 } >FLASH

 /* Constant data goes into FLASH */
 .rodata :
 {
 . = ALIGN(4);
 *(.rodata) /* .rodata sections (constants, strings, etc.) */
 *(.rodata*) /* .rodata* sections (constants, strings, etc.) */
 . = ALIGN(4);
 } >FLASH

 .ARM.extab (READONLY) : /* The "READONLY" keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */
 {
 . = ALIGN(4);
 *(.ARM.extab* .gnu.linkonce.armextab.*)
 . = ALIGN(4);
 } >FLASH

 .ARM (READONLY) : /* The "READONLY" keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */
 {
 . = ALIGN(4);
 __exidx_start = .;
 *(.ARM.exidx*)
 __exidx_end = .;
 . = ALIGN(4);
 } >FLASH

 .preinit_array (READONLY) : /* The "READONLY" keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */
 {
 . = ALIGN(4);
 PROVIDE_HIDDEN (__preinit_array_start = .);
 KEEP (*(.preinit_array*))
 PROVIDE_HIDDEN (__preinit_array_end = .);
 . = ALIGN(4);
 } >FLASH

 .init_array (READONLY) : /* The "READONLY" keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */
 {
 . = ALIGN(4);
 PROVIDE_HIDDEN (__init_array_start = .);
 KEEP (*(SORT(.init_array.*)))
 KEEP (*(.init_array*))
 PROVIDE_HIDDEN (__init_array_end = .);
 . = ALIGN(4);
 } >FLASH

 .fini_array (READONLY) : /* The "READONLY" keyword is only supported in GCC11 and later, remove it if using GCC10 or earlier. */
 {
 . = ALIGN(4);
 PROVIDE_HIDDEN (__fini_array_start = .);
 KEEP (*(SORT(.fini_array.*)))
 KEEP (*(.fini_array*))
 PROVIDE_HIDDEN (__fini_array_end = .);
 . = ALIGN(4);
 } >FLASH

 /* used by the startup to initialize data */
 _sidata = LOADADDR(.data);

 /* Initialized data sections goes into RAM, load LMA copy after code */
 .data :
 {
 . = ALIGN(4);
 _sdata = .; /* create a global symbol at data start */
 *(.data) /* .data sections */
 *(.data*) /* .data* sections */
 *(.RamFunc) /* .RamFunc sections */
 *(.RamFunc*) /* .RamFunc* sections */

 . = ALIGN(4);
 } >RAM_D1 AT> FLASH

 /* Initialized TLS data section */
 .tdata : ALIGN(4)
 {
 *(.tdata .tdata.* .gnu.linkonce.td.*)
 . = ALIGN(4);
 _edata = .; /* define a global symbol at data end */
 PROVIDE(__data_end = .);
 PROVIDE(__tdata_end = .);
 } >RAM_D1 AT> FLASH

 PROVIDE( __tdata_start = ADDR(.tdata) );
 PROVIDE( __tdata_size = __tdata_end - __tdata_start );

 PROVIDE( __data_start = ADDR(.data) );
 PROVIDE( __data_size = __data_end - __data_start );

 PROVIDE( __tdata_source = LOADADDR(.tdata) );
 PROVIDE( __tdata_source_end = LOADADDR(.tdata) + SIZEOF(.tdata) );
 PROVIDE( __tdata_source_size = __tdata_source_end - __tdata_source );

 PROVIDE( __data_source = LOADADDR(.data) );
 PROVIDE( __data_source_end = __tdata_source_end );
 PROVIDE( __data_source_size = __data_source_end - __data_source );
 /* Uninitialized data section */
 .tbss (NOLOAD) : ALIGN(4)
 {
 /* This is used by the startup in order to initialize the .bss secion */
 _sbss = .; /* define a global symbol at bss start */
 __bss_start__ = _sbss;
 *(.tbss .tbss.*)
 . = ALIGN(4);
 PROVIDE( __tbss_end = . );
 } >RAM_D1

 PROVIDE( __tbss_start = ADDR(.tbss) );
 PROVIDE( __tbss_size = __tbss_end - __tbss_start );
 PROVIDE( __tbss_offset = ADDR(.tbss) - ADDR(.tdata) );

 PROVIDE( __tls_base = __tdata_start );
 PROVIDE( __tls_end = __tbss_end );
 PROVIDE( __tls_size = __tls_end - __tls_base );
 PROVIDE( __tls_align = MAX(ALIGNOF(.tdata), ALIGNOF(.tbss)) );
 PROVIDE( __tls_size_align = (__tls_size + __tls_align - 1) & ~(__tls_align - 1) );
 PROVIDE( __arm32_tls_tcb_offset = MAX(8, __tls_align) );
 PROVIDE( __arm64_tls_tcb_offset = MAX(16, __tls_align) );

 .bss (NOLOAD) : ALIGN(4)
 {
 *(.bss)
 *(.bss*)
 *(COMMON)

 . = ALIGN(4);
 _ebss = .; /* define a global symbol at bss end */
 __bss_end__ = _ebss;
 PROVIDE( __bss_end = .);
 } >RAM_D1
 PROVIDE( __non_tls_bss_start = ADDR(.bss) );

 PROVIDE( __bss_start = __tbss_start );
 PROVIDE( __bss_size = __bss_end - __bss_start );

 /* User_heap_stack section, used to check that there is enough RAM left */
 ._user_heap_stack (NOLOAD) :
 {
 . = ALIGN(8);
 PROVIDE ( end = . );
 PROVIDE ( _end = . );
 . = . + _Min_Heap_Size;
 . = . + _Min_Stack_Size;
 . = ALIGN(8);
 } >DTCMRAM



 /* Remove information from the standard libraries */
 /DISCARD/ :
 {
 libc.a:* ( * )
 libm.a:* ( * )
 libgcc.a:* ( * )
 }








 BmpCacheSection (NOLOAD) : 
 {
 *(BmpCacheSection)
 } >SDRAM

 TouchGFX_Framebuffer (NOLOAD) : 
 {
 *(TouchGFX_Framebuffer)
 } >SDRAM

 TouchGFX_Framebuffer1 (NOLOAD) : 
 {
 *(TouchGFX_Framebuffer1)
 } >SDRAM

 TouchGFX_Framebuffer2 (NOLOAD) : 
 {
 *(TouchGFX_Framebuffer2)
 } >SDRAM

 Video_RGB_Buffer (NOLOAD) : 
 {
 *(Video_RGB_Buffer)
 } >SDRAM
}

[jumman_JHINGA]

are getting any TouchGFX  GUI content on  display without debug?

are you selected correct Externer Loader in the CubeIDE?

Dose QuadSPI BSP initialized correctly?

[ksale.1]

TouchGFX GUI is simple Analog clock only, just for trying the MVP esign pattern.

 

 

 

 

 

[ksale.1]

STM32H750B-DK Lockup After External Flash Programming - Seeking Recovery Advice:    I've been trying to run code from the external QSPI flash (MT25TL01G) and have gone through an extensive debugging process that ended with a hard lockup. Below is a detailed log of my steps.

1. Initial Setup & Goal

• Board: STM32H750B-DK (MB1381-H750XB-B01, Product ID DK32H750B$AT1)

• Tools: STM32CubeIDE, STM32CubeMX (FW_H7 V1.12.1), STM32CubeProgrammer.

• Goal: Configure and debug an application to run from external QSPI flash at 0x90000000.

2. Step-by-Step Troubleshooting & Results

A. CubeMX & Project Configuration

• Created project via Board Selector (not MCU selector).

• Verified QUADSPI configured in Memory-Mapped mode (Clock Prescaler=2, CS High Time=2, Flash Size=26).

• Linker Script: Manually confirmed .ld file defines FLASH region at ORIGIN = 0x90000000.

• Issue: The CubeMX "Application runs from" / "Application Entry Point" setting was greyed out/unavailable in the Project Manager, preventing automatic VTOR configuration.

B. Programming & External Loader

• STM32CubeProgrammer: Successfully programmed my .hex file to 0x90000000 (log confirms full erase, download, and verify).

• External Loader: MT25TL01G_STM32H750B-DISCO.stldr is selected with both Enabled and Initialize checked in the IDE debug configuration.

C. Debugging Attempts & Failures

• Default debug launch always halted at 0x80011b0 (internal flash), ignoring external flash.

• Attempt 1 (VTOR): Added SCB->VTOR = 0x90000000; early in main() and also tried setting it via GDB Run Commands (set *((unsigned int *)0xE000ED08) = 0x90000000).

• Result: The debugger seemed to jump but immediately hit a HardFault or Lockup state. The processor appears to crash as soon as it tries to fetch instructions from external flash.

• Attempt 2 (Run from CubeProgrammer): Used CubeProgrammer's "Run after programming" feature. The board enters a locked state (no functional code execution, debugger reports "ARM M in lockup state").

3. Current Status & Questions

The board is now unresponsive in normal operation. The core seems to be in a lockup, likely because it is trying to boot from/branch to an uninitialized or incorrectly accessed QSPI memory region.

My specific questions for the community are:

1. Recovery: What is the most reliable way to recover from this lockup on the STM32H750B-DK? I understand I may need to force boot from internal memory, but the board lacks a standard BOOT0 jumper. Should I bridge a specific resistor pad (e.g., R100)? Or is a full chip erase via STM32CubeProgrammer under reset sufficient?

2. Root Cause: Given that the flash programs and verifies correctly, what step am I missing to ensure the QSPI is initialized for memory-mapped mode before the CPU attempts to execute from 0x90000000? Does the SystemInit() function need modification for this board?

3. Configuration: Has anyone successfully automated this process with this specific board? What is the correct sequence in CubeMX/IDE to ensure the application is built and debugged for external flash from the start?

I have included as much detail as possible. Thank you in advance for any guidance you can provide.

[ksale.1]

I've been trying to run code from the external QSPI flash 

(MT25TL01G) and have gone through an extensive debugging process that ended with a hard lockup. Please find the full posting the following linkhttps://community.st.com/t5/stm32-mcus-touchgfx-and-gui/stm32h750b-dk-touchgfx-project-quot-cannot-access-memory-at/td-p/877543 

 

[ksale.1]

Successfully Recovered a Locked STM32H750B-DK (DK32H750B$AT1) - Step-by-Step Guide: After an intense debugging session that left my STM32H750B-DK board in a hard lockup (ARM core in lockup state), I managed to fully recover it. Since this process involved several non-obvious steps, I'm documenting my journey here to help others who might face a similar "bricked" board. My Board: STM32H750B-DK, Product ID DK32H750B$AT1 (MB1381-H750XB-B01). Summary of the Problem The board became completely unresponsive after a failed attempt to run code from external QSPI flash. The debugger reported a "lockup" state, and the chip would not execute any code or connect properly. The Step-by-Step Recovery Process 1. Initial Assessment and Tool Setup Tool Used: STM32CubeProgrammer (Version 2.21.0). Key Insight: Normal connection methods failed. The critical feature to use was "Connect Under Reset" to halt the core before any faulty code could run. 2. Critical Connection Method In STM32CubeProgrammer's ST-LINK configuration: Set "Reset Mode" to Hardware reset. The sequence is timing-sensitive: Physically press and hold the black NRST button on the board. In the software, click "Connect". Only release the NRST button after the connection is established and the "Target information" panel populates. 3. Performing a Clean Full Erase Once connected, I did not program a new file immediately. Went to the "Erasing & Programming" tab. Under "Automatic Mode", clicked the text link for Full chip erase. This erased both internal and potentially corrupted external flash, giving a clean slate. 4. Programming a Known-Good Test Firmware I created a simple LED blink project configured for internal flash (0x08000000) in STM32CubeIDE. Back in CubeProgrammer, I programmed this .elf file using the same "Connect Under Reset" method. Verification passed successfully. 5. Board-Specific Quirks and Verification LED Confusion: On my board revision, the user LED is the bicolor LD2. The pin PG3 controls its red segment. Don't be alarmed if LD4 (green) stays on—it's a power indicator. Power Port Matters: For the final autonomous boot test, powering the board via the dedicated CN15 (PWR) USB port provided a clean power-on reset. Using only the CN1 (STLK) port for this test could be unreliable. Success Test: After programming, a full power cycle (unplug USB, wait 10 seconds, replug into CN15) made the LED blink automatically, confirming a full recovery. Conclusion The key was using ST32CubeProgrammer's "Hardware reset" mode to gain access, followed by a full chip erase to remove any corrupted code. The board's power delivery via the correct USB port was also essential for testing standalone boot. I hope this log helps someone else recover their board. I will address the separate challenges of configuring the QSPI external flash for TouchGFX in a future post.