157 lines
7.4 KiB
C
157 lines
7.4 KiB
C
#include "periph28335.h"
|
|
#include <assert.h>
|
|
#include "balsam167_eeprom_block.h"
|
|
#include <string.h>
|
|
|
|
static void response(uint8_t *out, unsigned high, unsigned low)
|
|
{
|
|
/* Reply is low data byte, high data byte, then an unrelated timer.
|
|
* Nonzero timer detects accidentally copying four memory bytes per PEEK. */
|
|
uint8_t payload[] = {16,56,0,0,0xef,0xbe};
|
|
payload[2]=(uint8_t)low; payload[3]=(uint8_t)high;
|
|
assert(periph28335_append_crc(payload,6,out,10)==8);
|
|
out[8]=out[9]=0;
|
|
}
|
|
|
|
static void blocks(void)
|
|
{
|
|
periph28335_eeprom_reader r;
|
|
uint8_t req[8], reply[245], out[240];
|
|
unsigned start, transactions, n, a, i, old;
|
|
int got;
|
|
assert(!balsam167_eeprom_block_valid(6,0x8000,1));
|
|
assert(!balsam167_eeprom_block_valid(3,0xbfff,2));
|
|
assert(!balsam167_eeprom_block_valid(3,0xffff,120));
|
|
assert(!balsam167_eeprom_block_valid(3,0x8000,121));
|
|
assert(!balsam167_eeprom_block_valid(3,0x8000,0));
|
|
assert(balsam167_eeprom_block_valid(3,0xbfff,1));
|
|
for(start=0;start<2;start++) {
|
|
assert(!periph28335_eeprom_begin(&r,16,start,32768-start));
|
|
transactions=0;
|
|
while(r.received<r.length) {
|
|
assert(periph28335_eeprom_block_request(&r,req,8)==8);
|
|
assert(!periph28335_crc16_modbus(req,8));
|
|
a=((unsigned)req[2]*256+req[3]-0x8000)*2;
|
|
n=req[5]; assert(n && n<=120 && a+2*n<=32768);
|
|
reply[0]=5; reply[1]=3; reply[2]=(uint8_t)(2*n);
|
|
for(i=0;i<2*n;i++) reply[3+i]=(uint8_t)(a+i);
|
|
assert(periph28335_append_crc(reply,3+2*n,reply,sizeof reply)==5+2*n);
|
|
old=r.received;
|
|
reply[4]^=1;
|
|
assert(periph28335_eeprom_block_accept(&r,reply,5+2*n,out,240)==PERIPH28335_ERROR_CRC);
|
|
assert(r.received==old); reply[4]^=1;
|
|
assert(periph28335_eeprom_block_accept(&r,reply,5+2*n,out,0)==PERIPH28335_ERROR_CAPACITY);
|
|
assert(r.received==old);
|
|
got=periph28335_eeprom_block_accept(&r,reply,5+2*n,out,240);
|
|
assert(got>0);
|
|
for(i=0;i<(unsigned)got;i++) assert(out[i]==(uint8_t)(start+old+i));
|
|
transactions++;
|
|
}
|
|
assert(transactions==137);
|
|
assert(!periph28335_eeprom_block_request(&r,req,8));
|
|
}
|
|
}
|
|
|
|
static void profiles(void)
|
|
{
|
|
periph28335_eeprom_reader r;
|
|
uint8_t req[18], reply[245], out[240];
|
|
unsigned n, i, q, a, bankmask=0;
|
|
uint32_t pos, before;
|
|
assert(periph28335_eeprom_capacity_profile(0)==32768);
|
|
assert(periph28335_eeprom_capacity_profile(1)==262144);
|
|
assert(periph28335_eeprom_capacity_profile(2)==0);
|
|
assert(periph28335_eeprom_begin_profile(&r,16,262143,2,1)<0);
|
|
assert(periph28335_eeprom_begin_profile(&r,16,0,2,2)<0);
|
|
assert(!balsam167_eeprom_block_valid_profile(3,0xffff,0x8078,1));
|
|
assert(!balsam167_eeprom_block_valid_profile(3,0x8000,0x8401,1));
|
|
assert(!balsam167_eeprom_block_valid_profile(3,0x8000,0x8001,0));
|
|
assert(!balsam167_eeprom_block_valid_profile(3,0x8000,1,1));
|
|
assert(balsam167_eeprom_block_valid_profile(3,0xffff,0x8301,1));
|
|
/* Full 256-KiB dump from an odd start exercises every bank transition,
|
|
* first/last byte trimming, CRC failure and exact physical byte order. */
|
|
assert(!periph28335_eeprom_begin_profile(&r,16,1,262143,1));
|
|
while(r.received<r.length) {
|
|
assert(periph28335_eeprom_block_request_profile(&r,req,8,1)==8);
|
|
assert(!periph28335_crc16_modbus(req,8));
|
|
a=req[2]*256U+req[3]; q=req[4]*256U+req[5]; n=q&255U;
|
|
assert(balsam167_eeprom_block_valid_profile(3,a,q,1));
|
|
pos=balsam167_eeprom_block_word(a,q)*2UL;
|
|
assert(pos == (r.start+r.received)/2*2);
|
|
bankmask |= 1U << ((q>>8)&3U);
|
|
assert(periph28335_eeprom_block_expected_profile(&r,1)==5+2*n);
|
|
reply[0]=5; reply[1]=3; reply[2]=(uint8_t)(n*2);
|
|
for(i=0;i<n*2;i++) reply[3+i]=(uint8_t)((pos+i)^((pos+i)>>16));
|
|
periph28335_append_crc(reply,3+n*2,reply,sizeof(reply));
|
|
before=r.received; reply[4]^=1;
|
|
assert(periph28335_eeprom_block_accept_profile(&r,reply,5+2*n,out,240,1)==PERIPH28335_ERROR_CRC);
|
|
assert(r.received==before); reply[4]^=1;
|
|
assert(periph28335_eeprom_block_accept_profile(&r,reply,5+2*n,out,240,1)>0);
|
|
for(i=0;i<r.received-before;i++) {
|
|
pos=1+before+i;
|
|
assert(out[i]==(uint8_t)(pos^(pos>>16)));
|
|
}
|
|
}
|
|
assert(bankmask==15);
|
|
assert(!periph28335_eeprom_block_request_profile(&r,req,8,1));
|
|
assert(periph28335_eeprom_write_profile(5,0,0x200000,33514,0,req,18)==0);
|
|
assert(periph28335_eeprom_write_profile(5,0,0x200000,33514,1,req,18)==18);
|
|
assert(req[14]==0x44 && req[15]==0 && !periph28335_crc16_modbus(req,18));
|
|
assert(!periph28335_eeprom_write_profile(5,0x1ff7e,0,2,1,req,18));
|
|
assert(!periph28335_eeprom_write_profile(5,0xffffffff,0,2,1,req,18));
|
|
assert(periph28335_eeprom_write_profile(5,0,0,32438,0,req,18)==18 && req[14]==4);
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
periph28335_eeprom_reader reader;
|
|
blocks();
|
|
profiles();
|
|
uint8_t request[8], reply[10], data[2];
|
|
unsigned i;
|
|
assert(sizeof(reader)==16);
|
|
assert(periph28335_eeprom_begin(&reader,16,0,0)==PERIPH28335_ERROR_RANGE);
|
|
assert(periph28335_eeprom_begin(&reader,0,0,2)==PERIPH28335_ERROR_RANGE);
|
|
assert(periph28335_eeprom_begin(&reader,16,0x8000,1)==PERIPH28335_ERROR_RANGE);
|
|
assert(periph28335_eeprom_begin(&reader,16,0x7fff,2)==PERIPH28335_ERROR_RANGE);
|
|
assert(periph28335_eeprom_begin(&reader,16,1,0xffffffffUL)==PERIPH28335_ERROR_RANGE);
|
|
assert(periph28335_eeprom_request(&reader,request,8)==0);
|
|
assert(periph28335_eeprom_begin(&reader,16,1,3)==0);
|
|
assert(periph28335_eeprom_request(&reader,request,7)==0);
|
|
assert(periph28335_eeprom_request(&reader,request,8)==8);
|
|
assert(memcmp(request,"\x10\x38\0\0\0\0",6)==0);
|
|
response(reply,0x12,0x34);
|
|
assert(periph28335_eeprom_accept(&reader,reply,8,data,2)==1 && data[0]==0x34);
|
|
assert(reader.received==1);
|
|
assert(periph28335_eeprom_request(&reader,request,8)==8 && request[2]==1);
|
|
reply[2]^=1;
|
|
assert(periph28335_eeprom_accept(&reader,reply,8,data,2)==PERIPH28335_ERROR_CRC);
|
|
assert(reader.received==1);
|
|
response(reply,0x56,0x78);
|
|
assert(periph28335_eeprom_accept(&reader,reply,8,data,1)==PERIPH28335_ERROR_CAPACITY);
|
|
assert(reader.received==1);
|
|
assert(periph28335_eeprom_accept(&reader,reply,10,data,2)==2);
|
|
assert(data[0]==0x56 && data[1]==0x78 && reader.received==3);
|
|
assert(periph28335_eeprom_request(&reader,request,8)==0);
|
|
|
|
/* Every requested word of a complete dump remains in the EEPROM window.
|
|
* In particular, neither the RAM route nor selector 0x10000000 is used. */
|
|
assert(periph28335_eeprom_begin(&reader,16,0,32768)==0);
|
|
for (i=0;i<16384;i++) {
|
|
assert(periph28335_eeprom_request(&reader,request,8)==8);
|
|
assert(request[1]==56 && request[4]==0 && request[5]==0);
|
|
assert(((unsigned)request[3]*256+request[2])==i);
|
|
assert(periph28335_crc16_modbus(request,8)==0);
|
|
response(reply,i>>8,i);
|
|
assert(periph28335_eeprom_accept(&reader,reply,8,data,2)==2);
|
|
assert(data[0]==(i>>8) && data[1]==(i&255));
|
|
}
|
|
assert(reader.received==32768 && periph28335_eeprom_request(&reader,request,8)==0);
|
|
assert(periph28335_eeprom_begin(&reader,16,0x7fff,1)==0);
|
|
assert(periph28335_eeprom_request(&reader,request,8)==8);
|
|
assert(request[2]==0xff && request[3]==0x3f);
|
|
response(reply,0x9a,0xbc);
|
|
assert(periph28335_eeprom_accept(&reader,reply,8,data,2)==1 && data[0]==0xbc);
|
|
return 0;
|
|
}
|