Compiler Explorer

Source code

// Type your code here, or load an example.
#pragma once
#ifndef __EEMEM_H__
#define __EEMEM_H__
#include <stdint.h>

/* Data stored as:
 [tag]     u8 - valid range 0..126(127 not recommended); use only 7 bit, MSB =1 for active tag, =0 for forgotten
 [len-1]   u8 - legnt of record -1 to exlude value 0xff as stored value
 [payload] (variable) - user data
 [sum]     u8- simple checksum for check interity of paylad
*/

/*  According linker file */
#define PAGE0_BASE   0x08004000
#define PAGE1_BASE   0x08008000
#define PAGES_SIZE   0x4000
 /* MCU and project specifed */
#define PAGE0_DESC   FLASH_Sector_1
#define PAGE1_DESC   FLASH_Sector_2
#define VCC_RANGE    VoltageRange_3

void     E2M_Clean( void); // Erase all
void     E2M_Init( void);  // Initialization
uint8_t  E2M_Read( uint8_t tag, void* dest, uint8_t space);
void     E2M_Write( uint8_t tag, void* src, uint8_t len);

#endif /* __EEMEM_H__ */

#include "eemem.h"

#include "stm32f4xx_flash.h"
#include <string.h>
#include <stddef.h>

/* Emulated EEPROM memory 
 * written by Oleg Terentiev 
 * feb 2020
 * 
 * It uses only few interfaces for access hardware:
 *  FLASH_Unlock();
 *  FLASH_Lock();
 *  FLASH_EraseSector();
 *  FLASH_ProgramByte();
 */

/* TODO:
 * Increase write speed using x16, x32 parallelism
 * when voltage range allow its.
 */

typedef struct __attribute__ ((__packed__)) {
	uint8_t tg;   // Tag
	uint8_t lng;  // Lenght - 1
	uint8_t pl[]; // payload
    // last u8 - checksum: .pl[.lng+1]
} e2m_t;

#define E2M_HDR  offsetof(e2m_t, pl)
#define E2M_SSZ  sizeof(uint8_t) /* checksum size, == .pl[1] */
#define bm_A_TAG 0x80  /* 'Active tag' bitmask */
#define try_lim  5

static const uint32_t pages[2] = { PAGE0_BASE, PAGE1_BASE }; /* array of two pointers to uint8_t */
static const typeof(FLASH_Sector_1) descs[2] = { PAGE0_DESC, PAGE1_DESC};
static int pg_active_idx = 0;

__STATIC_INLINE void 
Page_erase( int pg_idx, int line)
{
	while ( (FLASH->SR &FLASH_SR_BSY) != 0); 
	FLASH_Unlock();
	FLASH_EraseSector( descs[pg_idx], VCC_RANGE);
	FLASH_Lock();
}

void E2M_Clean( void)
{
	Page_erase( 0, __LINE__);
	Page_erase( 1, __LINE__);
	pg_active_idx = 0;
}

// Calculate check summ
__STATIC_INLINE uint8_t
chk_sum( uint8_t *p_u8, uint8_t cnt)
{
	uint8_t sum=0;
	for( int i=0; i < cnt; i++) {
		sum += 0x21 + p_u8[i];
	}
	return(sum);
}

// Перебор тегов без проверки суммы
__STATIC_INLINE uint32_t
tag_next( uint8_t *tag, uint32_t addr)
{
	e2m_t *pmem = (e2m_t*)addr;
	if ( (pmem->tg == 0xFF) && (pmem->lng == 0xFF) )  {
		*tag = 0xFF;
		return(addr);
	} else {
		*tag = pmem->tg;
		uint8_t len = pmem->lng + 1;
		uint16_t x_idx = len + E2M_HDR + E2M_SSZ;
		return( addr +  x_idx );
	}
}

