void main(){
int i;
uint16 data0 = 0x0000;
uint16 data1 = 0x1000;
uint16 data2 = 0x2000;
uint16 data3 = 0x3000;
uint16 data4 = 0x1000;
uint16 data5 = 0x5000;
uint32 address = 0x000000;
uint16 blockRead[32];
uint16 blockWrite0[16];
uint16 blockWrite1[16];
uint16 blockWrite2[16];
uint16 blockWrite3[16];
uint16 blockWrite5[64];
uint16 incomingData[4];
for(i = 0 ; i < 16 ; i++){
blockWrite0[i] = data0;
data0++;
}
for(i = 0 ; i < 16 ; i++){
blockWrite1[i] = data1;
data1++;
}
for(i = 0 ; i < 16 ; i++){
blockWrite2[i] = data2;
data2++;
}
for(i = 0 ; i < 16 ; i++){
blockWrite3[i] = data3;
data3++;
}
for(i = 0 ; i < 64 ; i++){
blockWrite5[i] = data5;
data5++;
}
trisInit();
enter_HVP();
bulkErase();
enableWrite();
flashWriteBlock(blockWrite0, blockWrite1, 1);
flashWriteBlock(blockWrite2, blockWrite3, 2);
flashReadBlock(blockRead, 64, 1);
flashReadBlock(blockRead, 64, 2);
flashWriteData(blockWrite5, 64, 0);
flashReadBlock(blockRead, 64, 1);
flashReadBlock(blockRead, 64, 2);
exit_HVP();
while(1){}
}
int PrNetRomManager::writePartialPage(int page, struct data values) {
data *p = (data*) ADDRESS_OF_PAGE(page);
int rc = flashWriteBlock(p, &values, sizeof(values));
if( rc == 0) {
return 0;
} else {
return rc;
}
}
/**
* Write a block of bytes from the currently active input to the flash.
* The block will be written to offset 0 of this bank/chip.
* The whole block must be located in one bank and in one flash chip.
*
* return 1 for success, 0 for failure
*/
uint8_t flashWriteBankFromFile(uint8_t nBank, uint8_t nChip,
uint16_t nSize)
{
uint8_t bReplaceEAPI;
uint8_t oldState;
uint16_t nOffset;
uint16_t nBytes;
nOffset = 0;
bReplaceEAPI = 0;
while (nSize)
{
nBytes = (nSize > FLASH_WRITE_SIZE) ? FLASH_WRITE_SIZE : nSize;
oldState = progressGetStateAt(nBank, nChip);
progressSetBankState(nBank, nChip, PROGRESS_READING);
if (utilRead(buffer, nBytes) != nBytes)
{
screenPrintSimpleDialog(apStrFileTooShort);
progressSetBankState(nBank, nChip, PROGRESS_UNTOUCHED);
return 0;
}
progressSetBankState(nBank, nChip, oldState);
// Check if EAPI has to be replaced
if (nBank == 0 && nChip == 1 && nOffset == 0x1800 &&
memcmp(buffer, pStrEAPISignature, 4) == 0)
bReplaceEAPI = 1;
if (bReplaceEAPI)
{
if (nOffset == 0x1800)
memcpy(buffer, EAPI_LOAD_TO, 0x100);
else if (nOffset == 0x1900)
memcpy(buffer, EAPI_LOAD_TO + 0x100, 0x100);
else if (nOffset == 0x1a00)
memcpy(buffer, EAPI_LOAD_TO + 0x200, 0x100);
}
if (!flashWriteBlock(nBank, nChip, nOffset, buffer))
return 0;
if (!flashVerifyBlock(nBank, nChip, nOffset, buffer))
return 0;
nSize -= nBytes;
nOffset += nBytes;
refreshElapsedTime();
}
return 1;
}
int PrNetRomManager::updateConfig(struct prnet_config c) {
data *p = (data*) ADDRESS_OF_PAGE(SETTINGS_FLASH_PAGE);
return flashWriteBlock(p, &c, sizeof(c));
}
/**
Handle incomming frames from the serial port.
*/
void rxhandler(void) {
switch (serRxBuf.header.type) {
case ACK:
case NACK:
break;
case T_CONNECT: //connect JTAG to the target
InitTarget();
if (GetDevice() == STATUS_OK) {
txACK();
//printf("Device type: %04x\n", DEVICE);
} else{
txNACKstr("no target");
}
break;
case T_RELEASE: //release JTAG from target
ClrTCLK();
IR_Shift(IR_CNTRL_SIG_16BIT);
DR_Shift16(0x3001); //lch
IR_Shift(IR_CNTRL_SIG_RELEASE);
SetTCLK();
ReleaseTarget();
txACK();
break;
case T_RESET: //reset the target and release JTAG
ReleaseDevice(V_RESET);
ReleaseTarget();
txACK();
break;
case T_PUC: //reset the target through JTAG, keep connection
ExecutePUC();
txACK();
break;
case T_MEMREAD: //ream memory from target
{ //use a new block for local vars
word size = serRxBuf.data.memread.size;
word address = serRxBuf.data.memread.address;
word offset;
txACK();
HaltCPU();
if (size > sizeof(serTxBuf.data.memdata.data)) {
size = sizeof(serTxBuf.data.memdata.data);
}
if (address <= 0xff) { //peripherals in bytemode
for (offset = 0; offset < size; offset++) {
serTxBuf.data.memdata.data[offset] = ReadMem(F_BYTE, address+offset);
}
} else { //peripherals in wordmode as well as RAM and Flash
address = address & 0xfffe; //startaddress has to be even!
for (offset = 0; offset < size/2; offset++) {
((word *)serTxBuf.data.memdata.data)[offset] = ReadMem(F_WORD, address+offset*2);
}
if (size & 1) {
//odd size, read last byte separate
//odd sizes on word-mode peripherals yield wrong results
//in the last word!!
serTxBuf.data.memdata.data[size-1] = ReadMem(F_BYTE, address+size-1);
}
}
serTxBuf.data.memdata.address = address;
serTxBuf.header.type = T_MEMDATA;
serTxBuf.header.size = 2+size;
sendMessage(&serTxBuf);
}
break;
case T_MEMWRITE: //write target memory (Peripherals, RAM, Flash)
{
word offset;
word size = serRxBuf.header.size - 2;
HaltCPU();
if ((serRxBuf.data.memwrite.address >= 0x100) &&
(serRxBuf.data.memwrite.address <= 0x1ff)) { //peripherals in wordmode
for (offset = 0; offset < size; offset+=2) {
WriteMem(F_WORD,
serRxBuf.data.memwrite.address+offset,
((word*)serRxBuf.data.memwrite.data)[offset/2]
);
}
} else if (serRxBuf.data.memwrite.address < 0x1000) { //ram + peripherals, bytemode
for (offset = 0; offset < size; offset++) {
WriteMem(F_BYTE,
serRxBuf.data.memwrite.address+offset,
serRxBuf.data.memwrite.data[offset]
);
}
} else { //flash memory, wordmode
WriteFLASH(serRxBuf.data.memwrite.address,
size/2,
(word *)serRxBuf.data.memwrite.data
);
}
txACK();
}
break;
case T_EXEC: //execute target program located at given address
ReleaseDevice(serRxBuf.data.exec.address);
txACK();
break;
case T_MEMERASE: //erase target flash (Segment, Main or All)
HaltCPU();
EraseFLASH(
serRxBuf.data.memerase.mode,
serRxBuf.data.memerase.address
);
txACK();
break;
case T_MCLK: //provide MCLKs, allows sort of single stepping
ClrTCLK();
IR_Shift(IR_CNTRL_SIG_16BIT);
DR_Shift16(0x3401); //lch
while (serRxBuf.data.step.numsteps--) {
SetTCLK();
ClrTCLK();
}
SetTCLK();
txACK();
break;
case MEMREAD: //host memory read
{
word size = serRxBuf.data.memread.size;
byte *address = (byte*)serRxBuf.data.memread.address;
word offset;
txACK();
if (size > sizeof(serTxBuf.data.memdata.data)) {
size = sizeof(serTxBuf.data.memdata.data);
}
if (address <= (byte *)0xff) { //bytemode
for (offset = 0; offset < size; offset++) {
serTxBuf.data.memdata.data[offset] = address[offset];
}
} else { //wordmode
address = (byte *)((word)address & 0xfffe); //startaddress has to be even!
size &= 0xfffe; //size has to be even
for (offset = 0; offset < size/2; offset++) {
((word *)serTxBuf.data.memdata.data)[offset] = ((word *)address)[offset];
}
}
serTxBuf.data.memdata.address = (word)address;
serTxBuf.header.type = MEMDATA;
serTxBuf.header.size = 2+size;
sendMessage(&serTxBuf);
}
break;
case MEMWRITE: //host memory write, used to download user programs
{
void *adr = (byte *)serRxBuf.data.memwrite.address;
word offset;
word size = serRxBuf.header.size - 2;
if ((adr >= (void *)0x100) && (adr <= (void *)0x1ff)) { //peripherals, wordmode
for (offset = 0; offset < size/2; offset++) {
((word *)adr)[offset] = ((word *)serRxBuf.data.memwrite.data)[offset];
}
txACK();
return;
}
if (adr < (void *)0x1000) { //ram + peripherals, bytemode
for (offset = 0; offset < size; offset++) {
((byte *)adr)[offset] = serRxBuf.data.memwrite.data[offset];
}
} else { //flash
flashWriteBlock(
serRxBuf.data.memwrite.data,
(void *)serRxBuf.data.memwrite.address,
size);
}
txACK();
}
break;
case MEMERASE: //erase one segemnt on host
flashErase((void *)serRxBuf.data.memerase.address);
txACK();
break;
//~ case MEMEXEC: //exec code on host
//~ serRxBuf.memexec.function(
//~ serRxBuf.memexec.arg1,
//~ serRxBuf.memexec.arg2
//~ );
//~ txACK();
//~ break;
case STARTBSL: //start BSL for firmware upgrade
txACK();
while((UTCTL0 & TXEPT) == 0) {} //wait until last byte is sent
FCTL3 = 0; //generate a flash key violation -> POR reset, see main()
break;
default:
txNACKstr("unknown command"); //serialComm error: unknown command
}
}
