Extended IO operation functions

Extended IO operation functions. More...

Collaboration diagram for Extended IO operation functions:

Functions
HAL_StatusTypeDef	HAL_FLASHEx_Erase (FLASH_EraseInitTypeDef *pEraseInit, uint32_t *SectorError)
	Perform a mass erase or erase the specified FLASH memory sectors.
HAL_StatusTypeDef	HAL_FLASHEx_Erase_IT (FLASH_EraseInitTypeDef *pEraseInit)
	Perform a mass erase or erase the specified FLASH memory sectors with interrupt enabled.
HAL_StatusTypeDef	HAL_FLASHEx_OBProgram (FLASH_OBProgramInitTypeDef *pOBInit)
	Program option bytes.
void	HAL_FLASHEx_OBGetConfig (FLASH_OBProgramInitTypeDef *pOBInit)
	Get the Option byte configuration.
HAL_StatusTypeDef	HAL_FLASHEx_AdvOBProgram (FLASH_AdvOBProgramInitTypeDef *pAdvOBInit)
	Program option bytes.
void	HAL_FLASHEx_AdvOBGetConfig (FLASH_AdvOBProgramInitTypeDef *pAdvOBInit)
	Get the OBEX byte configuration.
HAL_StatusTypeDef	HAL_FLASHEx_OB_SelectPCROP (void)
	Select the Protection Mode.
HAL_StatusTypeDef	HAL_FLASHEx_OB_DeSelectPCROP (void)
	Deselect the Protection Mode.
uint16_t	HAL_FLASHEx_OB_GetBank2WRP (void)
	Returns the FLASH Write Protection Option Bytes value for Bank 2.
HAL_StatusTypeDef	HAL_FLASHEx_Unlock_Bank1 (void)
	Unlock the FLASH Bank1 control registers access.
HAL_StatusTypeDef	HAL_FLASHEx_Lock_Bank1 (void)
	Locks the FLASH Bank1 control registers access.
HAL_StatusTypeDef	HAL_FLASHEx_Unlock_Bank2 (void)
	Unlock the FLASH Bank2 control registers access.
HAL_StatusTypeDef	HAL_FLASHEx_Lock_Bank2 (void)
	Locks the FLASH Bank2 control registers access.
HAL_StatusTypeDef	HAL_FLASHEx_ComputeCRC (FLASH_CRCInitTypeDef *pCRCInit, uint32_t *CRC_Result)

Detailed Description

Extended IO operation functions.

 ===============================================================================
                ##### Extended programming operation functions #####
 ===============================================================================  
    [..]
    This subsection provides a set of functions allowing to manage the Extension FLASH 
    programming operations.

 ===============================================================================
                ##### Extended programming operation functions #####
 ===============================================================================  
    [..]
    This subsection provides a set of functions allowing to manage the Extension FLASH 
    programming operations Operations.

Function Documentation

HAL_FLASHEx_AdvOBGetConfig()

void HAL_FLASHEx_AdvOBGetConfig

(

FLASH_AdvOBProgramInitTypeDef *

pAdvOBInit

)

Get the OBEX byte configuration.

Parameters

pAdvOBInit

pointer to an FLASH_AdvOBProgramInitTypeDef structure that contains the configuration information for the programming.

Return values

None

Definition at line 482 of file stm32f4xx_hal_flash_ex.c.

{
#if defined(STM32F401xC) || defined(STM32F401xE) || defined(STM32F410Tx) || defined(STM32F410Cx) || defined(STM32F410Rx) ||\
    defined(STM32F411xE) || defined(STM32F446xx) 
  /*Get Sector*/
  pAdvOBInit->Sectors = (*(__IO uint16_t *)(OPTCR_BYTE2_ADDRESS));
#else  /* STM32F427xx || STM32F437xx || STM32F429xx|| STM32F439xx || STM32F469xx || STM32F479xx */
  /*Get Sector for Bank1*/
  pAdvOBInit->SectorsBank1 = (*(__IO uint16_t *)(OPTCR_BYTE2_ADDRESS));
 
  /*Get Sector for Bank2*/
  pAdvOBInit->SectorsBank2 = (*(__IO uint16_t *)(OPTCR1_BYTE2_ADDRESS));
 
  /*Get Boot config OB*/
  pAdvOBInit->BootConfig = *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS;
#endif /* STM32F401xC || STM32F401xE || STM32F410xx || STM32F411xE || STM32F446xx  */
}

