• Update stm32h7xx_hal_conf_template.h file to support legacy HAL ETH driver.

• Add macro UNUSED() to avoid the generation of a warning related to the unused argument ‘hadc’.

• Remove duplicate macro definition __HAL_RCC_AHB2_FORCE_RESET() for STM32F423xx devices.

• Add macro UNUSED() to avoid the generation of a warning related to the unused argument ‘Edge’.

• Read the last remaining bytes (3 or 2 or 1) of the data in a temporary variable (taking into account swap mode) and enter this variable into the HASH->DIN when the data is not a multiple of 4 bytes.

• Remove HAL_LOCK()/HAL_UNLOCK() APIs from HAL_FLASH_Program_IT() and HAL_FLASHEx_Erase_IT() APIs.

• Fix typo in LL_DMA_GetCurrentTargetMem() API.

• Remove redundant macro IS_LPTIM_AUTORELOAD().

• Updated HAL_MPU_ConfigRegion() API to allow the configuration of the MPU registers independently of the value of Enable/Disable field.
• Add new HAL_MPU_EnableRegion() / HAL_MPU_DisableRegion() APIs.
• Add missing parenthesis() in LL_MPU_ConfigRegion() API.

• Align DSI Initialization sequence to the recommended ‘Programing procedure overview’ part to avoid DSI read LCD controller register 0x0A error.

• Clear the QSPI.AR register when sCommand.AddressMode is QSPI_ADDRESS_NONE.

• Update HAL I2S driver to fix misplaced __HAL_LOCK() API and remove ‘go to’ instruction.

• Update HAL SPI driver to remove “got to” instruction and avoid misplaced __HAL_LOCK() API issue.

• Rework of UART_WaitOnFlagUntilTimeout() API to avoid being stuck forever when UART overrun error occurs and to enhance behavior.

• Add missing system time in different PTP APIs.
• Rename ETH_TxPacketConfig_t to ETH_TxPacketConfigTypeDef.
• Update ETH_Start_IT sequence.
• Update the PTP configuration state macros and Fix the wrong Doxygen comment descriptions.
• Fix wrong Ethernet constant definitions .
• Add condition to get the Timestamp only when it was captured (Check on Last Descriptor and TimeStamp flag set).
• Replace ETH_RX_BUF_SIZE define in ETH_UpdateDescriptor() and ETH_DMARxDescListInit() by Init.RxBuffLen.
• Get the latest buffer length received and not the predefined ethernet frame length.
• Update HAL_ETH_SetMDIOClockRange API to manage different frequency ranges.
• Remove multiple volatile reads or writes in interrupt handler for better performance.
• Move the MMC interrupts disable section from HAL_ETH_Start_IT() to HAL_ETH_Init().
• Change the way to increment the descriptor index within HAL_ETH_ReleaseTxPacket().
• Update the entry to critical section without enabling unwanted global interrupts.
• Add support of CRC stripping for Type frames (CSTF) feature.
• Fix MisraC-2012 and MCU ASTYLE warnings and remove empty lines.

• Ensure to reactivate the usb channel in case of transfer error.

• Fix a note about Ticks parameter.

• Allow redefinition of macro UNUSED(x).

• Correct the configuration macro of I2S clock source and the value of I2S external clock source.
• Set the minimum value of PLLM.
• Update the rest values for the macro __HAL_RCC_Axxx_FORCE_RESET() to avoid setting reserved bits.

• Add a call to UNUSED() macro to avoid the generation of a warning related to the unused argument ‘Regulator’.
• Add PWR_SLEEPENTRY_WFE_NO_EVT_CLEAR mode to avoid systematic clear of event in HAL_PWR_EnterSLEEPMode() and HAL_PWR_EnterSTOPMode().

• Add the following new HAL/LL CORTEX APIs to clear PWR pending event:
  • LL_LPM_ClearEvent().
  • HAL_CORTEX_ClearEvent().

• Fix computation of pExtiConfig->GPIOSel in HAL_EXTI_GetConfigLine.

• Cast both LL_ADC_REG_ReadConversionData6() and LL_ADC_REG_ReadConversionData8() returned values from uint16_t to uint8_t to be consistent with prototypes.
• Add a call to UNUSED() macro in LL_ADC_DMA_GetRegAddr() API to prevent compilation warning due to unused ‘Register’ parameter.

• Fix incorrect word ‘surcharged’ in functions headers.
• Updated DAC buffer calibration according to RM.

• Better performance by removing multiple volatile reads or writes in interrupt handler.

• Check if the RTC calendar has been previously initialized before entering initialization mode.
• Remove macro __HAL_RTC_TAMPER_GET_IT() as it is redundant with macro __HAL_RTC_TAMPER_GET_FLAG() and create an alias into the stm32_hal_legacy.h file.
• Correct misleading note about shadow registers.

• Update Crypt/Decrypt IT processes to avoid Computation Completed IRQ fires before the DINR pointer increment.

• HAL code quality enhancement for MISRA-C2012 Rule-2.2_c.

• Align TIM_TIM2_ETH_PTP definition with the reference manual specification.
• Improve driver robustness against wrong period values.
• Improve driver robustness against wrong DMA related parameters.
• Improve period configuration parameter check.
• Remove Lock management from callback management functions.
• Remove multiple volatile reads or writes in interrupt handler for better performance.
• Improve HAL TIM driver’s operational behavior.
• Remove unnecessary change of MOE bitfield in LL_TIM_BDTR_Init().

• Apply same naming rules to clear FLAG related functions.
• Remove Lock management from callback management functions.

• Removal of never reached code.
• Improve protection against bad inputs.

• Update to align DSI ULPS entry and exit sequences with reference manual.

• Update Rx descriptor tail pointer management to avoid race condition.

• New API HAL_UARTEx_GetRxEventType() to retrieve the type of event that has led the RxEventCallback execution.
• Removal of HAL_LOCK/HAL_UNLOCK() calls in HAL UART Tx and Rx APIs.
• Removal of __HAL_LOCK() from HAL_xxx_RegisterCallback()/HAL_xxx_UnRegisterCallback().
• Avoid ORE flag to be cleared by a transmit process in polling mode.
• Rework of UART_WaitOnFlagUntilTimeout() API to avoid being stuck forever when UART overrun error occurs and to enhance behavior.

• Removal of __HAL_LOCK() from HAL_xxx_RegisterCallback()/HAL_xxx_UnRegisterCallback().

• Declare an internal macro link to DMA macro to check remaining data: I2C_GET_DMA_REMAIN_DATA.
• Update I2C_MemoryTransmit_TXE_BTF process to disable TXE and BTF interrupts if nothing to do.
• Clear TXE Flag at the end of transfer.
• Move polling code of HAL memory interface through interrupt management to prevent timeout issue using HAL MEM interface through FreeRTOS.
• Update I2C_IsErrorOccurred to return error if timeout is detected.
• Clear the ADDRF flag only when direction is confirmed as changed, to prevent that the ADDRF flag is cleared too early when the restart is received.
• Update HAL_I2C_Master_Transmit_IT to return HAL_BUSY instead of HAL_ERROR when timeout occur and I2C_FLAG_BUSY is SET.
• Clear ACK bit once 3 bytes to read remain to be able to send the NACK once the transfer ends.
• Duplicate the test condition after timeout detection to avoid false timeout detection.
• Update HAL_I2C_IsDeviceReady() API to support 10_bit addressing mode: macro I2C_GENERATE_START is updated.
• Update HAL I2C driver to prefetch data before starting the transmission: implementation of errata sheet workaround I2C2-190208 : Transmission stalled after first byte.
• Update the HAL I2C driver to disactivate all interrupts after the end of transaction.
• Update HAL_I2C_Init API to clear ADD10 bit in 7 bit addressing mode.
• Solve Slave No stretch not functional by using HAL Slave interface.
• Update HAL_FMPI2C_Mem_Write_IT API to initialize XferSize at 0.
• Update I2C_Slave_ISR_IT, I2C_Slave_ISR_DMA and I2C_ITSlaveCplt to prevent the call of HAL_I2C_ListenCpltCallback twice.
• Update I2C_WaitOnRXNEFlagUntilTimeout to check I2C_FLAG_AF independently from I2C_FLAG_RXNE.
• Clear ACK bit once 3 bytes to read remain to be able to send the NACK once the transfer ends.
• Remove the unusable code in function HAL_I2C_IsDeviceReady.
• Update HAL_I2C_Master_Abort_IT to support memory abort transfer.
• Update LL_I2C_HandleTranfer function to prevent undefined behavior of volatile usage before updating the CR2 register.
• Update I2C_WaitOnFlagUntilTimeout to handle error case.
• Update the HAL I2C driver to reset PreviousState to I2C_STATE_NONE at the end of transfer.

• Update to fix issue of mismatched data received by master in case of data size to be transmitted by the slave is greater than the data size to be received by the master.
• Add flush on TX register.
• Change previous state from HAL_SMBUS_STATE_READY to HAL_SMBUS_STATE_NONE at the end of transfer.
• Update HAL SMBUS driver to prefetch data before starting the transmission: implementation of errata sheet workaround I2C2-190208 : Transmission stalled after first byte.

• Improve audio quality (avoid potential glitch).
• Fix incorrect word ‘surcharged’.

• Fix driver to don’t update state in case of error (HAL_SPI_STATE_READY will be set only in case of HAL_TIMEOUT).
• Update HAL_SPI_TransmitReceive API to set the bit CRCNEXT in case of one byte transaction.
• Update IT API to enable interrupts after process unlock.
• Add wait on flag TXE to be set at the end of transaction to be aligned with reference manual.

• Prevent hard fault by checking DMA usage.
• Tuning of default SPDIFRX timeout.

• ll_usb.c fix added to USB_ClearInterrupts(), should write “1” to clear the interrupt status bits of OTG_FS_GINTSTS register.
• ll_usb.c: remove useless software setting to setup the frame interval at 80%.
• ll_usb.c, hal_hcd.c: adding support of hub split transactions.
• ll_usb.c: improve delay management to set core mode.
• ll_usb.c, hal_pcd.c: fix device connection in case battery charging used with HS instance linked to internal FS PHY.
• ll_usb.c: increase timeout value to allow core reset to complete.

• Removal of __HAL_LOCK() from HAL_xxx_RegisterCallback()/HAL_xxx_UnRegisterCallback().

• Removal of __HAL_LOCK() from HAL_xxx_RegisterCallback()/HAL_xxx_UnRegisterCallback().

• Update HAL SD processes to manage STBITERR flag.

• HAL ETH update
  • Remove useless assert_param(IS_ETH_MAC_ADDRESS0123(MacAddr)) from static function ETH_MACAddressConfig().
  • Replace hard coded Rx buffer size (1000U) by macro ETH_RX_BUF_SIZE.
  • Correct bit positions when getting MAC and DMA configurations and replace ‘UnicastSlowProtocolPacketDetect’ by ‘UnicastPausePacketDetect’ in the MAC default configuration structure.
  • Ensure a delay of 4 TX_CLK/RX_CLK cycles between two successive write operations to the same register.
  • Disable DMA transmission in both HAL_ETH_Stop_IT() and HAL_ETH_Stop() APIs.

• Rework of HAL Ethernet driver to resolve problems and improve performance (compatibility break).
• A new HAL Ethernet driver has been redesigned with new APIs, to bypass limitations with previous HAL Ethernet driver version.
• The new HAL Ethernet driver is the recommended version. It is located as usual in Drivers/STM32F4xx_HAL_Driver/Src and Drivers/STM32F4xx_HAL_Driver/Inc folders.
  • It can be enabled through switch HAL_ETH_MODULE_ENABLED in stm32f4xx_hal_conf.h
• The legacy HAL Ethernet driver is also present in the release in Drivers/STM32F4xx_HAL_Driver/Src/Legacy and Drivers/STM32F4xx_HAL_Driver/Inc/Legacy folders for software compatibility reasons.
  • Its usage is not recommended as deprecated. It can however be enabled through switch HAL_ETH_LEGACY_MODULE_ENABLED in stm32f4xx_hal_conf.h

• HAL ETH update
  • Entire receive process reworked.
  • Resolve the problem of received data corruption.
  • Implement transmission in interrupt mode.
  • Handle one interrupt for multiple transmitted packets.
  • Implement APIs to handle PTP feature.
  • Implement APIs to handle Timestamp feature.
  • Add support of receive buffer unavailable.
  • Update HAL_ETH_IRQHandler() to handle receive buffer unavailable.
• HAL SMBUS update
  • Update to fix issue of mismatched data received by master in case of data size to be transmitted by the slave is greater than the data size to be received by the master.
    • Add flush on TX register.
• HAL TIM update
  • __LL_TIM_CALC_PSC() macro update to round up the evaluate value when the fractional part of the division is greater than 0.5.
• HAL LPTIM update
  • Add check on PRIMASK register to prevent from enabling unwanted global interrupts within LPTIM_Disable() and LL_LPTIM_Disable()
• HAL UART update
  • Add const qualifier for read only pointers.
  • Improve header description of UART_WaitOnFlagUntilTimeout() function.
  • Add a check on the UART parity before enabling the parity error interruption.
  • Fix typo in UART_IT_TXE bit description.
• HAL IRDA update
  • Improve header description of IRDA_WaitOnFlagUntilTimeout() function.
  • Add a check on the IRDA parity before enabling the parity error interrupt.
  • Add const qualifier for read only pointers.
• HAL SMARTCARD update
  • Improve header description of SMARTCARD_WaitOnFlagUntilTimeout() function
  • Add const qualifier for read only pointers.
• HAL NOR update
  • Apply adequate commands according to the command set field value
  • command set 1 for Micron JS28F512P33
  • command set 2 for Micron M29W128G and Cypress S29GL128P
  • Add new command operations:
    • NOR_CMD_READ_ARRAY
    • NOR_CMD_WORD_PROGRAM
    • NOR_CMD_BUFFERED_PROGRAM
    • NOR_CMD_CONFIRM
    • NOR_CMD_BLOCK_ERASE
    • NOR_CMD_BLOCK_UNLOCK
    • NOR_CMD_READ_STATUS_REG
    • NOR_CMD_CLEAR_STATUS_REG
  • Update some APIs in order to be compliant for memories with different command set, the updated APIs are:
    • HAL_NOR_Init()
    • HAL_NOR_Read_ID()
    • HAL_NOR_ReturnToReadMode()
    • HAL_NOR_Read()
    • HAL_NOR_Program()
    • HAL_NOR_ReadBuffer()
    • HAL_NOR_ProgramBuffer()
    • HAL_NOR_Erase_Block()
    • HAL_NOR_Erase_Chip()
    • HAL_NOR_GetStatus()
  • Align HAL_NOR_Init() API with core of the function when write operation is disabled to avoid HardFault.
• HAL SDMMC update
  • Take into account the voltage range in the CMD1 command.
  • Add new LL function to have correct response for MMC driver.
  • Update the driver to have all fields correctly initialized.
  • Add an internal variable to manage the power class and call it before to update speed of bus width.
  • Add new API to get the value of the Extended CSD register and populate the ExtCSD field of the MMC handle.
  • In HAL_MMC_InitCard(), call to SDIO_PowerState_ON() moved after __HAL_MMC_ENABLE() to ensure MMC clock is enabled before the call to HAL_Delay() from within SDIO_PowerState_ON().
• HAL DMA update
  • Manage the case of an invalid value of CallbackID passed to the HAL_DMA_RegisterCallback() API.
• HAL LTDC update
  • Update HAL_LTDC_DeInit() to fix MCU Hang up during LCD turn OFF.
• HAL I2C update
  • Update to fix issue detected due to low system frequency execution (HSI).
  • Declare an internal macro link to DMA macro to check remaining data: I2C_GET_DMA_REMAIN_DATA
  • Update HAL I2C Master Receive IT process to safe manage data N= 2 and N= 3.
    • Disable RxNE interrupt if nothing to do.
• HAL USART update
  • Improve header description of USART_WaitOnFlagUntilTimeout() function.
  • Add a check on the USART parity before enabling the parity error interrupt.
  • Add const qualifier for read only pointers.
• HAL/LL ADC update
  • Update LL_ADC_IsActiveFlag_MST_EOCS() API to get the appropriate flag.
  • Better performance by removing multiple volatile reads or writes in interrupt handler.
• HAL FMPI2C update
  • Update to handle errors in polling mode.
    • Rename I2C_IsAcknowledgeFailed() to I2C_IsErrorOccurred() and correctly manage when error occurs.
• HAL EXTI update
  • Update HAL_EXTI_GetConfigLine() API to fix wrong calculation of GPIOSel value.
• HAL QSPI update
  • Update HAL_QSPI_Abort() and HAL_QSPI_Abort_IT() APIs to check on QSPI BUSY flag status before executing the abort procedure.