__STATIC_INLINE char 
page_better(void)
{
	uint32_t pg_ends[2] = { PAGES_SIZE-1 + PAGE0_BASE, PAGES_SIZE-1 + PAGE1_BASE };
	for (int i = 0; i<2; i++) {
		uint8_t foo;
		uint32_t addr_prev;
		uint32_t addr_new = pages[i];
		do {
			addr_prev = addr_new ;
			addr_new = tag_next( &foo, addr_prev);
		} while( (addr_new != addr_prev) && (addr_new < pg_ends[i]) );
		if (addr_new > pg_ends[i])  addr_new = pg_ends[i]; // all bytes used include last one - correct
		// Calculate difference between begin free area and sectors end
		pg_ends[i] = pg_ends[i] - addr_new;
	}
	// Now we have info about free space
	if ( pg_ends[0] < pg_ends[1] ) {
		// Pg0 has less free space, erase page 1
		Page_erase(1, __LINE__);
		return(0);
	} else {
		// Pg1 has less free space, erase page 0
		Page_erase(0, __LINE__);
		return(1);
	}
}

/* Активная страница:
 если в обоих мусор - стереть обе
 если мусор  и стёртая - стереть мусор
0:
 если обе стёрты - 0
1:
2:
 если есть валидная - ЕЁ
3:
 если 2 валидных - где меньше свободно
*/ 
void E2M_Init(void)
{
	// Select active page
	char stat = 0;
	for (int i=0; i<2; i++) {
		e2m_t *p = (e2m_t*)pages[i];
		if ( (p->tg == 0xFF) && (p->lng == 0xFF) ) { // Erased page
			continue;
		} else {
			if (  chk_sum( p->pl, p->lng + 1) == p->pl[p->lng + 1] ) { // Has valid first tag
				stat += 1<<i;
			} else { // Damaged or hurt
				Page_erase( i, __LINE__);
				continue;
			}
		}
	}

switch(stat) {
		case 0:
			// Do nothing - both empty, 0 page is active
			break;
		case 1:
		case 2:
			stat = stat-1;  // Index of page
			break;
		case 3:
			stat = page_better();
			break;
		default: // Impossible status
			while(1);
			break;
	}
	pg_active_idx = stat;
}

// verify version
void place_tag( uint8_t tag, uint32_t dst, uint8_t *src, uint8_t len)
{
		static int iter=0;
		iter = 0;
	uint32_t pg_end = pages[pg_active_idx] + PAGES_SIZE - 1;
	uint32_t pg_space = pg_end - dst;

while ( pg_space >= (E2M_HDR+E2M_SSZ+len) ) {
		// Flash
		uint32_t entry = dst;
		FLASH_ProgramByte( dst++, tag); // .tag
		FLASH_ProgramByte( dst++, len-1);    // .len
		uint8_t sum = chk_sum( src, len);
		for( int i=0; i<len; i++) {
			while ( (FLASH->SR &FLASH_SR_BSY) != 0); 
			FLASH_ProgramByte( dst++, *src); // .payload
			src++;
		}
		FLASH_ProgramByte( dst++, sum);  // .chksum

if( chk_sum( entry+E2M_HDR, len) == sum ) { //Written ok, stop
			iter = 1;
			break;
		} else {
			uint8_t bad_tag;
			dst = tag_next( &bad_tag, entry);
			pg_space = pg_end - dst;
			if (iter > try_lim) {
				iter = 0;
				break;
			}
			iter++;
		}
	}
	return;
}

// When reading, Fn() does not overflow 'space'
// but return stored length of record to know details.
uint8_t  E2M_Read( uint8_t tag, void* dest, uint8_t space)
{
/* 1) read tag
   2) test to compare
   3) if not the same - next
   4) if the same and summ ok - store
   5) if free space - end */

uint32_t pg_end = pages[pg_active_idx] + PAGES_SIZE - 1 ;
	uint8_t itag = 0x8e;
	uint32_t a_prev;
	uint32_t a_new = pages[pg_active_idx];
	uint32_t a_lastfound = 0;
	uint8_t len = 0;
	tag = tag | bm_A_TAG;
	do {
		a_prev = a_new;
		a_new = tag_next( &itag, a_prev);
		if (itag == tag) { // Found tag
			// check its sum
			e2m_t *pmem = (e2m_t*)a_prev;
			len = pmem->lng + 1;
			if ( chk_sum( pmem->pl, len) == pmem->pl[len] ) {
				a_lastfound = a_prev;  // Store last found
			}
		}
	} while( (a_new != a_prev) && ( a_new < pg_end) );

uint8_t spc = (space < len) ? space : len ;
	if (a_lastfound != 0) {
		// Read exist payload!
    	memcpy( dest, (void*)(a_lastfound+E2M_HDR), spc);
	}
	return(len);
}

