Lpc17xx40xxEEPROMEmulation.cxx

Go to the documentation of this file.

 
#include "Lpc17xx40xxEEPROMEmulation.hxx"
 
#include <cstring>
 
#include "iap.h"
#include "chip.h"
 
// We can't put a weak definition of a constant, because GCC, due to a bug,
// will inline the definition that appears here even if it is overridden at link
// time.
//
// const size_t __attribute__((weak)) EEPROMEmulation::SECTOR_SIZE = 0x8000;
const size_t EEPROMEmulation::BLOCK_SIZE = 16;
const size_t EEPROMEmulation::BYTES_PER_BLOCK = 8;
 
static uint8_t get_first_sector() {
    unsigned estart = (unsigned)(&__eeprom_start);
    if (estart < 0x10000) {
        return estart / 0x1000;
    } else {
        return 16 - 2 + estart / 0x8000; // estart==0x10000  -> sector==16.
    }
}
 
LpcEEPROMEmulation::LpcEEPROMEmulation(const char *name, size_t file_size)
    : EEPROMEmulation(name, file_size), firstSector_(get_first_sector())
{
    /* IAP cannot access RAM below 0x10000200) */
    HASSERT(((uintptr_t)scratch) >= 0x10000200);
 
    unsigned eend = (unsigned)(&__eeprom_end);
    unsigned estart = (unsigned)(&__eeprom_start);
    if (eend <= 0x10000) {
        HASSERT(SECTOR_SIZE == 0x1000);
    } else if (estart >= 0x10000) {
        HASSERT(SECTOR_SIZE == 0x8000);
    } else {
        DIE("LPC17xx cannot have the EEPROM range cross the boundary of "
            "address of 0x10000");
    }
    HASSERT(estart % SECTOR_SIZE == 0);
    HASSERT(eend % SECTOR_SIZE == 0);
    
    mount();
}
 
inline const uint32_t *LpcEEPROMEmulation::get_block(
    unsigned sector, unsigned offset)
{
    return (uint32_t*)(&__eeprom_start + sector * EEPROMEmulation::SECTOR_SIZE + offset * EEPROMEmulation::BLOCK_SIZE);
}
 
const uint32_t* LpcEEPROMEmulation::block(unsigned sector, unsigned offset) {
    return get_block(sector, offset);
}
 
void LpcEEPROMEmulation::flash_erase(unsigned sector)
{
    HASSERT(sector < sectorCount_);
 
    unsigned s = sector + firstSector_;
    portENTER_CRITICAL();
    Chip_IAP_PreSectorForReadWrite(s, s);
    Chip_IAP_EraseSector(s, s);
    portEXIT_CRITICAL();
}
 
void LpcEEPROMEmulation::flash_program(
    unsigned relative_sector, unsigned start_block, uint32_t *data, uint32_t byte_count)
{
    HASSERT(relative_sector < sectorCount_);
    HASSERT((byte_count % BLOCK_SIZE) == 0);
    HASSERT(start_block + (byte_count / BLOCK_SIZE) <= rawBlockCount_);
    auto* address = get_block(relative_sector, start_block);
 
    /* make sure we have the correct frequency */
    SystemCoreClockUpdate();
 
    uint32_t start_address = (uintptr_t)address & ~(WRITE_SIZE - 1);
    uint32_t sector = firstSector_ + relative_sector;
 
    HASSERT(((uintptr_t)address + byte_count) <= (start_address + WRITE_SIZE));
 
    memset(scratch, 0xFF, sizeof(scratch));
    memcpy(scratch + ((uintptr_t)address - start_address), data, byte_count);
 
    portENTER_CRITICAL();
    Chip_IAP_PreSectorForReadWrite(sector, sector);
    Chip_IAP_CopyRamToFlash(start_address, (uint32_t*)scratch, WRITE_SIZE);
    portEXIT_CRITICAL();
}