eeprom.c

Go to the documentation of this file.

//////////////////////////////////////////////////////////////////////////////////
/// \file heivs/eeprom.c
/// \brief ARMEBS4 eeprom access functions
/// \author Pascal Sartoretti (sap at hevs dot ch)
//////////////////////////////////////////////////////////////////////////////////
#include "heivs/eeprom.h"
#include "heivs/stm32_i2c.h"
#include "heivs/delay.h"

// address of I2C EEPROM 24LC64 mounted on ARMEBS4
#define ADDR_24LC64         0x50
#define PAGE_SIZE_24LC64    32U
#define SIZE_24LC64         8192U

//////////////////////////////////////////////////////////////////////////////////
/// \brief Structure of the eeprom
//////////////////////////////////////////////////////////////////////////////////
#define MAGIC_NUMBER    0xAA55AA55
#define EEPROM_VERSION  0x00000100

/**
 * \brief EEPROM content
 * \internal
 */
struct eeprom_content_t
{
    uint32_t    magic;              ///< Magic number
    uint32_t    version;            ///< Version of data
    uint8_t     unique_number;
    uint8_t     calib_valid;
    uint8_t     touch_calib[24];
    uint8_t     mac_address[6];
};

static const struct heivs_bus_t *bus = &bus_i2c[0];

//////////////////////////////////////////////////////////////////////////////////
/// \brief Read data from EEPROM for a given size
/// \param address Address in EEPROM to read
/// \param dst Pointer to data buffer to be filled by eeprom data
/// \param size Number of bytes to read
//////////////////////////////////////////////////////////////////////////////////
static status_e EEPROM_Read(uint16_t address, void * dst, size_t size)
{
    status_e status;
    uint8_t eeAddress[2];

    if((address + size) > SIZE_24LC64 -1)
    {
        return ERROR_BAD_PARAM;
    }
    eeAddress[0] = address >> 8;
    eeAddress[1] = address;
    status = bus_init(bus);
    if(status != NO_ERROR) return status;
    status = bus_get(bus);
    if(status != NO_ERROR) return status;
    status = bus_writeread(bus,ADDR_24LC64,eeAddress,2,dst,size,NULL);
    if(status != NO_ERROR) return status;
    status = bus_release(bus);
    if(status != NO_ERROR) return status;

    return NO_ERROR;
}
//////////////////////////////////////////////////////////////////////////////////
/// \brief Write data in EEPROM for a given size
/// \param address Address in EEPROM to write
/// \param src Pointer to data buffer to write into eeprom
/// \param size Number of bytes to write
//////////////////////////////////////////////////////////////////////////////////
static status_e EEPROM_Write(uint16_t address, const void * src, size_t size)
{
    status_e status;
    uint8_t eePattern[PAGE_SIZE_24LC64 + 2];
    uint16_t addressCounter = address;
    size_t   calcSize;
    size_t   remainingSize=size;

    if((address + size) > SIZE_24LC64 -1)
    {
        return ERROR_BAD_PARAM;
    }
    do
    {
        eePattern[0] = addressCounter >> 8;
        eePattern[1] = addressCounter;
        calcSize = min(PAGE_SIZE_24LC64 - (addressCounter & (PAGE_SIZE_24LC64-1)),remainingSize);
        remainingSize -= calcSize;
        addressCounter += calcSize;
        memcpy(&eePattern[2],src,PAGE_SIZE_24LC64);
        src += calcSize;
        status = bus_init(bus);
        if(status != NO_ERROR) return status;
        status = bus_get(bus);
        if(status != NO_ERROR) return status;
        status = bus_write(bus,ADDR_24LC64,eePattern,calcSize+2);
        if(status != NO_ERROR) return status;
        status = bus_release(bus);
        if(status != NO_ERROR) return status;
        delay_wait_ms(5);       // max delay to write one page
    }while(addressCounter < (address + size));

    return NO_ERROR;
}

static status_e EEPROM_Valid(struct eeprom_content_t *eeprom)
{
    if (eeprom->magic != MAGIC_NUMBER)
    {
        return ERROR_EEPROM_BAD_MAGIC;
    }

    // We could update the version if it didn't match
    if (eeprom->version != EEPROM_VERSION)
    {
        return ERROR_EEPROM_BAD_MAGIC;
    }

    return NO_ERROR;
}


status_e EEPROM_ReadUniqueNumber(uint8_t * number)
{
    struct eeprom_content_t eeprom;
    status_e status;

    status = EEPROM_Read(0, &eeprom, sizeof(eeprom));
    if(status != NO_ERROR)
    {
        return status;
    }
    status = EEPROM_Valid(&eeprom);
    if(status != NO_ERROR)
    {
        return status;
    }
    *number = eeprom.unique_number;
    return NO_ERROR;
}

status_e EEPROM_Calib_Read(uint8_t calib[24])
{
    struct eeprom_content_t eeprom;
    status_e status;

    status = EEPROM_Read(0, &eeprom, sizeof(eeprom));
    if(status != NO_ERROR)
    {
        return status;
    }
    status = EEPROM_Valid(&eeprom);
    if(status != NO_ERROR)
    {
        return status;
    }
    if(eeprom.calib_valid != sizeof(eeprom.touch_calib))
    {
        return ERROR_EEPROM_BAD_CALIB;
    }
    memcpy(calib,&eeprom.touch_calib,sizeof(eeprom.touch_calib));
    return NO_ERROR;
}

status_e EEPROM_ReadMacAddress(uint8_t * mac)
{
    struct eeprom_content_t eeprom;
    status_e status;

    status = EEPROM_Read(0, &eeprom, sizeof(eeprom));
    if(status != NO_ERROR)
    {
        return status;
    }
    status = EEPROM_Valid(&eeprom);
    if(status != NO_ERROR)
    {
        return status;
    }

    memcpy(mac,&eeprom.mac_address,sizeof(eeprom.mac_address));

    return NO_ERROR;
}

status_e EEPROM_Calib_Write(const uint8_t calib[24])
{
    struct eeprom_content_t eeprom;
    status_e status;

    status = EEPROM_Read(0, &eeprom, sizeof(eeprom));
    if(status != NO_ERROR)
    {
        return status;
    }
    status = EEPROM_Valid(&eeprom);
    if(status != NO_ERROR)
    {
        return status;
    }

    if (calib)
    {
        eeprom.calib_valid = sizeof(eeprom.touch_calib);
        memcpy(&eeprom.touch_calib,calib,sizeof(eeprom.touch_calib));
    }
    else
    {
        eeprom.calib_valid = 0;
    }

    status = EEPROM_Write(0, &eeprom, sizeof(eeprom));
    return status;
}

status_e EEPROM_FirstInit(uint8_t number, uint8_t * macAddr)
{
    struct eeprom_content_t eeprom;
    status_e status;

    if (!number || !macAddr)
    {
        return ERROR_BAD_PARAM;
    }

    memset(&eeprom, 0x0, sizeof(eeprom));

    eeprom.magic = MAGIC_NUMBER;
    eeprom.version = EEPROM_VERSION;
    eeprom.calib_valid = 0;         // force calibration
    eeprom.unique_number = number;
    memcpy(&eeprom.mac_address, macAddr, sizeof(eeprom.mac_address));
    status = EEPROM_Write(0, &eeprom, sizeof(eeprom));
    return status;
}