/*
* Verify flash contents to ram contents.
*/
int
fl_verify_device(void *fl_base, void *data_base, int data_size, int verbose)
{
struct fl_map *map;
struct fl_device *dev;
void *fl_last;
int ok;
int i;
dev = fl_devident(fl_base, &map);
if(dev == NULL) {
return(-3); /* No flash device found at address */
}
if(data_size == -1 || (int)data_base == -1) {
return(-4); /* Bad parameters */
}
if((data_size + ((int)fl_base - map->fl_map_base)) > map->fl_map_size) {
return(-4); /* Size larger than device array */
}
if(verbose) {
printf("Verifying FLASH. ");
}
for(i = 0; i < data_size; i += map->fl_map_width) {
fl_last = fl_base;
switch(map->fl_map_bus) {
case FL_BUS_8:
ok = (*((u_char *)fl_base) == *((u_char *)data_base));
fl_base++;
data_base++;
break;
case FL_BUS_16:
ok = (*((u_short *)fl_base) == *((u_short *)data_base));
fl_base += 2;
data_base += 2;
break;
case FL_BUS_32:
ok = (*((u_int *)fl_base) == *((u_int *)data_base));
fl_base += 4;
data_base += 4;
break;
case FL_BUS_64:
movequad(&widedata, fl_base);
ok = (bcmp(data_base, (void *)&widedata, 8) == 0);
data_base += 8;
fl_base += 8;
break;
case FL_BUS_8_ON_64:
ok = (*((u_char *)map->fl_map_base +
(((int)fl_base - map->fl_map_base) << 3)) ==
*(u_char *)data_base++);
fl_base++;
break;
}
if(verbose & !ok) {
printf(" error offset %p\n", fl_last);
{
char str[100];
int timeout;
printf("erase all chip(y/N)?");
gets(str);
if(str[0]=='y'||str[0]=='Y')
{
tgt_flashwrite_enable();
fl_write_protect_unlock(map, dev, 0);/* Disable write protection of SST49LF040B/SST49LF008A */
printf("Erasing all FLASH blocks. ");
(*dev->functions->erase_chip)(map, dev);
delay(1000);
for(timeout = 0 ;
((ok = (*dev->functions->isbusy)(map, dev, 0xffffffff,0, TRUE)) == 1)
&& (timeout < PFLASH_MAX_TIMEOUT); timeout++) {
delay(1000);
if(verbose) {
dotik(256, 0);
}
}
delay(1000);
if(!(timeout < PFLASH_MAX_TIMEOUT)) {
(*dev->functions->erase_suspend)(map, dev);
}
(*dev->functions->reset)(map, dev);
tgt_flashwrite_disable();
fl_write_protect_lock(map, dev, 0);/* Enable write protection of SST49LF040B/SST49LF008A */
}
}
break;
}
else if(verbose) {
dotik(32, 0);
}
}
if(verbose && ok) {
printf("\b No Errors found.\n");
}
return(ok);
}
/*
* Program a flash device. Assumed that the area is erased already.
*/
int
fl_program_device(void *fl_base, void *data_base, int data_size, int verbose)
{
struct fl_map *map;
struct fl_device *dev;
int ok;
int i, off;
if(tgt_flashwrite_enable() == 0) {
return(-2); /* Flash can't be write enabled */
}
dev = fl_devident(fl_base, &map);
if(dev == NULL) {
tgt_flashwrite_disable();
return(-3); /* No flash device found at address */
}
if(data_size == -1 || (int)data_base == -1) {
return(-4); /* Bad parameters */
}
if((data_size + ((int)fl_base - map->fl_map_base)) > map->fl_map_size) {
return(-4); /* Size larger than device array */
}
off = (int)(fl_base - map->fl_map_base) + map->fl_map_offset;
if(verbose) {
printf("Programming FLASH. ");
}
tgt_flashwrite_enable();
fl_write_protect_unlock(map, dev, 0);/* Disable write protection of SST49LF040B/SST49LF008A */
for(i = 0; i < data_size; i += map->fl_map_width) {
ok = (*dev->functions->program)(map, dev, (int)off, data_base);
switch(map->fl_map_bus) {
case FL_BUS_8:
case FL_BUS_8_ON_64:
off++;
data_base++;
break;
case FL_BUS_16:
data_base += 2;
off += 2;
break;
case FL_BUS_32:
data_base += 4;
off += 4;
break;
case FL_BUS_64:
data_base += 8;
off += 8;
break;
}
if(verbose) {
dotik(256, 0);
}
}
(*dev->functions->reset)(map, dev);
if(verbose) {
printf("\b Done.\n");
}
tgt_flashwrite_disable();
fl_write_protect_lock(map, dev, 0);/* Enable write protection of SST49LF040B/SST49LF008A */
return(ok);
}
/*
* Erase the flash device(s) addressed.
*/
int
fl_erase_device(void *base, int size, int verbose)
{
struct fl_map *map;
struct fl_device *dev;
int mask, ok, block;
int timeout;
if(tgt_flashwrite_enable() == 0) {
printf("Flash can't be write enabled\n");
return(-2); /* Flash can't be write enabled */
}
dev = fl_devident(base, &map);
if(dev == NULL) {
printf("No flash found at %x\n",(u_int32_t)base);
return(-3); /* No flash device found at address */
}
/*
* Sanity checks!
*/
if(size == -1 && (int)base == map->fl_map_base) {
size = map->fl_map_size; /* Entire flash */
}
if(dev->fl_varsecsize != NULL) {
int offset = (int)(base - map->fl_map_base) + map->fl_map_offset;
int totalsize;
printf("offset=%x,base=%x\n",offset,map->fl_map_base);
for(block=0, totalsize=0; totalsize < offset; block++) {
totalsize += dev->fl_varsecsize[block] * map->fl_map_chips;
}
mask = ((dev->fl_varsecsize[block] * map->fl_map_width / map->fl_map_chips) - 1);
if((int)base & mask) {
size += (int)base & mask;
base = (void *)((int)base & ~mask);
} else if((size + ((int)base - map->fl_map_base)) > map->fl_map_size) {
return(-4); /* End beyound end of flash */
}
base -= map->fl_map_base;
} else {
mask = ((dev->fl_secsize * map->fl_map_width / map->fl_map_chips) - 1);
if((int)base & mask) {
size += (int)base & mask;
base = (void *)((int)base & ~mask);
} else if((size + ((int)base - map->fl_map_base)) > map->fl_map_size) {
return(-4); /* End beyound end of flash */
}
base -= map->fl_map_base;
block = (int)base / map->fl_map_chips / dev->fl_secsize;
size = (size + mask) & ~mask; /* Round up to catch entire flash */
}
tgt_flashwrite_enable();
fl_write_protect_unlock(map, dev, 0);/* Disable write protection of SST49LF040B/SST49LF008A */
while(size > 0) {
int boffs = (int)base;
#if 0
if(size == map->fl_map_size &&
dev->fl_cap & (FL_CAP_DE|FL_CAP_A7)) {
/*
* Erase entire devices using the BULK erase feature
*/
if(verbose) {
printf("Erasing all FLASH blocks. ");
}
(*dev->functions->erase_chip)(map, dev);
size = 0;
}
else {
#endif
/*
* Not entire flash or no BULK erase feature. We
* use sector/block erase.
*/
if(verbose) {
printf("\rErasing FLASH block %3d \b\b\b\b\b", block);
}
if((*dev->functions->erase_sector)(map, dev, boffs) != 0) {
printf("\nError: Failed to enter erase mode\n");
(*dev->functions->erase_suspend)(map, dev);
(*dev->functions->reset)(map, dev);
return(-4);
}
if(dev->fl_varsecsize != NULL) {
base += dev->fl_varsecsize[block] * map->fl_map_chips;
size -= dev->fl_varsecsize[block] * map->fl_map_chips;
block++;
} else {
base += dev->fl_secsize * map->fl_map_chips;
size -= dev->fl_secsize * map->fl_map_chips;
block++;
}
// }
delay(1000);
for(timeout = 0 ;
((ok = (*dev->functions->isbusy)(map, dev, 0xffffffff, boffs, TRUE)) == 1)
&& (timeout < PFLASH_MAX_TIMEOUT); timeout++) {
delay(1000);
if(verbose) {
dotik(256, 0);
}
}
delay(1000);
if(!(timeout < PFLASH_MAX_TIMEOUT)) {
(*dev->functions->erase_suspend)(map, dev);
}
(*dev->functions->reset)(map, dev);
if(verbose) {
if(!(timeout < PFLASH_MAX_TIMEOUT)) {
/* XXX if timed out what should really happen here? This doesn't look right. */
printf("\b\b, command timed out!\n");
} else {
printf("\b Done.\n");
}
}
}
tgt_flashwrite_disable();
fl_write_protect_lock(map, dev, 0);/* Enable write protection of SST49LF040B/SST49LF008A */
return(ok);
}
int fl_program(void *fl_base, void *data_base, int data_size, int verbose)
{
char *nvrambuf;
char *nvramsecbuf;
char *nvram;
int offs,count,left;
struct fl_device *dev=fl_devident(fl_base,0);
int nvram_size=dev->fl_secsize;
nvramsecbuf = (char *)malloc(nvram_size);
if(nvramsecbuf == 0) {
printf("Warning! Unable to malloc nvrambuffer!\n");
return(-1);
}
nvram = fl_base;
left = data_size;
while(left)
{
offs = (int)nvram &(nvram_size - 1);
nvram = (int)nvram & ~(nvram_size - 1);
count = min(nvram_size-offs,left);
memcpy(nvramsecbuf, nvram, nvram_size);
nvrambuf = nvramsecbuf + offs;
memcpy(nvrambuf,data_base,count);
#ifdef NVRAM_IN_FLASH
#ifndef LS3B_SPI_BOOT
if(fl_erase_device(nvram, nvram_size, verbose)) {
printf("Error! Nvram erase failed!\n");
free(nvramsecbuf);
return(0);
}
if(fl_program_device(nvram, nvramsecbuf, nvram_size, verbose)) {
printf("Error! Nvram program failed!\n");
free(nvramsecbuf);
return(0);
}
#else
spi_erase( (unsigned long)(nvram)- tgt_flashmap()->fl_map_base, nvram_size);
if( spi_program(nvramsecbuf, (unsigned long)(nvram)- tgt_flashmap()->fl_map_base, nvram_size, 0) ) {
printf("Error! Nvram program failed!\n");
free(nvramsecbuf);
return(0);
}
#endif
#endif
data_base += count;
nvram += nvram_size;
left -= count;
}
free(nvramsecbuf);
return 0;
}
/*
* Try to figure out what kind of flash there is on given address.
*/
struct fl_device *
fl_devident(void *base, struct fl_map **m)
{
struct fl_device *dev;
struct fl_map *map;
char mfgid, chipid;
/* If we can't write to flash, we can't identify */
if(!tgt_flashwrite_enable()) {
return((struct fl_device *)NULL);
}
map = fl_find_map(base);
if(map != NULL) {
fl_autoselect(map);
switch(map->fl_map_bus) {
case FL_BUS_8:
#ifndef LS3B_SPI_BOOT
mfgid = inb(map->fl_map_base);
chipid = inb(map->fl_map_base+1);
#else
mfgid = loongson_spi_readid();
chipid = loongson_spi_readchipid();
#endif
if(chipid == mfgid) { /* intel 16 bit flash mem */
chipid = inb(map->fl_map_base+3);
}
break;
case FL_BUS_8_ON_64:
mfgid = inb(map->fl_map_base);
chipid = inb(map->fl_map_base+8);
break;
case FL_BUS_16:
mfgid = inw(map->fl_map_base);
chipid = inw(map->fl_map_base+2);
break;
case FL_BUS_32:
mfgid = inl(map->fl_map_base);
chipid = inl(map->fl_map_base+4);
break;
case FL_BUS_64:
mfgid = inw(map->fl_map_base);
chipid = inw(map->fl_map_base+8);
break;
}
fl_reset(map);
/* Lookup device type using manufacturer and device id */
for(dev = &fl_known_dev[0]; dev->fl_name != 0; dev++) {
if(dev->fl_mfg == mfgid && dev->fl_id == chipid) {
tgt_flashwrite_disable();
if(m) {
*m = map;
}
return(dev); /* GOT IT! */
}
}
printf("Mfg %2x, Id %2x\n", mfgid, chipid);
}
tgt_flashwrite_disable();
outb((map->fl_map_base), 0xf0);
outb((map->fl_map_base), 0x90);
outb((map->fl_map_base), 0x00);
return((struct fl_device *)NULL);
}
/*
* Verify flash contents to ram contents.
*/
int
fl_verify_device(void *fl_base, void *data_base, int data_size, int verbose)
{
struct fl_map *map;
struct fl_device *dev;
void *fl_last;
int ok;
int i;
dev = fl_devident(fl_base, &map);
if(dev == NULL) {
return(-3); /* No flash device found at address */
}
if(data_size == -1 || (int)data_base == -1) {
return(-4); /* Bad parameters */
}
if((data_size + ((int)fl_base - map->fl_map_base)) > map->fl_map_size) {
return(-4); /* Size larger than device array */
}
if(verbose) {
printf("Verifying FLASH. ");
}
for(i = 0; i < data_size; i += map->fl_map_width) {
fl_last = fl_base;
switch(map->fl_map_bus) {
case FL_BUS_8:
ok = (*((u_char *)fl_base) == *((u_char *)data_base)); fl_base += 1; data_base += 1;
break;
case FL_BUS_16:
ok = (*(u_short *)fl_base == *((u_short *)data_base)); fl_base += 2; data_base += 2;
break;
case FL_BUS_32:
ok = (*(u_int *)fl_base == *(u_int *)data_base); fl_base += 4; data_base += 4;
break;
case FL_BUS_64:
movequad(&widedata, fl_base);
ok = (bcmp(data_base, (void *)&widedata, 8) == 0);
data_base += 8;
fl_base += 8;
break;
case FL_BUS_8_ON_64:
ok = (*((u_char *)map->fl_map_base +
(((int)fl_base - map->fl_map_base) << 3)) ==
*(u_char *)data_base++);
fl_base++;
break;
}
if(verbose & !ok) {
printf(" error offset %p\n", fl_last);
{
char str[100];
int timeout;
printf("erase all chip(y/N)?");
gets(str);
if(str[0]=='y'||str[0]=='Y')
{
tgt_flashwrite_enable();
printf("Erasing all FLASH blocks. ");
fl_erase_device(map->fl_map_base,map->fl_map_size,FALSE);
tgt_flashwrite_disable();
}
}
break;
}
else if(verbose) {
dotik(32, 0);
}
}
if(verbose && ok) {
printf("\b No Errors found.\n");
}
return(ok);
}
__attribute__((weak))fl_erase_device(void *base, int size, int verbose)
{
struct fl_map *map;
struct fl_device *dev;
int mask, ok, block;
int timeout;
if(tgt_flashwrite_enable() == 0) {
printf("Flash can't be write enabled\n");
return(-2); /* Flash can't be write enabled */
}
dev = fl_devident(base, &map);
if(dev == NULL) {
printf("No flash found at %x\n",(u_int32_t)base);
return(-3); /* No flash device found at address */
}
/*
* Sanity checks!
*/
if(size == -1 && (int)base == map->fl_map_base) {
size = map->fl_map_size; /* Entire flash */
}
if(dev->fl_varsecsize != NULL) {
int offset = (int)(base - map->fl_map_base) + map->fl_map_offset;
int totalsize;
printf("offset=%x,base=%x\n",offset,map->fl_map_base);
for(block=0, totalsize=0; totalsize < offset; block++) {
totalsize += dev->fl_varsecsize[block] * map->fl_map_chips;
}
mask = ((dev->fl_varsecsize[block] * map->fl_map_width / map->fl_map_chips) - 1);
if((int)base & mask) {
size += (int)base & mask;
base = (void *)((int)base & ~mask);
} else if((size + ((int)base - map->fl_map_base)) > map->fl_map_size) {
return(-4); /* End beyound end of flash */
}
base -= map->fl_map_base;
} else {
mask = ((dev->fl_secsize * map->fl_map_width / map->fl_map_chips) - 1);
if((int)base & mask) {
size += (int)base & mask;
base = (void *)((int)base & ~mask);
} else if((size + ((int)base - map->fl_map_base)) > map->fl_map_size) {
return(-4); /* End beyound end of flash */
}
base -= map->fl_map_base;
block = (int)base / map->fl_map_chips / dev->fl_secsize;
size = (size + mask) & ~mask; /* Round up to catch entire flash */
}
tgt_flashwrite_enable();
while(size > 0) {
int boffs = (int)base;
if(size == map->fl_map_size &&
dev->fl_cap & (FL_CAP_DE|FL_CAP_A7)) {
/*
* Erase entire devices using the BULK erase feature
*/
if(verbose) {
printf("Erasing all FLASH blocks. ");
}
(*dev->functions->erase_chip)(map, dev);
size = 0;
}
else {
/*
* Not entire flash or no BULK erase feature. We
* use sector/block erase.
*/
if(verbose) {
printf("\rErasing FLASH block %3d \b\b\b\b\b", block);
}
if((*dev->functions->erase_sector)(map, dev, boffs) != 0) {
printf("\nError: Failed to enter erase mode\n");
(*dev->functions->erase_suspend)(map, dev);
(*dev->functions->reset)(map, dev);
return(-4);
}
if(dev->fl_varsecsize != NULL) {
base += dev->fl_varsecsize[block] * map->fl_map_chips;
size -= dev->fl_varsecsize[block] * map->fl_map_chips;
block++;
} else {
base += dev->fl_secsize * map->fl_map_chips;
size -= dev->fl_secsize * map->fl_map_chips;
block++;
}
}
delay(1000);
for(timeout = 0 ;
((ok = (*dev->functions->isbusy)(map, dev, 0xffffffff, boffs, TRUE)) == 1)
&& (timeout < PFLASH_MAX_TIMEOUT); timeout++) {
delay(1000);
if(verbose) {
dotik(256, 0);
}
}
delay(1000);
if(!(timeout < PFLASH_MAX_TIMEOUT)) {
(*dev->functions->erase_suspend)(map, dev);
}
(*dev->functions->reset)(map, dev);
if(verbose) {
if(!(timeout < PFLASH_MAX_TIMEOUT)) {
/* XXX if timed out what should really happen here? This doesn't look right. */
printf("\b\b, command timed out!\n");
} else {
printf("\b Done.\n");
}
}
}
tgt_flashwrite_disable();
return(ok);
}