HAL_FLASHEx_AdvOBProgram()

HAL_StatusTypeDef HAL_FLASHEx_AdvOBProgram

(

FLASH_AdvOBProgramInitTypeDef *

pAdvOBInit

)

Program option bytes.

Parameters

pAdvOBInit

pointer to an FLASH_AdvOBProgramInitTypeDef structure that contains the configuration information for the programming.

Return values

HAL

Status

Definition at line 430 of file stm32f4xx_hal_flash_ex.c.

{
  HAL_StatusTypeDef status = HAL_ERROR;
  
  /* Check the parameters */
  assert_param(IS_OBEX(pAdvOBInit->OptionType));
 
  /*Program PCROP option byte*/
  if(((pAdvOBInit->OptionType) & OPTIONBYTE_PCROP) == OPTIONBYTE_PCROP)
  {
    /* Check the parameters */
    assert_param(IS_PCROPSTATE(pAdvOBInit->PCROPState));
    if((pAdvOBInit->PCROPState) == OB_PCROP_STATE_ENABLE)
    {
      /*Enable of Write protection on the selected Sector*/
#if defined(STM32F401xC) || defined(STM32F401xE) || defined(STM32F410Tx) || defined(STM32F410Cx) || defined(STM32F410Rx) ||\
    defined(STM32F411xE) || defined(STM32F446xx) 
      status = FLASH_OB_EnablePCROP(pAdvOBInit->Sectors);
#else  /* STM32F427xx || STM32F437xx || STM32F429xx|| STM32F439xx || STM32F469xx || STM32F479xx */
      status = FLASH_OB_EnablePCROP(pAdvOBInit->SectorsBank1, pAdvOBInit->SectorsBank2, pAdvOBInit->Banks);
#endif /* STM32F401xC || STM32F401xE || STM32F410xx || STM32F411xE || STM32F446xx  */
    }
    else
    {
      /*Disable of Write protection on the selected Sector*/
#if defined(STM32F401xC) || defined(STM32F401xE) || defined(STM32F410Tx) || defined(STM32F410Cx) || defined(STM32F410Rx) ||\
    defined(STM32F411xE) || defined(STM32F446xx)  
      status = FLASH_OB_DisablePCROP(pAdvOBInit->Sectors);
#else /* STM32F427xx || STM32F437xx || STM32F429xx|| STM32F439xx || STM32F469xx || STM32F479xx */
      status = FLASH_OB_DisablePCROP(pAdvOBInit->SectorsBank1, pAdvOBInit->SectorsBank2, pAdvOBInit->Banks);
#endif /* STM32F401xC || STM32F401xE || STM32F410xx || STM32F411xE || STM32F446xx  */
    }
  }
   
#if defined(STM32F427xx) || defined(STM32F437xx) || defined(STM32F429xx) || defined(STM32F439xx) || defined(STM32F469xx) || defined(STM32F479xx)
  /*Program BOOT config option byte*/
  if(((pAdvOBInit->OptionType) & OPTIONBYTE_BOOTCONFIG) == OPTIONBYTE_BOOTCONFIG)
  {
    status = FLASH_OB_BootConfig(pAdvOBInit->BootConfig);
  }
#endif /* STM32F427xx || STM32F437xx || STM32F429xx || STM32F439xx || STM32F469xx || STM32F479xx */
 
  return status;
}

Here is the call graph for this function:

HAL_FLASHEx_ComputeCRC()

HAL_StatusTypeDef HAL_FLASHEx_ComputeCRC	(	FLASH_CRCInitTypeDef *	pCRCInit,
		uint32_t *	CRC_Result
	)

Definition at line 708 of file stm32h7xx_hal_flash_ex.c.

