/****************************************************************************
* nand_bch_ecc_flip_bit - Routine to flip an errored bit
*
* PURPOSE:
* This is a helper routine that flips the bit (0 -> 1 or 1 -> 0) of the
* errored bit specified
*
* PARAMETERS:
* datap - Container that holds the 512 byte data
* errorLocation - Location of the bit that needs to be flipped
*
* RETURNS:
* None
****************************************************************************/
static void nand_bcm_umi_bch_ecc_flip_bit(uint8_t *datap, int errorLocation)
{
int locWithinAByte = (errorLocation & REG_UMI_BCH_ERR_LOC_BYTE) >> 0;
int locWithinAWord = (errorLocation & REG_UMI_BCH_ERR_LOC_WORD) >> 3;
int locWithinAPage = (errorLocation & REG_UMI_BCH_ERR_LOC_PAGE) >> 5;
uint8_t errorByte = 0;
uint8_t byteMask = 1 << locWithinAByte;
/* BCH uses big endian, need to change the location
* bits to little endian */
locWithinAWord = 3 - locWithinAWord;
errorByte = datap[locWithinAPage * sizeof(uint32_t) + locWithinAWord];
#ifdef BOOT0_BUILD
puthexs("\nECC Correct Offset: ",
locWithinAPage * sizeof(uint32_t) + locWithinAWord);
puthexs(" errorByte:", errorByte);
puthex8(" Bit: ", locWithinAByte);
#endif
if (errorByte & byteMask) {
/* bit needs to be cleared */
errorByte &= ~byteMask;
} else {
/* bit needs to be set */
errorByte |= byteMask;
}
/* write back the value with the fixed bit */
datap[locWithinAPage * sizeof(uint32_t) + locWithinAWord] = errorByte;
}
void uart_flash_loader(void) {
char buf[256]; //input data buffer
uint8_t ihx[32]; //ihex data buffer
uint32_t slot_offset = PROD_FW_IMAGE_LOCATION_ADDR; //initial slot offset to program to.
uint32_t extended_addr = 0x00000000; //extended Intel hex segment address
size_t sector_size = spi_flash_log2_sector_size();
ihex_record_t ihex_record;
ihex_record.data = ihx;
int i;
//not gonna win a turing prize for my C text parsing
while(1) {
gets(buf);
if(!strncmp(buf, "!SECTORSIZE", 7)) { //return the sector size in log format
putstr("OK ");
puthex8((uint32_t) sector_size); //err, this should probably be decimal for human readability. we do have itoa now...
putstr("\n");
}
else if(!strncmp(buf, "!SETADDR", 7)) { //set start address for programming
slot_offset = atol(&buf[8]);
puts("OK");
// puthex32(slot_offset);
// putstr("\n");
}
else if(!strncmp(buf, "!ERASE", 6)) { //erase a sector
uint32_t sector = atol(&buf[6]);
uint32_t size = 2 << (sector_size-1);
uint32_t addr = sector << sector_size;
spi_flash_erase(addr, size); //we DO NOT implement write protection here. it is up to the HOST PROGRAM to not issue an ERASE unless it means it.
//unfortunately the Flash cannot write-protect the segments that really matter, so we only use global write-protect
//as a means of avoiding accidental writes from runaway code / garbage on the SPI bus.
puts("OK");
}
//can't exactly run firmware if you're already executing out of main RAM
/* else if(!strncmp(buf, "!RUNSFW", 7)) {
if(is_valid_fw_image(SAFE_FW_IMAGE_LOCATION_ADDR)) {
puts("OK");
spi_flash_read(SAFE_FW_IMAGE_LOCATION_ADDR, FW_IMAGE_SIZE_BYTES, (void *)RAM_BASE);
start_program(RAM_BASE);
} else {
puts("NOK");
}
}
else if(!strncmp(buf, "!RUNPFW", 7)) {
if(is_valid_fw_image(PROD_FW_IMAGE_LOCATION_ADDR)) {
puts("OK");
spi_flash_read(PROD_FW_IMAGE_LOCATION_ADDR, FW_IMAGE_SIZE_BYTES-1, (void *)RAM_BASE);
start_program(RAM_BASE);
} else {
puts("NOK");
}
}
*/
else if(!strncmp(buf, "!RUNPFPGA", 8)) {
if(is_valid_fpga_image(PROD_FPGA_IMAGE_LOCATION_ADDR)) {
puts("OK");
//icap_reload_fpga(PROD_FPGA_IMAGE_LOCATION_ADDR);
} else {
puts("NOK");
}
}
else if(!strncmp(buf, "!RUNSFPGA", 8)) {
if(is_valid_fpga_image(SAFE_FPGA_IMAGE_LOCATION_ADDR)) {
puts("OK");
//icap_reload_fpga(SAFE_FPGA_IMAGE_LOCATION_ADDR);
} else {
puts("NOK");
}
}
else if(!strncmp(buf, "!READ", 5)) {
uint32_t addr = atol(&buf[5]);
spi_flash_read(addr, 16, ihx);
for(i=0; i < 16; i++) {
puthex8(ihx[i]);
}
putstr("\n");
}
else if(!ihex_parse(buf, &ihex_record)) { //last, try to see if the input was a valid IHEX line
switch (ihex_record.type) {
case 0:
spi_flash_program(ihex_record.addr + slot_offset + extended_addr, ihex_record.length, ihex_record.data);
puts("OK");
break;
case 1:
//here we would expect a CRC checking or something else to take place. for now we do nothing.
//well, we set the extended segment addr back to 0
extended_addr = 0;
puts("DONE");
break;
case 4:
//set the upper 16 bits of the address
extended_addr = ((ihex_record.data[0] << 8) + ihex_record.data[1]) << 16;
puts("OK");
break;
default:
puts("NOK");
}
}
else puts("NOK");
} //while(1)
}