File size: 6,657 Bytes
a2a15a2 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 |
/*
* Stefan's XMC EEPROM Library
*
* See the licence file on for copyright/left.
* (GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007)
*
* Author: Stefan Lenz, [email protected]
*
* A poor man's EEPROM emulation in the XMC flash.
* We buffer entire pages in RAM and only program the flash is we hve a page fault.
*
* Flash geometry: 16 bytes per block, 16 blocks per page. Organized in 4096 byte sectors.
* We use one sector i.e. 16 pages as a flat EEPROM data.
*
* The whole code is meant primarily to be used with the IoT BASIC interpreter and implements
* only a reduced API and a reduced buffering and flash protection algorithm:
*
* Buffering strategy:
* - One pagebuffer for an entire page. Takes all the writes to the page and keeps it
* until a pagefault occurs, i.e. writes go beyond the page, then flush and reload
* monitor if the page has changed. Always read the page and then write into the pagebuffer.
* - One blockbuffer for read. If the read is outside the page loaded for write, read the
* blockbuffer and hand back bytes from it. If the read is inside the page loaded for
* write, satisfy read request from there.
*
* The library does not do additional reduction of erase cycles like the more
* sophisticated solutions to. It works well if
* 1. you mostly write entire chunks of memory like the BASIC interpreter does on program save
* 2. when you do frequent read/write you mostly stay in one page like the BASIC interpreter does
* on EEPROM variable access
*
*/
#include "xmc_flash.h"
#ifndef XMCEEPROMLIB_H
#define XMCEEPROMLIB_H
// we keep this static and outside the class, needed for the memory managenent of one specifiy application
// change this if you find it annoying -> into the class.
static uint8_t xmceeprom_pagebuffer[256];
static uint8_t xmceeprom_blockbuffer[16];
class XMCEEPROM {
public:
// no constructor needed
XMCEEPROM(void) {};
~XMCEEPROM(void) {};
// begin is optional, as all the constants are already set for 64 kB flash and a 4kB EEPROM
void begin(uint16_t eepromsize=4096, uint32_t flashsize=65536) {
xmcdatasize=(eepromsize & 0xff00); // data size is reduced to full pages
xmcflashsize=flashsize; // anything goes here
xmcdatasector = xmcflashbase + xmcflashsize - xmcdatasize;
};
// read - done through the blockbuffer
uint8_t read(int address) {
// address in rage ?
if (address >=0 && address < xmcdatasize) {
// do we have a page in memory for write and try to read from it
if (page != -1 && address/256 == page) return pagebuffer[address%256];
// if not, read the block we are dealing with into the blockbuffer, if not already there
if (block == -1 || block != address/16) readblock(address/16);
// if that worked, satisfy read from the block buffer
if (error == 0) return blockbuffer[address%16]; else return 255;
} else {
error = -1;
return 255;
}
};
// write a byte, this is really update() of course */
void write(int address, uint8_t val) {
// address in rage ?
if (address >=0 && address < xmcdatasize) {
// do we have a page fault and valid data to flush
if (page != -1 && page != address/256) { writepage(); readpage(address/256); }
// get the requested page if we need to
if (page == -1) readpage(address/256);
if (error != 0) return;
// we have the requested page in the pagebuffer, set the value and mark the page changed
if (pagebuffer[address%256] != val) {
// here, one would additionally check, if the change can be done without erase
// this would mean to check if only bytes that were high go to low. In this case one could
// write straight through here and keep the page_changed to 0
pagebuffer[address%256]=val;
page_changed=1;
// if the block buffer overlaps with the page buffer, keep it up to date as well */
if (block != -1 && address/16 == block) blockbuffer[address%16]=val;
}
} else {
error = -1;
}
};
// this is trivial but helps with compatibility
void update(int address, uint8_t val) { write(address, val); }
// length is defined in the constants
uint16_t length() { return xmcdatasize; };
// commit like in the ESP world - flush the write page
void commit() { writepage(); };
void end() { commit(); };
int status() { return error; };
private:
// the real internal data type of flash would be words but we do byte
// the pagebuffer has the page we are writing
uint8_t* pagebuffer = xmceeprom_pagebuffer;
// the page we have in the buffer, -1 means no valid data
int page=-1;
// the page changed status
int page_changed = 0;
// the blockbuffer has the block we are reading
uint8_t* blockbuffer = xmceeprom_blockbuffer;
// the block we have loaded for read
int block=-1;
// the error status
int error = 0;
// the geometry of the flash
const unsigned long xmcflashbase = 0x10001000; // where does the flash start
unsigned long xmcflashsize = 0x00010000; // a 64kB flash
// static unsigned long xmcflashsize = 0x00008000; // a 32kB flash by default
unsigned int xmcdatasize = 0x00001000; // a 4kB data sector - this is the EEPROM size
unsigned long xmcdatasector = xmcflashbase + xmcflashsize - xmcdatasize; // we use the last sector
// read a page into the pagebuffer and set the page variable
void readpage(uint8_t p) {
if (p >= 0 && p < 16) {
XMC_FLASH_ReadBlocks( (uint32_t*) (xmcdatasector+p*256), (uint32_t*) pagebuffer, 16);
if ((error = XMC_FLASH_GetStatus()) == 0 ) {
page=p;
page_changed=0;
} else
page=-1;
} else {
error = -1;
}
}
// write out the current page in programming mode
void writepage() {
if (page != -1 && page_changed) {
XMC_FLASH_ProgramPage( (uint32_t*) (xmcdatasector+page*256), (uint32_t*) pagebuffer);
error = XMC_FLASH_GetStatus();
page_changed=0;
}
}
// read a block to the blockbuffer
void readblock(int b) {
if (b>=0 && b<256) {
XMC_FLASH_ReadBlocks( (uint32_t*) (xmcdatasector+b*16), (uint32_t*) blockbuffer, 1);
if ((error = XMC_FLASH_GetStatus()) == 0 ) block=b; else block=-1;
} else {
error = -1;
}
}
};
XMCEEPROM EEPROM;
#endif
|