{
  HAL_StatusTypeDef status;
  uint32_t sector_index;
 
  /* Check the parameters */
  assert_param(IS_FLASH_BANK_EXCLUSIVE(pCRCInit->Bank));
  assert_param(IS_FLASH_TYPECRC(pCRCInit->TypeCRC));
 
  /* Wait for OB change operation to be completed */
  status = FLASH_OB_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
 
  if (status == HAL_OK)
  {
    if (pCRCInit->Bank == FLASH_BANK_1)
    {
      /* Enable CRC feature */
      FLASH->CR1 |= FLASH_CR_CRC_EN;
 
      /* Clear CRC flags in Status Register: CRC end of calculation and CRC read error */
      FLASH->CCR1 |= (FLASH_CCR_CLR_CRCEND | FLASH_CCR_CLR_CRCRDERR);
 
      /* Clear current CRC result, program burst size and define memory area on which CRC has to be computed */
      FLASH->CRCCR1 |= FLASH_CRCCR_CLEAN_CRC | pCRCInit->BurstSize | pCRCInit->TypeCRC;
 
      if (pCRCInit->TypeCRC == FLASH_CRC_SECTORS)
      {
        /* Clear sectors list */
        FLASH->CRCCR1 |= FLASH_CRCCR_CLEAN_SECT;
 
        /* Select CRC sectors */
        for(sector_index = pCRCInit->Sector; sector_index < (pCRCInit->NbSectors + pCRCInit->Sector); sector_index++)
        {
          FLASH_CRC_AddSector(sector_index, FLASH_BANK_1);
        }
      }
      else if (pCRCInit->TypeCRC == FLASH_CRC_BANK)
      {
        /* Enable Bank 1 CRC select bit */
        FLASH->CRCCR1 |= FLASH_CRCCR_ALL_BANK;
      }
      else
      {
        /* Select CRC start and end addresses */
        FLASH_CRC_SelectAddress(pCRCInit->CRCStartAddr, pCRCInit->CRCEndAddr, FLASH_BANK_1);
      }
 
      /* Start the CRC calculation */
      FLASH->CRCCR1 |= FLASH_CRCCR_START_CRC;
 
      /* Wait on CRC busy flag */
      status = FLASH_CRC_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_1);
 
      /* Return CRC result */
      (*CRC_Result) = FLASH->CRCDATA;
 
      /* Disable CRC feature */
      FLASH->CR1 &= (~FLASH_CR_CRC_EN);
 
      /* Clear CRC flags */
      __HAL_FLASH_CLEAR_FLAG_BANK1(FLASH_FLAG_CRCEND_BANK1 | FLASH_FLAG_CRCRDERR_BANK1);
    }
#if defined (DUAL_BANK)
    else
    {
      /* Enable CRC feature */
      FLASH->CR2 |= FLASH_CR_CRC_EN;
 
      /* Clear CRC flags in Status Register: CRC end of calculation and CRC read error */
      FLASH->CCR2 |= (FLASH_CCR_CLR_CRCEND | FLASH_CCR_CLR_CRCRDERR);
 
      /* Clear current CRC result, program burst size and define memory area on which CRC has to be computed */
      FLASH->CRCCR2 |= FLASH_CRCCR_CLEAN_CRC | pCRCInit->BurstSize | pCRCInit->TypeCRC;
 
      if (pCRCInit->TypeCRC == FLASH_CRC_SECTORS)
      {
        /* Clear sectors list */
        FLASH->CRCCR2 |= FLASH_CRCCR_CLEAN_SECT;
 
        /* Add CRC sectors */
        for(sector_index = pCRCInit->Sector; sector_index < (pCRCInit->NbSectors + pCRCInit->Sector); sector_index++)
        {
          FLASH_CRC_AddSector(sector_index, FLASH_BANK_2);
        }
      }
      else if (pCRCInit->TypeCRC == FLASH_CRC_BANK)
      {
        /* Enable Bank 2 CRC select bit */
        FLASH->CRCCR2 |= FLASH_CRCCR_ALL_BANK;
      }
      else
      {
        /* Select CRC start and end addresses */
        FLASH_CRC_SelectAddress(pCRCInit->CRCStartAddr, pCRCInit->CRCEndAddr, FLASH_BANK_2);
      }
 
      /* Start the CRC calculation */
      FLASH->CRCCR2 |= FLASH_CRCCR_START_CRC;
 
      /* Wait on CRC busy flag */
      status = FLASH_CRC_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE, FLASH_BANK_2);
 
      /* Return CRC result */
      (*CRC_Result) = FLASH->CRCDATA;
 
      /* Disable CRC feature */
      FLASH->CR2 &= (~FLASH_CR_CRC_EN);
 
      /* Clear CRC flags */
      __HAL_FLASH_CLEAR_FLAG_BANK2(FLASH_FLAG_CRCEND_BANK2 | FLASH_FLAG_CRCRDERR_BANK2);
    }
