Files
edgetx-gx12/radio/src/targets/taranis/eeprom_driver.cpp
T

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;
}