• HAL/LL RTC cleanup
  • Use bits definitions from CMSIS Device header file instead of hard-coded values.
  • Wrap comments to be 80-character long and correct typos.
  • Move constants RTC_IT_TAMP. from hal_rtc.h to hal_rtc_ex.h.
  • Gather all instructions related to exiting the “init” mode into new function RTC_ExitInitMode().
  • Add new macro assert_param(IS_RTC_TAMPER_FILTER_CONFIG_CORRECT(sTamper->Filter, sTamper->Trigger)) to check tamper filtering is disabled in case tamper events are triggered on signal edges.
  • Rework functions HAL_RTCEx_SetTamper() and HAL_RTCEx_SetTamper_IT() to:
    • Write in TAFCR register in one single access instead of two.
    • Avoid modifying user structure sTamper.
  • Remove functions LL_RTC_EnablePushPullMode() and LL_RTC_DisablePushPullMode() as related to non-supported features.
  • Remove any reference to non-supported features (e.g., LL_RTC_ISR_TAMP3F).
  • Remove useless conditional defines as corresponding features are supported by all part-numbers (e.g., #if defined(RTC_TAFCR_TAMPPRCH)).
• HAL USB OTG update
  • Fix USB_FlushRxFifo() and USB_FlushTxFifo() APIs by adding check on AHB master IDLE state before flushing the USB FIFO
  • Fix to avoid resetting host channel direction during channel halt
  • Fix to report correct received amount of data with USB DMA enabled
  • Fix to avoid compiler optimization on count variable used for USB HAL timeout loop check
  • Add missing registered callbacks check for HAL_HCD_HC_NotifyURBChange_Callback()
  • Add new API HAL_PCD_SetTestMode() APIs to handle USB device high speed Test modes
  • Setting SNAK for EPs not required during device reset
  • Update USB IRQ handler to enable EP OUT disable
  • Add support of USB IN/OUT Iso incomplete
  • Fix USB BCD data contact timeout

• HAL EXTI update
  • Update HAL_EXTI_GetConfigLine() API to set default configuration value of Trigger and GPIOSel before checking each corresponding registers.
• HAL GPIO update
  • Update HAL_GPIO_Init() API to avoid the configuration of PUPDR register when Analog mode is selected.
• HAL DMA update
  • Update HAL_DMA_IRQHandler() API to set the DMA state before unlocking access to the DMA handle.
• LL ADC update
  • Update LL_ADC_DeInit() API to clear missing SQR3 register.
• HAL CAN update
  • Update HAL_CAN_Init() API to be aligned with reference manual and to avoid timeout error.
• HAL/LL RTC_BKP update
  • Update __HAL_RTC_…(__HANDLE__, …) macros to access registers through (__HANDLE__)->Instance pointer and avoid “unused variable” warnings.
  • Correct month management in IS_LL_RTC_MONTH() macro.
• HAL RNG update
  • Update timeout mechanism to avoid false timeout detection in case of preemption.
• HAL QSPI update
  • ES0305 workaround disabled for STM32412xx devices.
• HAL I2C update
  • Update HAL_I2C_Mem_Write_DMA() and HAL_I2C_Mem_Read_DMA() APIs to initialize Devaddress, Memaddress and EventCount parameters.
  • Update to prevent several calls of Start bit:
    • Update I2C_MemoryTransmit_TXE_BTF() API to increment EventCount.
  • Update to avoid I2C interrupt in endless loop:
    • Update HAL_I2C_Master_Transmit_IT(), HAL_I2C_Master_Receive_IT(), HAL_I2C_Master_Transmit_DMA() and HAL_I2C_Master_Receive_DMA() APIs to unlock the I2C peripheral before generating the start.
  • Update to use the right macro to clear I2C ADDR flag inside I2C_Slave_ADDR() API as it’s indicated in the reference manual.
  • Update I2C_IsAcknowledgeFailed() API to avoid I2C in busy state if NACK received after transmitting register address.
  • Update HAL_I2C_EV_IRQHandler() and I2C_MasterTransmit_BTF() APIs to correctly manage memory transfers:
    • Add check on memory mode before calling callbacks procedures.
• LL USART update
  • Handling of UART concurrent register access in case of race condition between Tx and Rx transfers (HAL UART and LL LPUART)
• HAL SMBUS update
  • Updated HAL_SMBUS_ER_IRQHandler() API to return the correct error code “SMBUS_FLAG_PECERR” in case of packet error occurs.
• HAL/LL SPI update
  • Updated to fix MISRA-C 2012 Rule-13.2.
  • Update LL_SPI_TransmitData8() API to avoid casting the result to 8 bits.
• HAL UART update
  • Fix wrong comment related to RX pin configuration within the description section
  • Correction on UART ReceptionType management in case of ReceptionToIdle API are called from RxEvent callback
  • Handling of UART concurrent register access in case of race condition between Tx and Rx transfers (HAL UART and LL LPUART)
    • Update CAN Initialization sequence to set “request initialization” bit before exit from sleep mode.
• HAL USB update
  • HAL PCD: add fix transfer complete for IN Interrupt transaction in single buffer mode
  • Race condition in USB PCD control endpoint receive ISR.

• HAL/LL USART update
  • Fix typo in USART_Receive_IT() and USART_TransmitReceive_IT() APIs to avoid possible compilation issues if the UART driver files are not included.

• The register storage class specifier was deprecated in C++11 and removed in C++17.

• HAL update
• General updates to fix known defects and enhancements implementation.
• Added new defines for ARM compiler V6:
  • __weak
  • __packed
  • __NOINLINE
• Updated HAL TimeBase TIM, RTC alarm and RTC WakeUp templates for more robustness
  • Updated Hal_Init_Tick() API to properly store the priority when using the non-default time base.
• Updated PPP_MODULE_ENABLED for FMPSMBUS.
• HAL/LL ADC update
  • Updated to add include of the LL ADC driver.
  • Updated the following APIs to set status HAL_ADC_STATE_ERROR_INTERNAL and error code HAL_ADC_ERROR_INTERNAL when error occurs:
    • HAL_ADC_Start()
    • HAL_ADC_Start_IT()
    • HAL_ADC_Start_DMA()
    • HAL_ADCEx_InjectedStart()
    • HAL_ADCEx_InjectedStart_IT()
    • HAL_ADCEx_MultiModeStart_DMA()
  • Updated HAL_ADC_Stop_DMA() API to check if DMA state is Busy before calling HAL_DMA_Abort() API to avoid DMA internal error.
  • Updated IS_ADC_CHANNEL to support temperature sensor for:
    • STM32F411xE
    • STM32F413xx
    • STM32F423xx
  • Fixed wrong defined values for:
    • LL_ADC_MULTI_REG_DMA_LIMIT_3
    • LL_ADC_MULTI_REG_DMA_UNLMT_3
  • Added __LL_ADC_CALC_VREFANALOG_VOLTAGE() macro to evaluate analog reference voltage.
  • Removed __LL_ADC_CALC_TEMPERATURE() macro for STM32F4x9 devices as the TS_CAL2 is not available.
• HAL/LL DAC update
  • Added restruction on DAC Channel 2 defines and parameters.
  • HAL_DAC_MSPINIT_CB_ID and HAL_DAC_MSPDEINIT_CB_ID used instead of HAL_DAC_MSP_INIT_CB_ID and HAL_DAC_MSP_DEINIT_CB_ID.
  • Updated to support dual mode:
    • Added two new APIs:
      • HAL_DACEx_DualStart()
      • HAL_DACEx_DualStop()
  • Added position bit definition to be used instead of __DAC_MASK_SHIFT macro
    • __DAC_MASK_SHIFT macro has been removed.
  • Updated HAL_DAC_Start_DMA() API to return HAL_ERROR when error occurs.
  • Updated HAL_DAC_Stop_DMA() API to not return HAL_ERROR when DAC is already disabled.
• HAL CEC update
  • Updated HAL_CEC_IRQHandler() API to avoid appending an extra byte to the end of a message.
• HAL/LL GPIO update
  • Updated IS_GPIO_AF() to add missing values for STM32F401xC and STM32F401xE devices:
    • GPIO_AF3_TIM9
    • GPIO_AF3_TIM10
    • GPIO_AF3_TIM11
  • Updated LL/HAL GPIO_TogglePin() APIs to allow multi Pin’s toggling.
  • Updated HAL_GPIO_Init() API to avoid the configuration of PUPDR register when Analog mode is selected.
• HAL/LL RCC update
  • Updated HAL_RCC_OscConfig() API to add missing checks and to don’t return HAL_ERROR if request repeats the current PLL configuration.
  • Updated IS_RCC_PLLN_VALUE(VALUE) macro in case of STM32F411xE device in order to be aligned with reference manual.
• HAL SD update
  • Update function SD_FindSCR() to resolve issue of FIFO blocking when reading.
  • Update read/write functions in DMA mode in order to force the DMA direction, updated functions:
    • HAL_SD_ReadBlocks_DMA()
    • HAL_SD_WriteBlocks_DMA()
  • Add the block size settings in the initialization functions and remove it from read/write transactions to avoid repeated and inefficient reconfiguration, updated functions:
    • HAL_SD_InitCard()
    • HAL_SD_GetCardStatus()
    • HAL_SD_ConfigWideBusOperation()
    • HAL_SD_ReadBlocks()
    • HAL_SD_WriteBlocks()
    • HAL_SD_ReadBlocks_IT()
    • HAL_SD_WriteBlocks_IT()
    • HAL_SD_ReadBlocks_DMA()
    • HAL_SD_WriteBlocks_DMA()
• HAL MMC update
  • Add the block size settings in the initialization function and remove it from read/write transactions to avoid repeated and inefficient reconfiguration, updated functions:
    • HAL_MMC_InitCard()
    • HAL_MMC_ReadBlocks()
    • HAL_MMC_WriteBlocks()
    • HAL_MMC_ReadBlocks_IT()
    • HAL_MMC_WriteBlocks_IT()
    • HAL_MMC_ReadBlocks_DMA()
    • HAL_MMC_WriteBlocks_DMA()
  • Update read/write functions in DMA mode in order to force the DMA direction, updated functions:
    • HAL_MMC_ReadBlocks_DMA()
    • HAL_MMC_WriteBlocks_DMA()
  • Deploy new functions MMC_ReadExtCSD() and SDMMC_CmdSendEXTCSD () that read and check the sectors number of the device in order to resolve the issue of wrongly reading big memory size.
• HAL NAND update
  • Update functions HAL_NAND_Read_SpareArea_16b() and HAL_NAND_Write_SpareArea_16b() to fix column address calculation issue.
• LL SDMMC update
  • Update the definition of SDMMC_DATATIMEOUT constant in order to allow the user to redefine it in his proper application.
  • Remove ‘register’ storage class specifier from LL SDMMC driver.
  • Deploy new functions MMC_ReadExtCSD() and SDMMC_CmdSendEXTCSD () that read and check the sectors number of the device in order to resolve the issue of wrongly reading big memory size.
• HAL SMBUS update
  • Support for Fast Mode Plus to be SMBUS rev 3 compliant.
  • Added HAL_FMPSMBUSEx_EnableFastModePlus() and HAL_FMPSMBUSEx_DisableFastModePlus() APIs to manage Fm+.
  • Updated SMBUS_MasterTransmit_BTF() , SMBUS_MasterTransmit_TXE() and SMBUS_MasterReceive_BTF() APIs to allow stop generation when CurrentXferOptions is different from SMBUS_FIRST_FRAME and SMBUS_NEXT_FRAME.
  • Updated SMBUS_ITError() API to correct the twice call of HAL_SMBUS_ErrorCallback.
• HAL SPI update
  • Updated HAL_SPI_Init() API
    • To avoid setting the BaudRatePrescaler in case of Slave Motorola Mode.
    • Use the bit-mask for SPI configuration.
  • Updated Transmit/Receive processes in half-duplex mode
    • Disable the SPI instance before setting BDIOE bit.
  • Fixed wrong timeout management
  • Calculate Timeout based on a software loop to avoid blocking issue if Systick is disabled.
• HAL SPDIFRX update
  • Remove ‘register’ storage class specifier from HAL SPDIFRX driver.
• HAL I2S update
  • Updated I2SEx APIs to correctly support circular transfers
    • Updated I2SEx_TxRxDMACplt() API to manage DMA circular mode.
  • Updated HAL_I2SEx_TransmitReceive_DMA() API to set hdmatx (transfer callback and half) to NULL.
• HAL SAI update
  • Updated to avoid the incorrect left/right synchronization.
    • Updated HAL_SAI_Transmit_DMA() API to follow the sequence described in the reference manual for slave transmitter mode.
  • Updated HAL_SAI_Init() API to correct the formula in case of SPDIF is wrong.
• HAL CRYP update
  • Updated HAL_CRYP_SetConfig() and HAL_CRYP_GetConfig() APIs to set/get the continent of KeyIVConfigSkip correctly.
• HAL EXTI update
  • __EXTI_LINE__ is now used instead of __LINE__ which is a standard C macro.
• HAL DCMI
  • Support of HAL callback registration feature for DCMI extended driver.
• HAL/LL TIM update
  • Updated HAL_TIMEx_OnePulseN_Start() and HAL_TIMEx_OnePulseN_Stop() APIs (pooling and IT mode) to take into consideration all OutputChannel parameters.
  • Corrected reversed description of TIM_LL_EC_ONEPULSEMODE One Pulse Mode.
  • Updated LL_TIM_GetCounterMode() API to return the correct counter mode.
• HAL/LL SMARTCARD update
  • Fixed invalid initialization of SMARTCARD configuration by removing FIFO mode configuration as it is not member of SMARTCARD_InitTypeDef Structure.
  • Fixed typos in SMARTCARD State definition description
• HAL/LL IRDA update
  • Fixed typos in IRDA State definition description
• LL USART update
  • Remove useless check on maximum BRR value by removing IS_LL_USART_BRR_MAX() macro.
  • Update USART polling and interruption processes to fix issues related to accesses out of user specified buffer.
• HAL USB update
  • Enhanced USB OTG host HAL with USB DMA is enabled:
    • fixed ping and data toggle issue,
    • reworked Channel error report management

• Update to fix hardfault issue with HAL_I2C_Mem_Write_DMA() API:
  • Abort the right ongoing DMA transfer when memory write access request operation failed: fix typo “hdmarx” replaced by “hdmatx”

• Update HAL_I2C_ER_IRQHandler() API to fix acknowledge failure issue with I2C memory IT processes
  • Add stop condition generation when NACK occurs.
• Update I2C_DMAXferCplt(), I2C_DMAError() and I2C_DMAAbort() APIs to fix hardfault issue when hdmatx and hdmarx parameters in i2c handle aren’t initialized (NULL pointer).
  • Add additional check on hi2c->hdmtx and hi2c->hdmarx before resetting DMA Tx/Rx complete callbacks
• Update Sequential transfer APIs to adjust xfermode condition.
  • Replace hi2c->XferCount < MAX_NBYTE_SIZE by hi2c->XferCount <= MAX_NBYTE_SIZE which corresponds to a case without reload

• Bug fix: USB_ReadPMA() and USB_WritePMA() by ensuring 16-bits access to USB PMA memory
• Bug fix: correct USB RX count calculation
• Fix USB Bulk transfer double buffer mode
• Remove register keyword from USB defined macros as no more supported by C++ compiler
• Minor rework on USBD_Start() and USBD_Stop() APIs: stopping device will be handled by HAL_PCD_DeInit() API.
• Remove non used API for USB device mode.

• Add handling USB host babble error interrupt
• Fix Enabling ULPI interface for platforms that integrates USB HS PHY
• Fix Host data toggling for IN Iso transfers
• Ensure to disable USB EP during endpoint deactivation

• Update HAL CRYP driver to support block by block decryption without initializing the IV and KEY at each call.
  • Add new CRYP Handler parameters: “KeyIVConfig” and “SizesSum”
  • Add new CRYP init parameter: "KeyIVConfigSkip

• Update HAL_I2S_DMAStop() API to be more safe
  • Add a check on BSY, TXE and RXNE flags before disabling the I2S
• Update HAL_I2S_DMAStop() API to fix multi-call transfer issue(to avoid re-initializing the I2S for the next transfer).
  • Add __HAL_I2SEXT_FLUSH_RX_DR() and __HAL_I2S_FLUSH_RX_DR() macros to flush the remaining data inside DR registers.
  • Add new ErrorCode define: HAL_I2S_ERROR_BUSY_LINE_RX

• HAL_SetTickFreq(): update to restore the previous tick frequency when HAL_InitTick() configuration failed.

• Update GPIO initialization sequence to avoid unwanted pulse on GPIO Pin’s

• General update to enhance HAL EXTI driver robustness
  • Add additional assert check on EXTI config lines
  • Update to compute EXTI line mask before read/write access to EXTI registers
• Update EXTI callbacks management to be compliant with reference manual: only one PR register for rising and falling interrupts.
  • Update parameters in EXTI_HandleTypeDef structure: merge HAL EXTI RisingCallback and FallingCallback in only one PendingCallback
  • Remove HAL_EXTI_RISING_CB_ID and HAL_EXTI_FALLING_CB_ID values from EXTI_CallbackIDTypeDef enumeration.
• Update HAL_EXTI_IRQHandler() API to serve interrupts correctly.
  • Update to compute EXTI line mask before handle EXTI interrupt.
• Update to support GPIO port interrupts:
  • Add new “GPIOSel” parameter in EXTI_ConfigTypeDef structure

• Update HAL_RCCEx_PeriphCLKConfig() API to support PLLI2S configuration for STM32F42xxx and STM32F43xxx devices
• Update the HAL_RCC_ClockConfig() and HAL_RCC_DeInit() API to don’t overwrite the custom tick priority
• Fix LL_RCC_DeInit() failure detected with gcc compiler and high optimization level is selected(-03)
• Update HAL_RCC_OscConfig() API to don’t return HAL_ERROR if request repeats the current PLL configuration

• Update LL_ADC_REG_Init() to fix wrong ADC CR1 register configuration
  • The ADC sequencer length is part of ADC SQR1 register not of ADC CR1 register

• Update HAL_CRYP_Encrypt() and HAL_CRYP_Decrypt() APIs to take into consideration the datatype fed to the DIN register (1-, 8-, 16-, or 32-bit data) when padding the last block of the payload, in case the size of this last block is less than 128 bits.

• Update HAL_RNG_IRQHandler() API to fix error code management issue: error code is assigned “HAL_RNG_ERROR_CLOCK” in case of clock error and “HAL_RNG_ERROR_SEED” in case of seed error, not the opposite.

• Update DFSDM_GetChannelFromInstance() API to remove unreachable check condition

• Update HAL_DMA_Start_IT() API to omit the FIFO error

• Update FLASH_Program_DoubleWord() API to fix with EWARM high level optimization issue

• Remove Lock mechanism from HAL_QSPI_Init() and HAL_QSPI_DeInit() APIs

• Null pointer on handler “hhash” is now checked before accessing structure member “hhash->Init.DataType” in the following API:
  • HAL_HASH_Init()
• Following interrupt-based APIs have been added. Interrupt mode could allow the MCU to enter “Sleep” mode while a data block is being processed. Please refer to the “##### How to use this driver #####” section for details about their use.
  • HAL_HASH_SHA1_Accmlt_IT()
  • HAL_HASH_MD5_Accmlt_IT()
  • HAL_HASHEx_SHA224_Accmlt_IT()
  • HAL_HASHEx_SHA256_Accmlt_IT()
• Following aliases have been added (just for clarity sake) as they shall be used at the end of the computation of a multi-buffers message and not at the start:
  • HAL_HASH_SHA1_Accmlt_End() to be used instead of HAL_HASH_SHA1_Start()
  • HAL_HASH_MD5_Accmlt_End() to be used instead of HAL_HASH_MD5_Start()
  • HAL_HASH_SHA1_Accmlt_End_IT() to be used instead of HAL_HASH_SHA1_Start_IT()
  • HAL_HASH_MD5_Accmlt_End_IT() to be used instead of HAL_HASH_MD5_Start_IT()
  • HAL_HASHEx_SHA224_Accmlt_End() to be used instead of HAL_HASHEx_SHA224_Start()
  • HAL_HASHEx_SHA256_Accmlt_End() to be used instead of HAL_HASHEx_SHA256_Start()
  • HAL_HASHEx_SHA224_Accmlt_End_IT() to be used instead of HAL_HASHEx_SHA224_Start_IT()
  • HAL_HASHEx_SHA256_Accmlt_End_IT() to be used instead of HAL_HASHEx_SHA256_Start_IT()
• MISRAC-2012 rule R.5.1 (identifiers shall be distinct in the first 31 characters) constrained the naming of the above listed aliases (e.g. HAL_HASHEx_SHA256_Accmlt_End() could not be named HAL_HASHEx_SHA256_Accumulate_End(). Otherwise the name would have conflicted with HAL_HASHEx_SHA256_Accumulate_End_IT()). In order to have aligned names following APIs have been renamed:
  • HAL_HASH_MD5_Accumulate() renamed HAL_HASH_MD5_Accmlt()
  • HAL_HASH_SHA1_Accumulate() renamed HAL_HASH_SHA1_Accmlt()
  • HAL_HASHEx_SHA224_Accumulate() renamed HAL_HASHEx_SHA224_Accmlt()
  • HAL_HASHEx_SHA256_Accumulate() renamed HAL_HASHEx_SHA256_Accmlt()
• HASH handler state is no more reset to HAL_HASH_STATE_READY once DMA has been started in the following APIs:
  • HAL_HASH_MD5_Start_DMA()
  • HAL_HMAC_MD5_Start_DMA()
  • HAL_HASH_SHA1_Start_DMA()
  • HAL_HMAC_SHA1_Start_DMA()
• HASH phase state is now set to HAL_HASH_PHASE_READY once the digest has been read in the following APIs:
  • HASH_IT()
  • HMAC_Processing()
  • HASH_Start()
  • HASH_Finish()
• Case of a large buffer scattered around in memory each piece of which is not necessarily a multiple of 4 bytes in length.
  • In section “##### How to use this driver #####”, sub-section "*** Remarks on message length ***" added to provide recommendations to follow in such case.
  • No modification of the driver as the root-cause is at design-level.

• HAL_CAN_GetRxMessage() update to get the correct value for the RTR (type of frame for the message that will be transmitted) field in the CAN_RxHeaderTypeDef structure.

• Add new HAL_DCMI_ConfigSyncUnmask() API to set embedded synchronization delimiters unmasks.

• Following IRQ handlers’ implementation has been aligned with the STM32Cube firmware specification (in case of interrupt lines shared by multiple events, first check the IT enable bit is set then check the IT flag is set too):
  • HAL_RTC_AlarmIRQHandler()
  • HAL_RTCEx_WakeUpTimerIRQHandler()
  • HAL_RTCEx_TamperTimeStampIRQHandler()

• In “##### WWDG Specific features #####” descriptive comment section:
  • Maximal prescaler value has been corrected (8 instead of 128).
  • Maximal APB frequency has been corrected (42MHz instead of 56MHz) and possible timeout values updated.

• Add the following API’s to Start DMA2D CLUT Loading.
  • HAL_DMA2D_CLUTStartLoad() Start DMA2D CLUT Loading.
  • HAL_DMA2D_CLUTStartLoad_IT() Start DMA2D CLUT Loading with interrupt enabled.
• The following old wrong services will be kept in the HAL DCMI driver for legacy purpose and a specific Note is added:
  • HAL_DMA2D_CLUTLoad() can be replaced with HAL_DMA2D_CLUTStartLoad()
  • HAL_DMA2D_CLUTLoad_IT() can be replaced with HAL_DMA2D_CLUTStartLoad_IT()
  • HAL_DMA2D_ConfigCLUT() can be omitted as the config can be performed using the HAL_DMA2D_CLUTStartLoad() API.

• Fix typo in “FileFormatGroup” parameter in the HAL_MMC_CardCSDTypeDef and HAL_SD_CardCSDTypeDef structures
• Fix an improve handle state and error management
• Rename the defined MMC card capacity type to be more meaningful:
  • Update MMC_HIGH_VOLTAGE_CARD to MMC LOW_CAPACITY_CARD
  • Update MMC_DUAL_VOLTAGE_CRAD to MMC_HIGH_CAPACITY_CARD
• Fix management of peripheral flags depending on commands or data transfers
  • Add new defines “SDIO_STATIC_CMD_FLAGS” and “SDIO_STATIC_DATA_FLAGS”
  • Updates HAL SD and HAL MMC drivers to manage the new SDIO static flags.
• Due to limitation SDIO hardware flow control indicated in Errata Sheet:
  • In 4-bits bus wide mode, do not use the HAL_SD_WriteBlocks_IT() or HAL_SD_WriteBlocks() APIs otherwise underrun will occur and it isn’t possible to activate the flow control.
  • Use DMA mode when using 4-bits bus wide mode or decrease the SDIO_CK frequency.

• Update UART polling processes to handle efficiently the Lock mechanism
  • Move the process unlock at the top of the HAL_UART_Receive() and HAL_UART_Transmit() API.
• Fix baudrate calculation error for clock higher than 172Mhz
  • Add a forced cast on UART_DIV_SAMPLING8() and UART_DIV_SAMPLING16() macros.
  • Remove useless parenthesis from UART_DIVFRAQ_SAMPLING8(), UART_DIVFRAQ_SAMPLING16(), UART_BRR_SAMPLING8() and UART_BRR_SAMPLING16() macros to solve some MISRA warnings.
• Update UART interruption handler to manage correctly the overrun interrupt
  • Add in the HAL_UART_IRQHandler() API a check on USART_CR1_RXNEIE bit when an overrun interrupt occurs.
• Fix baudrate calculation error UART9 and UART10
  • In UART_SetConfig() API fix UART9 and UART10 clock source when computing baudrate values by adding a check on these instances and setting clock sourcePCLK2 instead of PCLK1.
• Update UART_SetConfig() API
  • Split HAL_RCC_GetPCLK1Freq() and HAL_RCC_GetPCLK2Freq() macros from the UART_BRR_SAMPLING8() and UART_BRR_SAMPLING8() macros

• Fix baudrate calculation error for clock higher than 172Mhz
  • Add a forced cast on USART_DIV() macro.
  • Remove useless parenthesis from USART_DIVFRAQ() macro to solve some MISRA warnings.
• Update USART interruption handler to manage correctly the overrun interrupt
  • Add in the HAL_USART_IRQHandler() API a check on USART_CR1_RXNEIE bit when an overrun interrupt occurs.
• Fix baudrate calculation error UART9 and UART10
  • In USART_SetConfig() API fix UART9 and UART10 clock source when computing baudrate values by adding a check on these instances and setting clock sourcePCLK2 instead of PCLK1.
• Update USART_SetConfig() API
  • Split HAL_RCC_GetPCLK1Freq() and HAL_RCC_GetPCLK2Freq() macros from the USART_BRR() macro

• Fix baudrate calculation error for clock higher than 172Mhz
  • Add a forced cast on IRDA_DIV() macro.
  • Remove useless parenthesis from IRDA_DIVFRAQ() macro to solve some MISRA warnings.
• Update IRDA interruption handler to manage correctly the overrun interrupt
  • Add in the HAL_IRDA_IRQHandler() API a check on USART_CR1_RXNEIE bit when an overrun interrupt occurs.
• Fix baudrate calculation error UART9 and UART10
  • In IRDA_SetConfig() API fix UART9 and UART10 clock source when computing baudrate values by adding a check on these instances and setting clock sourcePCLK2 instead of PCLK1.
• Update IRDA_SetConfig() API
  • Split HAL_RCC_GetPCLK1Freq() and HAL_RCC_GetPCLK2Freq() macros from the IRDA_BRR() macro

• Fix baudrate calculation error for clock higher than 172Mhz
  • Add a forced cast on SMARTCARD_DIV() macro.
  • Remove useless parenthesis from SMARTCARD_DIVFRAQ() macro to solve some MISRA warnings.
• Update SMARTCARD interruption handler to manage correctly the overrun interrupti
  • Add in the HAL_SMARTCARD_IRQHandler() API a check on USART_CR1_RXNEIE bit when an overrun interrupt occurs.
• Update SMARTCARD_SetConfig() API
  • Split HAL_RCC_GetPCLK1Freq() and HAL_RCC_GetPCLK2Freq() macros from the SMARTCARD_BRR() macro

• Add new macros to enable and disable the fast mode when using the one pulse mode to output a waveform with a minimum delay
  • __HAL_TIM_ENABLE_OCxFAST() and __HAL_TIM_DISABLE_OCxFAST().
• Update Encoder interface mode to keep TIM_CCER_CCxNP bits low
  • Add TIM_ENCODERINPUTPOLARITY_RISING and TIM_ENCODERINPUTPOLARITY_FALLING definitions to determine encoder input polarity.
  • Add IS_TIM_ENCODERINPUT_POLARITY() macro to check the encoder input polarity.
  • Update HAL_TIM_Encoder_Init() API
    • Replace IS_TIM_IC_POLARITY() macro by IS_TIM_ENCODERINPUT_POLARITY() macro.
• Update TIM remapping input configuration in HAL_TIMEx_RemapConfig() API
  • Remove redundant check on LPTIM_OR_TIM5_ITR1_RMP bit and replace it by check on LPTIM_OR_TIM9_ITR1_RMP bit.
• Update HAL_TIMEx_MasterConfigSynchronization() API to avoid functional errors and assert fails when using some TIM instances as input trigger.
  • Replace IS_TIM_SYNCHRO_INSTANCE() macro by IS_TIM_MASTER_INSTANCE() macro.
  • Add IS_TIM_SLAVE_INSTANCE() macro to check on TIM_SMCR_MSM bit.
• Add lacking TIM input remapping definition
  • Add LL_TIM_TIM11_TI1_RMP_SPDIFRX and LL_TIM_TIM2_ITR1_RMP_ETH_PTP.
  • Add lacking definition for linked LPTIM_TIM input trigger remapping
    • Add following definitions : LL_TIM_TIM9_ITR1_RMP_TIM3_TRGO, LL_TIM_TIM9_ITR1_RMP_LPTIM, LL_TIM_TIM5_ITR1_RMP_TIM3_TRGO, LL_TIM_TIM5_ITR1_RMP_LPTIM, LL_TIM_TIM1_ITR2_RMP_TIM3_TRGO and LL_TIM_TIM1_ITR2_RMP_LPTIM.
    • Add a new mechanism in LL_TIM_SetRemap() API to remap TIM1, TIM9, and TIM5 input triggers mapped on LPTIM register.

• Add a polling mechanism to check on LPTIM_FLAG_XXOK flags in different API
  • Add LPTIM_WaitForFlag() API to wait for flag set.
  • Perform new checks on HAL_LPTIM_STATE_TIMEOUT.
• Add lacking definitions of LPTIM input trigger remapping and its related API
  • LL_LPTIM_INPUT1_SRC_PAD_AF, LL_LPTIM_INPUT1_SRC_PAD_PA4, LL_LPTIM_INPUT1_SRC_PAD_PB9 and LL_LPTIM_INPUT1_SRC_TIM_DAC.
  • Add a new API LL_LPTIM_SetInput1Src() to access to the LPTIM_OR register and remap the LPTIM input trigger.
• Perform a new check on indirect EXTI23 line associated to the LPTIM wake up timer
  • Condition the use of the LPTIM Wake-up Timer associated EXTI line configuration’s macros by EXTI_IMR_MR23 bit in different API :
    • __HAL_LPTIM_WAKEUPTIMER_EXTI_ENABLE/DDISABLE_FALLING_EDGE()
    • __HAL_LPTIM_WAKEUPTIMER_EXTI_DISABLE_FALLING_EDGE()
    • __HAL_LPTIM_WAKEUPTIMER_EXTI_ENABLE_RISING_EDGE()
    • __HAL_LPTIM_WAKEUPTIMER_EXTI_DISABLE_RISING_EDGE()
    • __HAL_LPTIM_WAKEUPTIMER_EXTI_ENABLE_RISING_FALLING_EDGE()
    • __HAL_LPTIM_WAKEUPTIMER_EXTI_DISABLE_RISING_FALLING_EDGE()
    • __HAL_LPTIM_WAKEUPTIMER_EXTI_GET_FLAG()
    • __HAL_LPTIM_WAKEUPTIMER_EXTI_CLEAR_FLAG()
    • __HAL_LPTIM_WAKEUPTIMER_EXTI_GENERATE_SWIT()
  • Update HAL_LPTIM_TimeOut_Start_IT(), HAL_LPTIM_TimeOut_Stop_IT(), HAL_LPTIM_Counter_Start_IT() and HAL_LPTIM_Counter_Stop_IT() API by adding Enable/Disable rising edge trigger on the LPTIM Wake-up Timer Exti line.
  • Add __HAL_LPTIM_WAKEUPTIMER_EXTI_CLEAR_FLAG() in the end of the HAL_LPTIM_IRQHandler() API conditioned by EXTI_IMR_MR23 bit.

• Update HAL_I2C_EV_IRQHandler() API to fix I2C send break issue
  • Add additional check on hi2c->hdmatx, hdmatx->XferCpltCallback, hi2c->hdmarx, hdmarx->XferCpltCallback in I2C_Master_SB() API to avoid enabling DMA request when IT mode is used.
• Update HAL_I2C_ER_IRQHandler() API to fix acknowledge failure issue with I2C memory IT processes
  • Add stop condition generation when NACK occurs.
• Update HAL_I2C_Init() API to force software reset before setting new I2C configuration
• Update HAL I2C processes to report ErrorCode when wrong I2C start condition occurs
  • Add new ErrorCode define: HAL_I2C_WRONG_START
  • Set ErrorCode parameter in I2C handle to HAL_I2C_WRONG_START
• Update I2C_DMAXferCplt(), I2C_DMAError() and I2C_DMAAbort() APIs to fix hardfault issue when hdmatx and hdmarx parameters in i2c handle aren’t initialized (NULL pointer).
  • Add additional check on hi2c->hdmtx and hi2c->hdmarx before resetting DMA Tx/Rx complete callbacks

• Fix HAL FMPI2C slave interrupt handling issue with I2C sequential transfers.
  • Update FMPI2C_Slave_ISR_IT() and FMPI2C_Slave_ISR_DMA() APIs to check on STOP condition and handle it before clearing the ADDR flag

• Update HAL_NAND_Write_Page_8b(), HAL_NAND_Write_Page_16b() and HAL_NAND_Write_SpareArea_16b() to manage correctly the time out condition.

• Optimize SAI_DMATxCplt() and SAI_DMARxCplt() APIs to check on “Mode” parameter instead of CIRC bit in the CR register.
• Remove unused SAI_FIFO_SIZE define
• Update HAL_SAI_Receive_DMA() programming sequence to be inline with reference manual

• Fix I2C send break issue in IT processes
  • Add additional check on hi2c->hdmatx and hi2c->hdmarx to avoid the DMA request enable when IT mode is used.

• Update to implement Erratasheet: BSY bit may stay high at the end of a data transfer in Slave mode

• Fix compilation errors with LL_LPTIM_WriteReg() and LL_LPTIM_ReadReg() macros

• Fix preprocessing compilation issue with SDIO STA STBITERR interrupt

• Updated USB_WritePacket(), USB_ReadPacket() APIs to prevent compilation warning with GCC GNU v8.2.0
• Rework USB_EPStartXfer() API to enable the USB endpoint before unmasking the TX FiFo empty interrupt in case DMA is not used
• USB HAL_HCD_Init() and HAL_PCD_Init() APIs updated to avoid enabling USB DMA feature for OTG FS instance, USB DMA feature is available only on OTG HS Instance
• Remove duplicated line in hal_hcd.c header file comment section
• Rework USB HAL driver to use instance PCD_SPEED_xxx, HCD_SPEED_xx speeds instead of OTG register Core speed definition during the instance initialization
• Software Quality improvement with a fix of CodeSonar warning on PCD_Port_IRQHandler() and HCD_Port_IRQHandler() interrupt handlers

• Rework of HAL CRYP driver (compatibility break)
  • HAL CRYP driver has been redesigned with new API’s, to bypass limitations on data Encryption/Decryption management present with previous HAL CRYP driver version.
  • The new HAL CRYP driver is the recommended version. It is located as usual in Drivers/STM32F4xx_HAL_Driver/Src and Drivers/STM32f4xx_HAL_Driver/Inc folders. It can be enabled through switch HAL_CRYP_MODULE_ENABLED in stm32f4xx_hal_conf.h
  • The legacy HAL CRYP driver is no longer supported.
• Add new AutoReloadPreload field in TIM_Base_InitTypeDef structure to allow the possibilities to enable or disable the TIM Auto Reload Preload.

• Add support of HAL callback registration feature
  • The feature disabled by default is available for the following HAL drivers:
    • ADC, CAN, CEC, CRYP, DAC, DCMI, DFSDM, DMA2D, DSI, ETH, HASH, HCD, I2C, FMPI2C, SMBUS, UART, USART, IRDA, SMARTCARD, LPTIM, LTDC, MMC, NAND, NOR, PCCARD, PCD, QSPI, RNG, RTC, SAI, SD, SDRAM, SRAM, SPDIFRX, SPI, I2S, TIM, and WWDG
  • The feature may be enabled individually per HAL PPP driver by setting the corresponding definition USE_HAL_PPP_REGISTER_CALLBACKS to 1U in stm32f4xx_hal_conf.h project configuration file (template file stm32f4xx_hal_conf_template.h available from Drivers/STM32F4xx_HAL_Driver/Inc)
  • Once enabled , the user application may resort to HAL_PPP_RegisterCallback() to register specific callback function(s) and unregister it(them) with HAL_PPP_UnRegisterCallback().
• General updates to fix MISRA 2012 compilation errors
  • Replace HAL_GetUID() API by HAL_GetUIDw0(), HAL_GetUIDw1() and HAL_GetUIDw2()
  • HAL_IS_BIT_SET()/HAL_IS_BIT_CLR() macros implementation update
  • “stdio.h” include updated with “stddef.h”

• Add missing define for SPI3 alternate function “GPIO_AF5_SPI3” for STM32F401VE devices
• Remove “GPIO_AF9_TIM14” from defined alternate function list for STM32F401xx devices
• HAL_GPIO_TogglePin() reentrancy robustness improvement
• HAL_GPIO_DeInit() API update to avoid potential pending interrupt after call
• Update GPIO_GET_INDEX() API for more compliance with STM32F412Vx/STM32F412Rx/STM32F412Cx devices
• Update GPIO_BRR registers with Reference Manual regarding registers and bit definition values

• The CRYP_InitTypeDef is no more supported, changed by CRYP_ConfigTypedef to allow changing parameters using HAL_CRYP_setConfig() API without reinitialize the CRYP IP using the HAL_CRYP_Init() API
• New parameters added in the CRYP_ConfigTypeDef structure: B0 and DataWidthUnit
• Input data size parameter is added in the CRYP_HandleTypeDef structure
• Add new APIs to manage the CRYP configuration:
  • HAL_CRYP_SetConfig()
  • HAL_CRYP_GetConfig()
• Add new APIs to manage the Key derivation:
  • HAL_CRYPEx_EnableAutoKeyDerivation()
  • HAL_CRYPEx_DisableAutoKeyDerivation()
• Add new APIs to encrypt and decrypt data:
  • HAL_CRYP_Encypt()
  • HAL_CRYP_Decypt()
  • HAL_CRYP_Encypt_IT()
  • HAL_CRYP_Decypt_IT()
  • HAL_CRYP_Encypt_DMA()
  • HAL_CRYP_Decypt_DMA()
• Add new APIs to generate TAG:
  • HAL_CRYPEx_AES__GCM___GenerateAuthTAG()
  • HAL_CRYPEx_AES__CCM___Generago teAuthTAG()

• Remove useless LPTIM Wakeup EXTI related macros from HAL_LPTIM_TimeOut_Start_IT() API

• I2C API changes for MISRA-C 2012 compliance:
  • Rename HAL_I2C_Master_Sequential_Transmit_IT() to HAL_I2C_Master_Seq_Transmit_IT()
  • Rename HAL_I2C_Master_Sequentiel_Receive_IT() to HAL_I2C_Master_Seq_Receive_IT()
  • Rename HAL_I2C_Slave_Sequentiel_Transmit_IT() to HAL_I2C_Slave_Seq_Transmit_IT()
  • Rename HAL_I2C_Slave_Sequentiel_Receive_DMA() to HAL_I2C_Slave_Seq_Receive_DMA()
• SMBUS defined flags are removed as not used by the HAL I2C driver
  • I2C_FLAG_SMBALERT
  • I2C_FLAG_TIMEOUT
  • I2C_FLAG_PECERR
  • I2C_FLAG_SMBHOST
  • I2C_FLAG_SMBDEFAULT
• Add support of I2C repeated start feature in DMA Mode:
  • With the following new API’s
    • HAL_I2C_Master_Seq_Transmit_DMA()
    • HAL_I2C_Master_Seq_Receive_DMA()
    • HAL_I2C_Slave_Seq_Transmit_DMA()
    • HAL_I2C_Slave_Seq_Receive_DMA()
• Add new I2C transfer options to easy manage the sequential transfers
  • I2C_FIRST_AND_NEXT_FRAME
  • I2C_LAST_FRAME_NO_STOP
  • I2C_OTHER_FRAME
  • I2C_OTHER_AND_LAST_FRAME

• I2C API changes for MISRA-C 2012 compliance:
  • Rename HAL_FMPI2C_Master_Sequential_Transmit_IT() to HAL_FMPI2C_Master_Seq_Transmit_IT()
  • Rename HAL_FMPI2C_Master_Sequentiel_Receive_IT() to HAL_FMPI2C_Master_Seq_Receive_IT()
  • Rename HAL_FMPI2C_Master_Sequentiel_Transmit_DMA() to HAL_FMPI2C_Master_Seq_Transmit_DMA()
  • Rename HAL_FMPI2C_Master_Sequentiel_Receive_DMA() to HAL_FMPI2C_Master_Seq_Receive_DMA()
• Rename FMPI2C_CR1_DFN to FMPI2C_CR1_DNF for more compliance with Reference Manual regarding registers and bit definition naming
• Add support of I2C repeated start feature in DMA Mode:
  • With the following new API’s
    • HAL_FMPI2C_Master_Seq_Transmit_DMA()
    • HAL_FMPI2C_Master_Seq_Receive_DMA()
    • HAL_FMPI2C_Slave_Seq_Transmit_DMA()
    • HAL_FMPI2C_Slave_Seq_Receive_DMA()

• Update the FLASH_OB_GetRDP() API to return the correct RDP level

• Remove GPIOD CLK macros for STM32F412Cx devices (X = D)
• Remove GPIOE CLK macros for STM32F412Rx\412Cx devices: (X = E)
• Remove GPIOF/G CLK macros for STM32F412Vx\412Rx\412Cx devices (X= F or G)
  • __HAL_RCC_GPIOX_CLK_ENABLE()
  • __HAL_RCC_GPIO__X___CLK_DISABLE()
  • __HAL_RCC_GPIO__X___IS_CLK_ENABLED()
  • __HAL_RCC_GPIO__X___IS_CLK_DISABLED()
  • __HAL_RCC_GPIO__X___FORCE_RESET()

• Update to manage RNG error code:
  • Add ErrorCode parameter in HAL RNG Handler structure

• Add __LL_ADC_CALC_TEMPERATURE() helper macro to calculate the temperature (unit: degree Celsius) from ADC conversion data of internal temperature sensor.
• Fix ADC channels configuration issues on STM32F413xx/423xx devices
  • To allow possibility to switch between VBAT and TEMPERATURE channels configurations
  • HAL_ADC_Start(), HAL_ADC_Start_IT() and HAL_ADC_Start_DMA() update to prevention from starting ADC2 or ADC3 once multimode is enabled

• General updates to be compliant with DFSDM bits naming used in CMSIS files.

• Update possible values list for FilterActivation parameter in CAN_FilterTypeDef structure
  • CAN_FILTER_ENABLE instead of ENABLE
  • CAN_FILTER_DISABLE instead of DISABLE

• Update HAL CEC State management method:
  • Remove HAL_CEC_StateTypeDef structure parameters
  • Add new defines for CEC states

• Add clean of callbacks in HAL_DMA_DeInit() API

• Remove unused DMA2D_ColorTypeDef structure to be compliant with MISRAC 2012 Rule 2.3
• General update to use dedicated defines for DMA2D_BACKGROUND_LAYER and DMA2D_FOREGROUND_LAYER instead of numerical values: 0/1.

• Fix read multibyte issue: remove extra call to HAL_UNLOCK from DSI_ShortWrite() API.

• HAL/ LL drivers optimization
  • HAL driver: remove unused variables
  • LL driver: getter APIs optimization

• Remove the following API’s as feature not supported by STM32F469xx/479xx devices
  • HAL_PWREx_EnableWakeUpPinPolarityRisingEdge()
  • HAL_PWREx_EnableWakeUpPinPolarityRisingEdge()

• Update HAL_SPI_StateTypeDef structure to add new state: HAL_SPI_STATE_ABORT

• Add new AutoReloadPreload field in TIM_Base_InitTypeDef structure
  • Refer to the TIM examples to identify the changes
• Move the following TIM structures from stm32f4xx_hal_tim_ex.h into stm32f4xx_hal_tim.h
  • TIM_MasterConfigTypeDef
  • TIM_BreakDeadTimeConfigTypeDef
• Add new TIM Callbacks API’s:
  • HAL_TIM_PeriodElapsedHalfCpltCallback()
  • HAL_TIM_IC_CaptureHalfCpltCallback()
  • HAL_TIM_PWM_PulseFinishedHalfCpltCallback()
  • HAL_TIM_TriggerHalfCpltCallback()
• TIM API changes for MISRA-C 2012 compliance:
  • Rename HAL_TIM_SlaveConfigSynchronization to HAL_TIM_SlaveConfigSynchro
  • Rename HAL_TIM_SlaveConfigSynchronization_IT to HAL_TIM_SlaveConfigSynchro_IT
  • Rename HAL_TIMEx_ConfigCommutationEvent to HAL_TIMEx_ConfigCommutEvent
  • Rename HAL_TIMEx_ConfigCommutationEvent_IT to HAL_TIMEx_ConfigCommutEvent_IT
  • Rename HAL_TIMEx_ConfigCommutationEvent_DMA to HAL_TIMEx_ConfigCommutEvent_DMA
  • Rename HAL_TIMEx_CommutationCallback to HAL_TIMEx_CommutCallback
  • Rename HAL_TIMEx_DMACommutationCplt to TIMEx_DMACommutationCplt

• Rework USB interrupt handler and improve HS DMA support in Device mode
• Fix BCD handling fr OTG instance in device mode
• cleanup reference to low speed in device mode
• allow writing TX FIFO in case of transfer length is equal to available space in the TX FIFO
• Fix Toggle OUT interrupt channel in host mode
• Update USB OTG max number of endpoints (6 FS and 9 HS instead of 5 and 8)
• Update USB OTG IP to enable internal transceiver when starting USB device after committee BCD negotiation

• Update LL inline macros to use IWDGx parameter instead of IWDG instance defined in CMSIS device

• Update UNUSED() macro implementation to avoid GCC warning
  • The warning is detected when the UNUSED() macro is called from C++ file
• Update to make RAMFUNC define as generic type instead of HAL_StatusTypdef type.

• Update the prototypes of the following APIs after change on RAMFUNC defines
  • HAL_FLASHEx_StopFlashInterfaceClk()
  • HAL_FLASHEx_StartFlashInterfaceClk()
  • HAL_FLASHEx_EnableFlashSleepMode()
  • HAL_FLASHEx_DisableFlashSleepMode()

• Update HAL_SAI_DMAStop() and HAL_SAI_Abort() process to fix the lock/unlock audio issue

• Rework of HAL CAN driver (compatibility break)
  • A new HAL CAN driver has been redesigned with new APIs, to bypass limitations on CAN Tx/Rx FIFO management present with previous HAL CAN driver version.
  • The new HAL CAN driver is the recommended version. It is located as usual in Drivers/STM32F4xx_HAL_Driver/Src and Drivers/STM32f4xx_HAL_Driver/Inc folders. It can be enabled through switch HAL_CAN_MODULE_ENABLED in stm32f4xx_hal_conf.h
  • The legacy HAL CAN driver is also present in the release in Drivers/STM32F4xx_HAL_Driver/Src/Legacy and Drivers/STM32F4xx_HAL_Driver/Inc/Legacy folders for software compatibility reasons. Its usage is not recommended as deprecated. It can however be enabled through switch HAL_CAN_LEGACY_MODULE_ENABLED in stm32f4xx_hal_conf.h

• Update HAL driver to allow user to change systick period to 1ms, 10 ms or 100 ms :
  • Add the following API’s :
    • HAL_GetTickPrio(): Returns a tick priority.
    • HAL_SetTickFreq(): Sets new tick frequency.
    • HAL_GetTickFreq(): Returns tick frequency.
  • Add HAL_TickFreqTypeDef enumeration for the different Tick Frequencies: 10 Hz, 100 Hz and 1KHz (default).

• Fields of CAN_InitTypeDef structure are reworked:
  • SJW to SyncJumpWidth, BS1 to TimeSeg1, BS2 to TimeSeg2, TTCM to TimeTriggeredMode, ABOM to AutoBusOff, AWUM to AutoWakeUp, NART to AutoRetransmission (inversed), RFLM to ReceiveFifoLocked and TXFP to TransmitFifoPriority
• HAL_CAN_Init() is split into both HAL_CAN_Init() and HAL_CAN_Start() API’s
• HAL_CAN_Transmit() is replaced by HAL_CAN_AddTxMessage() to place Tx Request, then HAL_CAN_GetTxMailboxesFreeLevel() for polling until completion.
• HAL_CAN_Transmit_IT() is replaced by HAL_CAN_ActivateNotification() to enable transmit IT, then HAL_CAN_AddTxMessage() for place Tx request.
• HAL_CAN_Receive() is replaced by HAL_CAN_GetRxFifoFillLevel() for polling until reception, then HAL_CAN_GetRxMessage() to get Rx message.
• HAL_CAN_Receive_IT() is replaced by HAL_CAN_ActivateNotification() to enable receive IT, then HAL_CAN_GetRxMessage() in the receivecallback to get Rx message
• HAL_CAN_Slepp() is renamed as HAL_CAN_RequestSleep()
• HAL_CAN_TxCpltCallback() is split into HAL_CAN_TxMailbox0CompleteCallback(), HAL_CAN_TxMailbox1CompleteCallback() and HAL_CAN_TxMailbox2CompleteCallback().
• HAL_CAN_RxCpltCallback is split into HAL_CAN_RxFifo0MsgPendingCallback() and HAL_CAN_RxFifo1MsgPendingCallback().
• More complete “How to use the new driver” is detailed in the driver header section itself.

• Add new option FMPI2C_LAST_FRAME_NO_STOP for the sequential transfer management
  • This option allows to manage a restart condition after several call of the same master sequential interface.

• Add new HAL macros
  • __HAL_RCC_GET_RTC_SOURCE() allowing to get the RTC clock source
  • __HAL_RCC_GET_RTC_HSE_PRESCALER() allowing to get the HSE clock divider for RTC peripheral
• Ensure reset of CIR and CSR registers when issuing HAL_RCC_DeInit()/LL_RCC_DeInit functions
• Update HAL_RCC_OscConfig() to keep backup domain enabled when configuring respectively LSE and RTC clock source
• Add new HAL interfaces allowing to control the activation or deactivation of PLLI2S and PLLSAI:
  • HAL_RCCEx_EnablePLLI2S()
  • HAL_RCCEx_DisablePLLI2S()
  • HAL_RCCEx_EnablePLLSAI()
  • HAL_RCCEx_DisablePLLSAI()

• Add new LL RCC macro
  • LL_RCC_PLL_SetMainSource() allowing to configure PLL main clock source

• Add clear of the PTYP bit to select the PCARD mode in FMC_PCCARD_Init() / FSMC_PCCARD_Init()
  

• stm32f4xx_hal_def.h file changes:
  • Update __weak and __packed defined values for ARM compiler
  • Update __ALIGN_BEGIN and __ALIGN_END defined values for ARM compiler
• stm32f4xx_ll_system.h file: add LL_SYSCFG_REMAP_SDRAM define

• Fix wrong definition of ADC channel temperature sensor for STM32F413xx and STM32F423xx devices.

• Update values for the following defines: DMA_FLAG_FEIF0_4 and DMA_FLAG_DMEIF0_4

• Fix Extra warning with SW4STM32 compiler
• Fix DSI display issue when using EWARM w/ high level optimization
• Fix MISRAC errors

• HAL_FLASH_Unlock() update to return state error when the FLASH is already unlocked

• Update Interface APIs headers to remove confusing message about device address
• Update FMPI2C_WaitOnRXNEFlagUntilTimeout() to resolve a race condition between STOPF and RXNE Flags
• Update FMPI2C_TransferConfig() to fix wrong bit management.
• Update code comments to use DMA stream instead of DMA channel

• HAL_PWR_EnableWakeUpPin() update description to add support of PWR_WAKEUP_PIN2 and PWR_WAKEUP_PIN3

• Add the support of STM32F412Rx devices

• Update Interface APIs headers to remove confusing message about device address
• Update I2C_MasterReceive_RXNE() and I2C_MasterReceive_BTF() static APIs to fix bad Handling of NACK in I2C master receive process.

• Update HAL_RCC_GetOscConfig() API to:
  • set PLLR in the RCC_OscInitStruct
  • check on null pointer
• Update HAL_RCC_ClockConfig() API to:
  • check on null pointer
  • optimize code size by updating the handling method of the SWS bits
  • update to use __HAL_FLASH_GET_LATENCY() flash macro instead of using direct register access to LATENCY bits in FLASH ACR register.
• Update HAL_RCC_DeInit() and LL_RCC_DeInit() APIs to
  • Be able to return HAL/LL status
  • Add checks for HSI, PLL and PLLI2S ready before modifying RCC CFGR registers
  • Clear all interrupt flags
  • Initialize systick interrupt period
• Update HAL_RCC_GetSysClockFreq() to avoid risk of rounding error which may leads to a wrong returned value.

• HAL_RNG_Init() remove Lock()/Unlock()

• HAL_MMC_Erase() API: add missing () to fix compilation warning detected with SW4STM32 when extra feature is enabled.

• HAL_RTC_Init() API: update to force the wait for synchro before setting TAFCR register when BYPSHAD bit in CR register is 0.

• Update HAL_SAI_DMAStop() API to flush fifo after disabling SAI

• Update I2S DMA fullduplex process to handle I2S Rx and Tx DMA Half transfer complete callback

• Update HAL_TIMEx_OCN_xxxx() and HAL_TIMEx_PWMN_xxx() API description to remove support of TIM_CHANNEL_4

• Update to clear DMA flags using WRITE_REG() instead SET_REG() API to avoid read access to the IFCR register that is write only.

• Fix warning with static analyzer

• Add assert macros to check USART BaudRate register

• Rename IS_I2C_CLOCK_SPEED() and IS_I2C_DUTY_CYCLE() respectively to IS_LL_I2C_CLOCK_SPEED() and IS_LL_I2C_DUTY_CYCLE() to avoid incompatible macros redefinition.

• Update LL_TIM_EnableUpdateEvent() API to clear UDIS bit in TIM CR1 register instead of setting it.
• Update LL_TIM_DisableUpdateEvent() API to set UDIS bit in TIM CR1 register instead of clearing it.

• Fix MISRA error w/ IS_LL_USART_BRR() macro
• Fix wrong check when UART10 instance is used

• Add management of overrun error.
• Allow possibility to receive messages from the 2 RX FIFOs in parallel via interrupt.
• Fix message lost issue with specific sequence of transmit requests.
• Handle transmission failure with error callback, when NART is enabled.
• Add __HAL_CAN_CANCEL_TRANSMIT() call to abort transmission when timeout is reached

• HAL_PWREx_EnterUnderDriveSTOPMode() API: remove check on UDRDY flag

• Fix wrong ADC group injected sequence configuration
  • LL_ADC_INJ_SetSequencerRanks() and LL_ADC_INJ_GetSequencerRanks() API’s update to take in consideration the ADC number of conversions
  • Update the defined values for ADC group injected seqencer ranks

• Low Layer drivers APIs provide register level programming: require deep knowledge of peripherals described in STM32F4xx Reference Manuals
• Low Layer drivers are available for: ADC, Cortex, CRC, DAC, DMA, DMA2D, EXTI, GPIO, I2C, IWDG, LPTIM, PWR, RCC, RNG, RTC, SPI, TIM, USART, WWDG peripherals and additional Low Level Bus, System and Utilities APIs.
• Low Layer drivers APIs are implemented as static inline function in new Inc/stm32f4xx_ll_ppp.h files for PPP peripherals, there is no configuration file and each stm32f4xx_ll_ppp.h file must be included in user code.

• Overall rework of the driver for a more efficient implementation
  • Modify initialization API and structures
  • Modify Read / Write sequences: separate transfer process and SD Cards state management
  • Adding interrupt mode for Read / Write operations
  • Update the HAL_SD_IRQHandler function by optimizing the management of interrupt errors
• Refer to the following example to identify the changes: BSP example and USB_Device/MSC_Standalone application

• Modify NAND_AddressTypeDef, NAND_DeviceConfigTypeDef and NAND_HandleTypeDef structures fields
• Add new HAL_NAND_ConfigDevice API

• Add support of Multichannel Delay feature
  • Add HAL_DFSDM_ConfigMultiChannelDelay API
  • The following APIs are moved to internal static functions: HAL_DFSDM_ClockIn_SourceSelection, HAL_DFSDM_ClockOut_SourceSelection, HAL_DFSDM_DataInX_SourceSelection (X=0,2,4,6), HAL_DFSDM_BitStreamClkDistribution_Config

• Add specific callback API to manage I2S full duplex end of transfer process:
  • HAL_I2S_TxCpltCallback() and HAL_I2S_RxCpltCallback() API’s will be replaced with only HAL_I2SEx_TxRxCpltCallback() API.

• Modify default HAL_Delay implementation to guarantee minimum delay

• Move HAL_MPU_Disable() and HAL_MPU_Enable() from stm32f4xx_hal_cortex.h to stm32f4xx_hal_cortex.c
• Clear the whole MPU control register in HAL_MPU_Disable() API

• IS_FLASH_ADDRESS() macro update to support OTP range
• FLASH_Program_DoubleWord(): Replace 64-bit accesses with 2 double-words operations

• Update IS_GPIO_PIN() macro implementation to be more safe

• Update IS_RCC_PLLQ_VALUE() macro implementation: the minimum accepted value is 2 instead of 4
• Rename RCC_LPTIM1CLKSOURCE_PCLK define to RCC_LPTIM1CLKSOURCE_PCLK1
• Fix compilation issue w/ __HAL_RCC_USB_OTG_FS_IS_CLK_ENABLED() and __HAL_RCC_USB_OTG_FS_IS_CLK_DISABLED() macros for STM32F401xx devices
• Add the following is clock enabled macros for STM32F401xx devices
  • __HAL_RCC_SDIO_IS_CLK_ENABLED()
  • __HAL_RCC_SPI4_IS_CLK_ENABLED()
  • __HAL_RCC_TIM10_IS_CLK_ENABLED()
• Add the following is clock enabled macros for STM32F410xx devices
  • __HAL_RCC_CRC_IS_CLK_ENABLED()
  • __HAL_RCC_RNG_IS_CLK_ENABLED()
• Update HAL_RCC_DeInit() to reset the RCC clock configuration to the default reset state.
• Remove macros to configure BKPSRAM from STM32F401xx devices
• Update to refer to AHBPrescTable[] and APBPrescTable[] tables defined in system_stm32f4xx.c file instead of APBAHBPrescTable[] table.

• Add FMPI2C_FIRST_AND_NEXT_FRAME define in Sequential Transfer Options

• HAL_ADCEx_InjectedConfigChannel(): update the external trigger injected condition

• HAL_DMA_Init(): update to check compatibility between FIFO threshold level and size of the memory burst

• QSPI_HandleTypeDef structure: Update transfer parameters on uint32_t instead of uint16_t

• DMA Receive process; the code has been updated to clear the USART OVR flag before enabling DMA receive request.
• UART_SetConfig() update to manage correctly USART6 instance that is not available on STM32F410Tx devices

• Remove Lock mechanism from HAL_CAN_Transmit_IT() and HAL_CAN_Receive_IT() processes

• Add __HAL_TIM_MOE_DISABLE_UNCONDITIONALLY() macro to disable Master output without check on TIM channel state.
• Update HAL_TIMEx_ConfigBreakDeadTime() to fix TIM BDTR register corruption.

• Update HAL_I2C_Master_Transmit() and HAL_I2C_Slave_Transmit() to avoid sending extra bytes at the end of the transmit processes
• Update HAL_I2C_Mem_Read() API to fix wrong check on misused parameter “Size”
• Update I2C_MasterReceive_RXNE() and I2C_MasterReceive_BTF() static APIs to enhance Master sequential reception process.

• Add transfer abort APIs and associated callbacks in interrupt mode
  • HAL_SPI_Abort()
  • HAL_SPI_Abort_IT()
  • HAL_SPI_AbortCpltCallback()

• Add specific callback API to manage I2S full duplex end of transfer process:
  • HAL_I2S_TxCpltCallback() and HAL_I2S_RxCpltCallback() API’s will be replaced with only HAL_I2SEx_TxRxCpltCallback() API.
• Update I2S Transmit/Receive polling process to manage Overrun and Underrun errors
• Move the I2S clock input frequency calculation to HAL RCC driver.
• Update the HAL I2SEx driver to keep only full duplex feature.
• HAL_I2S_Init() API updated to
  • Fix wrong I2S clock calculation when PCM mode is used.
  • Return state HAL_I2S_ERROR_PRESCALER when the I2S clock is wrongly configured

• Optimize HAL_LTDC_IRQHandler() function by using direct register read
• Rename the following API’s
  • HAL_LTDC_Relaod() by HAL_LTDC_Reload()
  • HAL_LTDC_StructInitFromVideoConfig() by HAL_LTDCEx_StructInitFromVideoConfig()
  • HAL_LTDC_StructInitFromAdaptedCommandConfig() by HAL_LTDCEx_StructInitFromAdaptedCommandConfig()
• Add new defines for LTDC layers (LTDC_LAYER_1 / LTDC_LAYER_2)
• Remove unused asserts

• Flush all TX FIFOs on USB Reset
• Remove Lock mechanism from HAL_PCD_EP_Transmit() and HAL_PCD_EP_Receive() API’s

• Enable DMA Burst mode for USB OTG HS
• Fix SD card detection issue

• Add new SDMMC_CmdSDEraseStartAdd, SDMMC_CmdSDEraseEndAdd, SDMMC_CmdOpCondition and SDMMC_CmdSwitch functions

• Update to add the support of 3 CAN management

• Update to add the support of AES features

• Add definitions for new external trigger filters
• Add definition for new Channels 4, 5, 6 and 7
• Add functions and API for Filter state configuration and management
• Add new functions:
  • HAL_DFSDM_BitstreamClock_Start()
  • HAL_DFSDM_BitstreamClock_Stop()
  • HAL_DFSDM_BitStreamClkDistribution_Config()

• Add the support of DMA Channels from 8 to 15
• Update HAL_DMA_DeInit() function with the check on DMA stream instance

• Update HAL_DSI_ConfigHostTimeouts() and HAL_DSI_Init() functions to avoid scratch in DSI_CCR register

• Enhance FLASH_WaitForLastOperation() function implementation
• Update __HAL_FLASH_GET_FLAG() macro implementation

• Add specific alternate functions definitions

• Update I2C_DMAError() function implementation to ignore DMA FIFO error

• Enhance HAL_I2S_Init() implementation to test on PCM_SHORT and PCM_LONG standards

• Add new functions and call backs for Transfer Abort
  • HAL_IRDA_Abort()
  • HAL_IRDA_AbortTransmit()
  • HAL_IRDA_AbortReceive()
  • HAL_IRDA_Abort_IT()
  • HAL_IRDA_AbortTransmit_IT()
  • HAL_IRDA_AbortReceive_IT()
  • HAL_IRDA_AbortCpltCallback()
  • HAL_IRDA_AbortTransmitCpltCallback()
  • HAL_IRDA_AbortReceiveCpltCallback()

• Update HAL_PCD_GetRxCount() function implementation

• Update __HAL_RCC_HSE_CONFIG() macro implementation
• Update __HAL_RCC_LSE_CONFIG() macro implementation

• Add new functions and call backs for Transfer Abort
  • HAL_ SMARTCARD_Abort()
  • HAL_ SMARTCARD_AbortTransmit()
  • HAL_ SMARTCARD_AbortReceive()
  • HAL_ SMARTCARD_Abort_IT()
  • HAL_ SMARTCARD_AbortTransmit_IT()
  • HAL_ SMARTCARD_AbortReceive_IT()
  • HAL_ SMARTCARD_AbortCpltCallback()
  • HAL_ SMARTCARD_AbortTransmitCpltCallback()
  • HAL_ SMARTCARD_AbortReceiveCpltCallback()

• Update HAL_TIMEx_RemapConfig() function to manage TIM internal trigger remap: LPTIM or TIM3_TRGO

• Add Transfer abort functions and callbacks

• Add Transfer abort functions and callbacks

• Fix wrong behavior in consecutive transfers in case of single byte transmission (Master/Memory Receive interfaces)
• Update HAL_I2C_Master_Transmit_DMA() / HAL_I2C_Master_Receive_DMA()/ HAL_I2C_Slave_Transmit_DMA() and HAL_I2C_Slave_Receive_DMA() to manage addressing phase through interruption instead of polling
• Add a check on I2C handle state at start of all I2C API’s to ensure that I2C is ready
• Update I2C API’s (Polling, IT and DMA interfaces) to manage I2C XferSize and XferCount handle parameters instead of API size parameter to help user to get information of counter in case of error.
• Update Abort functionality to manage DMA use case

• Update to disable Own Address before setting the new Own Address configuration:
  • Update HAL_FMPI2C_Init() to disable FMPI2C_OARx_EN bit before any configuration in OARx registers

• Update CAN receive processes to set CAN RxMsg FIFONumber parameter

• Update UART handle TxXferCount and RxXferCount parameters as volatile to avoid eventual issue with High Speed optimization

• HAL_GPIO_Init()/HAL_GPIO_DeInit() API’s: update GPIO_GET_INDEX() macro implementation to support all GPIO’s

• Fix regression issue: restore HAL_SPI_DMAPause() and HAL_SPI_DMAResume() API’s

• Fix FSMC macros compilation warnings with STM32F412Rx devices

• HAL_DMA_PollFortransfer() API clean up

• Update HAL_PPP_IRQHandler() to add a check on interrupt source before managing the error

• Implement workaround to fix the limitation pronounced in the Errata sheet 2.1.8 section: In some specific cases, DMA2 data corruption occurs when managing AHB and APB2 peripherals in a concurrent way

• Add new drivers stm32f4xx_hal_timebase_rtc_alarm_template.c and stm32f4xx_hal_timebase_rtc_wakeup_template.c which override the native HAL time base functions (defined as weak) to either use the RTC as time base tick source. For more details about the usage of these drivers, please refer to HAL_TimeBase_RTC examples and FreeRTOS-based applications

• HAL UART, USART, IRDA, SMARTCARD, SPI, I2C,FMPI2C, QSPI (referenced as PPP here below) drivers
  • Add PPP error management during DMA process. This requires the following updates on user application:
    • Configure and enable the PPP IRQ in HAL_PPP_MspInit() function
    • In stm32f4xx_it.c file, PPP_IRQHandler() function: add a call to HAL_PPP_IRQHandler() function
    • Add and customize the Error Callback API: HAL_PPP_ErrorCallback()
• HAL I2C, FMPI2C (referenced as PPP here below) drivers:
  • Update to avoid waiting on STOPF/BTF/AF flag under DMA ISR by using the PPP end of transfer interrupt in the DMA transfer process. This requires the following updates on user application:
    • Configure and enable the PPP IRQ in HAL_PPP_MspInit() function
    • In stm32f4xx_it.c file, PPP_IRQHandler() function: add a call to HAL_PPP_IRQHandler() function
• HAL I2C driver:
  • I2C transfer processes IT update: NACK during addressing phase is managed through I2C Error interrupt instead of HAL state
• HAL IWDG driver: rework overall driver for better implementation
  • Remove HAL_IWDG_Start(), HAL_IWDG_MspInit() and HAL_IWDG_GetState() APIs
• HAL WWDG driver: rework overall driver for better implementation
  • Remove HAL_WWDG_Start(), HAL_WWDG_Start_IT(), HAL_WWDG_MspDeInit() and HAL_WWDG_GetState() APIs
  • Update the HAL_WWDG_Refresh(WWDG_HandleTypeDef *hwwdg, uint32_t counter) function and API by removing the “counter” parameter
• HAL QSPI driver: Enhance the DMA transmit process by using PPP TC interrupt instead of waiting on TC flag under DMA ISR. This requires the following updates on user application:
  • Configure and enable the QSPI IRQ in HAL_QSPI_MspInit() function
  • In stm32f4xx_it.c file, QSPI_IRQHandler() function: add a call to HAL_QSPI_IRQHandler() function
• HAL CEC driver: Overall driver rework with compatibility break versus previous HAL version
  • Remove HAL CEC polling Process functions: HAL_CEC_Transmit() and HAL_CEC_Receive()
  • Remove HAL CEC receive interrupt process function HAL_CEC_Receive_IT() and enable the “receive” mode during the Init phase
  • Rename HAL_CEC_GetReceivedFrameSize() function to HAL_CEC_GetLastReceivedFrameSize()
  • Add new HAL APIs: HAL_CEC_SetDeviceAddress() and HAL_CEC_ChangeRxBuffer()
  • Remove the ‘InitiatorAddress’ field from the CEC_InitTypeDef structure and manage it as a parameter in the HAL_CEC_Transmit_IT() function
  • Add new parameter ‘RxFrameSize’ in HAL_CEC_RxCpltCallback() function
  • Move CEC Rx buffer pointer from CEC_HandleTypeDef structure to CEC_InitTypeDef structure

• Update HAL_RCC_ClockConfig() function to adjust the SystemCoreClock
• Rename macros and Literals:
  • RCC_PERIPHCLK_CK48 by RCC_PERIPHCLK_CLK48
  • IS_RCC_CK48CLKSOURCE by IS_RCC_CLK48CLKSOURCE
  • RCC_CK48CLKSOURCE_PLLSAIP by RCC_CLK48CLKSOURCE_PLLSAIP
  • RCC_SDIOCLKSOURCE_CK48 by RCC_SDIOCLKSOURCE_CLK48
  • RCC_CK48CLKSOURCE_PLLQ by RCC_CLK48CLKSOURCE_PLLQ
• Update HAL_RCCEx_GetPeriphCLKConfig() and HAL_RCCEx_PeriphCLKConfig() functions to support TIM Prescaler for STM32F411xx devices
• HAL_RCCEx_PeriphCLKConfig() API: update to fix the RTC clock configuration issue

• Overall driver rework with break of compatibility with HAL V1.4.4
  • Remove the HAL CEC polling Process: HAL_CEC_Transmit() and HAL_CEC_Receive()
  • Remove the HAL CEC receive interrupt process (HAL_CEC_Receive_IT()) and manage the “Receive” mode enable within the Init phase
  • Rename HAL_CEC_GetReceivedFrameSize() function to HAL_CEC_GetLastReceivedFrameSize() function
  • Add new HAL APIs: HAL_CEC_SetDeviceAddress() and HAL_CEC_ChangeRxBuffer()
  • Remove the ‘InitiatorAddress’ field from the CEC_InitTypeDef structure and manage it as a parameter in the HAL_CEC_Transmit_IT() function
  • Add new parameter ‘RxFrameSize’ in HAL_CEC_RxCpltCallback() function
  • Move CEC Rx buffer pointer from CEC_HandleTypeDef structure to CEC_InitTypeDef structure
• Update driver to implement the new CEC state machine:
  • Add new “rxState” field in CEC_HandleTypeDef structure to provide the CEC state information related to Rx Operations
  • Rename “state” field in CEC_HandleTypeDef structure to “gstate”: CEC state information related to global Handle management and Tx Operations
  • Update CEC process to manage the new CEC states.
  • Update __HAL_CEC_RESET_HANDLE_STATE() macro to handle the new CEC state parameters (gState, rxState)

• Update Polling management:
  • The user Timeout value must be estimated for the overall process duration: the Timeout measurement is cumulative
• Update DMA process:
  • Update the management of PPP peripheral errors during DMA process. This requires the following updates in user application:
    • Configure and enable the PPP IRQ in HAL_PPP_MspInit() function
    • In stm32f4xx_it.c file, PPP_IRQHandler() function: add a call to HAL_PPP_IRQHandler() function
    • Add and customize the Error Callback API: HAL_PPP_ErrorCallback()

• Update FMC_NORSRAM_Init() to remove the Burst access mode configuration
• Update FMC_SDRAM_Timing_Init() to fix initialization issue when configuring 2 SDRAM banks

• Update HCD_Port_IRQHandler() to unmask disconnect IT only when the port is disabled

• Update Polling management:
  • The Timeout value must be estimated for the overall process duration: the Timeout measurement is cumulative
• Add the management of Abort service: Abort DMA transfer through interrupt
  • In the case of Master Abort IT transfer usage:
    • Add new user HAL_I2C_AbortCpltCallback() to inform user of the end of abort process
    • A new abort state is defined in the HAL_I2C_StateTypeDef structure
• Add the management of I2C peripheral errors, ACK failure and STOP condition detection during DMA process. This requires the following updates on user application:
  • Configure and enable the I2C IRQ in HAL_I2C_MspInit() function
  • In stm32f4xx_it.c file, I2C_IRQHandler() function: add a call to HAL_I2C_IRQHandler() function
  • Add and customize the Error Callback API: HAL_I2C_ErrorCallback()
  • Refer to the I2C_EEPROM or I2C_TwoBoards_ComDMA project examples usage of the API
• NACK error during addressing phase is returned through interrupt instead of previously through I2C transfer API’s
• I2C addressing phase is updated to be managed using interrupt instead of polling (Only for HAL I2C driver)
  • Add new static functions to manage I2C SB, ADDR and ADD10 flags

• Overall driver optimization to improve performance in polling/interrupt mode to reach maximum peripheral frequency
  • Polling mode:
    • Replace the use of SPI_WaitOnFlagUnitTimeout() function by “if” statement to check on RXNE/TXE flags while transferring data
  • Interrupt mode:
    • Minimize access on SPI registers
  • All modes:
    • Add the USE_SPI_CRC switch to minimize the number of statements when CRC calculation is disabled
    • Update timeout management to check on global processes
    • Update error code management in all processes
  • Update DMA process:
    • Add the management of SPI peripheral errors during DMA process. This requires the following updates in the user application:
    • Configure and enable the SPI IRQ in HAL_SPI_MspInit() function
    • In stm32f4xx_it.c file, SPI_IRQHandler() function: add a call to HAL_SPI_IRQHandler() function
    • Add and customize the Error Callback API: HAL_SPI_ErrorCallback()
    • Refer to the following example which describe the changes: SPI_FullDuplex_ComDMA
  • Fix regression in polling mode:
    • Add preparing data to transmit in case of slave mode in HAL_SPI_TransmitReceive() and HAL_SPI_Transmit()
    • Add to manage properly the overrun flag at the end of a HAL_SPI_TransmitReceive()
  • Fix regression in interrupt mode:
    • Add a wait on TXE flag in SPI_CloseTx_ISR() and in SPI_CloseTxRx_ISR()
    • Add to manage properly the overrun flag in SPI_CloseRxTx_ISR() and SPI_CloseRx_ISR()

• Update the HAL_DMA2D_DeInit() function to:
  • Abort transfer in case of ongoing DMA2D transfer
  • Reset DMA2D control registers
• Update HAL_DMA2D_Abort() to disable DMA2D interrupts after stopping transfer
• Optimize HAL_DMA2D_IRQHandler() by reading status registers only once
• Update HAL_DMA2D_ProgramLineEvent() function to:
  • Return HAL error state in case of wrong line value
  • Enable line interrupt after setting the line watermark configuration
• Add new HAL_DMA2D_CLUTLoad() and HAL_DMA2D_CLUTLoad_IT() functions to start DMA2D CLUT loading
  • HAL_DMA2D_CLUTLoading_Abort() function to abort the DMA2D CLUT loading
  • HAL_DMA2D_CLUTLoading_Suspend() function to suspend the DMA2D CLUT loading
  • HAL_DMA2D_CLUTLoading_Resume() function to resume the DMA2D CLUT loading
• Add new DMA2D dead time management:
  • HAL_DMA2D_EnableDeadTime() function to enable DMA2D dead time feature
  • HAL_DMA2D_DisableDeadTime() function to disable DMA2D dead time feature
  • HAL_DMA2D_ConfigDeadTime() function to configure dead time
• Update the name of DMA2D Input/Output color mode defines to be more clear for user (DMA2D_INPUT_XXX for input layers Colors, DMA2D_OUTPUT_XXX for output framebuffer Colors)

• Update HAL_LTDC_IRQHandler() to manage the case of reload interrupt
• Add new callback API HAL_LTDC_ReloadEventCallback()
• Add HAL_LTDC_Reload() to configure LTDC reload feature
• Add new No Reload LTDC variant APIs
  • HAL_LTDC_ConfigLayer_NoReload() to configure the LTDC Layer according to the specified without reloading
  • HAL_LTDC_SetWindowSize_NoReload() to set the LTDC window size without reloading
  • HAL_LTDC_SetWindowPosition_NoReload() to set the LTDC window position without reloading
  • HAL_LTDC_SetPixelFormat_NoReload() to reconfigure the pixel format without reloading
  • HAL_LTDC_SetAlpha_NoReload() to reconfigure the layer alpha value without reloading
  • HAL_LTDC_SetAddress_NoReload() to reconfigure the frame buffer Address without reloading
  • HAL_LTDC_SetPitch_NoReload() to reconfigure the pitch for specific cases
  • HAL_LTDC_ConfigColorKeying_NoReload() to configure the color keying without reloading
  • HAL_LTDC_EnableColorKeying_NoReload() to enable the color keying without reloading
  • HAL_LTDC_DisableColorKeying_NoReload() to disable the color keying without reloading
  • HAL_LTDC_EnableCLUT_NoReload() to enable the color lookup table without reloading
  • HAL_LTDC_DisableCLUT_NoReload() to disable the color lookup table without reloading
  • Note: Variant functions with “_NoReload” post fix allows to set the LTDC configuration/settings without immediate reload. This is useful in case when the program requires to modify several LTDC settings (on one or both layers) then applying (reload) these settings in one shot by calling the function “HAL_LTDC_Reload”

• Add new timeout implementation based on cpu cycles for ALRAWF, ALRBWF and WUTWF flags

• Update SAI state in case of TIMEOUT error within the HAL_SAI_Transmit() / HAL_SAI_Receive()
• Update HAL_SAI_IRQHandler:
  • Add error management in case DMA errors through XferAbortCallback() and HAL_DMA_Abort_IT()
  • Add error management in case of IT
• Move SAI_BlockSynchroConfig() and SAI_GetInputClock() functions to stm32f4xx_hal_sai.c/.h files (extension files are kept empty for projects compatibility reason)

• Rename DCMI_DMAConvCplt to DCMI_DMAXferCplt
• Update HAL_DCMI_Start_DMA() function to Enable the DCMI peripheral
• Add new timeout implementation based on cpu cycles for DCMI stop
• Add HAL_DCMI_Suspend() function to suspend DCMI capture
• Add HAL_DCMI_Resume() function to resume capture after DCMI suspend
• Update lock mechanism for DCMI process
• Update HAL_DCMI_IRQHandler() function to:
  • Add error management in case DMA errors through XferAbortCallback() and HAL_DMA_Abort_IT()
  • Optimize code by using direct register read

• Add new APIs HAL_DMA_RegisterCallback() and HAL_DMA_UnRegisterCallback to register/unregister the different callbacks identified by the enum typedef HAL_DMA_CallbackIDTypeDef
• Add new API HAL_DMA_Abort_IT() to abort DMA transfer under interrupt context
  • The new registered Abort callback is called when DMA transfer abortion is completed
• Add the check of compatibility between FIFO threshold level and size of the memory burst in the HAL_DMA_Init() API
• Add new Error Codes: HAL_DMA_ERROR_PARAM, HAL_DMA_ERROR_NO_XFER and HAL_DMA_ERROR_NOT_SUPPORTED
• Remove all DMA states related to MEM0/MEM1 in HAL_DMA_StateTypeDef

• Overall rework of the driver for a more efficient implementation
  • Remove the following APIs:
    • HAL_IWDG_Start()
    • HAL_IWDG_MspInit()
    • HAL_IWDG_GetState()
• Update implementation:
  • HAL_IWDG_Init(): this function insures the configuration and the start of the IWDG counter
  • HAL_IWDG_Refresh(): this function insures the reload of the IWDG counter
• Refer to the following example to identify the changes: IWDG_Example

• Update HAL_LPTIM_TimeOut_Start_IT() and HAL_LPTIM_Counter_Start_IT( ) APIs to configure WakeUp Timer EXTI interrupt to be able to wakeup MCU from low power mode by pressing the EXTI line.
• Update HAL_LPTIM_TimeOut_Stop_IT() and HAL_LPTIM_Counter_Stop_IT( ) APIs to disable WakeUp Timer EXTI interrupt.

• Update NOR_ADDR_SHIFT macro implementation

• Update HAL_PCD_IRQHandler() to get HCLK frequency before setting TRDT value

• Update to manage QSPI error management during DMA process
• Improve the DMA transmit process by using QSPI TC interrupt instead of waiting loop on TC flag under DMA ISR
• These two improvements require the following updates on user application:
  • Configure and enable the QSPI IRQ in HAL_QSPI_MspInit() function
  • In stm32f4xx_it.c file, QSPI_IRQHandler() function: add a call to HAL_QSPI_IRQHandler() function
  • Add and customize the Error Callback API: HAL_QSPI_ErrorCallback()
• Add the management of non-blocking transfer abort service: HAL_QSPI_Abort_IT(). In this case the user must:
  • Add new callback HAL_QSPI_AbortCpltCallback() to inform user at the end of abort process
  • A new value of State in the HAL_QSPI_StateTypeDef provides the current state during the abort phase
• Polling management update:
  • The Timeout value user must be estimated for the overall process duration: the Timeout measurement is cumulative.
• Refer to the following examples, which describe the changes:
  • QSPI_ReadWrite_DMA
  • QSPI_MemoryMapped
  • QSPI_ExecuteInPlace
• Add two new APIs for the QSPI fifo threshold:
  • HAL_QSPI_SetFifoThreshold(): configure the FIFO threshold of the QSPI
  • HAL_QSPI_GetFifoThreshold(): give the current FIFO threshold
• Fix wrong data size management in HAL_QSPI_Receive_DMA()

• Add new __HAL_ADC_PATH_INTERNAL_VBAT_DISABLE() macro for STM32F42x and STM32F43x devices to provide the possibility to convert VrefInt channel when both VrefInt and Vbat channels are selected.

• Overall driver update for wait on flag management optimization

• Overall rework of the driver for more efficient implementation
  • Remove the following APIs:
    • HAL_WWDG_Start()
    • HAL_WWDG_Start_IT()
    • HAL_WWDG_MspDeInit()
    • HAL_WWDG_GetState()
  • Update implementation:
    • HAL_WWDG_Init()
      • A new parameter in the Init Structure: EWIMode
    • HAL_WWDG_MspInit()
    • HAL_WWDG_Refresh()
      • This function insures the reload of the counter
      • The “counter” parameter has been removed
    • HAL_WWDG_IRQHandler()
    • HAL_WWDG_EarlyWakeupCallback() is the new prototype of HAL_WWDG_WakeUpCallback()
• Refer to the following example to identify the changes: WWDG_Example

• stm32f4xx_hal_conf_template.h
  • Optimize HSE Startup Timeout value from 5000ms to 100 ms
  • Add new define LSE_STARTUP_TIMEOUT
  • Add new define USE_SPI_CRC for code cleanup when the CRC calculation is disabled.
• Update HAL drivers to support MISRA C 2004 rule 10.6
• Add new template driver to configure timebase using TIMER :
  • stm32f4xx_hal_timebase_tim_template.c

• Update HAL_CAN_Transmit() and HAL_CAN_Transmit_IT() functions to unlock process when all Mailboxes are busy

• Update HAL_DSI_SetPHYTimings() functions to use the correct mask

• Several update on HAL UART driver to implement the new UART state machine:
  • Add new field in UART_HandleTypeDef structure: “rxState”, UART state information related to Rx Operations
  • Rename “state” field in UART_HandleTypeDef structure by “gstate”: UART state information related to global Handle management and Tx Operations
  • Update UART process to manage the new UART states.
  • Update __HAL_UART_RESET_HANDLE_STATE() macro to handle the new UART state parameters (gState, rxState)
• Update UART_BRR_SAMPLING16() and UART_BRR_SAMPLING8() Macros to fix wrong baudrate calculation.

• Several update on HAL IRDA driver to implement the new UART state machine:
  • Add new field in IRDA_HandleTypeDef structure: “rxState”, IRDA state information related to Rx Operations
  • Rename “state” field in UART_HandleTypeDef structure by “gstate”: IRDA state information related to global Handle management and Tx Operations
  • Update IRDA process to manage the new UART states.
  • Update __HAL_IRDA_RESET_HANDLE_STATE() macro to handle the new IRDA state parameters (gState, rxState)
• Removal of IRDA_TIMEOUT_VALUE define
• Update IRDA_BRR() Macro to fix wrong baudrate calculation

• Several update on HAL SMARTCARD driver to implement the new UART state machine:
  • Add new field in SMARTCARD_HandleTypeDef structure: “rxState”, SMARTCARDstate information related to Rx Operations
  • Rename “state” field in UART_HandleTypeDef structure by “gstate”: SMARTCARDstate information related to global Handle management and Tx Operations
  • Update SMARTCARD process to manage the new UART states.
  • Update __HAL_SMARTCARD_RESET_HANDLE_STATE() macro to handle the new SMARTCARD state parameters (gState, rxState)
• Update SMARTCARD_BRR() macro to fix wrong baudrate calculation

• Add new default define value for HSI calibration “RCC_HSICALIBRATION_DEFAULT”
• Optimize Internal oscillators and PLL startup timeout

• Update to avoid the disable for HSE/LSE oscillators before setting the new RCC HSE/LSE configuration and add the following notes in HAL_RCC_OscConfig() API description:

                     * @note   Transitions LSE Bypass to LSE On and LSE On to LSE Bypass are not
                     *             supported by this API. User should request a transition to LSE Off
                     *             first and then LSE On or LSE Bypass.
                     * @note   Transition HSE Bypass to HSE On and HSE On to HSE Bypass are not
                     *             supported by this API. User should request a transition to HSE Off
                     *             first and then HSE On or HSE Bypass.

• Optimize the HAL_RCC_ClockConfig() API implementation.

• Update HAL_DMA2D_Abort() Function to end current DMA2D transfer properly
• Update HAL_DMA2D_PollForTransfer() function to add poll for background CLUT loading (layer 0 and layer 1).
• Update HAL_DMA2D_PollForTransfer() to set the corresponding ErrorCode in case of error occurrence
• Update HAL_DMA2D_ConfigCLUT() function to fix wrong CLUT size and color mode settings
• Removal of useless macro __HAL_DMA2D_DISABLE()
• Update HAL_DMA2D_Suspend() to manage correctly the case where no transfer is on going
• Update HAL_DMA2D_Resume() to manage correctly the case where no transfer is on going
• Update HAL_DMA2D_Start_IT() to enable all required interrupts before enabling the transfer.
• Add HAL_DMA2D_CLUTLoad_IT() Function to allow loading a CLUT with interruption model.

• Update HAL_DMA2D_IRQHandler() to manage the following cases :

  • CLUT transfer complete
  • CLUT access error
  • Transfer watermark reached
• Add new Callback APIs:
  • HAL_DMA2D_LineEventCallback() to signal a transfer watermark reached event
  • HAL_DMA2D_CLUTLoadingCpltCallback() to signal a CLUT loading complete event
• Miscellaneous Improvement:
  • Add “HAL_DMA2D_ERROR_CAE” new define for CLUT Access error management.
  • Add “assert_param” used for parameters check is now done on the top of the exported functions : before locking the process using __HAL_LOCK

• Add support of I2C repeated start feature:
  • With the following new API’s
    • HAL_I2C_Master_Sequential_Transmit_IT()
    • HAL_I2C_Master_Sequential_Receive_IT()
    • HAL_I2C_Master_Abort_IT()
    • HAL_I2C_Slave_Sequential_Transmit_IT()
    • HAL_I2C_Slave_Sequential_Receive_IT()
    • HAL_I2C_EnableListen_IT()
    • HAL_I2C_DisableListen_IT()
• Add new user callbacks:
  • HAL_I2C_ListenCpltCallback()
  • HAL_I2C_AddrCallback()
• Update to generate STOP condition when a acknowledge failure error is detected
• Several update on HAL I2C driver to implement the new I2C state machine:
  • Add new API to get the I2C mode: HAL_I2C_GetMode()
  • Update I2C process to manage the new I2C states.
• Fix wrong behaviour in single byte transmission
• Update I2C_WaitOnFlagUntilTimeout() to manage the NACK feature.
• Update I2C transmission process to support the case data size equal 0

• Add support of FMPI2C repeated start feature:
  • With the following new API’s
    • HAL_FMPI2C_Master_Sequential_Transmit_IT()
    • HAL_FMPI2C_Master_Sequential_Receive_IT()
    • HAL_FMPI2C_Master_Abort_IT()
    • HAL_FMPI2C_Slave_Sequential_Transmit_IT()
    • HAL_FMPI2C_Slave_Sequential_Receive_IT()
    • HAL_FMPI2C_EnableListen_IT()
    • HAL_FMPI2C_DisableListen_IT()
  • Add new user callbacks:
    • HAL_FMPI2C_ListenCpltCallback()
    • HAL_FMPI2C_AddrCallback()
  • Several update on HAL I2C driver to implement the new I2C state machine:
    • Add new API to get the FMPI2C mode: HAL_FMPI2C_GetMode()
    • Update FMPI2C process to manage the new FMPI2C states.

• Major Update to improve performance in polling/interrupt mode to reach max frequency:
  • Polling mode :
    • Replace use of SPI_WaitOnFlagUnitTimeout() funnction by “if” statement to check on RXNE/TXE flags while transferring data.
    • Use API data pointer instead of SPI handle data pointer.
    • Use a Goto implementation instead of “if..else” statements.
  • Interrupt mode
    • Minimize access on SPI registers.
    • Split the SPI modes into dedicated static functions to minimize checking statements under HAL_IRQHandler():
      • 1lines/2lines modes
      • 8 bit/ 16 bits data formats
      • CRC calculation enabled/disabled.
    • Remove waiting loop under ISR when closing the communication.
  • All modes:
    • Adding switch USE_SPI_CRC to minimize number of statements when CRC calculation is disabled.
    • Update Timeout management to check on global process.
    • Update Error code management in all processes.
• Add note to the max frequencies reached in all modes.
• Add note about Master Receive mode restrictions :
  • Master Receive mode restriction:
    (#) In Master unidirectional receive-only mode (MSTR =1, BIDIMODE=0, RXONLY=0) or bidirectional receive mode (MSTR=1, BIDIMODE=1, BIDIOE=0), to ensure that the SPI does not initiate a new transfer the following procedure has to be respected:
    (##) HAL_SPI_DeInit()
    (##) HAL_SPI_Init()

• Update for proper management of the external synchronization input selection
  • update of HAL_SAI_Init () function
  • update definition of SAI_Block_SyncExt and SAI_Block_Synchronization groups
• Update SAI_SLOTACTIVE_X defines values
• Update HAL_SAI_Init() function for proper companding mode management
• Update SAI_Transmit_ITxxBit() functions to add the check on transfer counter before writing new data to SAIx_DR registers
• Update SAI_FillFifo() function to avoid issue when the number of data to transmit is smaller than the FIFO size
• Update HAL_SAI_EnableRxMuteMode() function for proper mute management
• Update SAI_InitPCM() function to support 24bits configuration

• Removal of ETH MAC debug register defines

• Update FLASH_MassErase() function to apply correctly voltage range parameter

• Update I2S_DMATxCplt() and I2S_DMARxCplt() to manage properly FullDuplex mode without any risk of missing data.

• Update the FMC_NORSRAM_Init() function to use BurstAccessMode field properly

• Update the FSMC_NORSRAM_Init() function to use BurstAccessMode field properly

• Update HAL weak empty callbacks to prevent unused argument compilation warnings with some compilers by calling the following line:
  • UNUSED(hppp);
• STM32Fxxx_User_Manual.chm files regenerated for HAL V1.4.3

• Update HAL_ETH_Init() function to add timeout on the Software reset management

• Update HAL_CRYP_DESECB_Decrypt() API to invert pPlainData and pCypherData parameters
  

• Update HAL weak empty callbacks to prevent unused argument compilation warnings with some compilers by calling the following line:
  • UNUSED(hppp);
    

• Remove duplication for __HAL_CORTEX_SYSTICKCLK_CONFIG() macro
  

• Rename HAL_HASH_STATETypeDef to HAL_HASH_StateTypeDef
• Rename HAL_HASH_PhaseTypeDef to HAL_HASH_PhaseTypeDef

• Add new macros __HAL_RCC_PPP_IS_CLK_ENABLED() to check on Clock enable/disable status
• Update __HAL_RCC_USB_OTG_FS_CLK_DISABLE() macro to remove the disable for the SYSCFG
• Update HAL_RCC_MCOConfig() API to use new defines for the GPIO Speed
• Generic update to improve the PLL VCO min value(100MHz): PLLN, PLLI2S and PLLSAI min value is 50 instead of 192

• __HAL_FLASH_INSTRUCTION_CACHE_RESET() macro: update to reset ICRST bit in the ACR register after setting it.
• Update to support until 15 FLASH wait state (FLASH_LATENCY_15) for STM32F446xx devices

• Update HAL_CRYP_DESECB_Decrypt() API to fix the inverted pPlainData and pCypherData parameters issue

• Update HAL_I2S_Init() API to call __HAL_RCC_I2S_CONFIG() macro when external I2S clock is selected

• Update HAL_LTDC_SetWindowPosition() API to configure Immediate reload register instead of vertical blanking reload register.

• Update HAL_TIM_ConfigClockSource() API to check only the required parameters

• Update HAL_NAND_Read_Page()/HAL_NAND_Write_Page()/HAL_NAND_Read_SpareArea() APIs to manage correctly the NAND Page access

• Update to use “=” instead of “|=” to clear flags in the MSR, TSR, RF0R and RF1R registers

• Fix typo in __HAL_USB_OTG_HS_WAKEUP_EXTI_ENABLE_RISING_FALLING_EDGE() macro implementation

• Update HAL_PCD_IRQHandler() API to avoid issue when DMA mode enabled for Status Phase IN stage

• Update the FMC_NORSRAM_Extended_Timing_Init() API to remove the check on CLKDIvison and DataLatency parameters
• Update the FMC_NORSRAM_Init() API to add a check on the PageSize parameter for STM32F42/43xx devices

• Update the FSMC_NORSRAM_Extended_Timing_Init() API to remove the check on CLKDIvison and DataLatency parameters

• Update TCCR register assigned value in HAL_DSI_ConfigHostTimeouts() function
• Update WPCR register assigned value in HAL_DSI_Init(), HAL_DSI_SetSlewRateAndDelayTuning(), HAL_DSI_SetSlewRateAndDelayTuning(), HAL_DSI_SetLowPowerRXFilter() / HAL_DSI_SetSDD(), HAL_DSI_SetLanePinsConfiguration(), HAL_DSI_SetPHYTimings(), HAL_DSI_ForceTXStopMode(), HAL_DSI_ForceRXLowPower(), HAL_DSI_ForceDataLanesInRX(), HAL_DSI_SetPullDown() and HAL_DSI_SetContentionDetectionOff() functions
• Update DSI_HS_PM_ENABLE define value
• Implement workaround for the hardware limitation: “The time to activate the clock between HS transmissions is not calculated correctly”

• Rename ADC_CLOCKPRESCALER_PCLK_DIV2 define to ADC_CLOCK_SYNC_PCLK_DIV2
• Rename ADC_CLOCKPRESCALER_PCLK_DIV4 define to ADC_CLOCK_SYNC_PCLK_DIV4
• Rename ADC_CLOCKPRESCALER_PCLK_DIV6 define to ADC_CLOCK_SYNC_PCLK_DIV6
• Rename ADC_CLOCKPRESCALER_PCLK_DIV8 define to ADC_CLOCK_SYNC_PCLK_DIV8

• Add specific API for MPU management
  • add MPU_Region_InitTypeDef structure
  • add new function HAL_MPU_ConfigRegion()

• Overall driver update for code optimization
  • add StreamBaseAddress and StreamIndex new fields in the DMA_HandleTypeDef structure
  • add DMA_Base_Registers private structure
  • add static function DMA_CalcBaseAndBitshift()
  • update HAL_DMA_Init() function to use the new added static function
  • update HAL_DMA_DeInit() function to optimize clear flag operations
  • update HAL_DMA_Start_IT() function to optimize interrupts enable
  • update HAL_DMA_PollForTransfer() function to optimize check on flags
  • update HAL_DMA_IRQHandler() function to optimize interrupt flag management

• update HAL_FLASH_Program_IT() function by removing the pending flag clear
• update HAL_FLASH_IRQHandler() function to improve erase operation procedure
• update FLASH_WaitForLastOperation() function by checking on end of operation flag

• Rename GPIO_SPEED_LOW define to GPIO_SPEED_FREQ_LOW
• Rename GPIO_SPEED_MEDIUM define to GPIO_SPEED_FREQ_MEDIUM
• Rename GPIO_SPEED_FAST define to GPIO_SPEED_FREQ_HIGH
• Rename GPIO_SPEED_HIGH define to GPIO_SPEED_FREQ_VERY_HIGH

• Move I2S_Clock_Source defines to extension file to properly add the support of STM32F410xx devices

• rename HAL_LTDC_LineEvenCallback() function to HAL_LTDC_LineEventCallback()
• add new function HAL_LTDC_SetPitch()
• add new functions HAL_LTDC_StructInitFromVideoConfig() and HAL_LTDC_StructInitFromAdaptedCommandConfig() applicable only to STM32F469xx and STM32F479xx devices

• move __HAL_PWR_VOLTAGESCALING_CONFIG() macro to extension file
• move PWR_WAKEUP_PIN2 define to extension file
• add PWR_WAKEUP_PIN3 define, applicable only to STM32F10xx devices
• add new functions HAL_PWREx_EnableWakeUpPinPolarityRisingEdge() and HAL_PWREx_EnableWakeUpPinPolarityFallingEdge(), applicable only to STM32F469xx and STM32F479xx devices

• Update HAL_RTCEx_SetWakeUpTimer() and HAL_RTCEx_SetWakeUpTimer_IT() functions to properly check on the WUTWF flag

• add new defines TIM_SYSTEMBREAKINPUT_HARDFAULT, TIM_SYSTEMBREAKINPUT_PVD and TIM_SYSTEMBREAKINPUT_HARDFAULT_PVD, applicable only to STM32F410xx devices

• HASH IT process: update to call the HAL_HASH_InCpltCallback() at the end of the complete buffer instead of every each 512 bits

• HAL_RCCEx_PeriphCLKConfig() updates:
  • Update the LSE check condition after backup domain reset: update to check LSE ready flag when LSE oscillator is already enabled instead of check on LSE oscillator only when LSE is used as RTC clock source
  • Use the right macro to check the PLLI2SQ parameters

• __HAL_RTC_TAMPER_TIMESTAMP_EXTI_GET_FLAG() macro: fix implementation issue
• __HAL_RTC_ALARM_GET_IT(), __HAL_RTC_ALARM_CLEAR_FLAG(), __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(), __HAL_RTC_TIMESTAMP_CLEAR_FLAG() and __HAL_RTC_TAMPER_CLEAR_FLAG() macros implementation changed: remove unused cast
• IS_RTC_TAMPER() macro: update to use literal instead of hardcoded value
• Add new parameter SecondFraction in RTC_TimeTypeDef structure
• HAL_RTC_GetTime() API update to support the new parameter SecondFraction

• Add new literal: ADC_INJECTED_SOFTWARE_START to be used as possible value for the ExternalTrigInjecConvEdge parameter in the ADC_InitTypeDef structure to select the ADC software trigger mode.

• FLASH_OB_GetRDP() API update to return uint8_t instead of FlagStatus
• __HAL_FLASH_GET_LATENCY() new macro add to get the flash latency

• Fix the wrong definition of HAL_SPI_ERROR_FLAG literal

• HAL_I2S_Transmit() API update to check on busy flag only for I2S slave mode

• __HAL_CRC_SET_IDR() macro implementation change to use WRITE_REG() instead of MODIFY_REG()

• HAL_DMA2D_ConfigLayer() API update to use “=” instead of “|=” to erase BGCOLR and FGCOLR registers before setting the new configuration

• HAL_HASH_MODE_Start_IT() (MODE stands for MD5, SHA1, SHA224 and SHA36) updates:
  • Fix processing fail for small input buffers
  • Update to unlock the process and call return HAL_OK at the end of HASH processing to avoid incorrectly repeating software
  • Update to properly manage the HashITCounter
  • Update to call the HAL_HASH_InCpltCallback() at the end of the complete buffer instead of every each 512 bits
• __HAL_HASH_GET_FLAG() update to check the right register when the DINNE flag is selected
• HAL_HASH_SHA1_Accumulate() updates:
  • Add a call to the new IS_HASH_SHA1_BUFFER_SIZE() macro to check the size parameter.
  • Add the following note in API description
    • @note Input buffer size in bytes must be a multiple of 4 otherwise the digest computation is corrupted.

• Update to define hardware independent literals names:
  • Rename RTC_TAMPERPIN_PC13 by RTC_TAMPERPIN_DEFAULT
  • Rename RTC_TAMPERPIN_PA0 by RTC_TAMPERPIN_POS1
  • Rename RTC_TAMPERPIN_PI8 by RTC_TAMPERPIN_POS1
  • Rename RTC_TIMESTAMPPIN_PC13 by RTC_TIMESTAMPPIN_DEFAULT
  • Rename RTC_TIMESTAMPPIN_PA0 by RTC_TIMESTAMPPIN_POS1
  • Rename RTC_TIMESTAMPPIN_PI8 by RTC_TIMESTAMPPIN_POS1

• Remove duplicated IS_ETH_DUPLEX_MODE() and IS_ETH_RX_MODE() macros
• Remove illegal space ETH_MAC_READCONTROLLER_FLUSHING macro
• Update ETH_MAC_READCONTROLLER_XXX defined values (XXX can be IDLE, READING_DATA and READING_STATUS)

• HAL_PCD_IRQHandler API: fix the bad Configuration of Turnaround Time

• Update to use local variable in USB Host channel re-activation

• FMC_SDRAM_SendCommand() API: remove the following line: return HAL_ERROR;

• USB_FlushTxFifo API: update to flush all Tx FIFO
• Update to use local variable in USB Host channel re-activation

• Fix compilation issue with STM32F417xx product: update STM32F17xx by STM32F417xx

• Remove unused variable to avoid warning with TrueSTUDIO

• I2C Polling/IT/DMA processes: move the wait loop on busy flag at the top of the processes, to ensure that software not perform any write access to I2C_CR1 register before hardware clearing STOP bit and to avoid also the waiting loop on BUSY flag under I2C/DMA ISR.
• Update busy flag Timeout value
• I2C Master Receive Processes update to disable ACK before generate the STOP

• Fix V1.3.0 regression issue with DAC software trigger configuration

• Overall SAI driver rework to have exhaustive support of the peripheral features: details are provided in HAL SAI update section below –> Compatibility with previous version is impacted
• CRYP driver updated to support multi instance,so user must ensure that the new parameter Instance is initialized in his application(CRYPHandle.Instance = CRYP)

• stm32f4xx_hal_def.h
  • Remove NULL definition and add include for stdio.h
• stm32_hal_legacy.h
  • Update method to manage deference in alias implementation between all STM32 families
• stm32f4xx_hal_ppp.c
  • HAL_PPP_Init(): update to force the HAL_PPP_STATE_RESET before calling the HAL_PPP_MspInit()

• Add new function HAL_RCCEx_GetPeriphCLKFreq()
• Move RCC_PLLInitTypeDef structure to extension file and add the new PLLR field specific to STM32F446xx devices
• Move the following functions to extension file and add a __weak attribute in generic driver : this update is related to new system clock source (PLL/PLLR) added and only available for STM32F44xx devices
  • HAL_RCC_OscConfig()
  • HAL_RCC_GetSysClockFreq()
  • HAL_RCC_GetOscConfig()
• Move the following macro to extension file as they have device dependent implementation
  • __HAL_RCC_PLL_CONFIG()
  • __HAL_RCC_PLLI2S_CONFIG()
  • __HAL_RCC_I2S_CONFIG()
• Add new structure RCC_PLLI2SInitTypeDef containing new PLLI2S division factors used only w/ STM32F446xx devices
• Add new structure RCC_PLLSAIInitTypeDef containing new PLLSAI division factors used only w/ STM32F446xx devices
• Add new RCC_PeriphCLKInitTypeDef to support the peripheral source clock selection for (I2S, SAI, SDIO, FMPI2C, CEC, SPDIFRX and CLK48)
• Update the HAL_RCCEx_PeriphCLKConfig() and HAL_RCCEx_GetPeriphCLKConfig() functions to support the new peripherals Clock source selection
• Add __HAL_RCC_PLL_CONFIG() macro (the number of parameter and the implementation depend on the device part number)
• Add __HAL_RCC_PLLI2S_CONFIG() macro(the number of parameter and the implementation depend on device part number)
• Update __HAL_RCC_PLLSAI_CONFIG() macro to support new PLLSAI factors (PLLSAIM and PLLSAIP)
• Add new macros for clock enable/Disable for the following peripherals (CEC, SPDIFRX, SAI2, QUADSPI)
• Add the following new macros for clock source selection :
  • __HAL_RCC_SAI1_CONFIG() / __HAL_RCC_GET_SAI1_SOURCE()
  • __HAL_RCC_SAI2_CONFIG() / __HAL_RCC_GET_SAI2_SOURCE()
  • __HAL_RCC_I2S1_CONFIG() / __HAL_RCC_GET_I2S1_SOURCE()
  • __HAL_RCC_I2S2_CONFIG() / __HAL_RCC_GET_I2S2_SOURCE()
  • __HAL_RCC_CEC_CONFIG() / __HAL_RCC__GET_CEC_SOURCE()
  • __HAL_RCC_FMPI2C1_CONFIG() / __HAL_RCC_GET_FMPI2C1_SOURCE()
  • __HAL_RCC_SDIO_CONFIG() / __HAL_RCC_GET_SDIO_SOURCE()
  • __HAL_RCC_CLK48_CONFIG() / __HAL_RCC_GET_CLK48_SOURCE()
  • __HAL_RCC_SPDIFRXCLK_CONFIG() / __HAL_RCC_GET_SPDIFRX_SOURCE()
• __HAL_RCC_PPP_CLK_ENABLE(): Implement workaround to cover RCC limitation regarding peripheral enable delay
• HAL_RCC_OscConfig() fix issues:
  • Add a check on LSERDY flag when LSE_BYPASS is selected as new state for LSE oscillator.
• Add new possible value RCC_PERIPHCLK_PLLI2S to be selected as PeriphClockSelection parameter in the RCC_PeriphCLKInitTypeDef structure to allow the possibility to output the PLLI2S on MCO without activating the I2S or the SAI.

• __HAL_RCC_HSE_CONFIG() macro: add the comment below:
  * @note Transition HSE Bypass to HSE On and HSE On to HSE Bypass are not supported by this macro.
  * User should request a transition to HSE Off first and then HSE On or HSE Bypass.

• __HAL_RCC_LSE_CONFIG() macro: add the comment below:
  * @note Transition LSE Bypass to LSE On and LSE On to LSE Bypass are not supported by this macro.
  * User should request a transition to LSE Off first and then LSE On or LSE Bypass.

• Add the following new macros for PLL source and PLLM selection :
  • __HAL_RCC_PLL_PLLSOURCE_CONFIG()
  • __HAL_RCC_PLL_PLLM_CONFIG()
• Macros rename:
  • HAL_RCC_OTGHS_FORCE_RESET() by HAL_RCC_USB_OTG_HS_FORCE_RESET()
  • HAL_RCC_OTGHS_RELEASE_RESET() by HAL_RCC_USB_OTG_HS_RELEASE_RESET()
  • HAL_RCC_OTGHS_CLK_SLEEP_ENABLE() by HAL_RCC_USB_OTG_HS_CLK_SLEEP_ENABLE()
  • HAL_RCC_OTGHS_CLK_SLEEP_DISABLE() by HAL_RCC_USB_OTG_HS_CLK_SLEEP_DISABLE()
  • HAL_RCC_OTGHSULPI_CLK_SLEEP_ENABLE() by HAL_RCC_USB_OTG_HS_ULPI_CLK_SLEEP_ENABLE()
  • HAL_RCC_OTGHSULPI_CLK_SLEEP_DISABLE() by HAL_RCC_USB_OTG_HS_ULPI_CLK_SLEEP_DISABLE()
• Add __HAL_RCC_SYSCLK_CONFIG() new macro to configure the system clock source (SYSCLK)
• __HAL_RCC_GET_SYSCLK_SOURCE() updates:
  • Add new RCC Literals:
    • RCC_SYSCLKSOURCE_STATUS_HSI
    • RCC_SYSCLKSOURCE_STATUS_HSE
    • RCC_SYSCLKSOURCE_STATUS_PLLCLK
    • RCC_SYSCLKSOURCE_STATUS_PLLRCLK
  • Update macro description to refer to the literals above

• Add new define PWR_WAKEUP_PIN2
• Add new API to Control/Get VOS bits of CR register
  • HAL_PWR_HAL_PWREx_ControlVoltageScaling()
  • HAL_PWREx_GetVoltageRange()
• __HAL_PWR_ VOLTAGESCALING_CONFIG(): Implement workaround to cover VOS limitation delay when PLL is enabled after setting the VOS configuration

• Add the new Alternate functions literals related to remap for SPI, USART, I2C, SPDIFRX, CEC and QSPI
• HAL_GPIO_DeInit(): Update to check if GPIO Pin x is already used in EXTI mode on another GPIO Port before De-Initialize the EXTI registers

• __HAL_FLASH_INSTRUCTION_CACHE_RESET() macro: update to reset ICRST bit in the ACR register after setting it.
• __HAL_FLASH_DATA_CACHE_RESET() macro: update to reset DCRST bit in the ACR register after setting it.

• Add new literal: ADC_SOFTWARE_START to be used as possible value for the ExternalTrigConv parameter in the ADC_InitTypeDef structure to select the ADC software trigger mode.
• IS_ADC_CHANNEL() macro update to don’t assert stop the ADC_CHANNEL_TEMPSENSOR value
• HAL_ADC_PollForConversion(): update to manage particular case when ADC configured in DMA mode and ADC sequencer with several ranks and polling for end of each conversion
• HAL_ADC_Start()/HAL_ADC_Start_IT() /HAL_ADC_Start_DMA() update:
  • unlock the process before starting the ADC software conversion.
  • Optimize the ADC stabilization delays
• __HAL_ADC_GET_IT_SOURCE() update macro implementation
• Add more details in ‘How to use this driver’ section

• Add new macro to check if the specified DAC interrupt source is enabled or disabled
  • __HAL_DAC_GET_IT_SOURCE()
• HAL_DACEx_TriangleWaveGeneration() update to use DAC CR bit mask definition
• HAL_DACEx_NoiseWaveGeneration() update to use DAC CR bit mask definition

• CanTxMsgTypeDef structure: update to use uint8_t Data[8] instead of uint32_t Data[8]
• CanRxMsgTypeDef structure: update to use uint8_t Data[8] instead of uint32_t Data[8]

• Update to use CMSIS mask definition instead of hardcoded values (EXTI_IMR_IM17, EXTI_IMR_IM19..)

• LTDC_SetConfig() update to allow the drawing of partial bitmap in active layer.

• HAL_USART_Init() fix USART baud rate configuration issue: USART baud rate is twice Higher than expected

• HAL_SMARTCARD_Transmit_IT() update to force the disable for the ERR interrupt to avoid the OVR interrupt
• HAL_SMARTCARD_IRQHandler() update check condition for transmission end
• Clean up: remove the following literals that aren’t used in smartcard mode
  • SMARTCARD_PARITY_NONE
  • SMARTCARD_WORDLENGTH_8B
  • SMARTCARD_STOPBITS_1
  • SMARTCADR_STOPBITS_2

• HAL_SPI_Transmit_DMA()/HAL_SPI_Receive_DMA()/HAL_SPI_TarnsmitReceive_DMA() update to unlock the process before enabling the SPI peripheral
• HAL_SPI_Transmit_DMA() update to manage correctly the DMA RX stream in SPI Full duplex mode
• Section SPI_Exported_Functions_Group2 update to remove duplication in *.chm UM

• Update to manage multi instance:
  • Add new parameter Instance in the CRYP_HandleTypeDef Handle structure.
  • Add new parameter in all HAL CRYP macros
    • example: __HAL_CRYP_ENABLE() updated by __HAL_CRYP_ENABLE(__HANDLE__)

• Add an extension driver stm32f4xx_hal_dcmi_ex.c/h to manage the support of new Black and White feature
• Add __weak attribute for HAL_DCMI_Init() function and add a new implementation in the extension driver to manage the black and white configuration only available in the STM32F446xx devices.
• Move DCMI_InitTypeDef structure to extension driver and add the following new fields related to black and white feature: ByteSelectMode, ByteSelectStart, LineSelectMode and LineSelectStart

• Add the support of LPM feature
  • add PCD_LPM_StateTypeDef enum
  • update PCD_HandleTypeDef structure to support the LPM feature
  • add new functions HAL_PCDEx_ActivateLPM(), HAL_PCDEx_DeActivateLPM() and HAL_PCDEx_LPM_Callback() in the stm32f4xx_hal_pcd_ex.h/.c files

• Add TIM_TIM11_SPDIFRX define

• Add stm32f4xx_hal_sai_ex.h/.c files for the SAI_BlockSynchroConfig() and the SAI_GetInputClock() management
• Add new defines HAL_SAI_ERROR_AFSDET, HAL_SAI_ERROR_LFSDET, HAL_SAI_ERROR_CNREADY, HAL_SAI_ERROR_WCKCFG, HAL_SAI_ERROR_TIMEOUT in the SAI_Error_Code group
• Add new defines SAI_SYNCEXT_DISABLE, SAI_SYNCEXT_IN_ENABLE, SAI_SYNCEXT_OUTBLOCKA_ENABLE, SAI_SYNCEXT_OUTBLOCKB_ENABLE for the SAI External synchronization
• Add new defines SAI_I2S_STANDARD, SAI_I2S_MSBJUSTIFIED, SAI_I2S_LSBJUSTIFIED, SAI_PCM_LONG and SAI_PCM_SHORT for the SAI Supported protocol
• Add new defines SAI_PROTOCOL_DATASIZE_16BIT, SAI_PROTOCOL_DATASIZE_16BITEXTENDED, SAI_PROTOCOL_DATASIZE_24BIT and SAI_PROTOCOL_DATASIZE_32BIT for SAI protocol data size
• Add SAI Callback prototype definition
• Update SAI_InitTypeDef structure by adding new fields: SynchroExt, Mckdiv, MonoStereoMode, CompandingMode, TriState
• Update SAI_HandleTypeDef structure:
  • remove uint16_t pTxBuffPtr, pRxBuffPtr, TxXferSize, RxXferSize, TxXferCount and RxXferCount and replace them respectively by uint8_t *pBuffPtr, uint16_t XferSize and uint16_t XferCount
  • add mutecallback field
  • add struct __SAI_HandleTypeDef *hsai field
• Remove SAI_CLKSOURCE_PLLR and SAI_CLOCK_PLLSRC defines
• Add SAI_CLKSOURCE_NA define
• Add SAI_AUDIO_FREQUENCY_MCKDIV define
• Add SAI_SPDIF_PROTOCOL define
• Add SAI_SYNCHRONOUS_EXT define
• Add new functions HAL_SAI_InitProtocol(), HAL_SAI_Abort(), HAL_SAI_EnableTxMuteMode(), HAL_SAI_DisableTxMuteMode(), HAL_SAI_EnableRxMuteMode(), HAL_SAI_DisableRxMuteMode()
• Update HAL_SAI_Transmit(), HAL_SAI_Receive(), HAL_SAI_Transmit_IT(), HAL_SAI_Receive_IT(), HAL_SAI_Transmit_DMA(), HAL_SAI_Receive_DMA() functions to use uint8_t pData instead of uint16_t pData –> This update is mainly impacting the compatibility with previous driver version.

• Split the following functions between Generic and Extended API based on full duplex management and add the attribute __weak in the Generic API
  • HAL_I2S_Init(), HAL_I2S_DMAPause(), HAL_I2S_DMAStop(), HAL_I2S_DMAResume(), HAL_I2S_IRQHandle()
• Move the following static functions from generic to extension driver
  • I2S_DMARxCplt() and I2S_DMATxCplt()
• Remove static attribute from I2S_Transmit_IT() and I2S_Receive_IT() functions
• Move I2SxEXT() macro to extension file
• Add I2S_CLOCK_PLLR and I2S_CLOCK_PLLSRC defines for I2S clock source
• Add new function I2S_GetInputClock()

• Add WriteFifo and PageSize fields in the FMC_NORSRAM_InitTypeDef structure
• Add FMC_PAGE_SIZE_NONE, FMC_PAGE_SIZE_128, FMC_PAGE_SIZE_256, FMC_PAGE_SIZE_1024, FMC_WRITE_FIFO_DISABLE, FMC_WRITE_FIFO_ENABLE defines
• Update FMC_NORSRAM_Init(), FMC_NORSRAM_DeInit() and FMC_NORSRAM_Extended_Timing_Init() functions

• Update USB_OTG_CfgTypeDef structure to support LPM, lpm_enable field added
• Update USB_HostInit() and USB_DevInit() functions to support the VBUS Sensing B activation

• LSI_VALUE constant has been corrected in stm32f4xx_hal_conf.h file, its value changed from 40 KHz to 32 KHz
• UART, USART, IRDA and SMARTCARD (referenced as PPP here below) drivers: in DMA transmit process, the code has been updated to avoid waiting on TC flag under DMA ISR, PPP TC interrupt is used instead. Below the update to be done on user application:
  • Configure and enable the USART IRQ in HAL_PPP_MspInit() function
  • In stm32f4xx_it.c file, PPP_IRQHandler() function: add a call to HAL_PPP_IRQHandler() function

• stm32f4xx_hal_def.h
  • Update NULL definition to fix C++ compilation issue
  • Add UNUSED() macro
  • Add a new define __NOINLINE to be used for the no inline code independent from tool chain
• stm32f4xx_hal_conf_template.h
  • LSI_VALUE constant has been corrected, its value changed from 40 KHz to 32 KHz
• Update all macros and literals naming to be uper case
• ErrorCode parameter in PPP_HandleTypeDef structure updated to uint32_t instead of enum HAL_PPP_ErrorTypeDef
• Remove the unused FLAG and IT assert macros

• Fix temperature sensor channel configuration issue for STM32F427/437xx and STM32F429/439xx devices

• HAL_DAC_ConfigChannel(): update the access to the DAC peripheral registers via the hdac handle instance
• HAL_DAC_IRQHandler(): update to check on both DAC_FLAG_DMAUDR1 and DAC_FLAG_DMAUDR2
• HAL_DACEx_NoiseWaveGenerate(): update to reset DAC CR register before setting the new DAC configuration
• HAL_DACEx_TriangleWaveGenerate(): update to reset DAC CR register before setting the new DAC configuration

• Unlock the CAN process when communication error occurred

• Add new macro IS_NVIC_DEVICE_IRQ() to check on negative values of IRQn parameter

HAL CRYP update

• HAL_CRYP_DESECB_Decrypt_DMA(): fix the inverted pPlainData and pCypherData parameters issue
• CRYPEx_GCMCCM_SetInitVector(): remove the IVSize parameter as the key length 192bits and 256bits are not supported by this version
• Add restriction for the CCM Encrypt/Decrypt API’s that only DataType equal to 8bits is supported
• HAL_CRYPEx_AESGCM_Finish():
  • Add restriction that the implementation is limited to 32bits inputs data length (Plain/Ciphertext, Header) compared with GCM stadards specifications (800-38D)
  • Update Size parameter on 32bits instead of 16bits
  • Fix issue with 16-bit Data Type: update to use intrinsic __ROR() instead of __REV16()

HAL DCMI update

• HAL_DCMI_ConfigCROP(): Invert assert macros to check Y0 and Ysize parameters

HAL DMA update

• HAL_DMA_Init(): Update to clear the DBM bit in the SxCR register before setting the new configuration
• DMA_SetConfig(): add to clear the DBM bit in the SxCR register

HAL FLASH update

• Add “HAL_” prefix in the defined values for the FLASH error code
  • Example: FLASH_ERROR_PGP renamed by HAL_FLASH_ERROR_PGP
• Clear the Flash ErrorCode in the FLASH_WaitForLastOperation() function
• Update FLASH_SetErrorCode() function to use “|=” operant to update the Flash ErrorCode parameter in the FLASH handle
• IS_FLASH_ADDRESS(): Update the macro check using ‘<=’ condition instead of ‘<’
• IS_OPTIONBYTE(): Update the macro check using ‘<=’ condition instead of ‘<’
• Add “FLASH_” prefix in the defined values of FLASH Type Program parameter
  • Example: TYPEPROGRAM_BYTE renamed by FLASH_TYPEPROGRAM_BYTE
• Add “FLASH_” prefix in the defined values of FLASH Type Erase parameter
  • Example: TYPEERASE_SECTORS renamed by FLASH_TYPEERASE_SECTORS
• Add “FLASH_” prefix in the defined values of FLASH Voltage Range parameter
  • Example: VOLTAGE_RANGE_1 renamed by FLASH_VOLTAGE_RANGE_1
• Add “OB_” prefix in the defined values of FLASH WRP State parameter
  • Example: WRPSTATE_ENABLE renamed by OB_WRPSTATE_ENABLE
• Add “OB_” prefix in the defined values of the FLASH PCROP State parameter
  • PCROPSTATE_DISABLE updated by OB_PCROP_STATE_DISABLE
  • PCROPSTATE_ENABLE updated by OB_PCROP_STATE_ENABLE
• Change “OBEX” prefix by “OPTIONBYTE” prefix in these defines:
  • OBEX_PCROP by OPTIONBYTE_PCROP
  • OBEX_BOOTCONFIG by OPTIONBYTE_BOOTCONFIG

• Fix macros naming typo
  • Update __HAL_ETH_EXTI_SET_RISING_EGDE_TRIGGER() by __HAL_ETH_EXTI_SET_RISING_EDGE_TRIGGER()
  • Update __HAL_ETH_EXTI_SET_FALLING_EGDE_TRIGGER() by __HAL_ETH_EXTI_SET_FALLING_EDGE_TRIGGER()

• Add new API to manage SLEEPONEXIT and SEVONPEND bits of SCR register
  • HAL_PWR_DisableSleepOnExit()
  • HAL_PWR_EnableSleepOnExit()
  • HAL_PWR_EnableSEVOnPend()
  • HAL_PWR_DisableSEVOnPend()
• HAL_PWR_EnterSTOPMode()
  • Update to clear the CORTEX SLEEPDEEP bit of SCR register before entering in sleep mode
  • Update usage of __WFE() in low power entry function: if there is a pending event, calling __WFE() will not enter the CortexM4 core to sleep mode. The solution is to made the call below; the first __WFE() is always ignored and clears the event if one was already pending, the second is always applied
    __SEV()
    __WFE()
    __WFE()
• Add new PVD configuration modes
  • PWR_PVD_MODE_NORMAL
  • PWR_PVD_MODE_EVENT_RISING
  • PWR_PVD_MODE_EVENT_FALLING
  • PWR_PVD_MODE_EVENT_RISING_FALLING
• Add new macros to manage PVD Trigger
  • __HAL_PWR_PVD_EXTI_ENABLE_RISING_EDGE()
  • __HAL_PWR_PVD_EXTI_DISABLE_RISING_EDGE(
  • __HAL_PWR_PVD_EXTI_ENABLE_FALLING_EDGE()
  • __HAL_PWR_PVD_EXTI_DISABLE_FALLING_EDGE()
  • __HAL_PWR_PVD_EXTI_ENABLE_RISING_FALLING_EDGE()
  • __HAL_PWR_PVD_EXTI_DISABLE_RISING_FALLING_EDGE()
• PVD macros:
  • Remove the __EXTILINE__ parameter
  • Update to use prefix "__HAL_PWR_PVD_" instead of prefix "__HAL_PVD"
• Rename HAL_PWR_PVDConfig() by HAL_PWR_ConfigPVD()
• Rename HAL_PWREx_ActivateOverDrive() by HAL_PWREx_EnableOverDrive()
• Rename HAL_PWREx_DeactivateOverDrive() by HAL_PWREx_DisableOverDrive()

• HAL_GPIO_Init()/HAL_GPIO_DeInit(): add a call to the CMSIS assert macro to check GPIO instance: IS_GPIO_ALL_INSTANCE()
• HAL_GPIO_WritePin(): update to write in BSRR register
• Rename GPIO_GET_SOURCE() by GET_GPIO_INDEX() and move this later to file stm32f4xx_hal_gpio_ex.h
• Add new define for alternate function GPIO_AF5_SPI3 for STM32F429xx/439xx and STM32F427xx/437xx devices

• HAL_HASH_MD5_Start_IT(): fix input address management issue
  

• Rename the following Macros
  • __PPP_CLK_ENABLE() by __HAL_RCC_PPP_CLK_ENABLE()
  • __PPP_CLK_DISABLE() by __HAL_RCC_PPP_CLK_DISABLE()
  • __PPP_FORCE_RESET() by __HAL_RCC_PPP_FORCE_RESET()
  • __PPP_RELEASE_RESET() by __HAL_RCC_PPP_RELEASE_RESET()
  • __PPP_CLK_SLEEP_ENABLE() by __HAL_RCC_PPP_CLK_SLEEP_ENABLE()
  • __PPP_CLK_SLEEP_DISABLE() by __HAL_RCC_PPP_CLK_SLEEP_DISABLE()
• IS_RCC_PLLSAIN_VALUE() macro: update the check condition
• Add description of RCC known Limitations
• Rename HAL_RCC_CCSCallback() by HAL_RCC_CSSCallback()
• HAL_RCC_OscConfig() fix issues:
  • Remove the disable of HSE oscillator when HSE_BYPASS is used as system clock source or as PPL clock source
  • Add a check on HSERDY flag when HSE_BYPASS is selected as new state for HSE oscillator.
• Rename __HAL_RCC_I2SCLK() by __HAL_RCC_I2S_Config()

HAL I2S update

• HAL_I2S_Init(): add check on I2S instance using CMSIS macro IS_I2S_ALL_INSTANCE()
• HAL_I2S_IRQHandler() update for compliance w/ C++
• Add use of tmpreg variable in __HAL_I2S_CLEAR_OVRFLAG() and __HAL_I2S_CLEAR_UDRFLAG() macro for compliance with C++
• HAL_I2S_GetError(): update to return uint32_t instead of HAL_I2S_ErrorTypeDef enumeration

HAL I2C update

• Update to clear the POS bit in the CR1 register at the end of HAL_I2C_Master_Read_IT() and HAL_I2C_Mem_Read_IT() process
• Rename HAL_I2CEx_DigitalFilter_Config() by HAL_I2CEx_ConfigDigitalFilter()
• Rename HAL_I2CEx_AnalogFilter_Config() by HAL_I2CEx_ConfigAnalogFilter()
• Add use of tmpreg variable in __HAL_I2C_CLEAR_ADDRFLAG() and __HAL_I2C_CLEAR_STOPFLAG() macro for compliance with C++

• DMA transmit process; the code has been updated to avoid waiting on TC flag under DMA ISR, IrDA TC interrupt is used instead. Below the update to be done on user application:
  • Configure and enable the USART IRQ in HAL_IRDA_MspInit() function
  • In stm32f4xx_it.c file, UASRTx_IRQHandler() function: add a call to HAL_IRDA_IRQHandler() function
• IT transmit process; the code has been updated to avoid waiting on TC flag under IRDA ISR, IrDA TC interrupt is used instead. No impact on user application
• Rename Macros: add prefix "__HAL"
  • __IRDA_ENABLE() by __HAL_IRDA_ENABLE()
  • __IRDA_DISABLE() by __HAL_IRDA_DISABLE()

• __HAL_IRDA_ONE_BIT_SAMPLE_ENABLE()
• __HAL_IRDA_ONE_BIT_SAMPLE_DISABLE()

• Add clear the TC flag in the SR register before enabling the DMA transmit request

• Rename the defined IWDG keys:
  • KR_KEY_RELOAD by IWDG_KEY_RELOAD
  • KR_KEY_ENABLE by IWDG_KEY_ENABLE
  • KR_KEY_EWA by IWDG_KEY_WRITE_ACCESS_ENABLE
  • KR_KEY_DWA by IWDG_KEY_WRITE_ACCESS_DISABLE
• Add new macros __HAL_IWDG_RESET_HANDLE_STATE() and __HAL_IWDG_CLEAR_FLAG()
• Update __HAL_IWDG_ENABLE_WRITE_ACCESS() and __HAL_IWDG_DISABLE_WRITE_ACCESS() as private macro

HAL SPI update

• HAL_SPI_TransmitReceive_DMA() update to remove the DMA Tx Error Callback initialization when SPI RxOnly mode is selected
• Add use of UNUSED(tmpreg) in __HAL_SPI_CLEAR_MODFFLAG(), __HAL_SPI_CLEAR_OVRFLAG(), __HAL_SPI_CLEAR_FREFLAG() to fix “Unused variable” warning with TrueSTUDIO.
• Rename Literals: remove “D” from “DISABLED” and “ENABLED”
  • SPI_TIMODE_DISABLED by SPI_TIMODE_DISABLE
  • SPI_TIMODE_ENABLED by SPI_TIMODE_ENABLE
  • SPI_CRCCALCULATION_DISABLED by SPI_CRCCALCULATION_DISABLE
  • SPI_CRCCALCULATION_ENABLED by SPI_CRCCALCULATION_ENABLE
• Add use of tmpreg variable in __HAL_SPI_CLEAR_MODFFLAG(), __HAL_SPI_CLEAR_FREFLAG() and __HAL_SPI_CLEAR_OVRFLAG() macros for compliance with C++
  

HAL SDMMC update

• IS_SDIO_ALL_INSTANCE() macro moved to CMSIS files

• HAL_LTDC_ConfigCLUT: optimize the function when pixel format is LTDC_PIXEL_FORMAT_AL44
  • Update the size of color look up table to 16 instead of 256 when the pixel format is LTDC_PIXEL_FORMAT_AL44

• Rename NAND Address structure to NAND_AddressTypeDef instead of NAND_AddressTypedef
• Update the used algorithm of these functions
  • HAL_NAND_Read_Page()
  • HAL_NAND_Write_Page()
  • HAL_NAND_Read_SpareArea()
  • HAL_NAND_Write_SpareArea()
• HAL_NAND_Write_Page(): move initialization of tickstart before while loop
• HAL_NAND_Erase_Block(): add whait until NAND status is ready before exiting this function

• Rename NOR Address structure to NOR_AddressTypeDef instead of NOR_AddressTypedef
• NOR Status literals renamed
  • NOR_SUCCESS by HAL_NOR_STATUS_SUCCESS
  • NOR_ONGOING by HAL_NOR_STATUS_ONGOING
  • NOR_ERROR by HAL_NOR_STATUS_ERROR
  • NOR_TIMEOUT by HAL_NOR_STATUS_TIMEOUT
• HAL_NOR_GetStatus() update to fix Timeout issue and exit from waiting loop when timeout occurred

• Rename PCCARD Address structure to HAL_PCCARD_StatusTypeDef instead of CF_StatusTypedef
• PCCARD Status literals renamed
  • CF_SUCCESS by HAL_PCCARD_STATUS_SUCCESS
  • CF_ONGOING by HAL_PCCARD_STATUS_ONGOING
  • CF_ERROR by HAL_PCCARD_STATUS_ERROR
  • CF_TIMEOUT by HAL_PCCARD_STATUS_TIMEOUT
• Update “CF” by “PCCARD” in functions, literals and macros

• Rename functions
  • HAL_PCD_ActiveRemoteWakeup() by HAL_PCD_ActivateRemoteWakeup()
  • HAL_PCD_DeActiveRemoteWakeup() by HAL_PCD_DeActivateRemoteWakeup()
• Rename literals
  • USB_FS_EXTI_TRIGGER_RISING_EDGE by USB_OTG_FS_WAKEUP_EXTI_RISING_EDGE
  • USB_FS_EXTI_TRIGGER_FALLING_EDGE by USB_OTG_FS_WAKEUP_EXTI_FALLING_EDGE
  • USB_FS_EXTI_TRIGGER_BOTH_EDGE() by USB_OTG_FS_WAKEUP_EXTI_RISING_FALLING_EDGE
  • USB_HS_EXTI_TRIGGER_RISING_EDGE by USB_OTG_HS_WAKEUP_EXTI_RISING_EDGE
  • USB_HS_EXTI_TRIGGER_FALLING_EDGE by USB_OTG_HS_WAKEUP_EXTI_FALLING_EDGE
  • USB_HS_EXTI_TRIGGER_BOTH_EDGE by USB_OTG_HS_WAKEUP_EXTI_RISING_FALLING_EDGE
  • USB_HS_EXTI_LINE_WAKEUP by USB_OTG_HS_EXTI_LINE_WAKEUP
  • USB_FS_EXTI_LINE_WAKEUP by USB_OTG_FS_EXTI_LINE_WAKEUP

• __HAL_USB_SUBBLOCK_EXTI_ENABLE_IT() by __HAL_USB_OTG_SUBBLOCK_WAKEUP_EXTI_ENABLE_IT()
  
• __HAL_USB_SUBBLOCK_EXTI_DISABLE_IT() by __HAL_USB_OTG_SUBBLOCK_WAKEUP_EXTI_DISABLE_IT()
• __HAL_USB_SUBBLOCK_EXTI_GET_FLAG() by __HAL_USB_OTG_SUBBLOCK_WAKEUP_EXTI_GET_FLAG()
• __HAL_USB_SUBBLOCK_EXTI_CLEAR_FLAG() by __HAL_USB_OTG_SUBBLOCK_WAKEUP_EXTI_CLEAR_FLAG()
• __HAL_USB_SUBBLOCK_EXTI_SET_RISING_EGDE_TRIGGER() by __HAL_USB_OTG_SUBBLOCK_WAKEUP_EXTI_ENABLE_RISING_EDGE()
• __HAL_USB_SUBBLOCK_EXTI_SET_FALLING_EGDE_TRIGGER() by __HAL_USB_OTG_SUBBLOCK_WAKEUP_EXTI_ENABLE_FALLING_EDGE()
• __HAL_USB_SUBBLOCK_EXTI_SET_FALLINGRISING_TRIGGER() by __HAL_USB_OTG_SUBBLOCK_WAKEUP_EXTI_ENABLE_RISING_FALLING_EDGE()
• __HAL_USB_SUBBLOCK_EXTI_GENERATE_SWIT() by __HAL_USB_OTG_SUBBLOCK_WAKEUP_EXTI_GENERATE_SWIT()
  

• Add new functions
  • HAL_RNG_GenerateRandomNumber(): to generate a 32-bits random number, return random value in argument and return HAL status.
  • HAL_RNG_GenerateRandomNumber_IT(): to start generation of the 32-bits random number, user should call the HAL_RNG_ReadLastRandomNumber() function under the HAL_RNG_ReadyCallback() to get the generated random value.
  • HAL_RNG_ReadLastRandomNumber(): to return the last random value stored in the RNG handle
• HAL_RNG_GetRandomNumber(): return value update (obsolete), replaced by HAL_RNG_GenerateRandomNumber()
• HAL_RNG_GetRandomNumber_IT(): wrong implementation (obsolete), replaced by HAL_RNG_GenerateRandomNumber_IT()
• __HAL_RNG_CLEAR_FLAG() macro (obsolete), replaced by new __HAL_RNG_CLEAR_IT() macro
• Add new define for RNG ready interrupt: RNG_IT_DRDY

• HAL_RTC_GetTime() and HAL_RTC_GetDate(): add the comment below
  * @note You must call HAL_RTC_GetDate() after HAL_RTC_GetTime() to unlock the values
  * in the higher-order calendar shadow registers to ensure consistency between the time and date values.
  * Reading RTC current time locks the values in calendar shadow registers until Current date is read.

• Rename literals: add prefix "__HAL"
  • FORMAT_BIN by HAL_FORMAT_BIN
  • FORMAT_BCD by HAL_FORMAT_BCD
• Rename macros (ALARM, WAKEUPTIMER and TIMESTAMP referenced as SUBBLOCK here below)
  • __HAL_RTC_EXTI_ENABLE_IT() by __HAL_RTC_SUBBLOCK_EXTI_ENABLE_IT()
  • __HAL_RTC_EXTI_DISABLE_IT() by __HAL_RTC__SUBBLOCK_EXTI_DISABLE_IT()
  • __HAL_RTC_EXTI_CLEAR_FLAG() by __HAL_RTC_SUBBLOCK_EXTI_CLEAR_FLAG()
  • __HAL_RTC_EXTI_GENERATE_SWIT() by __HAL_RTC_SUBBLOCK_EXTI_GENERATE_SWIT()
• Add new macros (ALARM, WAKEUPTIMER and TAMPER_TIMESTAMP referenced as SUBBLOCK here below)
  • __HAL_RTC_SUBBLOCK_GET_IT_SOURCE()
  • __HAL_RTC_SUBBLOCK_EXTI_ENABLE_EVENT()
  • __HAL_RTC_SUBBLOCK_EXTI_DISABLE_EVENT()
  • __HAL_RTC_SUBBLOCK_EXTI_ENABLE_FALLING_EDGE()
  • __HAL_RTC_SUBBLOCK_EXTI_DISABLE_FALLING_EDGE()
  • __HAL_RTC_SUBBLOCK_EXTI_ENABLE_RISING_EDGE()
  • __HAL_RTC_SUBBLOCK_EXTI_DISABLE_RISING_EDGE()
  • __HAL_RTC_SUBBLOCK_EXTI_ENABLE_RISING_FALLING_EDGE()
  • __HAL_RTC_SUBBLOCK_EXTI_DISABLE_RISING_FALLING_EDGE()
  • __HAL_RTC_SUBBLOCK_EXTI_GET_FLAG()

• Update SAI_STREOMODE by SAI_STEREOMODE
• Update FIFO status Level defines in upper case
• Rename literals: remove “D” from “DISABLED” and “ENABLED”
  • SAI_OUTPUTDRIVE_DISABLED by SAI_OUTPUTDRIVE_DISABLE
  • SAI_OUTPUTDRIVE_ENABLED by SAI_OUTPUTDRIVE_ENABLE
  • SAI_MASTERDIVIDER_ENABLED by SAI_MASTERDIVIDER_ENABLE
  • SAI_MASTERDIVIDER_DISABLED by SAI_MASTERDIVIDER_DISABLE

• Rename SD_CMD_SD_APP_STAUS by SD_CMD_SD_APP_STATUS
• SD_PowerON() updated to add 1ms required power up waiting time before starting the SD initialization sequence
• SD_DMA_RxCplt()/SD_DMA_TxCplt(): add a call to HAL_DMA_Abort()
• HAL_SD_ReadBlocks() update to set the defined DATA_BLOCK_SIZE as SDIO DataBlockSize parameter
• HAL_SD_ReadBlocks_DMA()/HAL_SD_WriteBlocks_DMA() update to call the HAL_DMA_Start_IT() function with DMA Datalength set to BlockSize/4 as the DMA is configured in word

• DMA transmit process; the code has been updated to avoid waiting on TC flag under DMA ISR, SMARTCARD TC interrupt is used instead. Below the update to be done on user application:
  • Configure and enable the USART IRQ in HAL_SAMRTCARD_MspInit() function
  • In stm32f4xx_it.c file, UASRTx_IRQHandler() function: add a call to HAL_SMARTCARD_IRQHandler() function
• IT transmit process; the code has been updated to avoid waiting on TC flag under SMARTCARD ISR, SMARTCARD TC interrupt is used instead. No impact on user application
• Rename macros: add prefix "__HAL"
  • __SMARTCARD_ENABLE() by __HAL_SMARTCARD_ENABLE()
  • __SMARTCARD_DISABLE() by __HAL_SMARTCARD_DISABLE()
  • __SMARTCARD_ENABLE_IT() by __HAL_SMARTCARD_ENABLE_IT()
  • __SMARTCARD_DISABLE_IT() by __HAL_SMARTCARD_DISABLE_IT()
  • __SMARTCARD_DMA_REQUEST_ENABLE() by __HAL_SMARTCARD_DMA_REQUEST_ENABLE()
  • __SMARTCARD_DMA_REQUEST_DISABLE() by __HAL_SMARTCARD_DMA_REQUEST_DISABLE()
• Rename literals: remove “D” from “DISABLED” and “ENABLED”
  • SMARTCARD_NACK_ENABLED by SMARTCARD_NACK_ENABLE
  • SMARTCARD_NACK_DISABLED by SMARTCARD_NACK_DISABLE
• Add new user macros to manage the sample method feature
  • __HAL_SMARTCARD_ONE_BIT_SAMPLE_ENABLE()
  • __HAL_SMARTCARD_ONE_BIT_SAMPLE_DISABLE()
• Add use of tmpreg variable in __HAL_SMARTCARD_CLEAR_PEFLAG() macro for compliance with C++
• HAL_SMARTCARD_Transmit_DMA() update to follow the right procedure “Transmission using DMA” in the reference manual
  • Add clear the TC flag in the SR register before enabling the DMA transmit request

• Add TIM_CHANNEL_ALL as possible value for all Encoder Start/Stop APIs Description
• HAL_TIM_OC_ConfigChannel() remove call to IS_TIM_FAST_STATE() assert macro
• HAL_TIM_PWM_ConfigChannel() add a call to IS_TIM_FAST_STATE() assert macro to check the OCFastMode parameter
• HAL_TIM_DMADelayPulseCplt() Update to set the TIM Channel before to call HAL_TIM_PWM_PulseFinishedCallback()
• HAL_TIM_DMACaptureCplt() update to set the TIM Channel before to call HAL_TIM_IC_CaptureCallback()
• TIM_ICx_ConfigChannel() update to fix Timer CCMR1 register corruption when setting ICFilter parameter
• HAL_TIM_DMABurst_WriteStop()/HAL_TIM_DMABurst_ReadStop() update to abort the DMA transfer for the specific TIM channel
• Add new function for TIM Slave configuration in IT mode: HAL_TIM_SlaveConfigSynchronization_IT()
• HAL_TIMEx_ConfigBreakDeadTime() add an assert check on Break & DeadTime parameters values
• HAL_TIMEx_OCN_Start_IT() add the enable of Break Interrupt for all output modes
• Add new macros to ENABLE/DISABLE URS bit in TIM CR1 register:
  • __HAL_TIM_URS_ENABLE()
  • __HAL_TIM_URS_DISABLE()
• Add new macro for TIM Edge modification: __HAL_TIM_SET_CAPTUREPOLARITY()

• Add IS_LIN_WORD_LENGTH() and IS_LIN_OVERSAMPLING() macros: to check respectively WordLength and OverSampling parameters in LIN mode
• DMA transmit process; the code has been updated to avoid waiting on TC flag under DMA ISR, UART TC interrupt is used instead. Below the update to be done on user application:
  • Configure and enable the USART IRQ in HAL_UART_MspInit() function
  • In stm32f4xx_it.c file, USARTx_IRQHandler() function: add a call to HAL_UART_IRQHandler() function
• IT transmit process; the code has been updated to avoid waiting on TC flag under UART ISR, UART TC interrupt is used instead. No impact on user application
• Rename macros:
  • __HAL_UART_ONEBIT_ENABLE() by __HAL_UART_ONE_BIT_SAMPLE_ENABLE()
  • __HAL_UART_ONEBIT_DISABLE() by __HAL_UART_ONE_BIT_SAMPLE_DISABLE()
• Rename literals:
  • UART_WAKEUPMETHODE_IDLELINE by UART_WAKEUPMETHOD_IDLELINE
  • UART_WAKEUPMETHODE_ADDRESSMARK by UART_WAKEUPMETHOD_ADDRESSMARK
• Add use of tmpreg variable in __HAL_UART_CLEAR_PEFLAG() macro for compliance with C++
• HAL_UART_Transmit_DMA() update to follow the right procedure “Transmission using DMA” in the reference manual
  • Add clear the TC flag in the SR register before enabling the DMA transmit request

• DMA transmit process; the code has been updated to avoid waiting on TC flag under DMA ISR, USART TC interrupt is used instead. Below the update to be done on user application:
  • Configure and enable the USART IRQ in HAL_USART_MspInit() function
  • In stm32f4xx_it.c file, USARTx_IRQHandler() function: add a call to HAL_USART_IRQHandler() function
• IT transmit process; the code has been updated to avoid waiting on TC flag under USART ISR, USART TC interrupt is used instead. No impact on user application
• HAL_USART_Init() update to enable the USART oversampling by 8 by default in order to reach max USART frequencies
• USART_DMAReceiveCplt() update to set the new USART state after checking on the old state
• HAL_USART_Transmit_DMA()/HAL_USART_TransmitReceive_DMA() update to follow the right procedure “Transmission using DMA” in the reference manual
  • Add clear the TC flag in the SR register before enabling the DMA transmit request
• Rename macros:
  • __USART_ENABLE() by __HAL_USART_ENABLE()
  • __USART_DISABLE() by __HAL_USART_DISABLE()
  • __USART_ENABLE_IT() by __HAL_USART_ENABLE_IT()
  • __USART_DISABLE_IT() by __HAL_USART_DISABLE_IT()
• Rename literals: remove “D” from “DISABLED” and “ENABLED”
  • USART_CLOCK_DISABLED by USART_CLOCK_DISABLE
  • USART_CLOCK_ENABLED by USART_CLOCK_ENABLE
  • USARTNACK_ENABLED by USART_NACK_ENABLE
  • USARTNACK_DISABLED by USART_NACK_DISABLE
• Add new user macros to manage the sample method feature
  • __HAL_USART_ONE_BIT_SAMPLE_ENABLE()
  • __HAL_USART_ONE_BIT_SAMPLE_DISABLE()
• Add use of tmpreg variable in __HAL_USART_CLEAR_PEFLAG() macro for compliance with C++

• Add new parameter in __HAL_WWDG_ENABLE_IT() macro
• Add new macros to manage WWDG IT & correction:
  • __HAL_WWDG_DISABLE()
  • __HAL_WWDG_DISABLE_IT()
  • __HAL_WWDG_GET_IT()
  • __HAL_WWDG_GET_IT_SOURCE()

• Enhance HAL delay and time base implementation
  • Systick timer is used by default as source of time base, but user can eventually implement his proper time base source (a general purpose timer for example or other time source)
  • Functions affecting time base configurations are declared as __Weak to make override possible in case of other implementations in user file, for more details please refer to HAL_TimeBase example
• Fix flag clear procedure: use atomic write operation “=” instead of ready-modify-write operation “|=” or “&=”
• Fix on Timeout management, Timeout value set to 0 passed to API automatically exits the function after checking the flag without any wait
• Common update for the following communication peripherals: SPI, UART, USART and IRDA
  • Add DMA circular mode support
  • Remove lock from recursive process
• Add new macro __HAL_RESET_HANDLE_STATE to reset a given handle state
• Add a new attribute for functions executed from internal SRAM and depending from Compiler implementation
• When USE_RTOS == 1 (in stm32l0xx_hal_conf.h), the __HAL_LOCK() is not defined instead of being defined empty
• Miscellaneous comments and formatting update
• stm32f4xx_hal_conf_template.h
  • Add a new define for LSI default value LSI_VALUE
  • Add a new define for LSE default value LSE_VALUE
  • Add a new define for Tick interrupt priority TICK_INT_PRIORITY (needed for the enhanced time base implementation)
  • Important Note: aliases has been added for any API naming change, to keep compatibility with previous version

• Add a new macro __HAL_GPIO_EXTI_GENERATE_SWIT() to manage the generation of software interrupt on selected EXTI line
• HAL_GPIO_Init(): use temporary variable when modifying the registers, to avoid unexpected transition in the GPIO pin configuration
• Remove IS_GET_GPIO_PIN macro
• Add a new function HAL_GPIO_LockPin()
• Private Macro __HAL_GET_GPIO_SOURCE renamed into GET_GPIO_SOURCE
• Add the support of STM32F411xx devices : add the new Alternate functions values related to new remap added for SPI, USART, I2C
• Update the following HAL GPIO macros description: rename EXTI_Linex by GPIO_PIN_x
  • __HAL_GPIO_EXTI_CLEAR_IT()
  • __HAL_GPIO_EXTI_GET_IT()
  • __HAL_GPIO_EXTI_CLEAR_FLAG()
  • __HAL_GPIO_EXTI_GET_FLAG()

HAL DMA update

• Fix in HAL_DMA_PollForTransfer() to:
  • set DMA error code in case of HAL_ERROR status
  • set HAL Unlock before DMA state update

HAL DMA2D update

• Add configuration of source address in case of A8 or A4 M2M_PFC DMA2D mode

• Functions reorganization update, depending on the features supported by each STM32F4 device
• Add new driver (stm32f4xx_hal_flash_ramfunc.h/.c) to manage function executed from RAM, these functions are available only for STM32F411xx Devices
  • FLASH_StopFlashInterfaceClk() : Stop the flash interface while System Run
  • FLASH_StartFlashInterfaceClk() : Stop the flash interface while System Run
  • FLASH_EnableFlashSleepMode() : Enable the flash sleep while System Run
  • FLASH_DisableFlashSleepMode() : Disable the flash sleep while System Run

• HAL_PWR_PVDConfig(): add clear of the EXTI trigger before new configuration
• Fix in HAL_PWR_EnterSTANDBYMode() to not clear Wakeup flag (WUF), which need to be cleared at application level before to call this function
• HAL_PWR_EnterSLEEPMode()
  • Remove disable and enable of SysTick Timer
  • Update usage of __WFE() in low power entry function: if there is a pending event, calling __WFE() will not enter the CortexM4 core to sleep mode. The solution is to made the call below; the first __WFE() is always ignored and clears the event if one was already pending, the second is always applied
    __SEV()
    __WFE()
    __WFE()
• Add new macro for software event generation __HAL_PVD_EXTI_GENERATE_SWIT()
• Remove the following defines form Generic driver and add them under extension driver because they are only used within extension functions.
  • CR_FPDS_BB: used within HAL_PWREx_EnableFlashPowerDown() function
  • CSR_BRE_BB: used within HAL_PWREx_EnableBkUpReg() function
• Add the support of STM32F411xx devices add the define STM32F411xE
  • For STM32F401xC, STM32F401xE and STM32F411xE devices add the following functions used to enable or disable the low voltage mode for regulators
    • HAL_PWREx_EnableMainRegulatorLowVoltage()
    • HAL_PWREx_DisableMainRegulatorLowVoltage()
    • HAL_PWREx_EnableLowRegulatorLowVoltage()
    • HAL_PWREx_DisableLowRegulatorLowVoltage()
  • For STM32F42xxx/43xxx devices, add a new function for Under Driver management as the macro already added for this mode is not sufficient: HAL_PWREx_EnterUnderDriveSTOPMode()

• In HAL_RCC_ClockConfig() function: update the AHB clock divider before clock switch to new source
• Allow to calibrate the HSI when it is used as system clock source
• Rename the following macros
  • __OTGFS_FORCE_RESET () by __USB_OTG_FS_FORCE_RESET()
  • __OTGFS_RELEASE_RESET () by __USB_OTG_FS_RELEASE_RESET()
  • __OTGFS_CLK_SLEEP_ENABLE () by __USB_OTG_FS_CLK_SLEEP_ENABLE()
  • __OTGFS_CLK_SLEEP_DISABLE () by __USB_OTG_FS_CLK_SLEEP_DISABLE()
• Add new field PLLI2SM in RCC_PLLI2SInitTypeDef structure, this division factor is added for PLLI2S VCO input clock only STM32F411xE devices => the FW compatibility is broken vs. STM32F401xx devices
• Update HAL_RCCEx_PeriphCLKConfig() and HAL_RCCEx_GetPeriphCLKConfig() functions to support the new PLLI2SM
• Add new function to manage the new LSE mode : HAL_RCCEx_SelectLSEMode()
• Reorganize the macros depending from Part number used and make them more clear

HAL UART update

• Add new macros to control CTS and RTS
• Add specific macros to manage the flags cleared only by a software sequence
  • __HAL_UART_CLEAR_PEFLAG()
  • __HAL_UART_CLEAR_FEFLAG()
  • __HAL_UART_CLEAR_NEFLAG()
  • __HAL_UART_CLEAR_OREFLAG()
  • __HAL_UART_CLEAR_IDLEFLAG()
• Add several enhancements without affecting the driver functionalities
  • Remove the check on RXNE set after reading the Data in the DR register
  • Update the transmit processes to use TXE instead of TC
  • Update HAL_UART_Transmit_IT() to enable UART_IT_TXE instead of UART_IT_TC

HAL USART update

• Add specific macros to manage the flags cleared only by a software sequence
  • __HAL_USART_CLEAR_PEFLAG()
  • __HAL_USART_CLEAR_FEFLAG()
  • __HAL_USART_CLEAR_NEFLAG()
  • __HAL_USART_CLEAR_OREFLAG()
  • __HAL_USART_CLEAR_IDLEFLAG()
• Update HAL_USART_Transmit_IT() to enable USART_IT_TXE instead of USART_IT_TC

HAL IRDA update

• Add specific macros to manage the flags cleared only by a software sequence __HAL_IRDA_CLEAR_PEFLAG() __HAL_ IRDA _CLEAR_FEFLAG() __HAL_ IRDA _CLEAR_NEFLAG() __HAL_ IRDA _CLEAR_OREFLAG() __HAL_ IRDA _CLEAR_IDLEFLAG()
• Add several enhancements without affecting the driver functionalities
  • Remove the check on RXNE set after reading the Data in the DR register
  • Update HAL_IRDA_Transmit_IT() to enable IRDA_IT_TXE instead of IRDA_IT_TC
• Add the following APIs used within DMA process
  • HAL_StatusTypeDef HAL_IRDA_DMAPause(IRDA_HandleTypeDef *hirda);
  • HAL_StatusTypeDef HAL_IRDA_DMAResume(IRDA_HandleTypeDef *hirda);
  • HAL_StatusTypeDef HAL_IRDA_DMAStop(IRDA_HandleTypeDef *hirda);
  • void HAL_IRDA_TxHalfCpltCallback(IRDA_HandleTypeDef *hirda);
  • void HAL_IRDA_RxHalfCpltCallback(IRDA_HandleTypeDef *hirda);

HAL SMARTCARD update

• Add specific macros to manage the flags cleared only by a software sequence
  • __HAL_SMARTCARD_CLEAR_PEFLAG()
  • __HAL_SMARTCARD_CLEAR_FEFLAG()
  • __HAL_SMARTCARD_CLEAR_NEFLAG()
  • __HAL_SMARTCARD_CLEAR_OREFLAG()
  • __HAL_SMARTCARD_CLEAR_IDLEFLAG()
• Add several enhancements without affecting the driver functionalities
  • Add a new state HAL_SMARTCARD_STATE_BUSY_TX_RX and all processes has been updated accordingly
  • Update HAL_SMARTCARD_Transmit_IT() to enable SMARTCARD_IT_TXE instead of SMARTCARD_IT_TC

• Bugs fix
  • SPI interface is used in synchronous polling mode: at high clock rates like SPI prescaler 2 and 4, calling HAL_SPI_TransmitReceive() returns with error HAL_TIMEOUT
  • HAL_SPI_TransmitReceive_DMA() does not clean up the TX DMA, so any subsequent SPI calls return the DMA error
  • HAL_SPI_Transmit_DMA() is failing when data size is equal to 1 byte
• Add the following APIs used within the DMA process
  • HAL_StatusTypeDef HAL_SPI_DMAPause(SPI_HandleTypeDef *hspi);
  • HAL_StatusTypeDef HAL_SPI_DMAResume(SPI_HandleTypeDef *hspi);
  • HAL_StatusTypeDef HAL_SPI_DMAStop(SPI_HandleTypeDef *hspi);
  • void HAL_SPI_TxHalfCpltCallback(SPI_HandleTypeDef *hspi);
  • void HAL_SPI_RxHalfCpltCallback(SPI_HandleTypeDef *hspi);
  • void HAL_SPI_TxRxHalfCpltCallback(SPI_HandleTypeDef *hspi);

• Add a conditional define to make this driver visible for all STM32F4xx devices except STM32F401xx and STM32F411xx Devices.

• These macros are added to read/write the CRC IDR register: __HAL_CRC_SET_IDR() and __HAL_CRC_GET_IDR()

• Enhance the DMA channel configuration when used with DAC

• HAL_TIM_IRQHandler(): update to check the input capture channel 3 and 4 in CCMR2 instead of CCMR1
• __HAL_TIM_PRESCALER() updated to use ‘=’ instead of ‘|=’
• Add the following macro in TIM HAL driver
  • __HAL_TIM_GetCompare()
  • __HAL_TIM_GetCounter()
  • __HAL_TIM_GetAutoreload()
  • __HAL_TIM_GetClockDivision()
  • __HAL_TIM_GetICPrescaler()

• Use of CMSIS constants instead of magic values
• Miscellaneous update in functions internal coding

• Fix issue of macros returning wrong address for NAND blocks
• Fix issue for read/write NAND page/spare area

• Add the NOR address bank macro used within the API
• Update NOR API implementation to avoid the use of NOR address bank hard coded

• HCD_StateTypeDef structure members renamed
• These macro are renamed
  • __HAL_GET_FLAG(__HANDLE__, __INTERRUPT__) by __HAL_HCD_GET_FLAG(__HANDLE__, __INTERRUPT__)
  • __HAL_CLEAR_FLAG(__HANDLE__, __INTERRUPT__) by __HAL_HCD_CLEAR_FLAG(__HANDLE__, __INTERRUPT__)
  • __HAL_IS_INVALID_INTERRUPT(__HANDLE__) by __HAL_HCD_IS_INVALID_INTERRUPT(__HANDLE__)

• HAL_PCD_SetTxFiFo() and HAL_PCD_SetRxFiFo() renamed into HAL_PCDEx_SetTxFiFo() and HAL_PCDEx_SetRxFiFo() and moved to the extension files stm32f4xx_hal_pcd_ex.h/.c
• PCD_StateTypeDef structure members renamed
• Fix incorrect masking of TxFIFOEmpty
• stm32f4xx_ll_usb.c: fix issue in HS mode
• New macros added
  • __HAL_PCD_IS_PHY_SUSPENDED()
  • __HAL_USB_HS_EXTI_GENERATE_SWIT()
  • __HAL_USB_FS_EXTI_GENERATE_SWIT()
• These macro are renamed
  • __HAL_GET_FLAG(__HANDLE__, __INTERRUPT__) by __HAL_PCD_GET_FLAG(__HANDLE__, __INTERRUPT__)
  • __HAL_CLEAR_FLAG(__HANDLE__, __INTERRUPT__) by __HAL_PCD_CLEAR_FLAG(__HANDLE__, __INTERRUPT__)
  • __HAL_IS_INVALID_INTERRUPT(__HANDLE__) by __HAL_PCD_IS_INVALID_INTERRUPT(__HANDLE__)
  • __HAL_PCD_UNGATE_CLOCK(__HANDLE__) by __HAL_PCD_UNGATE_PHYCLOCK(__HANDLE__)
  • __HAL_PCD_GATE_CLOCK(__HANDLE___) by __HAL_PCD_GATE_PHYCLOCK(__HANDLE__)

• Update HAL_ETH_GetReceivedFrame_IT() function to return HAL_ERROR if the received packet is not complete
• Use HAL_Delay() instead of counting loop
• __HAL_ETH_MAC_CLEAR_FLAG() macro is removed: the MACSR register is read only
• Add the following macros used to Wake up the device from STOP mode by Ethernet event :
  • __HAL_ETH_EXTI_ENABLE_IT()
  • __HAL_ETH_EXTI_DISABLE_IT()
  • __HAL_ETH_EXTI_GET_FLAG()
  • __HAL_ETH_EXTI_CLEAR_FLAG()
  • __HAL_ETH_EXTI_SET_RISING_EGDE_TRIGGER()
  • __HAL_ETH_EXTI_SET_FALLING_EGDE_TRIGGER()
  • __HAL_ETH_EXTI_SET_FALLINGRISING_TRIGGER()

• Update macro parameters to use underscore: __XXX__
• Use of CMSIS constants instead of magic values
• Use MODIFY_REG macro in HAL_WWDG_Init()
• Add IS_WWDG_ALL_INSTANCE in HAL_WWDG_Init() and HAL_WWDG_DeInit()

• Use WRITE_REG instead of SET_BIT for all IWDG macros
• __HAL_IWDG_CLEAR_FLAG removed: no IWDG flag cleared by access to SR register
• Use MODIFY_REG macro in HAL_IWDG_Init()
• Add IS_IWDG_ALL_INSTANCE in HAL_IWDG_Init()Add the following macros used to Wake