#endif /* DUAL_BANK */
  }
 
  return status;
}

Here is the call graph for this function:

HAL_FLASHEx_Erase()

HAL_StatusTypeDef HAL_FLASHEx_Erase	(	FLASH_EraseInitTypeDef *	pEraseInit,
		uint32_t *	SectorError
	)

Perform a mass erase or erase the specified FLASH memory sectors.

Parameters

[in]	pEraseInit	pointer to an FLASH_EraseInitTypeDef structure that contains the configuration information for the erasing.
[out]	SectorError	pointer to variable that contains the configuration information on faulty sector in case of error (0xFFFFFFFF means that all the sectors have been correctly erased)

Return values

HAL

Status

Parameters

[in]	pEraseInit	pointer to an FLASH_EraseInitTypeDef structure that contains the configuration information for the erasing.
[out]	SectorError	pointer to variable that contains the configuration information on faulty sector in case of error (0xFFFFFFFF means that all the sectors have been correctly erased)

Return values

HAL

Status

Definition at line 190 of file stm32f4xx_hal_flash_ex.c.

{
  HAL_StatusTypeDef status = HAL_ERROR;
  uint32_t index = 0;
  
  /* Process Locked */
  __HAL_LOCK(&pFlash);
 
  /* Check the parameters */
  assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));
 
  /* Wait for last operation to be completed */
  status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
 
  if(status == HAL_OK)
  {
    /*Initialization of SectorError variable*/
    *SectorError = 0xFFFFFFFF;
    
    if(pEraseInit->TypeErase == FLASH_TYPEERASE_MASSERASE)
    {
      /*Mass erase to be done*/
      FLASH_MassErase((uint8_t) pEraseInit->VoltageRange, pEraseInit->Banks);
 
      /* Wait for last operation to be completed */
      status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
      
      /* if the erase operation is completed, disable the MER Bit */
      FLASH->CR &= (~FLASH_MER_BIT);
    }
    else
    {
      /* Check the parameters */
      assert_param(IS_FLASH_NBSECTORS(pEraseInit->NbSectors + pEraseInit->Sector));
 
      /* Erase by sector by sector to be done*/
      for(index = pEraseInit->Sector; index < (pEraseInit->NbSectors + pEraseInit->Sector); index++)
      {
        FLASH_Erase_Sector(index, (uint8_t) pEraseInit->VoltageRange);
 
        /* Wait for last operation to be completed */
        status = FLASH_WaitForLastOperation((uint32_t)FLASH_TIMEOUT_VALUE);
        
        /* If the erase operation is completed, disable the SER and SNB Bits */
        CLEAR_BIT(FLASH->CR, (FLASH_CR_SER | FLASH_CR_SNB));
 
        if(status != HAL_OK) 
        {
          /* In case of error, stop erase procedure and return the faulty sector*/
          *SectorError = index;
          break;
        }
      }
    }
    /* Flush the caches to be sure of the data consistency */
    FLASH_FlushCaches();    
  }
 
  /* Process Unlocked */
  __HAL_UNLOCK(&pFlash);
 
  return status;
}

Here is the call graph for this function:

HAL_FLASHEx_Erase_IT()