// Called when page hasn't space for record
// Return address of free space on 'dest' page
uint32_t 
Move_page( int d_idx, int s_idx)
{
	uint32_t pg_end = pages[s_idx] + PAGES_SIZE - 1;
	uint32_t a_dst  = pages[d_idx];
	uint32_t a_new  = pages[s_idx];
	uint32_t a_prev;
	uint8_t rd_tag  = 0;
	do {
		a_prev = a_new;
		a_new = tag_next( &rd_tag, a_prev);
		if ( (rd_tag&bm_A_TAG) != 0 )  {  // Tag is active
			e2m_t *pmem = (e2m_t*)a_prev;
			uint8_t len = pmem->lng;
			if ( len == 0xFF) { // check incorrect lenght (erased space)
				break;
			} else {
				len++;
			}
			uint8_t fl_sum = pmem->pl[len];
			if ( chk_sum( pmem->pl, len) == fl_sum ) { // Summ is correct, copy record
				uint8_t foo_tag;
				FLASH_Unlock();
				place_tag( rd_tag, a_dst, pmem->pl, len);
				FLASH_Lock();
				a_dst = tag_next( &foo_tag, a_dst);  // Update addr of erased space
			} else {
			}
		}
	} while( (a_new != a_prev) && (a_new < pg_end) );
	Page_erase( s_idx, __LINE__);
	pg_active_idx = d_idx;
	return(a_dst);
}

void E2M_Write( uint8_t tag, void* src, uint8_t len)
{
	uint32_t pg_end = pages[pg_active_idx] + PAGES_SIZE - 1;
	uint32_t a_prev;
	uint32_t a_new = pages[pg_active_idx];
	uint32_t a_preventry = 0;
	uint8_t itag = 0x0f;
	tag = tag | bm_A_TAG; // Set up MSBit
	do {
		a_prev = a_new;
		a_new = tag_next( &itag, a_prev);
		if (itag == tag) { // Found tag
			e2m_t *pm = (e2m_t*)a_prev;
			uint8_t len = pm->lng + 1;
			if ( chk_sum( pm->pl, len) == pm->pl[len] ) { // Record isn't hurt?
				if (a_preventry != 0) {  // Is exist prev-prev record?
					FLASH_Unlock();
					FLASH_ProgramByte( a_preventry, ~bm_A_TAG & tag);
					FLASH_Lock();
				}
				a_preventry = a_prev;
			} else { // Exlude hurt record from future search
				FLASH_Unlock();
				FLASH_ProgramByte( a_prev, ~bm_A_TAG & tag);
				FLASH_Lock();
			}
		}
	} while( (a_new != a_prev) && ( a_new < pg_end) );

if ( (pg_end - a_new) > len) { // Record it if space exist
		FLASH_Unlock();
		place_tag( tag, a_new, src, len);
		FLASH_ProgramByte( a_preventry, ~bm_A_TAG & tag);
		FLASH_Lock();
		return;
	} else {
		int dest_pg = (pg_active_idx == 0) ? 1 : 0;
		a_new = Move_page( dest_pg, pg_active_idx); // fn() change 'pg_active_idx'
		FLASH_Unlock();
		place_tag( tag, a_new, src, len);
		FLASH_ProgramByte( a_preventry, ~bm_A_TAG & tag);
		FLASH_Lock();
		return;
	}
}