STM32Cube BSP FW for STM32F769I-Discovery
Dependents: mbed-os-example-blinky-5 DISCO-F769NI_TOUCHSCREEN_demo_custom_1 Datarecorder2 DISCO-F769NI_TOUCHSCREEN_demo ... more
stm32f769i_discovery_eeprom.c
00001 /** 00002 ****************************************************************************** 00003 * @file stm32f769i_discovery_eeprom.c 00004 * @author MCD Application Team 00005 * @brief This file provides a set of functions needed to manage an I2C M24LR64 00006 * EEPROM memory. 00007 @verbatim 00008 To be able to use this driver, the switch EE_M24LR64 must be defined 00009 in your toolchain compiler preprocessor 00010 00011 =================================================================== 00012 Notes: 00013 - The I2C EEPROM memory (M24LR64) is available on separate daughter 00014 board ANT7-M24LR-A, which is not provided with the STM32F769I_DISCOVERY 00015 board. 00016 To use this driver you have to connect the ANT7-M24LR-A to CN2 00017 connector of STM32F769I_DISCOVERY board. 00018 =================================================================== 00019 00020 It implements a high level communication layer for read and write 00021 from/to this memory. The needed STM32F7xx hardware resources (I2C and 00022 GPIO) are defined in stm32f769i_discovery.h file, and the initialization is 00023 performed in EEPROM_IO_Init() function declared in stm32f769i_discovery.c 00024 file. 00025 You can easily tailor this driver to any other development board, 00026 by just adapting the defines for hardware resources and 00027 EEPROM_IO_Init() function. 00028 00029 @note In this driver, basic read and write functions (BSP_EEPROM_ReadBuffer() 00030 and BSP_EEPROM_WritePage()) use DMA mode to perform the data 00031 transfer to/from EEPROM memory. 00032 00033 @note Regarding BSP_EEPROM_WritePage(), it is an optimized function to perform 00034 small write (less than 1 page) BUT the number of bytes (combined to write start address) must not 00035 cross the EEPROM page boundary. This function can only writes into 00036 the boundaries of an EEPROM page. 00037 This function doesn't check on boundaries condition (in this driver 00038 the function BSP_EEPROM_WriteBuffer() which calls BSP_EEPROM_WritePage() is 00039 responsible of checking on Page boundaries). 00040 00041 00042 +-----------------------------------------------------------------+ 00043 | Pin assignment for M24LR64 EEPROM | 00044 +---------------------------------------+-----------+-------------+ 00045 | STM32F7xx I2C Pins | EEPROM | Pin | 00046 +---------------------------------------+-----------+-------------+ 00047 | . | E0(GND) | 1 (0V) | 00048 | . | AC0 | 2 | 00049 | . | AC1 | 3 | 00050 | . | VSS | 4 (0V) | 00051 | SDA | SDA | 5 | 00052 | SCL | SCL | 6 | 00053 | . | E1(GND) | 7 (0V) | 00054 | . | VDD | 8 (3.3V) | 00055 +---------------------------------------+-----------+-------------+ 00056 @endverbatim 00057 ****************************************************************************** 00058 * @attention 00059 * 00060 * <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2> 00061 * 00062 * Redistribution and use in source and binary forms, with or without modification, 00063 * are permitted provided that the following conditions are met: 00064 * 1. Redistributions of source code must retain the above copyright notice, 00065 * this list of conditions and the following disclaimer. 00066 * 2. Redistributions in binary form must reproduce the above copyright notice, 00067 * this list of conditions and the following disclaimer in the documentation 00068 * and/or other materials provided with the distribution. 00069 * 3. Neither the name of STMicroelectronics nor the names of its contributors 00070 * may be used to endorse or promote products derived from this software 00071 * without specific prior written permission. 00072 * 00073 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 00074 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 00075 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 00076 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 00077 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 00078 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 00079 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 00080 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 00081 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 00082 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00083 * 00084 ****************************************************************************** 00085 */ 00086 00087 /* Dependencies 00088 - stm32f769i_discovery.c 00089 EndDependencies */ 00090 00091 /* Includes ------------------------------------------------------------------*/ 00092 #include "stm32f769i_discovery_eeprom.h" 00093 00094 /** @addtogroup BSP 00095 * @{ 00096 */ 00097 00098 /** @addtogroup STM32F769I_DISCOVERY 00099 * @{ 00100 */ 00101 00102 /** @addtogroup STM32F769I_DISCOVERY_EEPROM STM32F769I_DISCOVERY EEPROM 00103 * @brief This file includes the I2C EEPROM driver of STM32F769I-DISCOVERY board. 00104 * @{ 00105 */ 00106 00107 /** @defgroup STM32F769I_DISCOVERY_EEPROM_Private_Types EEPROM Private Types 00108 * @{ 00109 */ 00110 /** 00111 * @} 00112 */ 00113 00114 /** @defgroup STM32F769I_DISCOVERY_EEPROM_Private_Defines EEPROM Private Defines 00115 * @{ 00116 */ 00117 /** 00118 * @} 00119 */ 00120 00121 /** @defgroup STM32F769I_DISCOVERY_EEPROM_Private_Macros EEPROM Private Macros 00122 * @{ 00123 */ 00124 /** 00125 * @} 00126 */ 00127 00128 /** @defgroup STM32F769I_DISCOVERY_EEPROM_Private_Variables EEPROM Private Variables 00129 * @{ 00130 */ 00131 __IO uint16_t EEPROMAddress = 0; 00132 __IO uint16_t EEPROMDataRead; 00133 __IO uint8_t EEPROMDataWrite; 00134 /** 00135 * @} 00136 */ 00137 00138 /** @defgroup STM32F769I_DISCOVERY_EEPROM_Private_Function_Prototypes EEPROM Private Function Prototypes 00139 * @{ 00140 */ 00141 /** 00142 * @} 00143 */ 00144 00145 /** @defgroup STM32F769I_DISCOVERY_EEPROM_Private_Functions EEPROM Private Functions 00146 * @{ 00147 */ 00148 00149 /** 00150 * @brief Initializes peripherals used by the I2C EEPROM driver. 00151 * @note There are 2 different versions of M24LR64 (A01 & A02). 00152 * Then try to connect on 1st one (EEPROM_I2C_ADDRESS_A01) 00153 * and if problem, check the 2nd one (EEPROM_I2C_ADDRESS_A02) 00154 * @retval EEPROM_OK (0) if operation is correctly performed, else return value 00155 * different from EEPROM_OK (0) 00156 */ 00157 uint32_t BSP_EEPROM_Init(void) 00158 { 00159 /* I2C Initialization */ 00160 EEPROM_IO_Init(); 00161 00162 /* Select the EEPROM address for A01 and check if OK */ 00163 EEPROMAddress = EEPROM_I2C_ADDRESS_A01; 00164 if(EEPROM_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK) 00165 { 00166 /* Select the EEPROM address for A02 and check if OK */ 00167 EEPROMAddress = EEPROM_I2C_ADDRESS_A02; 00168 if(EEPROM_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK) 00169 { 00170 return EEPROM_FAIL; 00171 } 00172 } 00173 return EEPROM_OK; 00174 } 00175 00176 /** 00177 * @brief DeInitializes the EEPROM. 00178 * @retval EEPROM state 00179 */ 00180 uint8_t BSP_EEPROM_DeInit(void) 00181 { 00182 /* I2C won't be disabled because common to other functionalities */ 00183 return EEPROM_OK; 00184 } 00185 00186 /** 00187 * @brief Reads a block of data from the EEPROM. 00188 * @param pBuffer: pointer to the buffer that receives the data read from 00189 * the EEPROM. 00190 * @param ReadAddr: EEPROM's internal address to start reading from. 00191 * @param NumByteToRead: pointer to the variable holding number of bytes to 00192 * be read from the EEPROM. 00193 * 00194 * @note The variable pointed by NumByteToRead is reset to 0 when all the 00195 * data are read from the EEPROM. Application should monitor this 00196 * variable in order know when the transfer is complete. 00197 * 00198 * @retval EEPROM_OK (0) if operation is correctly performed, else return value 00199 * different from EEPROM_OK (0) or the timeout user callback. 00200 */ 00201 uint32_t BSP_EEPROM_ReadBuffer(uint8_t* pBuffer, uint16_t ReadAddr, uint16_t* NumByteToRead) 00202 { 00203 uint32_t buffersize = *NumByteToRead; 00204 00205 /* Set the pointer to the Number of data to be read. This pointer will be used 00206 by the DMA Transfer Completer interrupt Handler in order to reset the 00207 variable to 0. User should check on this variable in order to know if the 00208 DMA transfer has been complete or not. */ 00209 EEPROMDataRead = *NumByteToRead; 00210 00211 if(EEPROM_IO_ReadData(EEPROMAddress, ReadAddr, pBuffer, buffersize) != HAL_OK) 00212 { 00213 BSP_EEPROM_TIMEOUT_UserCallback(); 00214 return EEPROM_FAIL; 00215 } 00216 00217 /* If all operations OK, return EEPROM_OK (0) */ 00218 return EEPROM_OK; 00219 } 00220 00221 /** 00222 * @brief Writes more than one byte to the EEPROM with a single WRITE cycle. 00223 * 00224 * @note The number of bytes (combined to write start address) must not 00225 * cross the EEPROM page boundary. This function can only write into 00226 * the boundaries of an EEPROM page. 00227 * This function doesn't check on boundaries condition (in this driver 00228 * the function BSP_EEPROM_WriteBuffer() which calls BSP_EEPROM_WritePage() is 00229 * responsible of checking on Page boundaries). 00230 * 00231 * @param pBuffer: pointer to the buffer containing the data to be written to 00232 * the EEPROM. 00233 * @param WriteAddr: EEPROM's internal address to write to. 00234 * @param NumByteToWrite: pointer to the variable holding number of bytes to 00235 * be written into the EEPROM. 00236 * 00237 * @note The variable pointed by NumByteToWrite is reset to 0 when all the 00238 * data are written to the EEPROM. Application should monitor this 00239 * variable in order know when the transfer is complete. 00240 * 00241 * @note This function just configure the communication and enable the DMA 00242 * channel to transfer data. Meanwhile, the user application may perform 00243 * other tasks in parallel. 00244 * 00245 * @retval EEPROM_OK (0) if operation is correctly performed, else return value 00246 * different from EEPROM_OK (0) or the timeout user callback. 00247 */ 00248 uint32_t BSP_EEPROM_WritePage(uint8_t* pBuffer, uint16_t WriteAddr, uint8_t* NumByteToWrite) 00249 { 00250 uint32_t buffersize = *NumByteToWrite; 00251 uint32_t status = EEPROM_OK; 00252 00253 /* Set the pointer to the Number of data to be written. This pointer will be used 00254 by the DMA Transfer Completer interrupt Handler in order to reset the 00255 variable to 0. User should check on this variable in order to know if the 00256 DMA transfer has been complete or not. */ 00257 EEPROMDataWrite = *NumByteToWrite; 00258 00259 if(EEPROM_IO_WriteData(EEPROMAddress, WriteAddr, pBuffer, buffersize) != HAL_OK) 00260 { 00261 BSP_EEPROM_TIMEOUT_UserCallback(); 00262 status = EEPROM_FAIL; 00263 } 00264 00265 if(BSP_EEPROM_WaitEepromStandbyState() != EEPROM_OK) 00266 { 00267 return EEPROM_FAIL; 00268 } 00269 00270 /* If all operations OK, return EEPROM_OK (0) */ 00271 return status; 00272 } 00273 00274 /** 00275 * @brief Writes buffer of data to the I2C EEPROM. 00276 * @param pBuffer: pointer to the buffer containing the data to be written 00277 * to the EEPROM. 00278 * @param WriteAddr: EEPROM's internal address to write to. 00279 * @param NumByteToWrite: number of bytes to write to the EEPROM. 00280 * @retval EEPROM_OK (0) if operation is correctly performed, else return value 00281 * different from EEPROM_OK (0) or the timeout user callback. 00282 */ 00283 uint32_t BSP_EEPROM_WriteBuffer(uint8_t *pBuffer, uint16_t WriteAddr, uint16_t NumByteToWrite) 00284 { 00285 uint16_t numofpage = 0, numofsingle = 0, count = 0; 00286 uint16_t addr = 0; 00287 uint8_t dataindex = 0; 00288 uint32_t status = EEPROM_OK; 00289 00290 addr = WriteAddr % EEPROM_PAGESIZE; 00291 count = EEPROM_PAGESIZE - addr; 00292 numofpage = NumByteToWrite / EEPROM_PAGESIZE; 00293 numofsingle = NumByteToWrite % EEPROM_PAGESIZE; 00294 00295 /* If WriteAddr is EEPROM_PAGESIZE aligned */ 00296 if(addr == 0) 00297 { 00298 /* If NumByteToWrite < EEPROM_PAGESIZE */ 00299 if(numofpage == 0) 00300 { 00301 /* Store the number of data to be written */ 00302 dataindex = numofsingle; 00303 /* Start writing data */ 00304 status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex)); 00305 if(status != EEPROM_OK) 00306 { 00307 return status; 00308 } 00309 } 00310 /* If NumByteToWrite > EEPROM_PAGESIZE */ 00311 else 00312 { 00313 while(numofpage--) 00314 { 00315 /* Store the number of data to be written */ 00316 dataindex = EEPROM_PAGESIZE; 00317 status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex)); 00318 if(status != EEPROM_OK) 00319 { 00320 return status; 00321 } 00322 00323 WriteAddr += EEPROM_PAGESIZE; 00324 pBuffer += EEPROM_PAGESIZE; 00325 } 00326 00327 if(numofsingle!=0) 00328 { 00329 /* Store the number of data to be written */ 00330 dataindex = numofsingle; 00331 status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex)); 00332 if(status != EEPROM_OK) 00333 { 00334 return status; 00335 } 00336 } 00337 } 00338 } 00339 /* If WriteAddr is not EEPROM_PAGESIZE aligned */ 00340 else 00341 { 00342 /* If NumByteToWrite < EEPROM_PAGESIZE */ 00343 if(numofpage== 0) 00344 { 00345 /* If the number of data to be written is more than the remaining space 00346 in the current page: */ 00347 if(NumByteToWrite > count) 00348 { 00349 /* Store the number of data to be written */ 00350 dataindex = count; 00351 /* Write the data contained in same page */ 00352 status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex)); 00353 if(status != EEPROM_OK) 00354 { 00355 return status; 00356 } 00357 00358 /* Store the number of data to be written */ 00359 dataindex = (NumByteToWrite - count); 00360 /* Write the remaining data in the following page */ 00361 status = BSP_EEPROM_WritePage((uint8_t*)(pBuffer + count), (WriteAddr + count), (uint8_t*)(&dataindex)); 00362 if(status != EEPROM_OK) 00363 { 00364 return status; 00365 } 00366 } 00367 else 00368 { 00369 /* Store the number of data to be written */ 00370 dataindex = numofsingle; 00371 status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex)); 00372 if(status != EEPROM_OK) 00373 { 00374 return status; 00375 } 00376 } 00377 } 00378 /* If NumByteToWrite > EEPROM_PAGESIZE */ 00379 else 00380 { 00381 NumByteToWrite -= count; 00382 numofpage = NumByteToWrite / EEPROM_PAGESIZE; 00383 numofsingle = NumByteToWrite % EEPROM_PAGESIZE; 00384 00385 if(count != 0) 00386 { 00387 /* Store the number of data to be written */ 00388 dataindex = count; 00389 status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex)); 00390 if(status != EEPROM_OK) 00391 { 00392 return status; 00393 } 00394 WriteAddr += count; 00395 pBuffer += count; 00396 } 00397 00398 while(numofpage--) 00399 { 00400 /* Store the number of data to be written */ 00401 dataindex = EEPROM_PAGESIZE; 00402 status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex)); 00403 if(status != EEPROM_OK) 00404 { 00405 return status; 00406 } 00407 WriteAddr += EEPROM_PAGESIZE; 00408 pBuffer += EEPROM_PAGESIZE; 00409 } 00410 if(numofsingle != 0) 00411 { 00412 /* Store the number of data to be written */ 00413 dataindex = numofsingle; 00414 status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex)); 00415 if(status != EEPROM_OK) 00416 { 00417 return status; 00418 } 00419 } 00420 } 00421 } 00422 00423 /* If all operations OK, return EEPROM_OK (0) */ 00424 return EEPROM_OK; 00425 } 00426 00427 /** 00428 * @brief Wait for EEPROM Standby state. 00429 * 00430 * @note This function allows to wait and check that EEPROM has finished the 00431 * last operation. It is mostly used after Write operation: after receiving 00432 * the buffer to be written, the EEPROM may need additional time to actually 00433 * perform the write operation. During this time, it doesn't answer to 00434 * I2C packets addressed to it. Once the write operation is complete 00435 * the EEPROM responds to its address. 00436 * 00437 * @retval EEPROM_OK (0) if operation is correctly performed, else return value 00438 * different from EEPROM_OK (0) or the timeout user callback. 00439 */ 00440 uint32_t BSP_EEPROM_WaitEepromStandbyState(void) 00441 { 00442 /* Check if the maximum allowed number of trials has bee reached */ 00443 if(EEPROM_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK) 00444 { 00445 /* If the maximum number of trials has been reached, exit the function */ 00446 BSP_EEPROM_TIMEOUT_UserCallback(); 00447 return EEPROM_TIMEOUT; 00448 } 00449 return EEPROM_OK; 00450 } 00451 00452 /** 00453 * @brief Basic management of the timeout situation. 00454 * @retval None 00455 */ 00456 __weak void BSP_EEPROM_TIMEOUT_UserCallback(void) 00457 { 00458 } 00459 00460 /** 00461 * @} 00462 */ 00463 00464 /** 00465 * @} 00466 */ 00467 00468 /** 00469 * @} 00470 */ 00471 00472 /** 00473 * @} 00474 */ 00475 00476 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Generated on Tue Jul 12 2022 17:55:04 by 1.7.2