HAL_StatusTypeDef HAL_FLASHEx_Erase_IT

(

FLASH_EraseInitTypeDef *

pEraseInit

)

Perform a mass erase or erase the specified FLASH memory sectors with interrupt enabled.

Parameters

pEraseInit

pointer to an FLASH_EraseInitTypeDef structure that contains the configuration information for the erasing.

Return values

HAL

Status

Parameters

pEraseInit

pointer to an FLASH_EraseInitTypeDef structure that contains the configuration information for the erasing.

Return values

HAL

Status

Definition at line 261 of file stm32f4xx_hal_flash_ex.c.

{
  HAL_StatusTypeDef status = HAL_OK;
 
  /* Process Locked */
  __HAL_LOCK(&pFlash);
 
  /* Check the parameters */
  assert_param(IS_FLASH_TYPEERASE(pEraseInit->TypeErase));
 
  /* Enable End of FLASH Operation interrupt */
  __HAL_FLASH_ENABLE_IT(FLASH_IT_EOP);
  
  /* Enable Error source interrupt */
  __HAL_FLASH_ENABLE_IT(FLASH_IT_ERR);
  
  /* Clear pending flags (if any) */  
  __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP    | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |\
                         FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR| FLASH_FLAG_PGSERR);  
  
  if(pEraseInit->TypeErase == FLASH_TYPEERASE_MASSERASE)
  {
    /*Mass erase to be done*/
    pFlash.ProcedureOnGoing = FLASH_PROC_MASSERASE;
    pFlash.Bank = pEraseInit->Banks;
    FLASH_MassErase((uint8_t) pEraseInit->VoltageRange, pEraseInit->Banks);
  }
  else
  {
    /* Erase by sector to be done*/
 
    /* Check the parameters */
    assert_param(IS_FLASH_NBSECTORS(pEraseInit->NbSectors + pEraseInit->Sector));
 
    pFlash.ProcedureOnGoing = FLASH_PROC_SECTERASE;
    pFlash.NbSectorsToErase = pEraseInit->NbSectors;
    pFlash.Sector = pEraseInit->Sector;
    pFlash.VoltageForErase = (uint8_t)pEraseInit->VoltageRange;
 
    /*Erase 1st sector and wait for IT*/
    FLASH_Erase_Sector(pEraseInit->Sector, pEraseInit->VoltageRange);
  }
 
  return status;
}

Here is the call graph for this function:

HAL_FLASHEx_Lock_Bank1()

HAL_StatusTypeDef HAL_FLASHEx_Lock_Bank1

(

void

)

Locks the FLASH Bank1 control registers access.

Return values

HAL

Status

Definition at line 655 of file stm32h7xx_hal_flash_ex.c.

{
  /* Set the LOCK Bit to lock the FLASH Bank1 Registers access */
  SET_BIT(FLASH->CR1, FLASH_CR_LOCK);
  return HAL_OK;
}

HAL_FLASHEx_Lock_Bank2()

HAL_StatusTypeDef HAL_FLASHEx_Lock_Bank2

(

void

)

Locks the FLASH Bank2 control registers access.

Return values

HAL

Status

Definition at line 689 of file stm32h7xx_hal_flash_ex.c.

{
  /* Set the LOCK Bit to lock the FLASH Bank2 Registers access */
  SET_BIT(FLASH->CR2, FLASH_CR_LOCK);
  return HAL_OK;
}

HAL_FLASHEx_OB_DeSelectPCROP()

HAL_StatusTypeDef HAL_FLASHEx_OB_DeSelectPCROP

(

void

)

Deselect the Protection Mode.

Note

After PCROP activated Option Byte modification NOT POSSIBLE! excepted Global Read Out Protection modification (from level1 to level0)

Once SPRMOD bit is active unprotection of a protected sector is not possible

Read a protected sector will set RDERR Flag and write a protected sector will set WRPERR Flag

This function can be used only for STM32F42xxx/STM32F43xxx/STM32F401xx/STM32F411xx/STM32F446xx/ STM32F469xx/STM32F479xx devices.

Return values

HAL

Status

