the Loader_Src.c Init() is only called in the entry and resets and initializes the quadspi so I wouldn't think it would need QSPI Abort in there. The loader does call QSPI Abort before write, erase is done. Maybe I'm missing something in what you are suggesting.
Found a resolution for this issue...
Apparently the enabling interrupts in the Init() function of the Loader_Src.c provided in the ST repository for the H7 external loader was hanging after it entered this function the first time. Made the modifications below per ST suggestion...
Once this was done however the HAL_Delay() in my QuadSPI drivers would hang (made sense since interrupts are disabled I guess) so I also had to include a local HAL_Delay() function that used NOP instead of ticks.
I added this in my quadspi.c file...
ST support is still looking into whey the enabling of interrupts is hanging in this case.
Tesla I have a mostly working external loader I developed for the Windbond W25Q64JV but for some reason the "Erase Chip" function for the external flash fails with the STM32Programmer as seen below...
This function works fine with the loader you provided for me (CLIVEONE-W25Q64_STM32H7XX-PB2-PB6-PD11-PF9-PE2-PA1.stldr) back in May 2023. Could you share your W25Q64 driver code with me so I can see what is wrong with mine?
Thanks for the response....
I've tried to increment some counters in RAM to see if I'm getting any errors from the QSPI HAL functions but it doesn't seem to be telling me anything.
It does not return immediately as a failure, spends about 15sec or so trying to do the erase.
When I set the Verbosity Level to 3 the first time it successfully completed the mass erase...but now fails again. I attached the log file
The Sector Erase works fine and I could've sworn the mass erase worked fine too when I tested this back in April, but now that I have a new laptop and installed a newer version of the STM32Programmer it fails.
Here is my Loader_Src function for sector and Mass erase:
/**
* @brief Sector erase.
* EraseStartAddress : erase start address
* EraseEndAddress : erase end address
* @retval LOADER_OK = 1 : Operation succeeded
* @retval LOADER_FAIL = 0 : Operation failed
*/
int SectorErase(uint32_t EraseStartAddress, uint32_t EraseEndAddress) {
__set_PRIMASK(0); //enable interrupts
if (HAL_QSPI_Abort(&hqspi) != HAL_OK) {
__set_PRIMASK(1); //disable interrupts
return LOADER_FAIL;
}
if (CSP_QSPI_EraseSector(EraseStartAddress, EraseEndAddress) != HAL_OK) {
__set_PRIMASK(1); //disable interrupts
return LOADER_FAIL;
}
__set_PRIMASK(1); //disable interrupts
return LOADER_OK;
}
/**
* Description :
* Mass erase of external flash area
* Optional command - delete in case usage of mass erase is not planed
* Inputs :
* none
* outputs :
* none
* Note: Optional for all types of device
*/
int MassErase(void) {
__set_PRIMASK(0); //enable interrupts
if (HAL_QSPI_Abort(&hqspi) != HAL_OK) {
*( (uint32_t *)ERASEMASSERR_ADDR) = ++ldrTest.errEraseMassAbort_cnt;
__set_PRIMASK(1); //disable interrupts
return LOADER_FAIL;
}
if (CSP_QSPI_Erase_Chip() != HAL_OK) {
*( (uint32_t *)ERASEMASSERR_ADDR) = ++ldrTest.errEraseMassAbort_cnt;
__set_PRIMASK(1); //disable interrupts
return LOADER_FAIL;
}
*( (uint32_t *)ERASEMASS_ADDR) = ++ldrTest.errEraseMass_cnt;
__set_PRIMASK(1); //disable interrupts
return LOADER_OK;
}
...and also the sector and mass erase driver code...
uint8_t CSP_QSPI_EraseBlock(uint32_t flash_address) {
QSPI_CommandTypeDef sCommand = { 0 };
HAL_StatusTypeDef ret;
sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
sCommand.AddressSize = QSPI_ADDRESS_24_BITS;
sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
sCommand.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
/* Enable write operations ------------------------------------------- */
if ((ret = QSPI_WriteEnable()) != HAL_OK) {
return ret;
}
/* Erasing Sequence -------------------------------------------------- */
sCommand.Instruction = BLOCK_ERASE_CMD;
sCommand.AddressMode = QSPI_ADDRESS_1_LINE;
sCommand.Address = flash_address;
sCommand.DataMode = QSPI_DATA_NONE;
sCommand.DummyCycles = 0;
if ((ret = HAL_QSPI_Command(&hqspi, &sCommand,
HAL_QPSI_TIMEOUT_DEFAULT_VALUE)) != HAL_OK) {
return ret;
}
/* Configure automatic polling mode to wait for end of erase */
if ((ret = QSPI_AutoPollingMemReady()) != HAL_OK)
{
return ret;
}
return HAL_OK;
}
uint8_t CSP_QSPI_Erase_Chip(void) {
QSPI_CommandTypeDef sCommand = { 0 };
if (QSPI_WriteEnable() != HAL_OK) {
return HAL_ERROR;
}
/* Erasing Sequence --------------------------------- */
sCommand.InstructionMode = QSPI_INSTRUCTION_1_LINE;
sCommand.Instruction = CHIP_ERASE_CMD;
sCommand.AddressMode = QSPI_ADDRESS_NONE;
sCommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
sCommand.DataMode = QSPI_DATA_NONE;
sCommand.DummyCycles = 0;
sCommand.DdrMode = QSPI_DDR_MODE_DISABLE;
sCommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
sCommand.SIOOMode = QSPI_SIOO_INST_EVERY_CMD;
if (HAL_QSPI_Command(&hqspi, &sCommand, HAL_MAX_DELAY) != HAL_OK) {
return HAL_ERROR;
}
if (QSPI_AutoPollingMemReady() != HAL_OK) {
return HAL_ERROR;
}
return HAL_OK;
}
I see no reason why it shouldn't be working.
