stm32746g_discovery_eeprom.c

00001 /**
00002   ******************************************************************************
00003   * @file    stm32746g_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 STM32746G_DISCOVERY
00015                 board.
00016                 To use this driver you have to connect the ANT7-M24LR-A to CN3 
00017                 connector of STM32746G_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 stm32746g_discovery.h file, and the initialization is
00023              performed in EEPROM_IO_Init() function declared in stm32746g_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>&copy; 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 - stm32746g_discovery.c
00089 EndDependencies */
00090 
00091 /* Includes ------------------------------------------------------------------*/
00092 #include "stm32746g_discovery_eeprom.h"
00093 
00094 /** @addtogroup BSP
00095   * @{
00096   */
00097   
00098 /** @addtogroup STM32746G_DISCOVERY
00099   * @{
00100   */ 
00101   
00102 /** @addtogroup STM32746G_DISCOVERY_EEPROM
00103   * @brief This file includes the I2C EEPROM driver of STM32746G-Discovery board.
00104   * @{
00105   */ 
00106 
00107 /** @defgroup STM32746G_DISCOVERY_EEPROM_Private_Types STM32746G_DISCOVERY_EEPROM Private Types
00108   * @{
00109   */ 
00110 /**
00111   * @}
00112   */ 
00113 
00114 /** @defgroup STM32746G_DISCOVERY_EEPROM_Private_Defines STM32746G_DISCOVERY_EEPROM Private Defines
00115   * @{
00116   */  
00117 /**
00118   * @}
00119   */ 
00120 
00121 /** @defgroup STM32746G_DISCOVERY_EEPROM_Private_Macros STM32746G_DISCOVERY_EEPROM Private Macros
00122   * @{
00123   */
00124 /**
00125   * @}
00126   */ 
00127   
00128 /** @defgroup STM32746G_DISCOVERY_EEPROM_Private_Variables STM32746G_DISCOVERY_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 STM32746G_DISCOVERY_EEPROM_Private_Function_Prototypes STM32746G_DISCOVERY_EEPROM Private Function Prototypes
00139   * @{
00140   */ 
00141 /**
00142   * @}
00143   */ 
00144 
00145 /** @defgroup STM32746G_DISCOVERY_EEPROM_Exported_Functions STM32746G_DISCOVERY_EEPROM Exported Functions
00146   * @{
00147   */ 
00148 
00149 /**
00150   * @brief  Initializes peripherals used by the I2C EEPROM driver.
00151   * 
00152   * @note   There are 2 different versions of M24LR64 (A01 & A02).
00153   *             Then try to connect on 1st one (EEPROM_I2C_ADDRESS_A01) 
00154   *             and if problem, check the 2nd one (EEPROM_I2C_ADDRESS_A02)
00155   * @retval EEPROM_OK (0) if operation is correctly performed, else return value 
00156   *         different from EEPROM_OK (0)
00157   */
00158 uint32_t BSP_EEPROM_Init(void)
00159 { 
00160   /* I2C Initialization */
00161   EEPROM_IO_Init();
00162   
00163   /* Select the EEPROM address for A01 and check if OK */
00164   EEPROMAddress = EEPROM_I2C_ADDRESS_A01;
00165   if(EEPROM_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK) 
00166   {
00167     /* Select the EEPROM address for A02 and check if OK */
00168     EEPROMAddress = EEPROM_I2C_ADDRESS_A02;
00169     if(EEPROM_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK)
00170     {
00171       return EEPROM_FAIL;
00172     }
00173   }
00174   return EEPROM_OK;
00175 }
00176 
00177 /**
00178   * @brief  DeInitializes the EEPROM.
00179   * @retval EEPROM state
00180   */
00181 uint8_t BSP_EEPROM_DeInit(void)
00182 { 
00183   /* I2C won't be disabled because common to other functionalities */
00184   return EEPROM_OK;
00185 }
00186 
00187 /**
00188   * @brief  Reads a block of data from the EEPROM.
00189   * @param  pBuffer: pointer to the buffer that receives the data read from 
00190   *         the EEPROM.
00191   * @param  ReadAddr: EEPROM's internal address to start reading from.
00192   * @param  NumByteToRead: pointer to the variable holding number of bytes to 
00193   *         be read from the EEPROM.
00194   * 
00195   *        @note The variable pointed by NumByteToRead is reset to 0 when all the 
00196   *              data are read from the EEPROM. Application should monitor this 
00197   *              variable in order know when the transfer is complete.
00198   * 
00199   * @retval EEPROM_OK (0) if operation is correctly performed, else return value 
00200   *         different from EEPROM_OK (0) or the timeout user callback.
00201   */
00202 uint32_t BSP_EEPROM_ReadBuffer(uint8_t* pBuffer, uint16_t ReadAddr, uint16_t* NumByteToRead)
00203 {  
00204   uint32_t buffersize = *NumByteToRead;
00205   
00206   /* Set the pointer to the Number of data to be read. This pointer will be used 
00207      by the DMA Transfer Completer interrupt Handler in order to reset the 
00208      variable to 0. User should check on this variable in order to know if the 
00209      DMA transfer has been complete or not. */
00210   EEPROMDataRead = *NumByteToRead;
00211   
00212   if(EEPROM_IO_ReadData(EEPROMAddress, ReadAddr, pBuffer, buffersize) != HAL_OK)
00213   {
00214     BSP_EEPROM_TIMEOUT_UserCallback();
00215     return EEPROM_FAIL;
00216   }
00217 
00218   /* If all operations OK, return EEPROM_OK (0) */
00219   return EEPROM_OK;
00220 }
00221 
00222 /**
00223   * @brief  Writes more than one byte to the EEPROM with a single WRITE cycle.
00224   *
00225   * @note   The number of bytes (combined to write start address) must not 
00226   *         cross the EEPROM page boundary. This function can only write into
00227   *         the boundaries of an EEPROM page.
00228   *         This function doesn't check on boundaries condition (in this driver 
00229   *         the function BSP_EEPROM_WriteBuffer() which calls BSP_EEPROM_WritePage() is 
00230   *         responsible of checking on Page boundaries).
00231   * 
00232   * @param  pBuffer: pointer to the buffer containing the data to be written to 
00233   *         the EEPROM.
00234   * @param  WriteAddr: EEPROM's internal address to write to.
00235   * @param  NumByteToWrite: pointer to the variable holding number of bytes to 
00236   *         be written into the EEPROM. 
00237   * 
00238   *        @note The variable pointed by NumByteToWrite is reset to 0 when all the 
00239   *              data are written to the EEPROM. Application should monitor this 
00240   *              variable in order know when the transfer is complete.
00241   * 
00242   *        @note This function just configure the communication and enable the DMA 
00243   *              channel to transfer data. Meanwhile, the user application may perform 
00244   *              other tasks in parallel.
00245   * 
00246   * @retval EEPROM_OK (0) if operation is correctly performed, else return value 
00247   *         different from EEPROM_OK (0) or the timeout user callback.
00248   */
00249 uint32_t BSP_EEPROM_WritePage(uint8_t* pBuffer, uint16_t WriteAddr, uint8_t* NumByteToWrite)
00250 { 
00251   uint32_t buffersize = *NumByteToWrite;
00252   uint32_t status = EEPROM_OK;
00253   
00254   /* Set the pointer to the Number of data to be written. This pointer will be used 
00255       by the DMA Transfer Completer interrupt Handler in order to reset the 
00256       variable to 0. User should check on this variable in order to know if the 
00257       DMA transfer has been complete or not. */
00258   EEPROMDataWrite = *NumByteToWrite;  
00259   
00260   if(EEPROM_IO_WriteData(EEPROMAddress, WriteAddr, pBuffer, buffersize) != HAL_OK)
00261   {
00262     BSP_EEPROM_TIMEOUT_UserCallback();
00263     status = EEPROM_FAIL;
00264   }
00265   
00266   if(BSP_EEPROM_WaitEepromStandbyState() != EEPROM_OK) 
00267   {
00268     return EEPROM_FAIL;
00269   }
00270   
00271   /* If all operations OK, return EEPROM_OK (0) */
00272   return status;
00273 }
00274 
00275 /**
00276   * @brief  Writes buffer of data to the I2C EEPROM.
00277   * @param  pBuffer: pointer to the buffer  containing the data to be written 
00278   *         to the EEPROM.
00279   * @param  WriteAddr: EEPROM's internal address to write to.
00280   * @param  NumByteToWrite: number of bytes to write to the EEPROM.
00281   * @retval EEPROM_OK (0) if operation is correctly performed, else return value 
00282   *         different from EEPROM_OK (0) or the timeout user callback.
00283   */
00284 uint32_t BSP_EEPROM_WriteBuffer(uint8_t *pBuffer, uint16_t WriteAddr, uint16_t NumByteToWrite)
00285 {
00286   uint16_t numofpage = 0, numofsingle = 0, count = 0;
00287   uint16_t addr = 0;
00288   uint8_t  dataindex = 0;
00289   uint32_t status = EEPROM_OK;
00290 
00291   addr = WriteAddr % EEPROM_PAGESIZE;
00292   count = EEPROM_PAGESIZE - addr;
00293   numofpage =  NumByteToWrite / EEPROM_PAGESIZE;
00294   numofsingle = NumByteToWrite % EEPROM_PAGESIZE;
00295  
00296   /* If WriteAddr is EEPROM_PAGESIZE aligned */
00297   if(addr == 0) 
00298   {
00299     /* If NumByteToWrite < EEPROM_PAGESIZE */
00300     if(numofpage == 0) 
00301     {
00302       /* Store the number of data to be written */
00303       dataindex = numofsingle;
00304       /* Start writing data */
00305       status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex));
00306       if(status != EEPROM_OK)
00307       {
00308         return status;
00309       }
00310     }
00311     /* If NumByteToWrite > EEPROM_PAGESIZE */
00312     else  
00313     {
00314       while(numofpage--)
00315       {
00316         /* Store the number of data to be written */
00317         dataindex = EEPROM_PAGESIZE;        
00318         status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex));
00319         if(status != EEPROM_OK)
00320         {
00321           return status;
00322         }
00323         
00324         WriteAddr +=  EEPROM_PAGESIZE;
00325         pBuffer += EEPROM_PAGESIZE;
00326       }
00327       
00328       if(numofsingle!=0)
00329       {
00330         /* Store the number of data to be written */
00331         dataindex = numofsingle;          
00332         status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex));
00333         if(status != EEPROM_OK)
00334         {
00335           return status;
00336         }
00337       }
00338     }
00339   }
00340   /* If WriteAddr is not EEPROM_PAGESIZE aligned */
00341   else 
00342   {
00343     /* If NumByteToWrite < EEPROM_PAGESIZE */
00344     if(numofpage== 0) 
00345     {
00346       /* If the number of data to be written is more than the remaining space 
00347       in the current page: */
00348       if(NumByteToWrite > count)
00349       {
00350         /* Store the number of data to be written */
00351         dataindex = count;        
00352         /* Write the data contained in same page */
00353         status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex));
00354         if(status != EEPROM_OK)
00355         {
00356           return status;
00357         }
00358         
00359         /* Store the number of data to be written */
00360         dataindex = (NumByteToWrite - count);          
00361         /* Write the remaining data in the following page */
00362         status = BSP_EEPROM_WritePage((uint8_t*)(pBuffer + count), (WriteAddr + count), (uint8_t*)(&dataindex));
00363         if(status != EEPROM_OK)
00364         {
00365           return status;
00366         }
00367       }      
00368       else      
00369       {
00370         /* Store the number of data to be written */
00371         dataindex = numofsingle;         
00372         status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex));
00373         if(status != EEPROM_OK)
00374         {
00375           return status;
00376         }
00377       }     
00378     }
00379     /* If NumByteToWrite > EEPROM_PAGESIZE */
00380     else
00381     {
00382       NumByteToWrite -= count;
00383       numofpage =  NumByteToWrite / EEPROM_PAGESIZE;
00384       numofsingle = NumByteToWrite % EEPROM_PAGESIZE;
00385       
00386       if(count != 0)
00387       {  
00388         /* Store the number of data to be written */
00389         dataindex = count;         
00390         status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex));
00391         if(status != EEPROM_OK)
00392         {
00393           return status;
00394         }
00395         WriteAddr += count;
00396         pBuffer += count;
00397       } 
00398       
00399       while(numofpage--)
00400       {
00401         /* Store the number of data to be written */
00402         dataindex = EEPROM_PAGESIZE;          
00403         status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex));
00404         if(status != EEPROM_OK)
00405         {
00406           return status;
00407         }
00408         WriteAddr +=  EEPROM_PAGESIZE;
00409         pBuffer += EEPROM_PAGESIZE;  
00410       }
00411       if(numofsingle != 0)
00412       {
00413         /* Store the number of data to be written */
00414         dataindex = numofsingle;           
00415         status = BSP_EEPROM_WritePage(pBuffer, WriteAddr, (uint8_t*)(&dataindex));
00416         if(status != EEPROM_OK)
00417         {
00418           return status;
00419         }
00420       }
00421     }
00422   }  
00423                                    
00424   /* If all operations OK, return EEPROM_OK (0) */
00425   return EEPROM_OK;
00426 }
00427 
00428 /**
00429   * @brief  Wait for EEPROM Standby state.
00430   * 
00431   * @note  This function allows to wait and check that EEPROM has finished the 
00432   *        last operation. It is mostly used after Write operation: after receiving
00433   *        the buffer to be written, the EEPROM may need additional time to actually
00434   *        perform the write operation. During this time, it doesn't answer to
00435   *        I2C packets addressed to it. Once the write operation is complete
00436   *        the EEPROM responds to its address.
00437   * 
00438   * @retval EEPROM_OK (0) if operation is correctly performed, else return value 
00439   *         different from EEPROM_OK (0) or the timeout user callback.
00440   */
00441 uint32_t BSP_EEPROM_WaitEepromStandbyState(void)      
00442 {
00443   /* Check if the maximum allowed number of trials has bee reached */
00444   if(EEPROM_IO_IsDeviceReady(EEPROMAddress, EEPROM_MAX_TRIALS) != HAL_OK)
00445   {
00446     /* If the maximum number of trials has been reached, exit the function */
00447     BSP_EEPROM_TIMEOUT_UserCallback();
00448     return EEPROM_TIMEOUT;
00449   }
00450   return EEPROM_OK;
00451 }
00452 
00453 /**
00454   * @brief  Basic management of the timeout situation.
00455   * @retval None
00456   */
00457 __weak void BSP_EEPROM_TIMEOUT_UserCallback(void)
00458 {
00459 }
00460 
00461 /**
00462   * @}
00463   */
00464 
00465 /**
00466   * @}
00467   */
00468 
00469 /**
00470   * @}
00471   */
00472 
00473 /**
00474   * @}
00475   */
00476 
00477 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/