Definition at line 537 of file stm32f4xx_hal_flash_ex.c.

{
  uint8_t optiontmp = 0xFF;
  
  /* Mask SPRMOD bit */
  optiontmp =  (uint8_t)((*(__IO uint8_t *)OPTCR_BYTE3_ADDRESS) & (uint8_t)0x7F); 
  
  /* Update Option Byte */
  *(__IO uint8_t *)OPTCR_BYTE3_ADDRESS = (uint8_t)(OB_PCROP_DESELECTED | optiontmp);  
  
  return HAL_OK;
}

HAL_FLASHEx_OB_GetBank2WRP()

uint16_t HAL_FLASHEx_OB_GetBank2WRP

(

void

)

Returns the FLASH Write Protection Option Bytes value for Bank 2.

Note

This function can be used only for STM32F42xxx/STM32F43xxx/STM32F469xx/STM32F479xx devices.

Return values

The	FLASH Write Protection Option Bytes value

Definition at line 558 of file stm32f4xx_hal_flash_ex.c.

{                            
  /* Return the FLASH write protection Register value */
  return (*(__IO uint16_t *)(OPTCR1_BYTE2_ADDRESS));
}

HAL_FLASHEx_OB_SelectPCROP()

HAL_StatusTypeDef HAL_FLASHEx_OB_SelectPCROP

(

void

)

Select the Protection Mode.

Note

After PCROP activated Option Byte modification NOT POSSIBLE! excepted Global Read Out Protection modification (from level1 to level0)

Once SPRMOD bit is active unprotection of a protected sector is not possible

Read a protected sector will set RDERR Flag and write a protected sector will set WRPERR Flag

This function can be used only for STM32F42xxx/STM32F43xxx/STM32F401xx/STM32F411xx/STM32F446xx/ STM32F469xx/STM32F479xx devices.

Return values

HAL

Status

Definition at line 512 of file stm32f4xx_hal_flash_ex.c.

{
  uint8_t optiontmp = 0xFF;
 
  /* Mask SPRMOD bit */
  optiontmp =  (uint8_t)((*(__IO uint8_t *)OPTCR_BYTE3_ADDRESS) & (uint8_t)0x7F); 
  
  /* Update Option Byte */
  *(__IO uint8_t *)OPTCR_BYTE3_ADDRESS = (uint8_t)(OB_PCROP_SELECTED | optiontmp); 
  
  return HAL_OK;
}

HAL_FLASHEx_OBGetConfig()

void HAL_FLASHEx_OBGetConfig

(

FLASH_OBProgramInitTypeDef *

pOBInit

)

Get the Option byte configuration.

Parameters

pOBInit

pointer to an FLASH_OBInitStruct structure that contains the configuration information for the programming.

Return values

None

Parameters

pOBInit

pointer to an FLASH_OBInitStruct structure that contains the configuration information for the programming.

Note

The parameter Banks of the pOBInit structure must be set exclusively to FLASH_BANK_1 or FLASH_BANK_2, as this parameter is use to get the given Bank WRP, PCROP and secured area configuration.

Return values

None

Definition at line 402 of file stm32f4xx_hal_flash_ex.c.

{
  pOBInit->OptionType = OPTIONBYTE_WRP | OPTIONBYTE_RDP | OPTIONBYTE_USER | OPTIONBYTE_BOR;
 
  /*Get WRP*/
  pOBInit->WRPSector = (uint32_t)FLASH_OB_GetWRP();
 
  /*Get RDP Level*/
  pOBInit->RDPLevel = (uint32_t)FLASH_OB_GetRDP();
 
  /*Get USER*/
  pOBInit->USERConfig = (uint8_t)FLASH_OB_GetUser();
 
  /*Get BOR Level*/
  pOBInit->BORLevel = (uint32_t)FLASH_OB_GetBOR();
}

Referenced by BOR_Get().

Here is the call graph for this function:

Here is the caller graph for this function:

HAL_FLASHEx_OBProgram()

HAL_StatusTypeDef HAL_FLASHEx_OBProgram

