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_STM32F7/stm32f7xx_hal_nand.c@579:53297373a894, 2015-07-01 (annotated)

Committer:
mbed_official
Date:
Wed Jul 01 09:45:11 2015 +0100
Revision:
579:53297373a894
Parent:
573:ad23fe03a082
Child:
610:813dcc80987e
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 573:ad23fe03a082 1 /**
mbed_official 573:ad23fe03a082 2 ******************************************************************************
mbed_official 573:ad23fe03a082 3 * @file stm32f7xx_hal_nand.c
mbed_official 573:ad23fe03a082 4 * @author MCD Application Team
mbed_official 573:ad23fe03a082 5 * @version V1.0.0
mbed_official 573:ad23fe03a082 6 * @date 12-May-2015
mbed_official 573:ad23fe03a082 7 * @brief NAND HAL module driver.
mbed_official 573:ad23fe03a082 8 * This file provides a generic firmware to drive NAND memories mounted
mbed_official 573:ad23fe03a082 9 * as external device.
mbed_official 573:ad23fe03a082 10 *
mbed_official 573:ad23fe03a082 11 @verbatim
mbed_official 573:ad23fe03a082 12 ==============================================================================
mbed_official 573:ad23fe03a082 13 ##### How to use this driver #####
mbed_official 573:ad23fe03a082 14 ==============================================================================
mbed_official 573:ad23fe03a082 15 [..]
mbed_official 573:ad23fe03a082 16 This driver is a generic layered driver which contains a set of APIs used to
mbed_official 573:ad23fe03a082 17 control NAND flash memories. It uses the FMC/FSMC layer functions to interface
mbed_official 573:ad23fe03a082 18 with NAND devices. This driver is used as follows:
mbed_official 573:ad23fe03a082 19
mbed_official 573:ad23fe03a082 20 (+) NAND flash memory configuration sequence using the function HAL_NAND_Init()
mbed_official 573:ad23fe03a082 21 with control and timing parameters for both common and attribute spaces.
mbed_official 573:ad23fe03a082 22
mbed_official 573:ad23fe03a082 23 (+) Read NAND flash memory maker and device IDs using the function
mbed_official 573:ad23fe03a082 24 HAL_NAND_Read_ID(). The read information is stored in the NAND_ID_TypeDef
mbed_official 573:ad23fe03a082 25 structure declared by the function caller.
mbed_official 573:ad23fe03a082 26
mbed_official 573:ad23fe03a082 27 (+) Access NAND flash memory by read/write operations using the functions
mbed_official 573:ad23fe03a082 28 HAL_NAND_Read_Page()/HAL_NAND_Read_SpareArea(), HAL_NAND_Write_Page()/HAL_NAND_Write_SpareArea()
mbed_official 573:ad23fe03a082 29 to read/write page(s)/spare area(s). These functions use specific device
mbed_official 573:ad23fe03a082 30 information (Block, page size..) predefined by the user in the HAL_NAND_Info_TypeDef
mbed_official 573:ad23fe03a082 31 structure. The read/write address information is contained by the Nand_Address_Typedef
mbed_official 573:ad23fe03a082 32 structure passed as parameter.
mbed_official 573:ad23fe03a082 33
mbed_official 573:ad23fe03a082 34 (+) Perform NAND flash Reset chip operation using the function HAL_NAND_Reset().
mbed_official 573:ad23fe03a082 35
mbed_official 573:ad23fe03a082 36 (+) Perform NAND flash erase block operation using the function HAL_NAND_Erase_Block().
mbed_official 573:ad23fe03a082 37 The erase block address information is contained in the Nand_Address_Typedef
mbed_official 573:ad23fe03a082 38 structure passed as parameter.
mbed_official 573:ad23fe03a082 39
mbed_official 573:ad23fe03a082 40 (+) Read the NAND flash status operation using the function HAL_NAND_Read_Status().
mbed_official 573:ad23fe03a082 41
mbed_official 573:ad23fe03a082 42 (+) You can also control the NAND device by calling the control APIs HAL_NAND_ECC_Enable()/
mbed_official 573:ad23fe03a082 43 HAL_NAND_ECC_Disable() to respectively enable/disable the ECC code correction
mbed_official 573:ad23fe03a082 44 feature or the function HAL_NAND_GetECC() to get the ECC correction code.
mbed_official 573:ad23fe03a082 45
mbed_official 573:ad23fe03a082 46 (+) You can monitor the NAND device HAL state by calling the function
mbed_official 573:ad23fe03a082 47 HAL_NAND_GetState()
mbed_official 573:ad23fe03a082 48
mbed_official 573:ad23fe03a082 49 [..]
mbed_official 573:ad23fe03a082 50 (@) This driver is a set of generic APIs which handle standard NAND flash operations.
mbed_official 573:ad23fe03a082 51 If a NAND flash device contains different operations and/or implementations,
mbed_official 573:ad23fe03a082 52 it should be implemented separately.
mbed_official 573:ad23fe03a082 53
mbed_official 573:ad23fe03a082 54 @endverbatim
mbed_official 573:ad23fe03a082 55 ******************************************************************************
mbed_official 573:ad23fe03a082 56 * @attention
mbed_official 573:ad23fe03a082 57 *
mbed_official 573:ad23fe03a082 58 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
mbed_official 573:ad23fe03a082 59 *
mbed_official 573:ad23fe03a082 60 * Redistribution and use in source and binary forms, with or without modification,
mbed_official 573:ad23fe03a082 61 * are permitted provided that the following conditions are met:
mbed_official 573:ad23fe03a082 62 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 573:ad23fe03a082 63 * this list of conditions and the following disclaimer.
mbed_official 573:ad23fe03a082 64 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 573:ad23fe03a082 65 * this list of conditions and the following disclaimer in the documentation
mbed_official 573:ad23fe03a082 66 * and/or other materials provided with the distribution.
mbed_official 573:ad23fe03a082 67 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 573:ad23fe03a082 68 * may be used to endorse or promote products derived from this software
mbed_official 573:ad23fe03a082 69 * without specific prior written permission.
mbed_official 573:ad23fe03a082 70 *
mbed_official 573:ad23fe03a082 71 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 573:ad23fe03a082 72 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 573:ad23fe03a082 73 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 573:ad23fe03a082 74 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 573:ad23fe03a082 75 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 573:ad23fe03a082 76 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 573:ad23fe03a082 77 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 573:ad23fe03a082 78 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 573:ad23fe03a082 79 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 573:ad23fe03a082 80 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 573:ad23fe03a082 81 *
mbed_official 573:ad23fe03a082 82 ******************************************************************************
mbed_official 573:ad23fe03a082 83 */
mbed_official 573:ad23fe03a082 84
mbed_official 573:ad23fe03a082 85 /* Includes ------------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 86 #include "stm32f7xx_hal.h"
mbed_official 573:ad23fe03a082 87
mbed_official 573:ad23fe03a082 88 /** @addtogroup STM32F7xx_HAL_Driver
mbed_official 573:ad23fe03a082 89 * @{
mbed_official 573:ad23fe03a082 90 */
mbed_official 573:ad23fe03a082 91
mbed_official 573:ad23fe03a082 92
mbed_official 573:ad23fe03a082 93 #ifdef HAL_NAND_MODULE_ENABLED
mbed_official 573:ad23fe03a082 94
mbed_official 573:ad23fe03a082 95 /** @defgroup NAND NAND
mbed_official 573:ad23fe03a082 96 * @brief NAND HAL module driver
mbed_official 573:ad23fe03a082 97 * @{
mbed_official 573:ad23fe03a082 98 */
mbed_official 573:ad23fe03a082 99
mbed_official 573:ad23fe03a082 100 /* Private typedef -----------------------------------------------------------*/
mbed_official 573:ad23fe03a082 101 /* Private Constants ------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 102 /* Private macro -------------------------------------------------------------*/
mbed_official 573:ad23fe03a082 103 /* Private variables ---------------------------------------------------------*/
mbed_official 573:ad23fe03a082 104 /* Private function prototypes -----------------------------------------------*/
mbed_official 573:ad23fe03a082 105 /* Exported functions ---------------------------------------------------------*/
mbed_official 573:ad23fe03a082 106
mbed_official 573:ad23fe03a082 107 /** @defgroup NAND_Exported_Functions NAND Exported Functions
mbed_official 573:ad23fe03a082 108 * @{
mbed_official 573:ad23fe03a082 109 */
mbed_official 573:ad23fe03a082 110
mbed_official 573:ad23fe03a082 111 /** @defgroup NAND_Exported_Functions_Group1 Initialization and de-initialization functions
mbed_official 573:ad23fe03a082 112 * @brief Initialization and Configuration functions
mbed_official 573:ad23fe03a082 113 *
mbed_official 573:ad23fe03a082 114 @verbatim
mbed_official 573:ad23fe03a082 115 ==============================================================================
mbed_official 573:ad23fe03a082 116 ##### NAND Initialization and de-initialization functions #####
mbed_official 573:ad23fe03a082 117 ==============================================================================
mbed_official 573:ad23fe03a082 118 [..]
mbed_official 573:ad23fe03a082 119 This section provides functions allowing to initialize/de-initialize
mbed_official 573:ad23fe03a082 120 the NAND memory
mbed_official 573:ad23fe03a082 121
mbed_official 573:ad23fe03a082 122 @endverbatim
mbed_official 573:ad23fe03a082 123 * @{
mbed_official 573:ad23fe03a082 124 */
mbed_official 573:ad23fe03a082 125
mbed_official 573:ad23fe03a082 126 /**
mbed_official 573:ad23fe03a082 127 * @brief Perform NAND memory Initialization sequence
mbed_official 573:ad23fe03a082 128 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 129 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 130 * @param ComSpace_Timing: pointer to Common space timing structure
mbed_official 573:ad23fe03a082 131 * @param AttSpace_Timing: pointer to Attribute space timing structure
mbed_official 573:ad23fe03a082 132 * @retval HAL status
mbed_official 573:ad23fe03a082 133 */
mbed_official 573:ad23fe03a082 134 HAL_StatusTypeDef HAL_NAND_Init(NAND_HandleTypeDef *hnand, FMC_NAND_PCC_TimingTypeDef *ComSpace_Timing, FMC_NAND_PCC_TimingTypeDef *AttSpace_Timing)
mbed_official 573:ad23fe03a082 135 {
mbed_official 573:ad23fe03a082 136 /* Check the NAND handle state */
mbed_official 573:ad23fe03a082 137 if(hnand == NULL)
mbed_official 573:ad23fe03a082 138 {
mbed_official 573:ad23fe03a082 139 return HAL_ERROR;
mbed_official 573:ad23fe03a082 140 }
mbed_official 573:ad23fe03a082 141
mbed_official 573:ad23fe03a082 142 if(hnand->State == HAL_NAND_STATE_RESET)
mbed_official 573:ad23fe03a082 143 {
mbed_official 573:ad23fe03a082 144 /* Allocate lock resource and initialize it */
mbed_official 573:ad23fe03a082 145 hnand->Lock = HAL_UNLOCKED;
mbed_official 573:ad23fe03a082 146 /* Initialize the low level hardware (MSP) */
mbed_official 573:ad23fe03a082 147 HAL_NAND_MspInit(hnand);
mbed_official 573:ad23fe03a082 148 }
mbed_official 573:ad23fe03a082 149
mbed_official 573:ad23fe03a082 150 /* Initialize NAND control Interface */
mbed_official 573:ad23fe03a082 151 FMC_NAND_Init(hnand->Instance, &(hnand->Init));
mbed_official 573:ad23fe03a082 152
mbed_official 573:ad23fe03a082 153 /* Initialize NAND common space timing Interface */
mbed_official 573:ad23fe03a082 154 FMC_NAND_CommonSpace_Timing_Init(hnand->Instance, ComSpace_Timing, hnand->Init.NandBank);
mbed_official 573:ad23fe03a082 155
mbed_official 573:ad23fe03a082 156 /* Initialize NAND attribute space timing Interface */
mbed_official 573:ad23fe03a082 157 FMC_NAND_AttributeSpace_Timing_Init(hnand->Instance, AttSpace_Timing, hnand->Init.NandBank);
mbed_official 573:ad23fe03a082 158
mbed_official 573:ad23fe03a082 159 /* Enable the NAND device */
mbed_official 573:ad23fe03a082 160 __FMC_NAND_ENABLE(hnand->Instance);
mbed_official 573:ad23fe03a082 161
mbed_official 573:ad23fe03a082 162 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 163 hnand->State = HAL_NAND_STATE_READY;
mbed_official 573:ad23fe03a082 164
mbed_official 573:ad23fe03a082 165 return HAL_OK;
mbed_official 573:ad23fe03a082 166 }
mbed_official 573:ad23fe03a082 167
mbed_official 573:ad23fe03a082 168 /**
mbed_official 573:ad23fe03a082 169 * @brief Perform NAND memory De-Initialization sequence
mbed_official 573:ad23fe03a082 170 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 171 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 172 * @retval HAL status
mbed_official 573:ad23fe03a082 173 */
mbed_official 573:ad23fe03a082 174 HAL_StatusTypeDef HAL_NAND_DeInit(NAND_HandleTypeDef *hnand)
mbed_official 573:ad23fe03a082 175 {
mbed_official 573:ad23fe03a082 176 /* Initialize the low level hardware (MSP) */
mbed_official 573:ad23fe03a082 177 HAL_NAND_MspDeInit(hnand);
mbed_official 573:ad23fe03a082 178
mbed_official 573:ad23fe03a082 179 /* Configure the NAND registers with their reset values */
mbed_official 573:ad23fe03a082 180 FMC_NAND_DeInit(hnand->Instance, hnand->Init.NandBank);
mbed_official 573:ad23fe03a082 181
mbed_official 573:ad23fe03a082 182 /* Reset the NAND controller state */
mbed_official 573:ad23fe03a082 183 hnand->State = HAL_NAND_STATE_RESET;
mbed_official 573:ad23fe03a082 184
mbed_official 573:ad23fe03a082 185 /* Release Lock */
mbed_official 573:ad23fe03a082 186 __HAL_UNLOCK(hnand);
mbed_official 573:ad23fe03a082 187
mbed_official 573:ad23fe03a082 188 return HAL_OK;
mbed_official 573:ad23fe03a082 189 }
mbed_official 573:ad23fe03a082 190
mbed_official 573:ad23fe03a082 191 /**
mbed_official 573:ad23fe03a082 192 * @brief NAND MSP Init
mbed_official 573:ad23fe03a082 193 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 194 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 195 * @retval None
mbed_official 573:ad23fe03a082 196 */
mbed_official 573:ad23fe03a082 197 __weak void HAL_NAND_MspInit(NAND_HandleTypeDef *hnand)
mbed_official 573:ad23fe03a082 198 {
mbed_official 573:ad23fe03a082 199 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 200 the HAL_NAND_MspInit could be implemented in the user file
mbed_official 573:ad23fe03a082 201 */
mbed_official 573:ad23fe03a082 202 }
mbed_official 573:ad23fe03a082 203
mbed_official 573:ad23fe03a082 204 /**
mbed_official 573:ad23fe03a082 205 * @brief NAND MSP DeInit
mbed_official 573:ad23fe03a082 206 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 207 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 208 * @retval None
mbed_official 573:ad23fe03a082 209 */
mbed_official 573:ad23fe03a082 210 __weak void HAL_NAND_MspDeInit(NAND_HandleTypeDef *hnand)
mbed_official 573:ad23fe03a082 211 {
mbed_official 573:ad23fe03a082 212 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 213 the HAL_NAND_MspDeInit could be implemented in the user file
mbed_official 573:ad23fe03a082 214 */
mbed_official 573:ad23fe03a082 215 }
mbed_official 573:ad23fe03a082 216
mbed_official 573:ad23fe03a082 217
mbed_official 573:ad23fe03a082 218 /**
mbed_official 573:ad23fe03a082 219 * @brief This function handles NAND device interrupt request.
mbed_official 573:ad23fe03a082 220 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 221 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 222 * @retval HAL status
mbed_official 573:ad23fe03a082 223 */
mbed_official 573:ad23fe03a082 224 void HAL_NAND_IRQHandler(NAND_HandleTypeDef *hnand)
mbed_official 573:ad23fe03a082 225 {
mbed_official 573:ad23fe03a082 226 /* Check NAND interrupt Rising edge flag */
mbed_official 573:ad23fe03a082 227 if(__FMC_NAND_GET_FLAG(hnand->Instance, hnand->Init.NandBank, FMC_FLAG_RISING_EDGE))
mbed_official 573:ad23fe03a082 228 {
mbed_official 573:ad23fe03a082 229 /* NAND interrupt callback*/
mbed_official 573:ad23fe03a082 230 HAL_NAND_ITCallback(hnand);
mbed_official 573:ad23fe03a082 231
mbed_official 573:ad23fe03a082 232 /* Clear NAND interrupt Rising edge pending bit */
mbed_official 573:ad23fe03a082 233 __FMC_NAND_CLEAR_FLAG(hnand->Instance, FMC_FLAG_RISING_EDGE);
mbed_official 573:ad23fe03a082 234 }
mbed_official 573:ad23fe03a082 235
mbed_official 573:ad23fe03a082 236 /* Check NAND interrupt Level flag */
mbed_official 573:ad23fe03a082 237 if(__FMC_NAND_GET_FLAG(hnand->Instance, hnand->Init.NandBank, FMC_FLAG_LEVEL))
mbed_official 573:ad23fe03a082 238 {
mbed_official 573:ad23fe03a082 239 /* NAND interrupt callback*/
mbed_official 573:ad23fe03a082 240 HAL_NAND_ITCallback(hnand);
mbed_official 573:ad23fe03a082 241
mbed_official 573:ad23fe03a082 242 /* Clear NAND interrupt Level pending bit */
mbed_official 573:ad23fe03a082 243 __FMC_NAND_CLEAR_FLAG(hnand->Instance, FMC_FLAG_LEVEL);
mbed_official 573:ad23fe03a082 244 }
mbed_official 573:ad23fe03a082 245
mbed_official 573:ad23fe03a082 246 /* Check NAND interrupt Falling edge flag */
mbed_official 573:ad23fe03a082 247 if(__FMC_NAND_GET_FLAG(hnand->Instance, hnand->Init.NandBank, FMC_FLAG_FALLING_EDGE))
mbed_official 573:ad23fe03a082 248 {
mbed_official 573:ad23fe03a082 249 /* NAND interrupt callback*/
mbed_official 573:ad23fe03a082 250 HAL_NAND_ITCallback(hnand);
mbed_official 573:ad23fe03a082 251
mbed_official 573:ad23fe03a082 252 /* Clear NAND interrupt Falling edge pending bit */
mbed_official 573:ad23fe03a082 253 __FMC_NAND_CLEAR_FLAG(hnand->Instance, FMC_FLAG_FALLING_EDGE);
mbed_official 573:ad23fe03a082 254 }
mbed_official 573:ad23fe03a082 255
mbed_official 573:ad23fe03a082 256 /* Check NAND interrupt FIFO empty flag */
mbed_official 573:ad23fe03a082 257 if(__FMC_NAND_GET_FLAG(hnand->Instance, hnand->Init.NandBank, FMC_FLAG_FEMPT))
mbed_official 573:ad23fe03a082 258 {
mbed_official 573:ad23fe03a082 259 /* NAND interrupt callback*/
mbed_official 573:ad23fe03a082 260 HAL_NAND_ITCallback(hnand);
mbed_official 573:ad23fe03a082 261
mbed_official 573:ad23fe03a082 262 /* Clear NAND interrupt FIFO empty pending bit */
mbed_official 573:ad23fe03a082 263 __FMC_NAND_CLEAR_FLAG(hnand->Instance, FMC_FLAG_FEMPT);
mbed_official 573:ad23fe03a082 264 }
mbed_official 573:ad23fe03a082 265
mbed_official 573:ad23fe03a082 266 }
mbed_official 573:ad23fe03a082 267
mbed_official 573:ad23fe03a082 268 /**
mbed_official 573:ad23fe03a082 269 * @brief NAND interrupt feature callback
mbed_official 573:ad23fe03a082 270 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 271 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 272 * @retval None
mbed_official 573:ad23fe03a082 273 */
mbed_official 573:ad23fe03a082 274 __weak void HAL_NAND_ITCallback(NAND_HandleTypeDef *hnand)
mbed_official 573:ad23fe03a082 275 {
mbed_official 573:ad23fe03a082 276 /* NOTE : This function Should not be modified, when the callback is needed,
mbed_official 573:ad23fe03a082 277 the HAL_NAND_ITCallback could be implemented in the user file
mbed_official 573:ad23fe03a082 278 */
mbed_official 573:ad23fe03a082 279 }
mbed_official 573:ad23fe03a082 280
mbed_official 573:ad23fe03a082 281 /**
mbed_official 573:ad23fe03a082 282 * @}
mbed_official 573:ad23fe03a082 283 */
mbed_official 573:ad23fe03a082 284
mbed_official 573:ad23fe03a082 285 /** @defgroup NAND_Exported_Functions_Group2 Input and Output functions
mbed_official 573:ad23fe03a082 286 * @brief Input Output and memory control functions
mbed_official 573:ad23fe03a082 287 *
mbed_official 573:ad23fe03a082 288 @verbatim
mbed_official 573:ad23fe03a082 289 ==============================================================================
mbed_official 573:ad23fe03a082 290 ##### NAND Input and Output functions #####
mbed_official 573:ad23fe03a082 291 ==============================================================================
mbed_official 573:ad23fe03a082 292 [..]
mbed_official 573:ad23fe03a082 293 This section provides functions allowing to use and control the NAND
mbed_official 573:ad23fe03a082 294 memory
mbed_official 573:ad23fe03a082 295
mbed_official 573:ad23fe03a082 296 @endverbatim
mbed_official 573:ad23fe03a082 297 * @{
mbed_official 573:ad23fe03a082 298 */
mbed_official 573:ad23fe03a082 299
mbed_official 573:ad23fe03a082 300 /**
mbed_official 573:ad23fe03a082 301 * @brief Read the NAND memory electronic signature
mbed_official 573:ad23fe03a082 302 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 303 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 304 * @param pNAND_ID: NAND ID structure
mbed_official 573:ad23fe03a082 305 * @retval HAL status
mbed_official 573:ad23fe03a082 306 */
mbed_official 573:ad23fe03a082 307 HAL_StatusTypeDef HAL_NAND_Read_ID(NAND_HandleTypeDef *hnand, NAND_IDTypeDef *pNAND_ID)
mbed_official 573:ad23fe03a082 308 {
mbed_official 573:ad23fe03a082 309 __IO uint32_t data = 0;
mbed_official 573:ad23fe03a082 310 uint32_t deviceAddress = 0;
mbed_official 573:ad23fe03a082 311
mbed_official 573:ad23fe03a082 312 /* Process Locked */
mbed_official 573:ad23fe03a082 313 __HAL_LOCK(hnand);
mbed_official 573:ad23fe03a082 314
mbed_official 573:ad23fe03a082 315 /* Check the NAND controller state */
mbed_official 573:ad23fe03a082 316 if(hnand->State == HAL_NAND_STATE_BUSY)
mbed_official 573:ad23fe03a082 317 {
mbed_official 573:ad23fe03a082 318 return HAL_BUSY;
mbed_official 573:ad23fe03a082 319 }
mbed_official 573:ad23fe03a082 320
mbed_official 573:ad23fe03a082 321 /* Identify the device address */
mbed_official 573:ad23fe03a082 322 deviceAddress = NAND_DEVICE;
mbed_official 573:ad23fe03a082 323
mbed_official 573:ad23fe03a082 324 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 325 hnand->State = HAL_NAND_STATE_BUSY;
mbed_official 573:ad23fe03a082 326
mbed_official 573:ad23fe03a082 327 /* Send Read ID command sequence */
mbed_official 573:ad23fe03a082 328 *(__IO uint8_t *)((uint32_t)(deviceAddress | CMD_AREA)) = NAND_CMD_READID;
mbed_official 573:ad23fe03a082 329 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = 0x00;
mbed_official 573:ad23fe03a082 330
mbed_official 573:ad23fe03a082 331 /* Read the electronic signature from NAND flash */
mbed_official 573:ad23fe03a082 332 data = *(__IO uint32_t *)deviceAddress;
mbed_official 573:ad23fe03a082 333
mbed_official 573:ad23fe03a082 334 /* Return the data read */
mbed_official 573:ad23fe03a082 335 pNAND_ID->Maker_Id = ADDR_1ST_CYCLE(data);
mbed_official 573:ad23fe03a082 336 pNAND_ID->Device_Id = ADDR_2ND_CYCLE(data);
mbed_official 573:ad23fe03a082 337 pNAND_ID->Third_Id = ADDR_3RD_CYCLE(data);
mbed_official 573:ad23fe03a082 338 pNAND_ID->Fourth_Id = ADDR_4TH_CYCLE(data);
mbed_official 573:ad23fe03a082 339
mbed_official 573:ad23fe03a082 340 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 341 hnand->State = HAL_NAND_STATE_READY;
mbed_official 573:ad23fe03a082 342
mbed_official 573:ad23fe03a082 343 /* Process unlocked */
mbed_official 573:ad23fe03a082 344 __HAL_UNLOCK(hnand);
mbed_official 573:ad23fe03a082 345
mbed_official 573:ad23fe03a082 346 return HAL_OK;
mbed_official 573:ad23fe03a082 347 }
mbed_official 573:ad23fe03a082 348
mbed_official 573:ad23fe03a082 349 /**
mbed_official 573:ad23fe03a082 350 * @brief NAND memory reset
mbed_official 573:ad23fe03a082 351 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 352 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 353 * @retval HAL status
mbed_official 573:ad23fe03a082 354 */
mbed_official 573:ad23fe03a082 355 HAL_StatusTypeDef HAL_NAND_Reset(NAND_HandleTypeDef *hnand)
mbed_official 573:ad23fe03a082 356 {
mbed_official 573:ad23fe03a082 357 uint32_t deviceAddress = 0;
mbed_official 573:ad23fe03a082 358
mbed_official 573:ad23fe03a082 359 /* Process Locked */
mbed_official 573:ad23fe03a082 360 __HAL_LOCK(hnand);
mbed_official 573:ad23fe03a082 361
mbed_official 573:ad23fe03a082 362 /* Check the NAND controller state */
mbed_official 573:ad23fe03a082 363 if(hnand->State == HAL_NAND_STATE_BUSY)
mbed_official 573:ad23fe03a082 364 {
mbed_official 573:ad23fe03a082 365 return HAL_BUSY;
mbed_official 573:ad23fe03a082 366 }
mbed_official 573:ad23fe03a082 367
mbed_official 573:ad23fe03a082 368 /* Identify the device address */
mbed_official 573:ad23fe03a082 369 deviceAddress = NAND_DEVICE;
mbed_official 573:ad23fe03a082 370
mbed_official 573:ad23fe03a082 371 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 372 hnand->State = HAL_NAND_STATE_BUSY;
mbed_official 573:ad23fe03a082 373
mbed_official 573:ad23fe03a082 374 /* Send NAND reset command */
mbed_official 573:ad23fe03a082 375 *(__IO uint8_t *)((uint32_t)(deviceAddress | CMD_AREA)) = 0xFF;
mbed_official 573:ad23fe03a082 376
mbed_official 573:ad23fe03a082 377
mbed_official 573:ad23fe03a082 378 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 379 hnand->State = HAL_NAND_STATE_READY;
mbed_official 573:ad23fe03a082 380
mbed_official 573:ad23fe03a082 381 /* Process unlocked */
mbed_official 573:ad23fe03a082 382 __HAL_UNLOCK(hnand);
mbed_official 573:ad23fe03a082 383
mbed_official 573:ad23fe03a082 384 return HAL_OK;
mbed_official 573:ad23fe03a082 385
mbed_official 573:ad23fe03a082 386 }
mbed_official 573:ad23fe03a082 387
mbed_official 573:ad23fe03a082 388 /**
mbed_official 573:ad23fe03a082 389 * @brief Read Page(s) from NAND memory block
mbed_official 573:ad23fe03a082 390 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 391 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 392 * @param pAddress : pointer to NAND address structure
mbed_official 573:ad23fe03a082 393 * @param pBuffer : pointer to destination read buffer
mbed_official 573:ad23fe03a082 394 * @param NumPageToRead : number of pages to read from block
mbed_official 573:ad23fe03a082 395 * @retval HAL status
mbed_official 573:ad23fe03a082 396 */
mbed_official 573:ad23fe03a082 397 HAL_StatusTypeDef HAL_NAND_Read_Page(NAND_HandleTypeDef *hnand, NAND_AddressTypeDef *pAddress, uint8_t *pBuffer, uint32_t NumPageToRead)
mbed_official 573:ad23fe03a082 398 {
mbed_official 573:ad23fe03a082 399 __IO uint32_t index = 0;
mbed_official 573:ad23fe03a082 400 uint32_t deviceAddress = 0, size = 0, numPagesRead = 0, nandAddress = 0;
mbed_official 573:ad23fe03a082 401
mbed_official 573:ad23fe03a082 402 /* Process Locked */
mbed_official 573:ad23fe03a082 403 __HAL_LOCK(hnand);
mbed_official 573:ad23fe03a082 404
mbed_official 573:ad23fe03a082 405 /* Check the NAND controller state */
mbed_official 573:ad23fe03a082 406 if(hnand->State == HAL_NAND_STATE_BUSY)
mbed_official 573:ad23fe03a082 407 {
mbed_official 573:ad23fe03a082 408 return HAL_BUSY;
mbed_official 573:ad23fe03a082 409 }
mbed_official 573:ad23fe03a082 410
mbed_official 573:ad23fe03a082 411 /* Identify the device address */
mbed_official 573:ad23fe03a082 412 deviceAddress = NAND_DEVICE;
mbed_official 573:ad23fe03a082 413
mbed_official 573:ad23fe03a082 414 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 415 hnand->State = HAL_NAND_STATE_BUSY;
mbed_official 573:ad23fe03a082 416
mbed_official 573:ad23fe03a082 417 /* NAND raw address calculation */
mbed_official 573:ad23fe03a082 418 nandAddress = ARRAY_ADDRESS(pAddress, hnand);
mbed_official 573:ad23fe03a082 419
mbed_official 573:ad23fe03a082 420 /* Page(s) read loop */
mbed_official 573:ad23fe03a082 421 while((NumPageToRead != 0) && (nandAddress < ((hnand->Info.BlockSize) * (hnand->Info.PageSize) * (hnand->Info.ZoneSize))))
mbed_official 573:ad23fe03a082 422 {
mbed_official 573:ad23fe03a082 423 /* update the buffer size */
mbed_official 573:ad23fe03a082 424 size = (hnand->Info.PageSize) + ((hnand->Info.PageSize) * numPagesRead);
mbed_official 573:ad23fe03a082 425
mbed_official 573:ad23fe03a082 426 /* Send read page command sequence */
mbed_official 573:ad23fe03a082 427 *(__IO uint8_t *)((uint32_t)(deviceAddress | CMD_AREA)) = NAND_CMD_AREA_A;
mbed_official 573:ad23fe03a082 428
mbed_official 573:ad23fe03a082 429 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = 0x00;
mbed_official 573:ad23fe03a082 430 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_1ST_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 431 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_2ND_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 432 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_3RD_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 433
mbed_official 573:ad23fe03a082 434 /* for 512 and 1 GB devices, 4th cycle is required */
mbed_official 573:ad23fe03a082 435 if(hnand->Info.BlockNbr >= 1024)
mbed_official 573:ad23fe03a082 436 {
mbed_official 573:ad23fe03a082 437 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_4TH_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 438 }
mbed_official 573:ad23fe03a082 439
mbed_official 573:ad23fe03a082 440 *(__IO uint8_t *)((uint32_t)(deviceAddress | CMD_AREA)) = NAND_CMD_AREA_TRUE1;
mbed_official 573:ad23fe03a082 441
mbed_official 573:ad23fe03a082 442 /* Get Data into Buffer */
mbed_official 573:ad23fe03a082 443 for(index = 0; index < size; index++)
mbed_official 573:ad23fe03a082 444 {
mbed_official 573:ad23fe03a082 445 *(uint8_t *)pBuffer++ = *(uint8_t *)deviceAddress;
mbed_official 573:ad23fe03a082 446 }
mbed_official 573:ad23fe03a082 447
mbed_official 573:ad23fe03a082 448 /* Increment read pages number */
mbed_official 573:ad23fe03a082 449 numPagesRead++;
mbed_official 573:ad23fe03a082 450
mbed_official 573:ad23fe03a082 451 /* Decrement pages to read */
mbed_official 573:ad23fe03a082 452 NumPageToRead--;
mbed_official 573:ad23fe03a082 453
mbed_official 573:ad23fe03a082 454 /* Increment the NAND address */
mbed_official 573:ad23fe03a082 455 nandAddress = (uint32_t)(nandAddress + (hnand->Info.PageSize * 8));
mbed_official 573:ad23fe03a082 456
mbed_official 573:ad23fe03a082 457 }
mbed_official 573:ad23fe03a082 458
mbed_official 573:ad23fe03a082 459 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 460 hnand->State = HAL_NAND_STATE_READY;
mbed_official 573:ad23fe03a082 461
mbed_official 573:ad23fe03a082 462 /* Process unlocked */
mbed_official 573:ad23fe03a082 463 __HAL_UNLOCK(hnand);
mbed_official 573:ad23fe03a082 464
mbed_official 573:ad23fe03a082 465 return HAL_OK;
mbed_official 573:ad23fe03a082 466
mbed_official 573:ad23fe03a082 467 }
mbed_official 573:ad23fe03a082 468
mbed_official 573:ad23fe03a082 469 /**
mbed_official 573:ad23fe03a082 470 * @brief Write Page(s) to NAND memory block
mbed_official 573:ad23fe03a082 471 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 472 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 473 * @param pAddress : pointer to NAND address structure
mbed_official 573:ad23fe03a082 474 * @param pBuffer : pointer to source buffer to write
mbed_official 573:ad23fe03a082 475 * @param NumPageToWrite : number of pages to write to block
mbed_official 573:ad23fe03a082 476 * @retval HAL status
mbed_official 573:ad23fe03a082 477 */
mbed_official 573:ad23fe03a082 478 HAL_StatusTypeDef HAL_NAND_Write_Page(NAND_HandleTypeDef *hnand, NAND_AddressTypeDef *pAddress, uint8_t *pBuffer, uint32_t NumPageToWrite)
mbed_official 573:ad23fe03a082 479 {
mbed_official 573:ad23fe03a082 480 __IO uint32_t index = 0;
mbed_official 573:ad23fe03a082 481 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 482 uint32_t deviceAddress = 0, size = 0, numPagesWritten = 0, nandAddress = 0;
mbed_official 573:ad23fe03a082 483
mbed_official 573:ad23fe03a082 484 /* Process Locked */
mbed_official 573:ad23fe03a082 485 __HAL_LOCK(hnand);
mbed_official 573:ad23fe03a082 486
mbed_official 573:ad23fe03a082 487 /* Check the NAND controller state */
mbed_official 573:ad23fe03a082 488 if(hnand->State == HAL_NAND_STATE_BUSY)
mbed_official 573:ad23fe03a082 489 {
mbed_official 573:ad23fe03a082 490 return HAL_BUSY;
mbed_official 573:ad23fe03a082 491 }
mbed_official 573:ad23fe03a082 492
mbed_official 573:ad23fe03a082 493 /* Identify the device address */
mbed_official 573:ad23fe03a082 494 deviceAddress = NAND_DEVICE;
mbed_official 573:ad23fe03a082 495
mbed_official 573:ad23fe03a082 496 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 497 hnand->State = HAL_NAND_STATE_BUSY;
mbed_official 573:ad23fe03a082 498
mbed_official 573:ad23fe03a082 499 /* NAND raw address calculation */
mbed_official 573:ad23fe03a082 500 nandAddress = ARRAY_ADDRESS(pAddress, hnand);
mbed_official 573:ad23fe03a082 501
mbed_official 573:ad23fe03a082 502 /* Page(s) write loop */
mbed_official 573:ad23fe03a082 503 while((NumPageToWrite != 0) && (nandAddress < ((hnand->Info.BlockSize) * (hnand->Info.PageSize) * (hnand->Info.ZoneSize))))
mbed_official 573:ad23fe03a082 504 {
mbed_official 573:ad23fe03a082 505 /* update the buffer size */
mbed_official 573:ad23fe03a082 506 size = (hnand->Info.PageSize) + ((hnand->Info.PageSize) * numPagesWritten);
mbed_official 573:ad23fe03a082 507
mbed_official 573:ad23fe03a082 508 /* Send write page command sequence */
mbed_official 573:ad23fe03a082 509 *(__IO uint8_t *)((uint32_t)(deviceAddress | CMD_AREA)) = NAND_CMD_AREA_A;
mbed_official 573:ad23fe03a082 510 *(__IO uint8_t *)((uint32_t)(deviceAddress | CMD_AREA)) = NAND_CMD_WRITE0;
mbed_official 573:ad23fe03a082 511
mbed_official 573:ad23fe03a082 512 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = 0x00;
mbed_official 573:ad23fe03a082 513 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_1ST_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 514 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_2ND_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 515 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_3RD_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 516 __DSB();
mbed_official 573:ad23fe03a082 517
mbed_official 573:ad23fe03a082 518 /* for 512 and 1 GB devices, 4th cycle is required */
mbed_official 573:ad23fe03a082 519 if(hnand->Info.BlockNbr >= 1024)
mbed_official 573:ad23fe03a082 520 {
mbed_official 573:ad23fe03a082 521 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_4TH_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 522 __DSB();
mbed_official 573:ad23fe03a082 523 }
mbed_official 573:ad23fe03a082 524
mbed_official 573:ad23fe03a082 525 /* Write data to memory */
mbed_official 573:ad23fe03a082 526 for(index = 0; index < size; index++)
mbed_official 573:ad23fe03a082 527 {
mbed_official 573:ad23fe03a082 528 *(__IO uint8_t *)deviceAddress = *(uint8_t *)pBuffer++;
mbed_official 573:ad23fe03a082 529 __DSB();
mbed_official 573:ad23fe03a082 530 }
mbed_official 573:ad23fe03a082 531
mbed_official 573:ad23fe03a082 532 *(__IO uint8_t *)((uint32_t)(deviceAddress | CMD_AREA)) = NAND_CMD_WRITE_TRUE1;
mbed_official 573:ad23fe03a082 533
mbed_official 573:ad23fe03a082 534 /* Read status until NAND is ready */
mbed_official 573:ad23fe03a082 535 while(HAL_NAND_Read_Status(hnand) != NAND_READY)
mbed_official 573:ad23fe03a082 536 {
mbed_official 573:ad23fe03a082 537 /* Get tick */
mbed_official 573:ad23fe03a082 538 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 539
mbed_official 573:ad23fe03a082 540 if((HAL_GetTick() - tickstart ) > NAND_WRITE_TIMEOUT)
mbed_official 573:ad23fe03a082 541 {
mbed_official 573:ad23fe03a082 542 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 543 }
mbed_official 573:ad23fe03a082 544 }
mbed_official 573:ad23fe03a082 545
mbed_official 573:ad23fe03a082 546 /* Increment written pages number */
mbed_official 573:ad23fe03a082 547 numPagesWritten++;
mbed_official 573:ad23fe03a082 548
mbed_official 573:ad23fe03a082 549 /* Decrement pages to write */
mbed_official 573:ad23fe03a082 550 NumPageToWrite--;
mbed_official 573:ad23fe03a082 551
mbed_official 573:ad23fe03a082 552 /* Increment the NAND address */
mbed_official 573:ad23fe03a082 553 nandAddress = (uint32_t)(nandAddress + (hnand->Info.PageSize * 8));
mbed_official 573:ad23fe03a082 554 }
mbed_official 573:ad23fe03a082 555
mbed_official 573:ad23fe03a082 556 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 557 hnand->State = HAL_NAND_STATE_READY;
mbed_official 573:ad23fe03a082 558
mbed_official 573:ad23fe03a082 559 /* Process unlocked */
mbed_official 573:ad23fe03a082 560 __HAL_UNLOCK(hnand);
mbed_official 573:ad23fe03a082 561
mbed_official 573:ad23fe03a082 562 return HAL_OK;
mbed_official 573:ad23fe03a082 563 }
mbed_official 573:ad23fe03a082 564
mbed_official 573:ad23fe03a082 565 /**
mbed_official 573:ad23fe03a082 566 * @brief Read Spare area(s) from NAND memory
mbed_official 573:ad23fe03a082 567 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 568 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 569 * @param pAddress : pointer to NAND address structure
mbed_official 573:ad23fe03a082 570 * @param pBuffer: pointer to source buffer to write
mbed_official 573:ad23fe03a082 571 * @param NumSpareAreaToRead: Number of spare area to read
mbed_official 573:ad23fe03a082 572 * @retval HAL status
mbed_official 573:ad23fe03a082 573 */
mbed_official 573:ad23fe03a082 574 HAL_StatusTypeDef HAL_NAND_Read_SpareArea(NAND_HandleTypeDef *hnand, NAND_AddressTypeDef *pAddress, uint8_t *pBuffer, uint32_t NumSpareAreaToRead)
mbed_official 573:ad23fe03a082 575 {
mbed_official 573:ad23fe03a082 576 __IO uint32_t index = 0;
mbed_official 573:ad23fe03a082 577 uint32_t deviceAddress = 0, size = 0, numSpareAreaRead = 0, nandAddress = 0;
mbed_official 573:ad23fe03a082 578
mbed_official 573:ad23fe03a082 579 /* Process Locked */
mbed_official 573:ad23fe03a082 580 __HAL_LOCK(hnand);
mbed_official 573:ad23fe03a082 581
mbed_official 573:ad23fe03a082 582 /* Check the NAND controller state */
mbed_official 573:ad23fe03a082 583 if(hnand->State == HAL_NAND_STATE_BUSY)
mbed_official 573:ad23fe03a082 584 {
mbed_official 573:ad23fe03a082 585 return HAL_BUSY;
mbed_official 573:ad23fe03a082 586 }
mbed_official 573:ad23fe03a082 587
mbed_official 573:ad23fe03a082 588 /* Identify the device address */
mbed_official 573:ad23fe03a082 589 deviceAddress = NAND_DEVICE;
mbed_official 573:ad23fe03a082 590
mbed_official 573:ad23fe03a082 591 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 592 hnand->State = HAL_NAND_STATE_BUSY;
mbed_official 573:ad23fe03a082 593
mbed_official 573:ad23fe03a082 594 /* NAND raw address calculation */
mbed_official 573:ad23fe03a082 595 nandAddress = ARRAY_ADDRESS(pAddress, hnand);
mbed_official 573:ad23fe03a082 596
mbed_official 573:ad23fe03a082 597 /* Spare area(s) read loop */
mbed_official 573:ad23fe03a082 598 while((NumSpareAreaToRead != 0) && (nandAddress < ((hnand->Info.BlockSize) * (hnand->Info.SpareAreaSize) * (hnand->Info.ZoneSize))))
mbed_official 573:ad23fe03a082 599 {
mbed_official 573:ad23fe03a082 600
mbed_official 573:ad23fe03a082 601 /* update the buffer size */
mbed_official 573:ad23fe03a082 602 size = (hnand->Info.SpareAreaSize) + ((hnand->Info.SpareAreaSize) * numSpareAreaRead);
mbed_official 573:ad23fe03a082 603
mbed_official 573:ad23fe03a082 604 /* Send read spare area command sequence */
mbed_official 573:ad23fe03a082 605 *(__IO uint8_t *)((uint32_t)(deviceAddress | CMD_AREA)) = NAND_CMD_AREA_C;
mbed_official 573:ad23fe03a082 606
mbed_official 573:ad23fe03a082 607 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = 0x00;
mbed_official 573:ad23fe03a082 608 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_1ST_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 609 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_2ND_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 610 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_3RD_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 611
mbed_official 573:ad23fe03a082 612 /* for 512 and 1 GB devices, 4th cycle is required */
mbed_official 573:ad23fe03a082 613 if(hnand->Info.BlockNbr >= 1024)
mbed_official 573:ad23fe03a082 614 {
mbed_official 573:ad23fe03a082 615 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_4TH_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 616 }
mbed_official 573:ad23fe03a082 617
mbed_official 573:ad23fe03a082 618 *(__IO uint8_t *)((uint32_t)(deviceAddress | CMD_AREA)) = NAND_CMD_AREA_TRUE1;
mbed_official 573:ad23fe03a082 619
mbed_official 573:ad23fe03a082 620 /* Get Data into Buffer */
mbed_official 573:ad23fe03a082 621 for(index = 0; index < size; index++)
mbed_official 573:ad23fe03a082 622 {
mbed_official 573:ad23fe03a082 623 *(uint8_t *)pBuffer++ = *(uint8_t *)deviceAddress;
mbed_official 573:ad23fe03a082 624 }
mbed_official 573:ad23fe03a082 625
mbed_official 573:ad23fe03a082 626 /* Increment read spare areas number */
mbed_official 573:ad23fe03a082 627 numSpareAreaRead++;
mbed_official 573:ad23fe03a082 628
mbed_official 573:ad23fe03a082 629 /* Decrement spare areas to read */
mbed_official 573:ad23fe03a082 630 NumSpareAreaToRead--;
mbed_official 573:ad23fe03a082 631
mbed_official 573:ad23fe03a082 632 /* Increment the NAND address */
mbed_official 573:ad23fe03a082 633 nandAddress = (uint32_t)(nandAddress + (hnand->Info.SpareAreaSize));
mbed_official 573:ad23fe03a082 634 }
mbed_official 573:ad23fe03a082 635
mbed_official 573:ad23fe03a082 636 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 637 hnand->State = HAL_NAND_STATE_READY;
mbed_official 573:ad23fe03a082 638
mbed_official 573:ad23fe03a082 639 /* Process unlocked */
mbed_official 573:ad23fe03a082 640 __HAL_UNLOCK(hnand);
mbed_official 573:ad23fe03a082 641
mbed_official 573:ad23fe03a082 642 return HAL_OK;
mbed_official 573:ad23fe03a082 643 }
mbed_official 573:ad23fe03a082 644
mbed_official 573:ad23fe03a082 645 /**
mbed_official 573:ad23fe03a082 646 * @brief Write Spare area(s) to NAND memory
mbed_official 573:ad23fe03a082 647 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 648 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 649 * @param pAddress : pointer to NAND address structure
mbed_official 573:ad23fe03a082 650 * @param pBuffer : pointer to source buffer to write
mbed_official 573:ad23fe03a082 651 * @param NumSpareAreaTowrite : number of spare areas to write to block
mbed_official 573:ad23fe03a082 652 * @retval HAL status
mbed_official 573:ad23fe03a082 653 */
mbed_official 573:ad23fe03a082 654 HAL_StatusTypeDef HAL_NAND_Write_SpareArea(NAND_HandleTypeDef *hnand, NAND_AddressTypeDef *pAddress, uint8_t *pBuffer, uint32_t NumSpareAreaTowrite)
mbed_official 573:ad23fe03a082 655 {
mbed_official 573:ad23fe03a082 656 __IO uint32_t index = 0;
mbed_official 573:ad23fe03a082 657 uint32_t tickstart = 0;
mbed_official 573:ad23fe03a082 658 uint32_t deviceAddress = 0, size = 0, numSpareAreaWritten = 0, nandAddress = 0;
mbed_official 573:ad23fe03a082 659
mbed_official 573:ad23fe03a082 660 /* Process Locked */
mbed_official 573:ad23fe03a082 661 __HAL_LOCK(hnand);
mbed_official 573:ad23fe03a082 662
mbed_official 573:ad23fe03a082 663 /* Check the NAND controller state */
mbed_official 573:ad23fe03a082 664 if(hnand->State == HAL_NAND_STATE_BUSY)
mbed_official 573:ad23fe03a082 665 {
mbed_official 573:ad23fe03a082 666 return HAL_BUSY;
mbed_official 573:ad23fe03a082 667 }
mbed_official 573:ad23fe03a082 668
mbed_official 573:ad23fe03a082 669 /* Identify the device address */
mbed_official 573:ad23fe03a082 670 deviceAddress = NAND_DEVICE;
mbed_official 573:ad23fe03a082 671
mbed_official 573:ad23fe03a082 672 /* Update the FMC_NAND controller state */
mbed_official 573:ad23fe03a082 673 hnand->State = HAL_NAND_STATE_BUSY;
mbed_official 573:ad23fe03a082 674
mbed_official 573:ad23fe03a082 675 /* NAND raw address calculation */
mbed_official 573:ad23fe03a082 676 nandAddress = ARRAY_ADDRESS(pAddress, hnand);
mbed_official 573:ad23fe03a082 677
mbed_official 573:ad23fe03a082 678 /* Spare area(s) write loop */
mbed_official 573:ad23fe03a082 679 while((NumSpareAreaTowrite != 0) && (nandAddress < ((hnand->Info.BlockSize) * (hnand->Info.SpareAreaSize) * (hnand->Info.ZoneSize))))
mbed_official 573:ad23fe03a082 680 {
mbed_official 573:ad23fe03a082 681 /* update the buffer size */
mbed_official 573:ad23fe03a082 682 size = (hnand->Info.SpareAreaSize) + ((hnand->Info.SpareAreaSize) * numSpareAreaWritten);
mbed_official 573:ad23fe03a082 683
mbed_official 573:ad23fe03a082 684 /* Send write Spare area command sequence */
mbed_official 573:ad23fe03a082 685 *(__IO uint8_t *)((uint32_t)(deviceAddress | CMD_AREA)) = NAND_CMD_AREA_C;
mbed_official 573:ad23fe03a082 686 *(__IO uint8_t *)((uint32_t)(deviceAddress | CMD_AREA)) = NAND_CMD_WRITE0;
mbed_official 573:ad23fe03a082 687
mbed_official 573:ad23fe03a082 688 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = 0x00;
mbed_official 573:ad23fe03a082 689 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_1ST_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 690 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_2ND_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 691 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_3RD_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 692 __DSB();
mbed_official 573:ad23fe03a082 693 /* for 512 and 1 GB devices, 4th cycle is required */
mbed_official 573:ad23fe03a082 694 if(hnand->Info.BlockNbr >= 1024)
mbed_official 573:ad23fe03a082 695 {
mbed_official 573:ad23fe03a082 696 *(__IO uint8_t *)((uint32_t)(deviceAddress | ADDR_AREA)) = ADDR_4TH_CYCLE(nandAddress);
mbed_official 573:ad23fe03a082 697 __DSB();
mbed_official 573:ad23fe03a082 698 }
mbed_official 573:ad23fe03a082 699
mbed_official 573:ad23fe03a082 700 /* Write data to memory */
mbed_official 573:ad23fe03a082 701 for(index = 0; index < size; index++)
mbed_official 573:ad23fe03a082 702 {
mbed_official 573:ad23fe03a082 703 *(__IO uint8_t *)deviceAddress = *(uint8_t *)pBuffer++;
mbed_official 573:ad23fe03a082 704 __DSB();
mbed_official 573:ad23fe03a082 705 }
mbed_official 573:ad23fe03a082 706
mbed_official 573:ad23fe03a082 707 *(__IO uint8_t *)((uint32_t)(deviceAddress | CMD_AREA)) = NAND_CMD_WRITE_TRUE1;
mbed_official 573:ad23fe03a082 708 __DSB();
mbed_official 573:ad23fe03a082 709
mbed_official 573:ad23fe03a082 710 /* Read status until NAND is ready */
mbed_official 573:ad23fe03a082 711 while(HAL_NAND_Read_Status(hnand) != NAND_READY)
mbed_official 573:ad23fe03a082 712 {
mbed_official 573:ad23fe03a082 713 /* Get tick */
mbed_official 573:ad23fe03a082 714 tickstart = HAL_GetTick();
mbed_official 573:ad23fe03a082 715
mbed_official 573:ad23fe03a082 716 if((HAL_GetTick() - tickstart ) > NAND_WRITE_TIMEOUT)
mbed_official 573:ad23fe03a082 717 {
mbed_official 573:ad23fe03a082 718 return HAL_TIMEOUT;
mbed_official 573:ad23fe03a082 719 }
mbed_official 573:ad23fe03a082 720 }
mbed_official 573:ad23fe03a082 721
mbed_official 573:ad23fe03a082 722 /* Increment written spare areas number */
mbed_official 573:ad23fe03a082 723 numSpareAreaWritten++;
mbed_official 573:ad23fe03a082 724
mbed_official 573:ad23fe03a082 725 /* Decrement spare areas to write */
mbed_official 573:ad23fe03a082 726 NumSpareAreaTowrite--;
mbed_official 573:ad23fe03a082 727
mbed_official 573:ad23fe03a082 728 /* Increment the NAND address */
mbed_official 573:ad23fe03a082 729 nandAddress = (uint32_t)(nandAddress + (hnand->Info.PageSize));
mbed_official 573:ad23fe03a082 730 }
mbed_official 573:ad23fe03a082 731
mbed_official 573:ad23fe03a082 732 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 733 hnand->State = HAL_NAND_STATE_READY;
mbed_official 573:ad23fe03a082 734
mbed_official 573:ad23fe03a082 735 /* Process unlocked */
mbed_official 573:ad23fe03a082 736 __HAL_UNLOCK(hnand);
mbed_official 573:ad23fe03a082 737
mbed_official 573:ad23fe03a082 738 return HAL_OK;
mbed_official 573:ad23fe03a082 739 }
mbed_official 573:ad23fe03a082 740
mbed_official 573:ad23fe03a082 741 /**
mbed_official 573:ad23fe03a082 742 * @brief NAND memory Block erase
mbed_official 573:ad23fe03a082 743 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 744 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 745 * @param pAddress : pointer to NAND address structure
mbed_official 573:ad23fe03a082 746 * @retval HAL status
mbed_official 573:ad23fe03a082 747 */
mbed_official 573:ad23fe03a082 748 HAL_StatusTypeDef HAL_NAND_Erase_Block(NAND_HandleTypeDef *hnand, NAND_AddressTypeDef *pAddress)
mbed_official 573:ad23fe03a082 749 {
mbed_official 573:ad23fe03a082 750 uint32_t DeviceAddress = 0;
mbed_official 573:ad23fe03a082 751
mbed_official 573:ad23fe03a082 752 /* Process Locked */
mbed_official 573:ad23fe03a082 753 __HAL_LOCK(hnand);
mbed_official 573:ad23fe03a082 754
mbed_official 573:ad23fe03a082 755 /* Check the NAND controller state */
mbed_official 573:ad23fe03a082 756 if(hnand->State == HAL_NAND_STATE_BUSY)
mbed_official 573:ad23fe03a082 757 {
mbed_official 573:ad23fe03a082 758 return HAL_BUSY;
mbed_official 573:ad23fe03a082 759 }
mbed_official 573:ad23fe03a082 760
mbed_official 573:ad23fe03a082 761 /* Identify the device address */
mbed_official 573:ad23fe03a082 762 DeviceAddress = NAND_DEVICE;
mbed_official 573:ad23fe03a082 763
mbed_official 573:ad23fe03a082 764 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 765 hnand->State = HAL_NAND_STATE_BUSY;
mbed_official 573:ad23fe03a082 766
mbed_official 573:ad23fe03a082 767 /* Send Erase block command sequence */
mbed_official 573:ad23fe03a082 768 *(__IO uint8_t *)((uint32_t)(DeviceAddress | CMD_AREA)) = NAND_CMD_ERASE0;
mbed_official 573:ad23fe03a082 769
mbed_official 573:ad23fe03a082 770 *(__IO uint8_t *)((uint32_t)(DeviceAddress | ADDR_AREA)) = ADDR_1ST_CYCLE(ARRAY_ADDRESS(pAddress, hnand));
mbed_official 573:ad23fe03a082 771 *(__IO uint8_t *)((uint32_t)(DeviceAddress | ADDR_AREA)) = ADDR_2ND_CYCLE(ARRAY_ADDRESS(pAddress, hnand));
mbed_official 573:ad23fe03a082 772 *(__IO uint8_t *)((uint32_t)(DeviceAddress | ADDR_AREA)) = ADDR_3RD_CYCLE(ARRAY_ADDRESS(pAddress, hnand));
mbed_official 573:ad23fe03a082 773 __DSB();
mbed_official 573:ad23fe03a082 774
mbed_official 573:ad23fe03a082 775 /* for 512 and 1 GB devices, 4th cycle is required */
mbed_official 573:ad23fe03a082 776 if(hnand->Info.BlockNbr >= 1024)
mbed_official 573:ad23fe03a082 777 {
mbed_official 573:ad23fe03a082 778 *(__IO uint8_t *)((uint32_t)(DeviceAddress | ADDR_AREA)) = ADDR_4TH_CYCLE(ARRAY_ADDRESS(pAddress, hnand));
mbed_official 573:ad23fe03a082 779 __DSB();
mbed_official 573:ad23fe03a082 780 }
mbed_official 573:ad23fe03a082 781
mbed_official 573:ad23fe03a082 782 *(__IO uint8_t *)((uint32_t)(DeviceAddress | CMD_AREA)) = NAND_CMD_ERASE1;
mbed_official 573:ad23fe03a082 783 __DSB();
mbed_official 573:ad23fe03a082 784
mbed_official 573:ad23fe03a082 785 /* Update the NAND controller state */
mbed_official 573:ad23fe03a082 786 hnand->State = HAL_NAND_STATE_READY;
mbed_official 573:ad23fe03a082 787
mbed_official 573:ad23fe03a082 788 /* Process unlocked */
mbed_official 573:ad23fe03a082 789 __HAL_UNLOCK(hnand);
mbed_official 573:ad23fe03a082 790
mbed_official 573:ad23fe03a082 791 return HAL_OK;
mbed_official 573:ad23fe03a082 792 }
mbed_official 573:ad23fe03a082 793
mbed_official 573:ad23fe03a082 794 /**
mbed_official 573:ad23fe03a082 795 * @brief NAND memory read status
mbed_official 573:ad23fe03a082 796 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 797 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 798 * @retval NAND status
mbed_official 573:ad23fe03a082 799 */
mbed_official 573:ad23fe03a082 800 uint32_t HAL_NAND_Read_Status(NAND_HandleTypeDef *hnand)
mbed_official 573:ad23fe03a082 801 {
mbed_official 573:ad23fe03a082 802 uint32_t data = 0;
mbed_official 573:ad23fe03a082 803 uint32_t DeviceAddress = 0;
mbed_official 573:ad23fe03a082 804
mbed_official 573:ad23fe03a082 805 /* Identify the device address */
mbed_official 573:ad23fe03a082 806 DeviceAddress = NAND_DEVICE;
mbed_official 573:ad23fe03a082 807
mbed_official 573:ad23fe03a082 808 /* Send Read status operation command */
mbed_official 573:ad23fe03a082 809 *(__IO uint8_t *)((uint32_t)(DeviceAddress | CMD_AREA)) = NAND_CMD_STATUS;
mbed_official 573:ad23fe03a082 810
mbed_official 573:ad23fe03a082 811 /* Read status register data */
mbed_official 573:ad23fe03a082 812 data = *(__IO uint8_t *)DeviceAddress;
mbed_official 573:ad23fe03a082 813
mbed_official 573:ad23fe03a082 814 /* Return the status */
mbed_official 573:ad23fe03a082 815 if((data & NAND_ERROR) == NAND_ERROR)
mbed_official 573:ad23fe03a082 816 {
mbed_official 573:ad23fe03a082 817 return NAND_ERROR;
mbed_official 573:ad23fe03a082 818 }
mbed_official 573:ad23fe03a082 819 else if((data & NAND_READY) == NAND_READY)
mbed_official 573:ad23fe03a082 820 {
mbed_official 573:ad23fe03a082 821 return NAND_READY;
mbed_official 573:ad23fe03a082 822 }
mbed_official 573:ad23fe03a082 823
mbed_official 573:ad23fe03a082 824 return NAND_BUSY;
mbed_official 573:ad23fe03a082 825 }
mbed_official 573:ad23fe03a082 826
mbed_official 573:ad23fe03a082 827 /**
mbed_official 573:ad23fe03a082 828 * @brief Increment the NAND memory address
mbed_official 573:ad23fe03a082 829 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 830 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 831 * @param pAddress: pointer to NAND address structure
mbed_official 573:ad23fe03a082 832 * @retval The new status of the increment address operation. It can be:
mbed_official 573:ad23fe03a082 833 * - NAND_VALID_ADDRESS: When the new address is valid address
mbed_official 573:ad23fe03a082 834 * - NAND_INVALID_ADDRESS: When the new address is invalid address
mbed_official 573:ad23fe03a082 835 */
mbed_official 573:ad23fe03a082 836 uint32_t HAL_NAND_Address_Inc(NAND_HandleTypeDef *hnand, NAND_AddressTypeDef *pAddress)
mbed_official 573:ad23fe03a082 837 {
mbed_official 573:ad23fe03a082 838 uint32_t status = NAND_VALID_ADDRESS;
mbed_official 573:ad23fe03a082 839
mbed_official 573:ad23fe03a082 840 /* Increment page address */
mbed_official 573:ad23fe03a082 841 pAddress->Page++;
mbed_official 573:ad23fe03a082 842
mbed_official 573:ad23fe03a082 843 /* Check NAND address is valid */
mbed_official 573:ad23fe03a082 844 if(pAddress->Page == hnand->Info.BlockSize)
mbed_official 573:ad23fe03a082 845 {
mbed_official 573:ad23fe03a082 846 pAddress->Page = 0;
mbed_official 573:ad23fe03a082 847 pAddress->Block++;
mbed_official 573:ad23fe03a082 848
mbed_official 573:ad23fe03a082 849 if(pAddress->Block == hnand->Info.ZoneSize)
mbed_official 573:ad23fe03a082 850 {
mbed_official 573:ad23fe03a082 851 pAddress->Block = 0;
mbed_official 573:ad23fe03a082 852 pAddress->Zone++;
mbed_official 573:ad23fe03a082 853
mbed_official 573:ad23fe03a082 854 if(pAddress->Zone == (hnand->Info.ZoneSize/ hnand->Info.BlockNbr))
mbed_official 573:ad23fe03a082 855 {
mbed_official 573:ad23fe03a082 856 status = NAND_INVALID_ADDRESS;
mbed_official 573:ad23fe03a082 857 }
mbed_official 573:ad23fe03a082 858 }
mbed_official 573:ad23fe03a082 859 }
mbed_official 573:ad23fe03a082 860
mbed_official 573:ad23fe03a082 861 return (status);
mbed_official 573:ad23fe03a082 862 }
mbed_official 573:ad23fe03a082 863 /**
mbed_official 573:ad23fe03a082 864 * @}
mbed_official 573:ad23fe03a082 865 */
mbed_official 573:ad23fe03a082 866
mbed_official 573:ad23fe03a082 867 /** @defgroup NAND_Exported_Functions_Group3 Peripheral Control functions
mbed_official 573:ad23fe03a082 868 * @brief management functions
mbed_official 573:ad23fe03a082 869 *
mbed_official 573:ad23fe03a082 870 @verbatim
mbed_official 573:ad23fe03a082 871 ==============================================================================
mbed_official 573:ad23fe03a082 872 ##### NAND Control functions #####
mbed_official 573:ad23fe03a082 873 ==============================================================================
mbed_official 573:ad23fe03a082 874 [..]
mbed_official 573:ad23fe03a082 875 This subsection provides a set of functions allowing to control dynamically
mbed_official 573:ad23fe03a082 876 the NAND interface.
mbed_official 573:ad23fe03a082 877
mbed_official 573:ad23fe03a082 878 @endverbatim
mbed_official 573:ad23fe03a082 879 * @{
mbed_official 573:ad23fe03a082 880 */
mbed_official 573:ad23fe03a082 881
mbed_official 573:ad23fe03a082 882
mbed_official 573:ad23fe03a082 883 /**
mbed_official 573:ad23fe03a082 884 * @brief Enables dynamically NAND ECC feature.
mbed_official 573:ad23fe03a082 885 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 886 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 887 * @retval HAL status
mbed_official 573:ad23fe03a082 888 */
mbed_official 573:ad23fe03a082 889 HAL_StatusTypeDef HAL_NAND_ECC_Enable(NAND_HandleTypeDef *hnand)
mbed_official 573:ad23fe03a082 890 {
mbed_official 573:ad23fe03a082 891 /* Check the NAND controller state */
mbed_official 573:ad23fe03a082 892 if(hnand->State == HAL_NAND_STATE_BUSY)
mbed_official 573:ad23fe03a082 893 {
mbed_official 573:ad23fe03a082 894 return HAL_BUSY;
mbed_official 573:ad23fe03a082 895 }
mbed_official 573:ad23fe03a082 896
mbed_official 573:ad23fe03a082 897 /* Update the NAND state */
mbed_official 573:ad23fe03a082 898 hnand->State = HAL_NAND_STATE_BUSY;
mbed_official 573:ad23fe03a082 899
mbed_official 573:ad23fe03a082 900 /* Enable ECC feature */
mbed_official 573:ad23fe03a082 901 FMC_NAND_ECC_Enable(hnand->Instance, hnand->Init.NandBank);
mbed_official 573:ad23fe03a082 902
mbed_official 573:ad23fe03a082 903 /* Update the NAND state */
mbed_official 573:ad23fe03a082 904 hnand->State = HAL_NAND_STATE_READY;
mbed_official 573:ad23fe03a082 905
mbed_official 573:ad23fe03a082 906 return HAL_OK;
mbed_official 573:ad23fe03a082 907 }
mbed_official 573:ad23fe03a082 908
mbed_official 573:ad23fe03a082 909 /**
mbed_official 573:ad23fe03a082 910 * @brief Disables dynamically FMC_NAND ECC feature.
mbed_official 573:ad23fe03a082 911 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 912 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 913 * @retval HAL status
mbed_official 573:ad23fe03a082 914 */
mbed_official 573:ad23fe03a082 915 HAL_StatusTypeDef HAL_NAND_ECC_Disable(NAND_HandleTypeDef *hnand)
mbed_official 573:ad23fe03a082 916 {
mbed_official 573:ad23fe03a082 917 /* Check the NAND controller state */
mbed_official 573:ad23fe03a082 918 if(hnand->State == HAL_NAND_STATE_BUSY)
mbed_official 573:ad23fe03a082 919 {
mbed_official 573:ad23fe03a082 920 return HAL_BUSY;
mbed_official 573:ad23fe03a082 921 }
mbed_official 573:ad23fe03a082 922
mbed_official 573:ad23fe03a082 923 /* Update the NAND state */
mbed_official 573:ad23fe03a082 924 hnand->State = HAL_NAND_STATE_BUSY;
mbed_official 573:ad23fe03a082 925
mbed_official 573:ad23fe03a082 926 /* Disable ECC feature */
mbed_official 573:ad23fe03a082 927 FMC_NAND_ECC_Disable(hnand->Instance, hnand->Init.NandBank);
mbed_official 573:ad23fe03a082 928
mbed_official 573:ad23fe03a082 929 /* Update the NAND state */
mbed_official 573:ad23fe03a082 930 hnand->State = HAL_NAND_STATE_READY;
mbed_official 573:ad23fe03a082 931
mbed_official 573:ad23fe03a082 932 return HAL_OK;
mbed_official 573:ad23fe03a082 933 }
mbed_official 573:ad23fe03a082 934
mbed_official 573:ad23fe03a082 935 /**
mbed_official 573:ad23fe03a082 936 * @brief Disables dynamically NAND ECC feature.
mbed_official 573:ad23fe03a082 937 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 938 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 939 * @param ECCval: pointer to ECC value
mbed_official 573:ad23fe03a082 940 * @param Timeout: maximum timeout to wait
mbed_official 573:ad23fe03a082 941 * @retval HAL status
mbed_official 573:ad23fe03a082 942 */
mbed_official 573:ad23fe03a082 943 HAL_StatusTypeDef HAL_NAND_GetECC(NAND_HandleTypeDef *hnand, uint32_t *ECCval, uint32_t Timeout)
mbed_official 573:ad23fe03a082 944 {
mbed_official 573:ad23fe03a082 945 HAL_StatusTypeDef status = HAL_OK;
mbed_official 573:ad23fe03a082 946
mbed_official 573:ad23fe03a082 947 /* Check the NAND controller state */
mbed_official 573:ad23fe03a082 948 if(hnand->State == HAL_NAND_STATE_BUSY)
mbed_official 573:ad23fe03a082 949 {
mbed_official 573:ad23fe03a082 950 return HAL_BUSY;
mbed_official 573:ad23fe03a082 951 }
mbed_official 573:ad23fe03a082 952
mbed_official 573:ad23fe03a082 953 /* Update the NAND state */
mbed_official 573:ad23fe03a082 954 hnand->State = HAL_NAND_STATE_BUSY;
mbed_official 573:ad23fe03a082 955
mbed_official 573:ad23fe03a082 956 /* Get NAND ECC value */
mbed_official 573:ad23fe03a082 957 status = FMC_NAND_GetECC(hnand->Instance, ECCval, hnand->Init.NandBank, Timeout);
mbed_official 573:ad23fe03a082 958
mbed_official 573:ad23fe03a082 959 /* Update the NAND state */
mbed_official 573:ad23fe03a082 960 hnand->State = HAL_NAND_STATE_READY;
mbed_official 573:ad23fe03a082 961
mbed_official 573:ad23fe03a082 962 return status;
mbed_official 573:ad23fe03a082 963 }
mbed_official 573:ad23fe03a082 964
mbed_official 573:ad23fe03a082 965 /**
mbed_official 573:ad23fe03a082 966 * @}
mbed_official 573:ad23fe03a082 967 */
mbed_official 573:ad23fe03a082 968
mbed_official 573:ad23fe03a082 969
mbed_official 573:ad23fe03a082 970 /** @defgroup NAND_Exported_Functions_Group4 Peripheral State functions
mbed_official 573:ad23fe03a082 971 * @brief Peripheral State functions
mbed_official 573:ad23fe03a082 972 *
mbed_official 573:ad23fe03a082 973 @verbatim
mbed_official 573:ad23fe03a082 974 ==============================================================================
mbed_official 573:ad23fe03a082 975 ##### NAND State functions #####
mbed_official 573:ad23fe03a082 976 ==============================================================================
mbed_official 573:ad23fe03a082 977 [..]
mbed_official 573:ad23fe03a082 978 This subsection permits to get in run-time the status of the NAND controller
mbed_official 573:ad23fe03a082 979 and the data flow.
mbed_official 573:ad23fe03a082 980
mbed_official 573:ad23fe03a082 981 @endverbatim
mbed_official 573:ad23fe03a082 982 * @{
mbed_official 573:ad23fe03a082 983 */
mbed_official 573:ad23fe03a082 984
mbed_official 573:ad23fe03a082 985 /**
mbed_official 573:ad23fe03a082 986 * @brief return the NAND state
mbed_official 573:ad23fe03a082 987 * @param hnand: pointer to a NAND_HandleTypeDef structure that contains
mbed_official 573:ad23fe03a082 988 * the configuration information for NAND module.
mbed_official 573:ad23fe03a082 989 * @retval HAL state
mbed_official 573:ad23fe03a082 990 */
mbed_official 573:ad23fe03a082 991 HAL_NAND_StateTypeDef HAL_NAND_GetState(NAND_HandleTypeDef *hnand)
mbed_official 573:ad23fe03a082 992 {
mbed_official 573:ad23fe03a082 993 return hnand->State;
mbed_official 573:ad23fe03a082 994 }
mbed_official 573:ad23fe03a082 995
mbed_official 573:ad23fe03a082 996 /**
mbed_official 573:ad23fe03a082 997 * @}
mbed_official 573:ad23fe03a082 998 */
mbed_official 573:ad23fe03a082 999
mbed_official 573:ad23fe03a082 1000 /**
mbed_official 573:ad23fe03a082 1001 * @}
mbed_official 573:ad23fe03a082 1002 */
mbed_official 573:ad23fe03a082 1003
mbed_official 573:ad23fe03a082 1004 #endif /* HAL_NAND_MODULE_ENABLED */
mbed_official 573:ad23fe03a082 1005
mbed_official 573:ad23fe03a082 1006 /**
mbed_official 573:ad23fe03a082 1007 * @}
mbed_official 573:ad23fe03a082 1008 */
mbed_official 573:ad23fe03a082 1009
mbed_official 573:ad23fe03a082 1010 /**
mbed_official 573:ad23fe03a082 1011 * @}
mbed_official 573:ad23fe03a082 1012 */
mbed_official 573:ad23fe03a082 1013
mbed_official 573:ad23fe03a082 1014 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/