UHSDR/UHSDR-active-devel/mchf-eclipse/misc/serial_eeprom.c

621 lines
21 KiB
C
Raw Normal View History

2022-11-08 16:13:55 +01:00
/* -*- mode: c; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4; coding: utf-8 -*- */
/************************************************************************************
** **
** mcHF QRP Transceiver **
** K Atanassov - M0NKA 2014 **
** **
**---------------------------------------------------------------------------------**
** **
** File name: **
** Description: **
** Last Modified: **
** Licence: GNU GPLv3 **
************************************************************************************/
// Common
#include "uhsdr_board.h"
#include "uhsdr_hw_i2c.h"
#include "serial_eeprom.h"
// for MAX_VAR_ADDR only
#include "ui_configuration.h"
typedef struct SerialEEPROM_Configuration
{
uint8_t device_type;
uint8_t use_type;
bool detection;
} SerialEEPROM_Configuration_t;
// static SerialEEPROM_Configuration_t ser_eeprom_config;
const SerialEEPROM_EEPROMTypeDescriptor SerialEEPROM_eepromTypeDescs[SERIAL_EEPROM_DESC_NUM] = {
// 0
{
.size = 0,
.supported = false,
.pagesize = 0,
.name = "No EEPROM"
},
// 1
{
.size = 0,
.supported = false,
.pagesize = 0,
.name = "Wrong Signature"
},
// 2
{
.size = 0,
.supported = false,
.pagesize = 0,
.name = "Unknown Type"
},
// 3
{
.size = 0,
.supported = false,
.pagesize = 0,
.name = "Not used"
},
// 4
{
.size = 0,
.supported = false,
.pagesize = 64,
.name = "Not used"
},
// 5
{
.size = 0,
.supported = false,
.pagesize = 0,
.name = "Not used"
},
// 6
{
.size = 0,
.supported = false,
.pagesize = 0,
.name = "Not used"
},
// 7
{
.size = 128,
.supported = false,
.pagesize = 8,
.name = "24xx01"
},
// 8
{
.size = 256,
.supported = false,
.pagesize = 8,
.name = "24xx02"
},
// 9
{
.size = 2*256,
.supported = false,
.pagesize = 16,
.name = "24xx04"
},
// 10
{
.size = 1*1024,
.supported = false,
.pagesize = 16,
.name = "24xx08"
},
// 11
{
.size = 2*1024,
.supported = false,
.pagesize = 16,
.name = "24xx16"
},
// 12
{
.size = 4*1024,
.supported = false,
.pagesize = 32,
.name = "24xx32"
},
// 13
{
.size = 8*1024,
.supported = false,
.pagesize = 32,
.name = "24xx64"
},
// 14
{
.size = 16*1024,
.supported = false,
.pagesize = 64,
.name = "24xx128"
},
// 15
{
.size = 32*1024,
.supported = true,
.pagesize = 64,
.name = "24xx256"
},
// 16
{
.size = 64*1024,
.supported = true,
.pagesize = 128,
.name = "24xx512"
},
// 17
{
.size = 128*1024,
.supported = true,
.pagesize = 128,
.name = "24xx1025"
},
// 18
{
.size = 128 * 1024,
.supported = true,
.pagesize = 128,
.name = "24xx1026/CM01"
},
// 19
{
.size = 256*1024,
.supported = true,
.pagesize = 256,
.name = "24CM02"
}
};
typedef struct
{
uint8_t devaddr;
uint16_t addr;
uint16_t addr_size;
} SerialEEPROM_24CXX_Descriptor;
static SerialEEPROM_24CXX_Descriptor serialEeprom_desc;
// THIS CAN BE USED ONLY WITH SINGLE EEPROM AND SINGLE THREAD
// NOT THREAD SAFE, USE local variable instead then
#define MEM_DEVICE_WRITE_ADDR 0xA0
// serial eeprom functions by DF8OE
static uint16_t SerialEEPROM_24Cxx_DeviceConnected(void)
{
uint16_t retVal = UhsdrHw_I2C_DeviceReady(&hi2c2,MEM_DEVICE_WRITE_ADDR);
return retVal;
}
static void SerialEEPROM_24Cxx_AdjustAddrs(const uint8_t Mem_Type, uint8_t* devaddr_ptr, uint32_t* Addr_ptr)
{
*devaddr_ptr = MEM_DEVICE_WRITE_ADDR;
if (*Addr_ptr > 0xFFFF) {
switch (Mem_Type)
{
case 17: // 24LC1025
*devaddr_ptr = MEM_DEVICE_WRITE_ADDR + 8; // 24LC1025
break;
case 18:
*devaddr_ptr = MEM_DEVICE_WRITE_ADDR + 2; // 24LC1026
break;
case 19: // 24CM02
*devaddr_ptr = MEM_DEVICE_WRITE_ADDR + ((*Addr_ptr & 0x30000) >> 15); // the upper bits 16 and 17 determine the I2C address offset
break;
}
*Addr_ptr &= 0xFFFF; // mask address to 16bits in all cases
}
}
static uint16_t SerialEEPROM_24Cxx_ackPolling(uint32_t Addr, uint8_t Mem_Type)
{
uint8_t devaddr;
SerialEEPROM_24Cxx_AdjustAddrs(Mem_Type,&devaddr,&Addr);
uint16_t retVal = UhsdrHw_I2C_DeviceReady(&hi2c2,devaddr); // != HAL_OK?0xFD00:0;
return retVal;
}
static void SerialEEPROM_24Cxx_StartTransfer_Prep(uint32_t Addr, uint8_t Mem_Type, SerialEEPROM_24CXX_Descriptor* eeprom_desc_ptr)
{
SerialEEPROM_24Cxx_AdjustAddrs(Mem_Type,&eeprom_desc_ptr->devaddr,&Addr);
eeprom_desc_ptr->addr = (uint16_t)((0xFFFF)&(Addr));
if (Mem_Type > 8)
{
eeprom_desc_ptr->addr_size = I2C_MEMADD_SIZE_16BIT;
}
else
{
eeprom_desc_ptr->addr_size = I2C_MEMADD_SIZE_8BIT;
}
}
uint16_t SerialEEPROM_24Cxx_Write(uint32_t Addr, uint8_t Data, uint8_t Mem_Type)
{
SerialEEPROM_24Cxx_StartTransfer_Prep(Addr, Mem_Type,&serialEeprom_desc);
uint16_t retVal = UhsdrHw_I2C_WriteRegister(SERIALEEPROM_I2C,serialEeprom_desc.devaddr,serialEeprom_desc.addr,serialEeprom_desc.addr_size,Data);
if (!retVal)
{
retVal = SerialEEPROM_24Cxx_ackPolling(Addr,Mem_Type);
}
return retVal;
}
uint16_t SerialEEPROM_24Cxx_Read(uint32_t Addr, uint8_t Mem_Type)
{
uint8_t value;
SerialEEPROM_24Cxx_StartTransfer_Prep(Addr, Mem_Type,&serialEeprom_desc);
uint16_t retVal = UhsdrHw_I2C_ReadRegister(SERIALEEPROM_I2C,serialEeprom_desc.devaddr,serialEeprom_desc.addr,serialEeprom_desc.addr_size,&value);
if (!retVal)
{
retVal = value;
}
return retVal;
}
uint16_t SerialEEPROM_24Cxx_ReadBulk(uint32_t Addr, uint8_t *buffer, uint16_t length, uint8_t Mem_Type)
{
uint16_t retVal = 0xFFFF;
if (Mem_Type < SERIAL_EEPROM_DESC_NUM) {
uint32_t page, count;
count = 0;
page =SerialEEPROM_eepromTypeDescs[Mem_Type].pagesize;
while(count < length)
{
if (length - count < page)
{
// make sure we do not read more than asked for! Buffer Overflow!
page = (length - count);
}
SerialEEPROM_24Cxx_StartTransfer_Prep(Addr + count, Mem_Type,&serialEeprom_desc);
retVal = UhsdrHw_I2C_ReadBlock(SERIALEEPROM_I2C,serialEeprom_desc.devaddr,serialEeprom_desc.addr,serialEeprom_desc.addr_size,&buffer[count],page);
count+=page;
if (retVal)
{
break;
}
}
}
return retVal;
}
/**
* Write a consecutive area of memory into the I2C eeprom starting with Addr.
* @param Addr the location of the first byte in the eeprom. May have any value within the memory size of the eeprom
* @param buffer memory to copy from
* @param length how many bytes to copy
* @param Mem_Type which eeprom type are we having
* @return 0 if success, I2C error code otherwise
*/
uint16_t SerialEEPROM_24Cxx_WriteBulk(uint32_t Addr, const uint8_t *buffer, uint16_t length, uint8_t Mem_Type)
{
uint16_t retVal = 0;
if (Mem_Type < SERIAL_EEPROM_DESC_NUM) {
uint32_t count = 0;
const uint32_t page = SerialEEPROM_eepromTypeDescs[Mem_Type].pagesize;
while(retVal == 0 && count < length)
{
SerialEEPROM_24Cxx_StartTransfer_Prep(Addr + count, Mem_Type,&serialEeprom_desc);
uint32_t transfer_size = page;
// correct the transfer_size to keep inside a single page
// if the start address is not on a page boundary
// this will happen only for the first bulkd write (if at all)
// then the Addr + count will be aligned on page boundaries
transfer_size -= ((Addr+count) % page);
if (length - count < transfer_size)
{
transfer_size = length - count;
}
retVal = UhsdrHw_I2C_WriteBlock(SERIALEEPROM_I2C,serialEeprom_desc.devaddr,serialEeprom_desc.addr,serialEeprom_desc.addr_size,&buffer[count],transfer_size);
count+=transfer_size;
if (retVal)
{
break;
}
retVal = SerialEEPROM_24Cxx_ackPolling(Addr,Mem_Type);
}
}
return retVal;
}
/**
* @brief in general a non-destructive probing to identify the used EEPROM, in some cases devices are written (and changed data restored)
* this code uses hardware properties to identify the connected I2C eeprom, no previously signature etc. used or required
* @returns identified eeprom chip type or EEPROM_SER_UNKNOWN
*/
static uint8_t SerialEEPROM_24Cxx_DetectProbeHardware(void)
{
uint8_t ser_eeprom_type = EEPROM_SER_UNKNOWN;
const uint8_t testsignatureA = 0x66;
const uint8_t testsignatureB = 0x77; // has to be different from testsignature 1
const uint16_t testaddr1 = 0x0001;
const uint16_t testaddr1plus128 = testaddr1 + 0x80;
// 8 Bit Test First
uint16_t test8Byte1 = SerialEEPROM_24Cxx_Read(testaddr1,8);
// first decide if 8 or 16 bit addressable eeprom by trying to read with 8 or 16 bit algorithm
// if an algorithm succeeds we know the address width
if(test8Byte1 < 0x100)
{
// 8 bit addressing
uint16_t test8Byte2 = SerialEEPROM_24Cxx_Read(testaddr1plus128,8);
SerialEEPROM_24Cxx_Write(testaddr1,testsignatureB,8);
SerialEEPROM_24Cxx_Write(testaddr1plus128,testsignatureB,8);
if (SerialEEPROM_24Cxx_Read(testaddr1,8) == testsignatureB)
{
SerialEEPROM_24Cxx_Write(testaddr1,testsignatureA,8); // write test signature
ser_eeprom_type = 7; // smallest possible 8 bit EEPROM (128Bytes)
if(SerialEEPROM_24Cxx_Read(testaddr1plus128,8) == testsignatureB)
{
ser_eeprom_type = 8;
}
}
SerialEEPROM_24Cxx_Write(testaddr1,test8Byte1,8); // write back old data
SerialEEPROM_24Cxx_Write(testaddr1plus128,test8Byte2,8);
}
if (ser_eeprom_type == EEPROM_SER_UNKNOWN)
{
// 16 bit addressing check
// the other banks are mapped to different I2C
// device addresses. We simply try to read from them
// and if it succeeds we know the device type
// We need to check unique addresses for each EEPROM type
// 0xA0 + 0x10000: 0xA8
if(SerialEEPROM_24Cxx_Read(0x10000,17) < 0x100)
{
ser_eeprom_type = 17; // 24LC1025
}
// 0xA0 + 0x10000: 0xA2
if(SerialEEPROM_24Cxx_Read(0x10000,18) < 0x100)
{
ser_eeprom_type = 18; // 24LC1026
}
// 0xA0 + 0x10000: 0xA2 + 0x20000: 0xA4 + 0x30000: 0xA6
if(SerialEEPROM_24Cxx_Read(0x20000,19) < 0x100)
{
ser_eeprom_type = 19; // 24CM02
}
// it is not a large EEPROM (i.e. >64KB Data)
//
// the following test requires writing to EEPROM,
// we remember content of test locations
// and write them back later
if(ser_eeprom_type == EEPROM_SER_UNKNOWN)
{
const uint16_t testaddr1plus256 = 0x0100 + testaddr1; // same as before but 0x100 == 256 byte spacing
uint16_t testByte1 = SerialEEPROM_24Cxx_Read(testaddr1,16); // read old content
uint16_t testByte2 = SerialEEPROM_24Cxx_Read(testaddr1plus256,16); // of test bytes
if (testByte1 < 0x100 && testByte2 < 0x100) {
// successful read from both locations, let us start
SerialEEPROM_24Cxx_Write(testaddr1, testsignatureA,16); // write testsignature 1
SerialEEPROM_24Cxx_Write(testaddr1plus256, testsignatureB,16); // write testsignature 2
if(SerialEEPROM_24Cxx_Read(testaddr1,16) == testsignatureA && SerialEEPROM_24Cxx_Read(testaddr1plus256,16) == testsignatureB)
{
// 16 bit addressing
ser_eeprom_type = 9; // smallest possible 16 bit EEPROM
// we look for the "looping" in data, i.e. we read back 0x66
// which we wrote to address 0x0003
// from a address we did not wrote it to
// once it occurs, we know the size of the EEPROM
// since all of these EEPROMS are ignoring the unused bits in the address
for (int shift = 0; shift < 8; shift++) {
uint16_t shift_test_addr = (0x200 << shift)+testaddr1;
if(SerialEEPROM_24Cxx_Read(shift_test_addr,16) == testsignatureA) {
// now we write test signature 2 to make sure the match was no accident
// i.e. match with same content in EEPROM
SerialEEPROM_24Cxx_Write(shift_test_addr,testsignatureB,16);
if(SerialEEPROM_24Cxx_Read(testaddr1,16) == testsignatureB) {
// we found the looping,
// now stop checking and set EEPROM type
ser_eeprom_type = 9 + shift;
break;
}
else
{
// oops: just an accident, so we write back old content and continue
SerialEEPROM_24Cxx_Write(shift_test_addr,testsignatureA,16);
}
}
}
}
SerialEEPROM_24Cxx_Write(testaddr1,testByte1,16); // write back old data
SerialEEPROM_24Cxx_Write(testaddr1plus256,testByte2,16);
}
}
}
return ser_eeprom_type;
}
static void SerialEEPROM_Read_Signature(uint8_t ser_eeprom_type, uint16_t* type_p, uint16_t* state_p)
{
*type_p = SerialEEPROM_24Cxx_Read(0,ser_eeprom_type);
*state_p = SerialEEPROM_24Cxx_Read(1,ser_eeprom_type);
}
uint16_t SerialEEPROM_Set_UseStateInSignature(uint8_t state)
{
return SerialEEPROM_24Cxx_Write(1,SER_EEPROM_IN_USE,ts.ser_eeprom_type);
}
uint16_t SerialEEPROM_Get_UseStateInSignature()
{
return SerialEEPROM_24Cxx_Read(1,ts.ser_eeprom_type);
}
uint8_t SerialEEPROM_Detect() {
uint16_t ser_eeprom_type = EEPROM_SER_UNKNOWN;
// serial EEPROM init
if(SerialEEPROM_24Cxx_DeviceConnected() != HAL_OK || SerialEEPROM_24xx_Exists() == false) // Issue with Ser EEPROM, either not available or other problems
{
ser_eeprom_type = EEPROM_SER_NONE; // no serial EEPROM available
}
else
{
// this initial read will bring us the first byte of any eeprom (8 or 16bits)
// if we read anything but the 0xff == SER_EERPM_NOT_IN_USE value which indicates empty eeprom
// we assume some configuration information tells us what EEPROM we have and how it is used
if(SerialEEPROM_24Cxx_Read(0,16) != SER_EEPROM_NOT_IN_USE)
{
ser_eeprom_type = EEPROM_SER_WRONG_SIG;
// unless we find a correct signature, we have to assume the EEPROM has incorrect/corrupted data
uint16_t ser_eeprom_type_read;
uint16_t ser_eeprom_sig;
SerialEEPROM_Read_Signature(8, &ser_eeprom_type_read, &ser_eeprom_sig);
// all 8 bit (i.e. 256 or 128 Byte) EEPROMS are marked as "too small" during detection
if(ser_eeprom_sig == SER_EEPROM_TOO_SMALL && ser_eeprom_type_read >= SERIAL_EEPROM_DESC_REAL && ser_eeprom_type_read < 9)
{
ser_eeprom_type = ser_eeprom_type_read;
}
else
{
SerialEEPROM_Read_Signature(16, &ser_eeprom_type_read, &ser_eeprom_sig);
// we either have a new EEPROM, just being initialized ( ser_eeprom_sig = SER_EEPROM_NOT_IN_USE && valid type) or
// we have an used EEPROM (ser_eeprom_sig = SER_EEPROM_IN_USE && valid type)
// please note, that even though no 16 bit EEPROM gets the "too small" signature written in, these may still be
// consider too small by the later code. Only EEPROMS which have the "supported" flag set in the descriptor will
// be consider of sufficient size for actual use
if((ser_eeprom_sig == SER_EEPROM_IN_USE || ser_eeprom_sig == SER_EEPROM_NOT_IN_USE) && ser_eeprom_type_read < SERIAL_EEPROM_DESC_NUM && ser_eeprom_type_read > 8)
{
ser_eeprom_type = ser_eeprom_type_read;
}
}
}
else
{
ser_eeprom_type = SerialEEPROM_24Cxx_DetectProbeHardware();
if (ser_eeprom_type >= SERIAL_EEPROM_DESC_REAL && ser_eeprom_type < SERIAL_EEPROM_DESC_NUM)
{
SerialEEPROM_24Cxx_Write(0,ser_eeprom_type,ser_eeprom_type);
if (SerialEEPROM_eepromTypeDescs[ser_eeprom_type].supported == false)
{
SerialEEPROM_24Cxx_Write(1,SER_EEPROM_TOO_SMALL,ser_eeprom_type);
}
}
}
// just to be save. Never ever deliver a type id outside the array boundaries.
if (ser_eeprom_type >= SERIAL_EEPROM_DESC_NUM)
{
ser_eeprom_type = EEPROM_SER_UNKNOWN;
}
}
return ser_eeprom_type;
}
static void SerialEEPROM_Clear_Variable(uint16_t addr)
{
const uint8_t empty_var[2] = { 0xff, 0xff };
SerialEEPROM_24Cxx_WriteBulk(addr*2, empty_var,2, ts.ser_eeprom_type);
}
void SerialEEPROM_Clear_AllVariables()
{
// variable 0 is the reserved signature variable
for(uint16_t count=1; count <= MAX_VAR_ADDR; count++)
{
SerialEEPROM_Clear_Variable(count);
}
}
void SerialEEPROM_Clear_Signature()
{
// variable 0 is the reserved signature variable
ts.ser_eeprom_type = SerialEEPROM_24Cxx_DetectProbeHardware();
SerialEEPROM_Clear_Variable(0);
}
bool SerialEEPROM_24xx_Exists()
{
return SerialEEPROM_24Cxx_Read(0,8) < 0x100;
}
//
// Interface for serial EEPROM functions
//
uint16_t SerialEEPROM_ReadVariable(uint16_t addr, uint16_t *value) // reference to serial EEPROM read function
{
uint8_t bytes[2];
uint16_t retval = SerialEEPROM_24Cxx_ReadBulk(addr*2,bytes, 2, ts.ser_eeprom_type);
if (retval == HAL_OK)
{
*value = ((uint16_t)bytes[0])<<8;
*value |= bytes[1];
}
return retval;
}
uint16_t SerialEEPROM_UpdateVariable(uint16_t addr, uint16_t value)
{
uint16_t value_read = 0;
uint16_t retval = SerialEEPROM_ReadVariable(addr,&value_read);
if (retval != 0 || value_read != value )
{
retval = SerialEEPROM_WriteVariable(addr,value);
}
return retval;
}
uint16_t SerialEEPROM_WriteVariable(uint16_t addr, uint16_t value) // reference to serial EEPROM write function, writing unsigned 16 bit
{
uint8_t bytes[2];
bytes[0] = (uint8_t)((value&(0xFF00))>>8);
bytes[1] = (uint8_t)(value&(0x00FF));
return SerialEEPROM_24Cxx_WriteBulk(addr*2, bytes, 2, ts.ser_eeprom_type);
}