(

FLASH_OBProgramInitTypeDef *

pOBInit

)

Program option bytes.

Parameters

pOBInit

pointer to an FLASH_OBInitStruct structure that contains the configuration information for the programming.

Return values

HAL

Status

Parameters

pOBInit

pointer to an FLASH_OBInitStruct structure that contains the configuration information for the programming.

Return values

HAL

Status

Definition at line 314 of file stm32f4xx_hal_flash_ex.c.

{
  HAL_StatusTypeDef status = HAL_ERROR;
  
  /* Process Locked */
  __HAL_LOCK(&pFlash);
 
  /* Check the parameters */
  assert_param(IS_OPTIONBYTE(pOBInit->OptionType));
 
  /*Write protection configuration*/
  if((pOBInit->OptionType & OPTIONBYTE_WRP) == OPTIONBYTE_WRP)
  {
    assert_param(IS_WRPSTATE(pOBInit->WRPState));
    if(pOBInit->WRPState == OB_WRPSTATE_ENABLE)
    {
      /*Enable of Write protection on the selected Sector*/
      status = FLASH_OB_EnableWRP(pOBInit->WRPSector, pOBInit->Banks);
    }
    else
    {
      /*Disable of Write protection on the selected Sector*/
      status = FLASH_OB_DisableWRP(pOBInit->WRPSector, pOBInit->Banks);
    }
  }
 
  /*Read protection configuration*/
  if((pOBInit->OptionType & OPTIONBYTE_RDP) == OPTIONBYTE_RDP)
  {
    status = FLASH_OB_RDP_LevelConfig(pOBInit->RDPLevel);
  }
 
  /*USER  configuration*/
  if((pOBInit->OptionType & OPTIONBYTE_USER) == OPTIONBYTE_USER)
  {
    status = FLASH_OB_UserConfig(pOBInit->USERConfig&OB_IWDG_SW, 
                                     pOBInit->USERConfig&OB_STOP_NO_RST,
                                     pOBInit->USERConfig&OB_STDBY_NO_RST);
  }
 
  /*BOR Level  configuration*/
  if((pOBInit->OptionType & OPTIONBYTE_BOR) == OPTIONBYTE_BOR)
  {
    status = FLASH_OB_BOR_LevelConfig(pOBInit->BORLevel);
  }
 
  /* Process Unlocked */
  __HAL_UNLOCK(&pFlash);
 
  return status;
}

Referenced by BOR_Set().

Here is the call graph for this function:

Here is the caller graph for this function:

HAL_FLASHEx_Unlock_Bank1()

HAL_StatusTypeDef HAL_FLASHEx_Unlock_Bank1

(

void

)

Unlock the FLASH Bank1 control registers access.

Return values

HAL

Status

Definition at line 633 of file stm32h7xx_hal_flash_ex.c.

{
  if(READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
  {
    /* Authorize the FLASH Bank1 Registers access */
    WRITE_REG(FLASH->KEYR1, FLASH_KEY1);
    WRITE_REG(FLASH->KEYR1, FLASH_KEY2);
 
    /* Verify Flash Bank1 is unlocked */
    if (READ_BIT(FLASH->CR1, FLASH_CR_LOCK) != 0U)
    {
      return HAL_ERROR;
    }
  }
 
  return HAL_OK;
}

HAL_FLASHEx_Unlock_Bank2()

HAL_StatusTypeDef HAL_FLASHEx_Unlock_Bank2

(

void

)

Unlock the FLASH Bank2 control registers access.

Return values

HAL

Status

Definition at line 667 of file stm32h7xx_hal_flash_ex.c.

{
  if(READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
  {
    /* Authorize the FLASH Bank2 Registers access */
    WRITE_REG(FLASH->KEYR2, FLASH_KEY1);
    WRITE_REG(FLASH->KEYR2, FLASH_KEY2);
 
    /* Verify Flash Bank1 is unlocked */
    if (READ_BIT(FLASH->CR2, FLASH_CR_LOCK) != 0U)
    {
      return HAL_ERROR;
    }
  }
 
  return HAL_OK;
}