lzbp li / mbed-stm32l0l1-src-1

SHIO

Fork of mbed-stm32l0/l1-src by lzbp li

targets/cmsis/TARGET_STM/TARGET_STM32L1/stm32l1xx_hal_nor.c@638:56887a2974b9, 2016-09-08 (annotated)

Committer:
lzbpli
Date:
Thu Sep 08 02:46:37 2016 +0000
Revision:
638:56887a2974b9
Parent:
394:83f921546702 
????

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****/