172 lines
4.4 KiB
C++
172 lines
4.4 KiB
C++
/*
|
|
* Copyright (C) EdgeTX
|
|
*
|
|
* Based on code named
|
|
* opentx - https://github.com/opentx/opentx
|
|
* th9x - http://code.google.com/p/th9x
|
|
* er9x - http://code.google.com/p/er9x
|
|
* gruvin9x - http://code.google.com/p/gruvin9x
|
|
*
|
|
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
#include "stm32_hal_ll.h"
|
|
#include "stm32_hal.h"
|
|
#include "stm32_i2c_driver.h"
|
|
#include "hal.h"
|
|
|
|
#include "hal/eeprom_driver.h"
|
|
|
|
static int enable_wp_clock(GPIO_TypeDef *GPIOx)
|
|
{
|
|
if (GPIOx == GPIOB)
|
|
__HAL_RCC_GPIOB_CLK_ENABLE();
|
|
else if (GPIOx == GPIOD)
|
|
__HAL_RCC_GPIOD_CLK_ENABLE();
|
|
else if (GPIOx == GPIOF)
|
|
__HAL_RCC_GPIOF_CLK_ENABLE();
|
|
else
|
|
return -1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void init_wp_pin()
|
|
{
|
|
enable_wp_clock(EEPROM_WP_GPIO);
|
|
|
|
LL_GPIO_InitTypeDef pinInit;
|
|
LL_GPIO_StructInit(&pinInit);
|
|
|
|
pinInit.Pin = EEPROM_WP_GPIO_PIN;
|
|
pinInit.Speed = LL_GPIO_SPEED_FREQ_LOW;
|
|
pinInit.Mode = LL_GPIO_MODE_OUTPUT;
|
|
pinInit.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;
|
|
pinInit.Pull = LL_GPIO_PULL_UP;
|
|
LL_GPIO_Init(EEPROM_WP_GPIO, &pinInit);
|
|
|
|
// Enable write operations on EEPROM
|
|
LL_GPIO_ResetOutputPin(EEPROM_WP_GPIO, EEPROM_WP_GPIO_PIN);
|
|
}
|
|
|
|
void eepromInit()
|
|
{
|
|
stm32_i2c_deinit(EEPROM_I2C_BUS);
|
|
stm32_i2c_init(EEPROM_I2C_BUS, I2C_B1_CLK_RATE);
|
|
init_wp_pin();
|
|
}
|
|
|
|
/**
|
|
* @brief Wait for EEPROM Standby state
|
|
* @param None
|
|
* @retval None
|
|
*/
|
|
static bool I2C_EE_WaitEepromStandbyState(void)
|
|
{
|
|
if (stm32_i2c_is_dev_ready(EEPROM_I2C_BUS, EEPROM_I2C_ADDRESS, 20 /* 20ms */) < 0)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static void eepromWaitEepromStandbyState(void)
|
|
{
|
|
// TODO: seriously? no timeout, no bailout ???
|
|
while (!I2C_EE_WaitEepromStandbyState()) {
|
|
eepromInit();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Reads a block of data from the EEPROM.
|
|
* @param pBuffer : pointer to the buffer that receives the data read
|
|
* from the EEPROM.
|
|
* @param ReadAddr : EEPROM's internal address to read from.
|
|
* @param NumByteToRead : number of bytes to read from the EEPROM.
|
|
* @retval None
|
|
*/
|
|
static bool I2C_EE_ReadBlock(uint8_t* pBuffer, uint16_t ReadAddr, uint16_t NumByteToRead)
|
|
{
|
|
if (stm32_i2c_read(EEPROM_I2C_BUS, EEPROM_I2C_ADDRESS, ReadAddr, 1,
|
|
pBuffer, NumByteToRead, 100) < 0) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void eepromReadBlock(uint8_t * buffer, size_t address, size_t size)
|
|
{
|
|
while (!I2C_EE_ReadBlock(buffer, address, size)) {
|
|
eepromInit();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Writes more than one byte to the EEPROM with a single WRITE cycle.
|
|
* @note The number of byte can't exceed the EEPROM page size.
|
|
* @param pBuffer : pointer to the buffer containing the data to be
|
|
* written to the EEPROM.
|
|
* @param WriteAddr : EEPROM's internal address to write to.
|
|
* @param NumByteToWrite : number of bytes to write to the EEPROM.
|
|
* @retval None
|
|
*/
|
|
static bool I2C_EE_PageWrite(uint8_t * pBuffer, uint16_t WriteAddr, uint8_t NumByteToWrite)
|
|
{
|
|
if (stm32_i2c_write(EEPROM_I2C_BUS, EEPROM_I2C_ADDRESS, WriteAddr, 1,
|
|
pBuffer, NumByteToWrite, 100) < 0) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void eepromPageWrite(uint8_t* pBuffer, uint16_t WriteAddr, uint8_t NumByteToWrite)
|
|
{
|
|
while (!I2C_EE_PageWrite(pBuffer, WriteAddr, NumByteToWrite)) {
|
|
eepromInit();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Writes buffer of data to the I2C EEPROM.
|
|
* @param buffer : pointer to the buffer containing the data to be
|
|
* written to the EEPROM.
|
|
* @param address : EEPROM's internal address to write to.
|
|
* @param size : number of bytes to write to the EEPROM.
|
|
* @retval None
|
|
*/
|
|
void eepromWriteBlock(uint8_t * buffer, size_t address, size_t size)
|
|
{
|
|
uint8_t offset = address % EEPROM_PAGESIZE;
|
|
uint8_t count = EEPROM_PAGESIZE - offset;
|
|
if (size < count) {
|
|
count = size;
|
|
}
|
|
while (count > 0) {
|
|
eepromPageWrite(buffer, address, count);
|
|
eepromWaitEepromStandbyState();
|
|
address += count;
|
|
buffer += count;
|
|
size -= count;
|
|
count = EEPROM_PAGESIZE;
|
|
if (size < EEPROM_PAGESIZE) {
|
|
count = size;
|
|
}
|
|
}
|
|
}
|
|
|
|
uint8_t eepromIsTransferComplete()
|
|
{
|
|
return 1;
|
|
}
|