mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_nor.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
394:83f921546702 
Synchronized with git revision d5b4d2ab9c47edb4dc5776e7177b0c2263459081



Full URL: https://github.com/mbedmicro/mbed/commit/d5b4d2ab9c47edb4dc5776e7177b0c2263459081/



Initial version of drivers for SAMR21

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 354:e67efb2aab0e 1 /**
mbed_official 354:e67efb2aab0e 2 ******************************************************************************
mbed_official 354:e67efb2aab0e 3 * @file stm32l1xx_hal_nor.c
mbed_official 354:e67efb2aab0e 4 * @author MCD Application Team
mbed_official 354:e67efb2aab0e 5 * @version V1.0.0
mbed_official 354:e67efb2aab0e 6 * @date 5-September-2014
mbed_official 354:e67efb2aab0e 7 * @brief NOR HAL module driver.
mbed_official 354:e67efb2aab0e 8 * This file provides a generic firmware to drive NOR memories mounted
mbed_official 354:e67efb2aab0e 9 * as external device.
mbed_official 354:e67efb2aab0e 10 *
mbed_official 354:e67efb2aab0e 11 @verbatim
mbed_official 354:e67efb2aab0e 12 ==============================================================================
mbed_official 354:e67efb2aab0e 13 ##### How to use this driver #####
mbed_official 354:e67efb2aab0e 14 ==============================================================================
mbed_official 354:e67efb2aab0e 15 [..]
mbed_official 354:e67efb2aab0e 16 This driver is a generic layered driver which contains a set of APIs used to
mbed_official 354:e67efb2aab0e 17 control NOR flash memories. It uses the FSMC layer functions to interface
mbed_official 354:e67efb2aab0e 18 with NOR devices. This driver is used as follows:
mbed_official 354:e67efb2aab0e 19
mbed_official 354:e67efb2aab0e 20 (+) NOR flash memory configuration sequence using the function HAL_NOR_Init()
mbed_official 354:e67efb2aab0e 21 with control and timing parameters for both normal and extended mode.
mbed_official 354:e67efb2aab0e 22
mbed_official 354:e67efb2aab0e 23 (+) Read NOR flash memory manufacturer code and device IDs using the function
mbed_official 354:e67efb2aab0e 24 HAL_NOR_Read_ID(). The read information is stored in the NOR_ID_TypeDef
mbed_official 354:e67efb2aab0e 25 structure declared by the function caller.
mbed_official 354:e67efb2aab0e 26
mbed_official 354:e67efb2aab0e 27 (+) Access NOR flash memory by read/write data unit operations using the functions
mbed_official 354:e67efb2aab0e 28 HAL_NOR_Read(), HAL_NOR_Program().
mbed_official 354:e67efb2aab0e 29
mbed_official 354:e67efb2aab0e 30 (+) Perform NOR flash erase block/chip operations using the functions
mbed_official 354:e67efb2aab0e 31 HAL_NOR_Erase_Block() and HAL_NOR_Erase_Chip().
mbed_official 354:e67efb2aab0e 32
mbed_official 354:e67efb2aab0e 33 (+) Read the NOR flash CFI (common flash interface) IDs using the function
mbed_official 354:e67efb2aab0e 34 HAL_NOR_Read_CFI(). The read information is stored in the NOR_CFI_TypeDef
mbed_official 354:e67efb2aab0e 35 structure declared by the function caller.
mbed_official 354:e67efb2aab0e 36
mbed_official 354:e67efb2aab0e 37 (+) You can also control the NOR device by calling the control APIs HAL_NOR_WriteOperation_Enable()/
mbed_official 354:e67efb2aab0e 38 HAL_NOR_WriteOperation_Disable() to respectively enable/disable the NOR write operation
mbed_official 354:e67efb2aab0e 39
mbed_official 354:e67efb2aab0e 40 (+) You can monitor the NOR device HAL state by calling the function
mbed_official 354:e67efb2aab0e 41 HAL_NOR_GetState()
mbed_official 354:e67efb2aab0e 42 [..]
mbed_official 354:e67efb2aab0e 43 (@) This driver is a set of generic APIs which handle standard NOR flash operations.
mbed_official 354:e67efb2aab0e 44 If a NOR flash device contains different operations and/or implementations,
mbed_official 354:e67efb2aab0e 45 it should be implemented separately.
mbed_official 354:e67efb2aab0e 46
mbed_official 354:e67efb2aab0e 47 *** NOR HAL driver macros list ***
mbed_official 354:e67efb2aab0e 48 =============================================
mbed_official 354:e67efb2aab0e 49 [..]
mbed_official 354:e67efb2aab0e 50 Below the list of most used macros in NOR HAL driver.
mbed_official 354:e67efb2aab0e 51
mbed_official 354:e67efb2aab0e 52 (+) __NOR_WRITE : NOR memory write data to specified address
mbed_official 354:e67efb2aab0e 53
mbed_official 354:e67efb2aab0e 54 @endverbatim
mbed_official 354:e67efb2aab0e 55 ******************************************************************************
mbed_official 354:e67efb2aab0e 56 * @attention
mbed_official 354:e67efb2aab0e 57 *
mbed_official 354:e67efb2aab0e 58 * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
mbed_official 354:e67efb2aab0e 59 *
mbed_official 354:e67efb2aab0e 60 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 354:e67efb2aab0e 61 * are permitted provided that the following conditions are met:
mbed_official 354:e67efb2aab0e 62 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 354:e67efb2aab0e 63 * this list of conditions and the following disclaimer.
mbed_official 354:e67efb2aab0e 64 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 354:e67efb2aab0e 65 * this list of conditions and the following disclaimer in the documentation
mbed_official 354:e67efb2aab0e 66 * and/or other materials provided with the distribution.
mbed_official 354:e67efb2aab0e 67 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 354:e67efb2aab0e 68 * may be used to endorse or promote products derived from this software
mbed_official 354:e67efb2aab0e 69 * without specific prior written permission.
mbed_official 354:e67efb2aab0e 70 *
mbed_official 354:e67efb2aab0e 71 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 354:e67efb2aab0e 72 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 354:e67efb2aab0e 73 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 354:e67efb2aab0e 74 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 354:e67efb2aab0e 75 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 354:e67efb2aab0e 76 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 354:e67efb2aab0e 77 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 354:e67efb2aab0e 78 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 354:e67efb2aab0e 79 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 354:e67efb2aab0e 80 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 354:e67efb2aab0e 81 *
mbed_official 354:e67efb2aab0e 82 ******************************************************************************
mbed_official 354:e67efb2aab0e 83 */
mbed_official 354:e67efb2aab0e 84
mbed_official 354:e67efb2aab0e 85 /* Includes ------------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 86 #include "stm32l1xx_hal.h"
mbed_official 354:e67efb2aab0e 87
mbed_official 354:e67efb2aab0e 88 /** @addtogroup STM32L1xx_HAL_Driver
mbed_official 354:e67efb2aab0e 89 * @{
mbed_official 354:e67efb2aab0e 90 */
mbed_official 354:e67efb2aab0e 91
mbed_official 354:e67efb2aab0e 92 /** @defgroup NOR NOR
mbed_official 354:e67efb2aab0e 93 * @brief NOR driver modules
mbed_official 354:e67efb2aab0e 94 * @{
mbed_official 354:e67efb2aab0e 95 */
mbed_official 354:e67efb2aab0e 96 #ifdef HAL_NOR_MODULE_ENABLED
mbed_official 354:e67efb2aab0e 97 #if defined (STM32L151xD) || defined (STM32L152xD) || defined (STM32L162xD)
mbed_official 354:e67efb2aab0e 98
mbed_official 354:e67efb2aab0e 99 /* Private typedef -----------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 100 /* Private define ------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 101 /* Private macro -------------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 102 /* Private variables ---------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 103
mbed_official 354:e67efb2aab0e 104 /** @defgroup NOR_Private_Variables NOR Private Variables
mbed_official 354:e67efb2aab0e 105 * @{
mbed_official 354:e67efb2aab0e 106 */
mbed_official 354:e67efb2aab0e 107
mbed_official 354:e67efb2aab0e 108 static uint32_t uwNORAddress = NOR_MEMORY_ADRESS1;
mbed_official 354:e67efb2aab0e 109 static uint32_t uwNORMememoryDataWidth = NOR_MEMORY_8B;
mbed_official 354:e67efb2aab0e 110
mbed_official 354:e67efb2aab0e 111 /**
mbed_official 354:e67efb2aab0e 112 * @}
mbed_official 354:e67efb2aab0e 113 */
mbed_official 354:e67efb2aab0e 114
mbed_official 354:e67efb2aab0e 115 /* Private function prototypes -----------------------------------------------*/
mbed_official 354:e67efb2aab0e 116 /* Private functions ---------------------------------------------------------*/
mbed_official 354:e67efb2aab0e 117
mbed_official 354:e67efb2aab0e 118 /** @defgroup NOR_Exported_Functions NOR Exported Functions
mbed_official 354:e67efb2aab0e 119 * @{
mbed_official 354:e67efb2aab0e 120 */
mbed_official 354:e67efb2aab0e 121
mbed_official 354:e67efb2aab0e 122 /** @defgroup NOR_Exported_Functions_Group1 Initialization and de-initialization functions
mbed_official 354:e67efb2aab0e 123 * @brief Initialization and Configuration functions
mbed_official 354:e67efb2aab0e 124 *
mbed_official 354:e67efb2aab0e 125 @verbatim
mbed_official 354:e67efb2aab0e 126 ==============================================================================
mbed_official 354:e67efb2aab0e 127 ##### NOR Initialization and de_initialization functions #####
mbed_official 354:e67efb2aab0e 128 ==============================================================================
mbed_official 354:e67efb2aab0e 129 [..]
mbed_official 354:e67efb2aab0e 130 This section provides functions allowing to initialize/de-initialize
mbed_official 354:e67efb2aab0e 131 the NOR memory
mbed_official 354:e67efb2aab0e 132
mbed_official 354:e67efb2aab0e 133 @endverbatim
mbed_official 354:e67efb2aab0e 134 * @{
mbed_official 354:e67efb2aab0e 135 */
mbed_official 354:e67efb2aab0e 136
mbed_official 354:e67efb2aab0e 137 /**
mbed_official 354:e67efb2aab0e 138 * @brief Perform the NOR memory Initialization sequence
mbed_official 354:e67efb2aab0e 139 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 140 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 141 * @param Timing: pointer to NOR control timing structure
mbed_official 354:e67efb2aab0e 142 * @param ExtTiming: pointer to NOR extended mode timing structure
mbed_official 354:e67efb2aab0e 143 * @retval HAL status
mbed_official 354:e67efb2aab0e 144 */
mbed_official 354:e67efb2aab0e 145 HAL_StatusTypeDef HAL_NOR_Init(NOR_HandleTypeDef *hnor, FSMC_NORSRAM_TimingTypeDef *Timing, FSMC_NORSRAM_TimingTypeDef *ExtTiming)
mbed_official 354:e67efb2aab0e 146 {
mbed_official 354:e67efb2aab0e 147 /* Check the NOR handle parameter */
mbed_official 354:e67efb2aab0e 148 if(hnor == HAL_NULL)
mbed_official 354:e67efb2aab0e 149 {
mbed_official 354:e67efb2aab0e 150 return HAL_ERROR;
mbed_official 354:e67efb2aab0e 151 }
mbed_official 354:e67efb2aab0e 152
mbed_official 354:e67efb2aab0e 153 if(hnor->State == HAL_NOR_STATE_RESET)
mbed_official 354:e67efb2aab0e 154 {
mbed_official 354:e67efb2aab0e 155 /* Initialize the low level hardware (MSP) */
mbed_official 354:e67efb2aab0e 156 HAL_NOR_MspInit(hnor);
mbed_official 354:e67efb2aab0e 157 }
mbed_official 354:e67efb2aab0e 158
mbed_official 354:e67efb2aab0e 159 /* Initialize NOR control Interface */
mbed_official 354:e67efb2aab0e 160 FSMC_NORSRAM_Init(hnor->Instance, &(hnor->Init));
mbed_official 354:e67efb2aab0e 161
mbed_official 354:e67efb2aab0e 162 /* Initialize NOR timing Interface */
mbed_official 354:e67efb2aab0e 163 FSMC_NORSRAM_Timing_Init(hnor->Instance, Timing, hnor->Init.NSBank);
mbed_official 354:e67efb2aab0e 164
mbed_official 354:e67efb2aab0e 165 /* Initialize NOR extended mode timing Interface */
mbed_official 354:e67efb2aab0e 166 FSMC_NORSRAM_Extended_Timing_Init(hnor->Extended, ExtTiming, hnor->Init.NSBank, hnor->Init.ExtendedMode);
mbed_official 354:e67efb2aab0e 167
mbed_official 354:e67efb2aab0e 168 /* Enable the NORSRAM device */
mbed_official 354:e67efb2aab0e 169 __FSMC_NORSRAM_ENABLE(hnor->Instance, hnor->Init.NSBank);
mbed_official 354:e67efb2aab0e 170
mbed_official 354:e67efb2aab0e 171 /* Initialize NOR address mapped by FSMC */
mbed_official 354:e67efb2aab0e 172 if (hnor->Init.NSBank == FSMC_BANK1_NORSRAM1)
mbed_official 354:e67efb2aab0e 173 {
mbed_official 354:e67efb2aab0e 174 uwNORAddress = NOR_MEMORY_ADRESS1;
mbed_official 354:e67efb2aab0e 175 }
mbed_official 354:e67efb2aab0e 176 else if (hnor->Init.NSBank == FSMC_BANK1_NORSRAM2)
mbed_official 354:e67efb2aab0e 177 {
mbed_official 354:e67efb2aab0e 178 uwNORAddress = NOR_MEMORY_ADRESS2;
mbed_official 354:e67efb2aab0e 179 }
mbed_official 354:e67efb2aab0e 180 else if (hnor->Init.NSBank == FSMC_BANK1_NORSRAM3)
mbed_official 354:e67efb2aab0e 181 {
mbed_official 354:e67efb2aab0e 182 uwNORAddress = NOR_MEMORY_ADRESS3;
mbed_official 354:e67efb2aab0e 183 }
mbed_official 354:e67efb2aab0e 184 else
mbed_official 354:e67efb2aab0e 185 {
mbed_official 354:e67efb2aab0e 186 uwNORAddress = NOR_MEMORY_ADRESS4;
mbed_official 354:e67efb2aab0e 187 }
mbed_official 354:e67efb2aab0e 188
mbed_official 354:e67efb2aab0e 189 /* Initialize NOR Memory Data Width*/
mbed_official 354:e67efb2aab0e 190 if (hnor->Init.MemoryDataWidth == FSMC_NORSRAM_MEM_BUS_WIDTH_8)
mbed_official 354:e67efb2aab0e 191 {
mbed_official 354:e67efb2aab0e 192 uwNORMememoryDataWidth = NOR_MEMORY_8B;
mbed_official 354:e67efb2aab0e 193 }
mbed_official 354:e67efb2aab0e 194 else
mbed_official 354:e67efb2aab0e 195 {
mbed_official 354:e67efb2aab0e 196 uwNORMememoryDataWidth = NOR_MEMORY_16B;
mbed_official 354:e67efb2aab0e 197 }
mbed_official 354:e67efb2aab0e 198
mbed_official 354:e67efb2aab0e 199 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 200 hnor->State = HAL_NOR_STATE_READY;
mbed_official 354:e67efb2aab0e 201
mbed_official 354:e67efb2aab0e 202 return HAL_OK;
mbed_official 354:e67efb2aab0e 203 }
mbed_official 354:e67efb2aab0e 204
mbed_official 354:e67efb2aab0e 205 /**
mbed_official 354:e67efb2aab0e 206 * @brief Perform NOR memory De-Initialization sequence
mbed_official 354:e67efb2aab0e 207 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 208 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 209 * @retval HAL status
mbed_official 354:e67efb2aab0e 210 */
mbed_official 354:e67efb2aab0e 211 HAL_StatusTypeDef HAL_NOR_DeInit(NOR_HandleTypeDef *hnor)
mbed_official 354:e67efb2aab0e 212 {
mbed_official 354:e67efb2aab0e 213 /* De-Initialize the low level hardware (MSP) */
mbed_official 354:e67efb2aab0e 214 HAL_NOR_MspDeInit(hnor);
mbed_official 354:e67efb2aab0e 215
mbed_official 354:e67efb2aab0e 216 /* Configure the NOR registers with their reset values */
mbed_official 354:e67efb2aab0e 217 FSMC_NORSRAM_DeInit(hnor->Instance, hnor->Extended, hnor->Init.NSBank);
mbed_official 354:e67efb2aab0e 218
mbed_official 354:e67efb2aab0e 219 /* Update the NOR controller state */
mbed_official 354:e67efb2aab0e 220 hnor->State = HAL_NOR_STATE_RESET;
mbed_official 354:e67efb2aab0e 221
mbed_official 354:e67efb2aab0e 222 /* Release Lock */
mbed_official 354:e67efb2aab0e 223 __HAL_UNLOCK(hnor);
mbed_official 354:e67efb2aab0e 224
mbed_official 354:e67efb2aab0e 225 return HAL_OK;
mbed_official 354:e67efb2aab0e 226 }
mbed_official 354:e67efb2aab0e 227
mbed_official 354:e67efb2aab0e 228 /**
mbed_official 354:e67efb2aab0e 229 * @brief NOR MSP Init
mbed_official 354:e67efb2aab0e 230 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 231 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 232 * @retval None
mbed_official 354:e67efb2aab0e 233 */
mbed_official 354:e67efb2aab0e 234 __weak void HAL_NOR_MspInit(NOR_HandleTypeDef *hnor)
mbed_official 354:e67efb2aab0e 235 {
mbed_official 354:e67efb2aab0e 236 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 354:e67efb2aab0e 237 the HAL_NOR_MspInit could be implemented in the user file
mbed_official 354:e67efb2aab0e 238 */
mbed_official 354:e67efb2aab0e 239 }
mbed_official 354:e67efb2aab0e 240
mbed_official 354:e67efb2aab0e 241 /**
mbed_official 354:e67efb2aab0e 242 * @brief NOR MSP DeInit
mbed_official 354:e67efb2aab0e 243 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 244 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 245 * @retval None
mbed_official 354:e67efb2aab0e 246 */
mbed_official 354:e67efb2aab0e 247 __weak void HAL_NOR_MspDeInit(NOR_HandleTypeDef *hnor)
mbed_official 354:e67efb2aab0e 248 {
mbed_official 354:e67efb2aab0e 249 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 354:e67efb2aab0e 250 the HAL_NOR_MspDeInit could be implemented in the user file
mbed_official 354:e67efb2aab0e 251 */
mbed_official 354:e67efb2aab0e 252 }
mbed_official 354:e67efb2aab0e 253
mbed_official 354:e67efb2aab0e 254 /**
mbed_official 354:e67efb2aab0e 255 * @brief NOR BSP Wait fro Ready/Busy signal
mbed_official 354:e67efb2aab0e 256 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 257 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 258 * @param Timeout: Maximum timeout value
mbed_official 354:e67efb2aab0e 259 * @retval None
mbed_official 354:e67efb2aab0e 260 */
mbed_official 354:e67efb2aab0e 261 __weak void HAL_NOR_MspWait(NOR_HandleTypeDef *hnor, uint32_t Timeout)
mbed_official 354:e67efb2aab0e 262 {
mbed_official 354:e67efb2aab0e 263 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 354:e67efb2aab0e 264 the HAL_NOR_BspWait could be implemented in the user file
mbed_official 354:e67efb2aab0e 265 */
mbed_official 354:e67efb2aab0e 266 }
mbed_official 354:e67efb2aab0e 267
mbed_official 354:e67efb2aab0e 268 /**
mbed_official 354:e67efb2aab0e 269 * @}
mbed_official 354:e67efb2aab0e 270 */
mbed_official 354:e67efb2aab0e 271
mbed_official 354:e67efb2aab0e 272 /** @defgroup NOR_Exported_Functions_Group2 Input and Output functions
mbed_official 354:e67efb2aab0e 273 * @brief Input Output and memory control functions
mbed_official 354:e67efb2aab0e 274 *
mbed_official 354:e67efb2aab0e 275 @verbatim
mbed_official 354:e67efb2aab0e 276 ==============================================================================
mbed_official 354:e67efb2aab0e 277 ##### NOR Input and Output functions #####
mbed_official 354:e67efb2aab0e 278 ==============================================================================
mbed_official 354:e67efb2aab0e 279 [..]
mbed_official 354:e67efb2aab0e 280 This section provides functions allowing to use and control the NOR memory
mbed_official 354:e67efb2aab0e 281
mbed_official 354:e67efb2aab0e 282 @endverbatim
mbed_official 354:e67efb2aab0e 283 * @{
mbed_official 354:e67efb2aab0e 284 */
mbed_official 354:e67efb2aab0e 285
mbed_official 354:e67efb2aab0e 286 /**
mbed_official 354:e67efb2aab0e 287 * @brief Read NOR flash IDs
mbed_official 354:e67efb2aab0e 288 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 289 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 290 * @param pNOR_ID : pointer to NOR ID structure
mbed_official 354:e67efb2aab0e 291 * @retval HAL status
mbed_official 354:e67efb2aab0e 292 */
mbed_official 354:e67efb2aab0e 293 HAL_StatusTypeDef HAL_NOR_Read_ID(NOR_HandleTypeDef *hnor, NOR_IDTypeDef *pNOR_ID)
mbed_official 354:e67efb2aab0e 294 {
mbed_official 354:e67efb2aab0e 295 /* Process Locked */
mbed_official 354:e67efb2aab0e 296 __HAL_LOCK(hnor);
mbed_official 354:e67efb2aab0e 297
mbed_official 354:e67efb2aab0e 298 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 299 if(hnor->State == HAL_NOR_STATE_BUSY)
mbed_official 354:e67efb2aab0e 300 {
mbed_official 354:e67efb2aab0e 301 return HAL_BUSY;
mbed_official 354:e67efb2aab0e 302 }
mbed_official 354:e67efb2aab0e 303
mbed_official 354:e67efb2aab0e 304 /* Update the NOR controller state */
mbed_official 354:e67efb2aab0e 305 hnor->State = HAL_NOR_STATE_BUSY;
mbed_official 354:e67efb2aab0e 306
mbed_official 354:e67efb2aab0e 307 /* Send read ID command */
mbed_official 354:e67efb2aab0e 308 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0555), 0x00AA);
mbed_official 354:e67efb2aab0e 309 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x02AA), 0x0055);
mbed_official 354:e67efb2aab0e 310 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0555), 0x0090);
mbed_official 354:e67efb2aab0e 311
mbed_official 354:e67efb2aab0e 312 /* Read the NOR IDs */
mbed_official 354:e67efb2aab0e 313 pNOR_ID->ManufacturerCode = *(__IO uint16_t *) __NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, MC_ADDRESS);
mbed_official 354:e67efb2aab0e 314 pNOR_ID->DeviceCode1 = *(__IO uint16_t *) __NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, DEVICE_CODE1_ADDR);
mbed_official 354:e67efb2aab0e 315 pNOR_ID->DeviceCode2 = *(__IO uint16_t *) __NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, DEVICE_CODE2_ADDR);
mbed_official 354:e67efb2aab0e 316 pNOR_ID->DeviceCode3 = *(__IO uint16_t *) __NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, DEVICE_CODE3_ADDR);
mbed_official 354:e67efb2aab0e 317
mbed_official 354:e67efb2aab0e 318 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 319 hnor->State = HAL_NOR_STATE_READY;
mbed_official 354:e67efb2aab0e 320
mbed_official 354:e67efb2aab0e 321 /* Process unlocked */
mbed_official 354:e67efb2aab0e 322 __HAL_UNLOCK(hnor);
mbed_official 354:e67efb2aab0e 323
mbed_official 354:e67efb2aab0e 324 return HAL_OK;
mbed_official 354:e67efb2aab0e 325 }
mbed_official 354:e67efb2aab0e 326
mbed_official 354:e67efb2aab0e 327 /**
mbed_official 354:e67efb2aab0e 328 * @brief Returns the NOR memory to Read mode.
mbed_official 354:e67efb2aab0e 329 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 330 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 331 * @retval HAL status
mbed_official 354:e67efb2aab0e 332 */
mbed_official 354:e67efb2aab0e 333 HAL_StatusTypeDef HAL_NOR_ReturnToReadMode(NOR_HandleTypeDef *hnor)
mbed_official 354:e67efb2aab0e 334 {
mbed_official 354:e67efb2aab0e 335 /* Process Locked */
mbed_official 354:e67efb2aab0e 336 __HAL_LOCK(hnor);
mbed_official 354:e67efb2aab0e 337
mbed_official 354:e67efb2aab0e 338 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 339 if(hnor->State == HAL_NOR_STATE_BUSY)
mbed_official 354:e67efb2aab0e 340 {
mbed_official 354:e67efb2aab0e 341 return HAL_BUSY;
mbed_official 354:e67efb2aab0e 342 }
mbed_official 354:e67efb2aab0e 343
mbed_official 354:e67efb2aab0e 344 __NOR_WRITE(uwNORAddress, 0x00F0);
mbed_official 354:e67efb2aab0e 345
mbed_official 354:e67efb2aab0e 346 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 347 hnor->State = HAL_NOR_STATE_READY;
mbed_official 354:e67efb2aab0e 348
mbed_official 354:e67efb2aab0e 349 /* Process unlocked */
mbed_official 354:e67efb2aab0e 350 __HAL_UNLOCK(hnor);
mbed_official 354:e67efb2aab0e 351
mbed_official 354:e67efb2aab0e 352 return HAL_OK;
mbed_official 354:e67efb2aab0e 353 }
mbed_official 354:e67efb2aab0e 354
mbed_official 354:e67efb2aab0e 355 /**
mbed_official 354:e67efb2aab0e 356 * @brief Read data from NOR memory
mbed_official 354:e67efb2aab0e 357 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 358 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 359 * @param pAddress: pointer to Device address
mbed_official 354:e67efb2aab0e 360 * @param pData : pointer to read data
mbed_official 354:e67efb2aab0e 361 * @retval HAL status
mbed_official 354:e67efb2aab0e 362 */
mbed_official 354:e67efb2aab0e 363 HAL_StatusTypeDef HAL_NOR_Read(NOR_HandleTypeDef *hnor, uint32_t *pAddress, uint16_t *pData)
mbed_official 354:e67efb2aab0e 364 {
mbed_official 354:e67efb2aab0e 365 /* Process Locked */
mbed_official 354:e67efb2aab0e 366 __HAL_LOCK(hnor);
mbed_official 354:e67efb2aab0e 367
mbed_official 354:e67efb2aab0e 368 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 369 if(hnor->State == HAL_NOR_STATE_BUSY)
mbed_official 354:e67efb2aab0e 370 {
mbed_official 354:e67efb2aab0e 371 return HAL_BUSY;
mbed_official 354:e67efb2aab0e 372 }
mbed_official 354:e67efb2aab0e 373
mbed_official 354:e67efb2aab0e 374 /* Update the NOR controller state */
mbed_official 354:e67efb2aab0e 375 hnor->State = HAL_NOR_STATE_BUSY;
mbed_official 354:e67efb2aab0e 376
mbed_official 354:e67efb2aab0e 377 /* Send read data command */
mbed_official 354:e67efb2aab0e 378 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x00555), 0x00AA);
mbed_official 354:e67efb2aab0e 379 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x002AA), 0x0055);
mbed_official 354:e67efb2aab0e 380 __NOR_WRITE(*pAddress, 0x00F0);
mbed_official 354:e67efb2aab0e 381
mbed_official 354:e67efb2aab0e 382 /* Read the data */
mbed_official 354:e67efb2aab0e 383 *pData = *(__IO uint32_t *)pAddress;
mbed_official 354:e67efb2aab0e 384
mbed_official 354:e67efb2aab0e 385 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 386 hnor->State = HAL_NOR_STATE_READY;
mbed_official 354:e67efb2aab0e 387
mbed_official 354:e67efb2aab0e 388 /* Process unlocked */
mbed_official 354:e67efb2aab0e 389 __HAL_UNLOCK(hnor);
mbed_official 354:e67efb2aab0e 390
mbed_official 354:e67efb2aab0e 391 return HAL_OK;
mbed_official 354:e67efb2aab0e 392 }
mbed_official 354:e67efb2aab0e 393
mbed_official 354:e67efb2aab0e 394 /**
mbed_official 354:e67efb2aab0e 395 * @brief Program data to NOR memory
mbed_official 354:e67efb2aab0e 396 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 397 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 398 * @param pAddress: Device address
mbed_official 354:e67efb2aab0e 399 * @param pData : pointer to the data to write
mbed_official 354:e67efb2aab0e 400 * @retval HAL status
mbed_official 354:e67efb2aab0e 401 */
mbed_official 354:e67efb2aab0e 402 HAL_StatusTypeDef HAL_NOR_Program(NOR_HandleTypeDef *hnor, uint32_t *pAddress, uint16_t *pData)
mbed_official 354:e67efb2aab0e 403 {
mbed_official 354:e67efb2aab0e 404 /* Process Locked */
mbed_official 354:e67efb2aab0e 405 __HAL_LOCK(hnor);
mbed_official 354:e67efb2aab0e 406
mbed_official 354:e67efb2aab0e 407 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 408 if(hnor->State == HAL_NOR_STATE_BUSY)
mbed_official 354:e67efb2aab0e 409 {
mbed_official 354:e67efb2aab0e 410 return HAL_BUSY;
mbed_official 354:e67efb2aab0e 411 }
mbed_official 354:e67efb2aab0e 412
mbed_official 354:e67efb2aab0e 413 /* Update the NOR controller state */
mbed_official 354:e67efb2aab0e 414 hnor->State = HAL_NOR_STATE_BUSY;
mbed_official 354:e67efb2aab0e 415
mbed_official 354:e67efb2aab0e 416 /* Send program data command */
mbed_official 354:e67efb2aab0e 417 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0555), 0x00AA);
mbed_official 354:e67efb2aab0e 418 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x02AA), 0x0055);
mbed_official 354:e67efb2aab0e 419 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0555), 0x00A0);
mbed_official 354:e67efb2aab0e 420
mbed_official 354:e67efb2aab0e 421 /* Write the data */
mbed_official 354:e67efb2aab0e 422 __NOR_WRITE(pAddress, *pData);
mbed_official 354:e67efb2aab0e 423
mbed_official 354:e67efb2aab0e 424 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 425 hnor->State = HAL_NOR_STATE_READY;
mbed_official 354:e67efb2aab0e 426
mbed_official 354:e67efb2aab0e 427 /* Process unlocked */
mbed_official 354:e67efb2aab0e 428 __HAL_UNLOCK(hnor);
mbed_official 354:e67efb2aab0e 429
mbed_official 354:e67efb2aab0e 430 return HAL_OK;
mbed_official 354:e67efb2aab0e 431 }
mbed_official 354:e67efb2aab0e 432
mbed_official 354:e67efb2aab0e 433 /**
mbed_official 354:e67efb2aab0e 434 * @brief Reads a block of data from the FSMC NOR memory.
mbed_official 354:e67efb2aab0e 435 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 436 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 437 * @param uwAddress: NOR memory internal address to read from.
mbed_official 354:e67efb2aab0e 438 * @param pData: pointer to the buffer that receives the data read from the
mbed_official 354:e67efb2aab0e 439 * NOR memory.
mbed_official 354:e67efb2aab0e 440 * @param uwBufferSize : number of Half word to read.
mbed_official 354:e67efb2aab0e 441 * @retval HAL status
mbed_official 354:e67efb2aab0e 442 */
mbed_official 354:e67efb2aab0e 443 HAL_StatusTypeDef HAL_NOR_ReadBuffer(NOR_HandleTypeDef *hnor, uint32_t uwAddress, uint16_t *pData, uint32_t uwBufferSize)
mbed_official 354:e67efb2aab0e 444 {
mbed_official 354:e67efb2aab0e 445 /* Process Locked */
mbed_official 354:e67efb2aab0e 446 __HAL_LOCK(hnor);
mbed_official 354:e67efb2aab0e 447
mbed_official 354:e67efb2aab0e 448 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 449 if(hnor->State == HAL_NOR_STATE_BUSY)
mbed_official 354:e67efb2aab0e 450 {
mbed_official 354:e67efb2aab0e 451 return HAL_BUSY;
mbed_official 354:e67efb2aab0e 452 }
mbed_official 354:e67efb2aab0e 453
mbed_official 354:e67efb2aab0e 454 /* Update the NOR controller state */
mbed_official 354:e67efb2aab0e 455 hnor->State = HAL_NOR_STATE_BUSY;
mbed_official 354:e67efb2aab0e 456
mbed_official 354:e67efb2aab0e 457 /* Send read data command */
mbed_official 354:e67efb2aab0e 458 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x00555), 0x00AA);
mbed_official 354:e67efb2aab0e 459 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x002AA), 0x0055);
mbed_official 354:e67efb2aab0e 460 __NOR_WRITE(uwAddress, 0x00F0);
mbed_official 354:e67efb2aab0e 461
mbed_official 354:e67efb2aab0e 462 /* Read buffer */
mbed_official 354:e67efb2aab0e 463 while( uwBufferSize > 0)
mbed_official 354:e67efb2aab0e 464 {
mbed_official 354:e67efb2aab0e 465 *pData++ = *(__IO uint16_t *)uwAddress;
mbed_official 354:e67efb2aab0e 466 uwAddress += 2;
mbed_official 354:e67efb2aab0e 467 uwBufferSize--;
mbed_official 354:e67efb2aab0e 468 }
mbed_official 354:e67efb2aab0e 469
mbed_official 354:e67efb2aab0e 470 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 471 hnor->State = HAL_NOR_STATE_READY;
mbed_official 354:e67efb2aab0e 472
mbed_official 354:e67efb2aab0e 473 /* Process unlocked */
mbed_official 354:e67efb2aab0e 474 __HAL_UNLOCK(hnor);
mbed_official 354:e67efb2aab0e 475
mbed_official 354:e67efb2aab0e 476 return HAL_OK;
mbed_official 354:e67efb2aab0e 477 }
mbed_official 354:e67efb2aab0e 478
mbed_official 354:e67efb2aab0e 479 /**
mbed_official 354:e67efb2aab0e 480 * @brief Writes a half-word buffer to the FSMC NOR memory. This function
mbed_official 354:e67efb2aab0e 481 * must be used only with S29GL128P NOR memory.
mbed_official 354:e67efb2aab0e 482 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 483 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 484 * @param uwAddress: NOR memory internal address from which the data
mbed_official 354:e67efb2aab0e 485 * @param pData: pointer to source data buffer.
mbed_official 354:e67efb2aab0e 486 * @param uwBufferSize: number of Half words to write. The maximum allowed
mbed_official 354:e67efb2aab0e 487 * @retval HAL status
mbed_official 354:e67efb2aab0e 488 */
mbed_official 354:e67efb2aab0e 489 HAL_StatusTypeDef HAL_NOR_ProgramBuffer(NOR_HandleTypeDef *hnor, uint32_t uwAddress, uint16_t *pData, uint32_t uwBufferSize)
mbed_official 354:e67efb2aab0e 490 {
mbed_official 354:e67efb2aab0e 491 uint32_t lastloadedaddress = 0;
mbed_official 354:e67efb2aab0e 492 uint32_t currentaddress = 0;
mbed_official 354:e67efb2aab0e 493 uint32_t endaddress = 0;
mbed_official 354:e67efb2aab0e 494
mbed_official 354:e67efb2aab0e 495 /* Process Locked */
mbed_official 354:e67efb2aab0e 496 __HAL_LOCK(hnor);
mbed_official 354:e67efb2aab0e 497
mbed_official 354:e67efb2aab0e 498 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 499 if(hnor->State == HAL_NOR_STATE_BUSY)
mbed_official 354:e67efb2aab0e 500 {
mbed_official 354:e67efb2aab0e 501 return HAL_BUSY;
mbed_official 354:e67efb2aab0e 502 }
mbed_official 354:e67efb2aab0e 503
mbed_official 354:e67efb2aab0e 504 /* Update the NOR controller state */
mbed_official 354:e67efb2aab0e 505 hnor->State = HAL_NOR_STATE_BUSY;
mbed_official 354:e67efb2aab0e 506
mbed_official 354:e67efb2aab0e 507 /* Initialize variables */
mbed_official 354:e67efb2aab0e 508 currentaddress = uwAddress;
mbed_official 354:e67efb2aab0e 509 endaddress = uwAddress + uwBufferSize - 1;
mbed_official 354:e67efb2aab0e 510 lastloadedaddress = uwAddress;
mbed_official 354:e67efb2aab0e 511
mbed_official 354:e67efb2aab0e 512 /* Issue unlock command sequence */
mbed_official 354:e67efb2aab0e 513 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0555), 0x00AA);
mbed_official 354:e67efb2aab0e 514 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x02AA), 0x0055);
mbed_official 354:e67efb2aab0e 515
mbed_official 354:e67efb2aab0e 516 /* Write Buffer Load Command */
mbed_official 354:e67efb2aab0e 517 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, uwAddress), 0x25);
mbed_official 354:e67efb2aab0e 518 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, uwAddress), (uwBufferSize - 1));
mbed_official 354:e67efb2aab0e 519
mbed_official 354:e67efb2aab0e 520 /* Load Data into NOR Buffer */
mbed_official 354:e67efb2aab0e 521 while(currentaddress <= endaddress)
mbed_official 354:e67efb2aab0e 522 {
mbed_official 354:e67efb2aab0e 523 /* Store last loaded address & data value (for polling) */
mbed_official 354:e67efb2aab0e 524 lastloadedaddress = currentaddress;
mbed_official 354:e67efb2aab0e 525
mbed_official 354:e67efb2aab0e 526 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, currentaddress), *pData++);
mbed_official 354:e67efb2aab0e 527
mbed_official 354:e67efb2aab0e 528 currentaddress += 1;
mbed_official 354:e67efb2aab0e 529 }
mbed_official 354:e67efb2aab0e 530
mbed_official 354:e67efb2aab0e 531 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, lastloadedaddress), 0x29);
mbed_official 354:e67efb2aab0e 532
mbed_official 354:e67efb2aab0e 533 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 534 hnor->State = HAL_NOR_STATE_READY;
mbed_official 354:e67efb2aab0e 535
mbed_official 354:e67efb2aab0e 536 /* Process unlocked */
mbed_official 354:e67efb2aab0e 537 __HAL_UNLOCK(hnor);
mbed_official 354:e67efb2aab0e 538
mbed_official 354:e67efb2aab0e 539 return HAL_OK;
mbed_official 354:e67efb2aab0e 540
mbed_official 354:e67efb2aab0e 541 }
mbed_official 354:e67efb2aab0e 542
mbed_official 354:e67efb2aab0e 543 /**
mbed_official 354:e67efb2aab0e 544 * @brief Erase the specified block of the NOR memory
mbed_official 354:e67efb2aab0e 545 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 546 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 547 * @param BlockAddress : Block to erase address
mbed_official 354:e67efb2aab0e 548 * @param Address: Device address
mbed_official 354:e67efb2aab0e 549 * @retval HAL status
mbed_official 354:e67efb2aab0e 550 */
mbed_official 354:e67efb2aab0e 551 HAL_StatusTypeDef HAL_NOR_Erase_Block(NOR_HandleTypeDef *hnor, uint32_t BlockAddress, uint32_t Address)
mbed_official 354:e67efb2aab0e 552 {
mbed_official 354:e67efb2aab0e 553 /* Process Locked */
mbed_official 354:e67efb2aab0e 554 __HAL_LOCK(hnor);
mbed_official 354:e67efb2aab0e 555
mbed_official 354:e67efb2aab0e 556 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 557 if(hnor->State == HAL_NOR_STATE_BUSY)
mbed_official 354:e67efb2aab0e 558 {
mbed_official 354:e67efb2aab0e 559 return HAL_BUSY;
mbed_official 354:e67efb2aab0e 560 }
mbed_official 354:e67efb2aab0e 561
mbed_official 354:e67efb2aab0e 562 /* Update the NOR controller state */
mbed_official 354:e67efb2aab0e 563 hnor->State = HAL_NOR_STATE_BUSY;
mbed_official 354:e67efb2aab0e 564
mbed_official 354:e67efb2aab0e 565 /* Send block erase command sequence */
mbed_official 354:e67efb2aab0e 566 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0555), 0x00AA);
mbed_official 354:e67efb2aab0e 567 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x02AA), 0x0055);
mbed_official 354:e67efb2aab0e 568 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0555), 0x0080);
mbed_official 354:e67efb2aab0e 569 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0555), 0x00AA);
mbed_official 354:e67efb2aab0e 570 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x02AA), 0x0055);
mbed_official 354:e67efb2aab0e 571 __NOR_WRITE((uint32_t)(BlockAddress + Address), 0x30);
mbed_official 354:e67efb2aab0e 572
mbed_official 354:e67efb2aab0e 573 /* Check the NOR memory status and update the controller state */
mbed_official 354:e67efb2aab0e 574 hnor->State = HAL_NOR_STATE_READY;
mbed_official 354:e67efb2aab0e 575
mbed_official 354:e67efb2aab0e 576 /* Process unlocked */
mbed_official 354:e67efb2aab0e 577 __HAL_UNLOCK(hnor);
mbed_official 354:e67efb2aab0e 578
mbed_official 354:e67efb2aab0e 579 return HAL_OK;
mbed_official 354:e67efb2aab0e 580
mbed_official 354:e67efb2aab0e 581 }
mbed_official 354:e67efb2aab0e 582
mbed_official 354:e67efb2aab0e 583 /**
mbed_official 354:e67efb2aab0e 584 * @brief Erase the entire NOR chip.
mbed_official 354:e67efb2aab0e 585 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 586 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 587 * @param Address : Device address
mbed_official 354:e67efb2aab0e 588 * @retval HAL status
mbed_official 354:e67efb2aab0e 589 */
mbed_official 354:e67efb2aab0e 590 HAL_StatusTypeDef HAL_NOR_Erase_Chip(NOR_HandleTypeDef *hnor, uint32_t Address)
mbed_official 354:e67efb2aab0e 591 {
mbed_official 354:e67efb2aab0e 592 /* Process Locked */
mbed_official 354:e67efb2aab0e 593 __HAL_LOCK(hnor);
mbed_official 354:e67efb2aab0e 594
mbed_official 354:e67efb2aab0e 595 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 596 if(hnor->State == HAL_NOR_STATE_BUSY)
mbed_official 354:e67efb2aab0e 597 {
mbed_official 354:e67efb2aab0e 598 return HAL_BUSY;
mbed_official 354:e67efb2aab0e 599 }
mbed_official 354:e67efb2aab0e 600
mbed_official 354:e67efb2aab0e 601 /* Update the NOR controller state */
mbed_official 354:e67efb2aab0e 602 hnor->State = HAL_NOR_STATE_BUSY;
mbed_official 354:e67efb2aab0e 603
mbed_official 354:e67efb2aab0e 604 /* Send NOR chip erase command sequence */
mbed_official 354:e67efb2aab0e 605 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0555), 0x00AA);
mbed_official 354:e67efb2aab0e 606 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x02AA), 0x0055);
mbed_official 354:e67efb2aab0e 607 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0555), 0x0080);
mbed_official 354:e67efb2aab0e 608 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0555), 0x00AA);
mbed_official 354:e67efb2aab0e 609 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x02AA), 0x0055);
mbed_official 354:e67efb2aab0e 610 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0555), 0x0010);
mbed_official 354:e67efb2aab0e 611
mbed_official 354:e67efb2aab0e 612 /* Check the NOR memory status and update the controller state */
mbed_official 354:e67efb2aab0e 613 hnor->State = HAL_NOR_STATE_READY;
mbed_official 354:e67efb2aab0e 614
mbed_official 354:e67efb2aab0e 615 /* Process unlocked */
mbed_official 354:e67efb2aab0e 616 __HAL_UNLOCK(hnor);
mbed_official 354:e67efb2aab0e 617
mbed_official 354:e67efb2aab0e 618 return HAL_OK;
mbed_official 354:e67efb2aab0e 619 }
mbed_official 354:e67efb2aab0e 620
mbed_official 354:e67efb2aab0e 621 /**
mbed_official 354:e67efb2aab0e 622 * @brief Read NOR flash CFI IDs
mbed_official 354:e67efb2aab0e 623 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 624 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 625 * @param pNOR_CFI : pointer to NOR CFI IDs structure
mbed_official 354:e67efb2aab0e 626 * @retval HAL status
mbed_official 354:e67efb2aab0e 627 */
mbed_official 354:e67efb2aab0e 628 HAL_StatusTypeDef HAL_NOR_Read_CFI(NOR_HandleTypeDef *hnor, NOR_CFITypeDef *pNOR_CFI)
mbed_official 354:e67efb2aab0e 629 {
mbed_official 354:e67efb2aab0e 630 /* Process Locked */
mbed_official 354:e67efb2aab0e 631 __HAL_LOCK(hnor);
mbed_official 354:e67efb2aab0e 632
mbed_official 354:e67efb2aab0e 633 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 634 if(hnor->State == HAL_NOR_STATE_BUSY)
mbed_official 354:e67efb2aab0e 635 {
mbed_official 354:e67efb2aab0e 636 return HAL_BUSY;
mbed_official 354:e67efb2aab0e 637 }
mbed_official 354:e67efb2aab0e 638
mbed_official 354:e67efb2aab0e 639 /* Update the NOR controller state */
mbed_official 354:e67efb2aab0e 640 hnor->State = HAL_NOR_STATE_BUSY;
mbed_official 354:e67efb2aab0e 641
mbed_official 354:e67efb2aab0e 642 /* Send read CFI query command */
mbed_official 354:e67efb2aab0e 643 __NOR_WRITE(__NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, 0x0055), 0x0098);
mbed_official 354:e67efb2aab0e 644
mbed_official 354:e67efb2aab0e 645 /* read the NOR CFI information */
mbed_official 354:e67efb2aab0e 646 pNOR_CFI->CFI1 = *(__IO uint16_t *) __NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, CFI1_ADDRESS);
mbed_official 354:e67efb2aab0e 647 pNOR_CFI->CFI2 = *(__IO uint16_t *) __NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, CFI2_ADDRESS);
mbed_official 354:e67efb2aab0e 648 pNOR_CFI->CFI3 = *(__IO uint16_t *) __NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, CFI3_ADDRESS);
mbed_official 354:e67efb2aab0e 649 pNOR_CFI->CFI4 = *(__IO uint16_t *) __NOR_ADDR_SHIFT(uwNORAddress, uwNORMememoryDataWidth, CFI4_ADDRESS);
mbed_official 354:e67efb2aab0e 650
mbed_official 354:e67efb2aab0e 651 /* Check the NOR controller state */
mbed_official 354:e67efb2aab0e 652 hnor->State = HAL_NOR_STATE_READY;
mbed_official 354:e67efb2aab0e 653
mbed_official 354:e67efb2aab0e 654 /* Process unlocked */
mbed_official 354:e67efb2aab0e 655 __HAL_UNLOCK(hnor);
mbed_official 354:e67efb2aab0e 656
mbed_official 354:e67efb2aab0e 657 return HAL_OK;
mbed_official 354:e67efb2aab0e 658 }
mbed_official 354:e67efb2aab0e 659
mbed_official 354:e67efb2aab0e 660 /**
mbed_official 354:e67efb2aab0e 661 * @}
mbed_official 354:e67efb2aab0e 662 */
mbed_official 354:e67efb2aab0e 663
mbed_official 354:e67efb2aab0e 664 /** @defgroup NOR_Exported_Functions_Group3 Control functions
mbed_official 354:e67efb2aab0e 665 * @brief management functions
mbed_official 354:e67efb2aab0e 666 *
mbed_official 354:e67efb2aab0e 667 @verbatim
mbed_official 354:e67efb2aab0e 668 ==============================================================================
mbed_official 354:e67efb2aab0e 669 ##### NOR Control functions #####
mbed_official 354:e67efb2aab0e 670 ==============================================================================
mbed_official 354:e67efb2aab0e 671 [..]
mbed_official 354:e67efb2aab0e 672 This subsection provides a set of functions allowing to control dynamically
mbed_official 354:e67efb2aab0e 673 the NOR interface.
mbed_official 354:e67efb2aab0e 674
mbed_official 354:e67efb2aab0e 675 @endverbatim
mbed_official 354:e67efb2aab0e 676 * @{
mbed_official 354:e67efb2aab0e 677 */
mbed_official 354:e67efb2aab0e 678
mbed_official 354:e67efb2aab0e 679 /**
mbed_official 354:e67efb2aab0e 680 * @brief Enables dynamically NOR write operation.
mbed_official 354:e67efb2aab0e 681 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 682 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 683 * @retval HAL status
mbed_official 354:e67efb2aab0e 684 */
mbed_official 354:e67efb2aab0e 685 HAL_StatusTypeDef HAL_NOR_WriteOperation_Enable(NOR_HandleTypeDef *hnor)
mbed_official 354:e67efb2aab0e 686 {
mbed_official 354:e67efb2aab0e 687 /* Process Locked */
mbed_official 354:e67efb2aab0e 688 __HAL_LOCK(hnor);
mbed_official 354:e67efb2aab0e 689
mbed_official 354:e67efb2aab0e 690 /* Enable write operation */
mbed_official 354:e67efb2aab0e 691 FSMC_NORSRAM_WriteOperation_Enable(hnor->Instance, hnor->Init.NSBank);
mbed_official 354:e67efb2aab0e 692
mbed_official 354:e67efb2aab0e 693 /* Update the NOR controller state */
mbed_official 354:e67efb2aab0e 694 hnor->State = HAL_NOR_STATE_READY;
mbed_official 354:e67efb2aab0e 695
mbed_official 354:e67efb2aab0e 696 /* Process unlocked */
mbed_official 354:e67efb2aab0e 697 __HAL_UNLOCK(hnor);
mbed_official 354:e67efb2aab0e 698
mbed_official 354:e67efb2aab0e 699 return HAL_OK;
mbed_official 354:e67efb2aab0e 700 }
mbed_official 354:e67efb2aab0e 701
mbed_official 354:e67efb2aab0e 702 /**
mbed_official 354:e67efb2aab0e 703 * @brief Disables dynamically NOR write operation.
mbed_official 354:e67efb2aab0e 704 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 705 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 706 * @retval HAL status
mbed_official 354:e67efb2aab0e 707 */
mbed_official 354:e67efb2aab0e 708 HAL_StatusTypeDef HAL_NOR_WriteOperation_Disable(NOR_HandleTypeDef *hnor)
mbed_official 354:e67efb2aab0e 709 {
mbed_official 354:e67efb2aab0e 710 /* Process Locked */
mbed_official 354:e67efb2aab0e 711 __HAL_LOCK(hnor);
mbed_official 354:e67efb2aab0e 712
mbed_official 354:e67efb2aab0e 713 /* Update the SRAM controller state */
mbed_official 354:e67efb2aab0e 714 hnor->State = HAL_NOR_STATE_BUSY;
mbed_official 354:e67efb2aab0e 715
mbed_official 354:e67efb2aab0e 716 /* Disable write operation */
mbed_official 354:e67efb2aab0e 717 FSMC_NORSRAM_WriteOperation_Disable(hnor->Instance, hnor->Init.NSBank);
mbed_official 354:e67efb2aab0e 718
mbed_official 354:e67efb2aab0e 719 /* Update the NOR controller state */
mbed_official 354:e67efb2aab0e 720 hnor->State = HAL_NOR_STATE_PROTECTED;
mbed_official 354:e67efb2aab0e 721
mbed_official 354:e67efb2aab0e 722 /* Process unlocked */
mbed_official 354:e67efb2aab0e 723 __HAL_UNLOCK(hnor);
mbed_official 354:e67efb2aab0e 724
mbed_official 354:e67efb2aab0e 725 return HAL_OK;
mbed_official 354:e67efb2aab0e 726 }
mbed_official 354:e67efb2aab0e 727
mbed_official 354:e67efb2aab0e 728 /**
mbed_official 354:e67efb2aab0e 729 * @}
mbed_official 354:e67efb2aab0e 730 */
mbed_official 354:e67efb2aab0e 731
mbed_official 354:e67efb2aab0e 732 /** @defgroup NOR_Exported_Functions_Group4 State functions
mbed_official 354:e67efb2aab0e 733 * @brief Peripheral State functions
mbed_official 354:e67efb2aab0e 734 *
mbed_official 354:e67efb2aab0e 735 @verbatim
mbed_official 354:e67efb2aab0e 736 ==============================================================================
mbed_official 354:e67efb2aab0e 737 ##### NOR State functions #####
mbed_official 354:e67efb2aab0e 738 ==============================================================================
mbed_official 354:e67efb2aab0e 739 [..]
mbed_official 354:e67efb2aab0e 740 This subsection permits to get in run-time the status of the NOR controller
mbed_official 354:e67efb2aab0e 741 and the data flow.
mbed_official 354:e67efb2aab0e 742
mbed_official 354:e67efb2aab0e 743 @endverbatim
mbed_official 354:e67efb2aab0e 744 * @{
mbed_official 354:e67efb2aab0e 745 */
mbed_official 354:e67efb2aab0e 746
mbed_official 354:e67efb2aab0e 747 /**
mbed_official 354:e67efb2aab0e 748 * @brief return the NOR controller state
mbed_official 354:e67efb2aab0e 749 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 750 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 751 * @retval NOR controller state
mbed_official 354:e67efb2aab0e 752 */
mbed_official 354:e67efb2aab0e 753 HAL_NOR_StateTypeDef HAL_NOR_GetState(NOR_HandleTypeDef *hnor)
mbed_official 354:e67efb2aab0e 754 {
mbed_official 354:e67efb2aab0e 755 return hnor->State;
mbed_official 354:e67efb2aab0e 756 }
mbed_official 354:e67efb2aab0e 757
mbed_official 354:e67efb2aab0e 758 /**
mbed_official 354:e67efb2aab0e 759 * @brief Returns the NOR operation status.
mbed_official 354:e67efb2aab0e 760 * @param hnor: pointer to a NOR_HandleTypeDef structure that contains
mbed_official 354:e67efb2aab0e 761 * the configuration information for NOR module.
mbed_official 354:e67efb2aab0e 762 * @param Address: Device address
mbed_official 354:e67efb2aab0e 763 * @param Timeout: NOR progamming Timeout
mbed_official 354:e67efb2aab0e 764 * @retval NOR_Status: The returned value can be: NOR_SUCCESS, NOR_ERROR
mbed_official 354:e67efb2aab0e 765 * or NOR_TIMEOUT
mbed_official 354:e67efb2aab0e 766 */
mbed_official 354:e67efb2aab0e 767 NOR_StatusTypedef HAL_NOR_GetStatus(NOR_HandleTypeDef *hnor, uint32_t Address, uint32_t Timeout)
mbed_official 354:e67efb2aab0e 768 {
mbed_official 354:e67efb2aab0e 769 NOR_StatusTypedef status = NOR_ONGOING;
mbed_official 354:e67efb2aab0e 770 uint16_t tmpSR1 = 0, tmpSR2 = 0;
mbed_official 354:e67efb2aab0e 771 uint32_t tickstart = 0;
mbed_official 354:e67efb2aab0e 772
mbed_official 354:e67efb2aab0e 773 /* Poll on NOR memory Ready/Busy signal ------------------------------------*/
mbed_official 354:e67efb2aab0e 774 HAL_NOR_MspWait(hnor, Timeout);
mbed_official 354:e67efb2aab0e 775
mbed_official 354:e67efb2aab0e 776 /* Get the NOR memory operation status -------------------------------------*/
mbed_official 354:e67efb2aab0e 777 while(status != NOR_TIMEOUT)
mbed_official 354:e67efb2aab0e 778 {
mbed_official 354:e67efb2aab0e 779 /* Get tick */
mbed_official 354:e67efb2aab0e 780 tickstart = HAL_GetTick();
mbed_official 354:e67efb2aab0e 781
mbed_official 354:e67efb2aab0e 782 if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))
mbed_official 354:e67efb2aab0e 783 {
mbed_official 354:e67efb2aab0e 784 status = NOR_TIMEOUT;
mbed_official 354:e67efb2aab0e 785 }
mbed_official 354:e67efb2aab0e 786
mbed_official 354:e67efb2aab0e 787 /* Read NOR status register (DQ6 and DQ5) */
mbed_official 354:e67efb2aab0e 788 tmpSR1 = *(__IO uint16_t *)Address;
mbed_official 354:e67efb2aab0e 789 tmpSR2 = *(__IO uint16_t *)Address;
mbed_official 354:e67efb2aab0e 790
mbed_official 354:e67efb2aab0e 791 /* If DQ6 did not toggle between the two reads then return NOR_Success */
mbed_official 354:e67efb2aab0e 792 if((tmpSR1 & 0x0040) == (tmpSR2 & 0x0040))
mbed_official 354:e67efb2aab0e 793 {
mbed_official 354:e67efb2aab0e 794 return NOR_SUCCESS;
mbed_official 354:e67efb2aab0e 795 }
mbed_official 354:e67efb2aab0e 796
mbed_official 354:e67efb2aab0e 797 if((tmpSR1 & 0x0020) == 0x0020)
mbed_official 354:e67efb2aab0e 798 {
mbed_official 354:e67efb2aab0e 799 return NOR_ONGOING;
mbed_official 354:e67efb2aab0e 800 }
mbed_official 354:e67efb2aab0e 801
mbed_official 354:e67efb2aab0e 802 tmpSR1 = *(__IO uint16_t *)Address;
mbed_official 354:e67efb2aab0e 803 tmpSR2 = *(__IO uint16_t *)Address;
mbed_official 354:e67efb2aab0e 804
mbed_official 354:e67efb2aab0e 805 /* If DQ6 did not toggle between the two reads then return NOR_Success */
mbed_official 354:e67efb2aab0e 806 if((tmpSR1 & 0x0040) == (tmpSR2 & 0x0040))
mbed_official 354:e67efb2aab0e 807 {
mbed_official 354:e67efb2aab0e 808 return NOR_SUCCESS;
mbed_official 354:e67efb2aab0e 809 }
mbed_official 354:e67efb2aab0e 810
mbed_official 354:e67efb2aab0e 811 if((tmpSR1 & 0x0020) == 0x0020)
mbed_official 354:e67efb2aab0e 812 {
mbed_official 354:e67efb2aab0e 813 return NOR_ERROR;
mbed_official 354:e67efb2aab0e 814 }
mbed_official 354:e67efb2aab0e 815 }
mbed_official 354:e67efb2aab0e 816
mbed_official 354:e67efb2aab0e 817 /* Return the operation status */
mbed_official 354:e67efb2aab0e 818 return status;
mbed_official 354:e67efb2aab0e 819 }
mbed_official 354:e67efb2aab0e 820
mbed_official 354:e67efb2aab0e 821 /**
mbed_official 354:e67efb2aab0e 822 * @}
mbed_official 354:e67efb2aab0e 823 */
mbed_official 354:e67efb2aab0e 824
mbed_official 354:e67efb2aab0e 825 /**
mbed_official 354:e67efb2aab0e 826 * @}
mbed_official 354:e67efb2aab0e 827 */
mbed_official 354:e67efb2aab0e 828 #endif /* STM32L151xD || STM32L152xD || STM32L162xD */
mbed_official 354:e67efb2aab0e 829 #endif /* HAL_NOR_MODULE_ENABLED */
mbed_official 354:e67efb2aab0e 830 /**
mbed_official 354:e67efb2aab0e 831 * @}
mbed_official 354:e67efb2aab0e 832 */
mbed_official 354:e67efb2aab0e 833
mbed_official 354:e67efb2aab0e 834 /**
mbed_official 354:e67efb2aab0e 835 * @}
mbed_official 354:e67efb2aab0e 836 */
mbed_official 354:e67efb2aab0e 837
mbed_official 354:e67efb2aab0e 838 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/