eeprom_driver.c

Go to the documentation of this file.

 
#include "eeprom_driver.h"
 
#include "chip.h"
 
#include <string.h>
 
#define EEPROM_DRIVER_PAGE_WORDS (EEPROM_PAGE_SIZE / sizeof(uint32_t))
 
static bool eeprom_driver_inicializado_ = false;
 
static void driver_eeprom_programar_pagina(uint32_t pagina, const uint8_t* datos_pagina)
{
    volatile uint32_t* palabra_destino = (volatile uint32_t*) EEPROM_ADDRESS(pagina, 0U);
    uint32_t palabras_origen[EEPROM_DRIVER_PAGE_WORDS];
    uint32_t indice = 0U;
 
    (void) memcpy(palabras_origen, datos_pagina, EEPROM_PAGE_SIZE);
 
    Chip_EEPROM_SetAutoProg(LPC_EEPROM, EEPROM_AUTOPROG_AFT_LASTWORDWRITTEN);
    for (indice = 0U; indice < EEPROM_DRIVER_PAGE_WORDS; ++indice) {
        palabra_destino[indice] = palabras_origen[indice];
    }
    Chip_EEPROM_WaitForIntStatus(LPC_EEPROM, EEPROM_INT_ENDOFPROG);
    Chip_EEPROM_SetAutoProg(LPC_EEPROM, EEPROM_AUTOPROG_OFF);
}
 
bool driver_eeprom_init(void)
{
    Chip_EEPROM_Init(LPC_EEPROM);
    Chip_EEPROM_SetAutoProg(LPC_EEPROM, EEPROM_AUTOPROG_OFF);
    eeprom_driver_inicializado_ = true;
    return true;
}
 
bool driver_eeprom_read(void* destino, uint32_t cantidad)
{
    if (!eeprom_driver_inicializado_ || (destino == 0)) {
        return false;
    }
 
    if (cantidad == 0U) {
        return true;
    }
 
    if (cantidad > DRIVER_EEPROM_REGION_SIZE) {
        return false;
    }
 
    (void) memcpy(destino, (const void*) EEPROM_START, cantidad);
    return true;
}
 
bool driver_eeprom_write(const void* origen, uint32_t cantidad)
{
    const uint8_t* datos_origen = (const uint8_t*) origen;
    uint8_t pagina_buffer[EEPROM_PAGE_SIZE];
    uint32_t offset = 0U;
 
    if (!eeprom_driver_inicializado_ || (origen == 0)) {
        return false;
    }
 
    if (cantidad == 0U) {
        return true;
    }
 
    if (cantidad > DRIVER_EEPROM_REGION_SIZE) {
        return false;
    }
 
    while (cantidad > 0U) {
        const uint32_t direccion_actual = offset;
        const uint32_t pagina = direccion_actual / EEPROM_PAGE_SIZE;
        const uint32_t offset_pagina = direccion_actual % EEPROM_PAGE_SIZE;
        const uint32_t bytes_pagina = EEPROM_PAGE_SIZE - offset_pagina;
        const uint32_t bytes_a_copiar = (cantidad < bytes_pagina) ? cantidad : bytes_pagina;
        const uint8_t* direccion_pagina = (const uint8_t*) EEPROM_ADDRESS(pagina, 0U);
 
        (void) memcpy(pagina_buffer, direccion_pagina, EEPROM_PAGE_SIZE);
        (void) memcpy(&pagina_buffer[offset_pagina], datos_origen, bytes_a_copiar);
 
        if (memcmp(pagina_buffer, direccion_pagina, EEPROM_PAGE_SIZE) != 0) {
            driver_eeprom_programar_pagina(pagina, pagina_buffer);
        }
 
        offset += bytes_a_copiar;
        datos_origen += bytes_a_copiar;
        cantidad -= bytes_a_copiar;
    }
 
    return true;
}