flash.c

linux下的jtag调试软件

/*
 * Flash tool for Armonie.
 *
 * Memory organisation:
 *
 * 0xA0000000 -> 0xA0000000 + 10 MB: enough space for this program and data.
 * 0xA0000000 + 12 MB: stack
 * 0xA0000000 + 16 MB: space for parameter passing.
 *
 */
#include "serial.h"

volatile unsigned short *flash=0;
volatile unsigned int *mem = 0;
unsigned short *flashImage= (unsigned short *) (0xA0000000 + (9*1024*1024));

typedef struct {
	unsigned start;
	unsigned end;
} FlashSector;

// contains WORD address. multiply by 2 to get BYTE address.
FlashSector SectorAddress[] = {
	{ 0x0, 0x01FFF},
	{ 0x2000, 0x2FFF},
	{ 0x3000, 0x3FFF},
	{ 0x4000, 0x7FFF},
	{ 0x8000, 0xFFFF},
	{ 0x10000, 0x17FFF},
	{ 0x18000, 0x1FFFF},
	{ 0x20000, 0x27FFF},
	{ 0x28000, 0x2FFFF},
	{ 0x30000, 0x37FFF},
	{ 0x38000, 0x3FFFF},
	{ 0x40000, 0x47FFF},
	{ 0x48000, 0x4FFFF},
	{ 0x50000, 0x57FFF},
	{ 0x58000, 0x5FFFF},
	{ 0x60000, 0x67FFF},
	{ 0x68000, 0x6FFFF},
	{ 0x70000, 0x77FFF},
	{ 0x78000, 0x7FFFF}
};

//! \return one if sector is protected, 0 if it's not.
int is_sector_protected(int sector) {
	unsigned short r;

	if (sector < 0) sector =0;
	if (sector > 18) sector = 18;

	flash[0x555] = 0xaa;
	flash[0x2aa] = 0x55;
	flash[0x555] = 0x90;

	r = flash[ SectorAddress[sector].start | 0x02 ];
	flash[0] = 0xF0; // back to Reset/Read
	return r;
}

void protect_sector(int sector) {

}

void unprotect_sector(int sector) {

}

void erase(int sector) {

	if ((sector < 0) || (sector > 18)) {
		printf("erase(%d): invalid sector.\n\r", sector);
		return;
	}

	flash[0x555] = 0xaa;
	flash[0x2aa] = 0x55;
	flash[0x555] = 0x80;
	flash[0x555] = 0xaa;
	flash[0x2aa] = 0x55;
	flash[SectorAddress[sector].start] = 0x30;

	// wait until the flash is finished
	while ((flash[SectorAddress[sector].start] &0x80) == 0) ;

	flash[0] = 0xF0; // back to Reset/Read
}

void program(unsigned byte_address, unsigned short *data, unsigned int nb_words) {
	unsigned addr = byte_address >> 1;
	unsigned i, err_cnt;

	// some verification.
	if (nb_words == 0) return;
	
	if (addr + nb_words >= (512 * 1024)) {
		printf("Sorry, the flash is not big enough for data. Not programming.\n\r");
		return;
	}

	if (((unsigned)byte_address & 0x01) || ((unsigned)data & 0x01)) {
		printf("data or destination address not aligned. Not programming.\n\r");
		return;
	}

	printf("Ready to program %d bytes at 0x%x\n\r", nb_words<<1, byte_address);

	// unlock bypass command sequence.
	
	// unlock cycles
	flash[0x555] = 0xaa;
	flash[0x2aa] = 0x55;
	flash[0x555] = 0x20;
	
	// unlock bypass programming
	for (i=0; i<nb_words; ++i) {
		unsigned dq6;

		flash[addr] = 0xA0;
		flash[addr] = data[i];
		
		dq6 = flash[addr] & (1 << 6);
		
		while(1) {
			unsigned dq6_ = flash[addr] & (1 << 6);
			if (dq6 == dq6_)
				break;
			dq6 = dq6_;
		}
		++addr;
	}

	// exit unlock bypass program 
	flash[0] = 0x90; 
	flash[1] = 0x00;
	printf("done. Verifying...\n\r");

	addr = byte_address >> 1;
	for (i= err_cnt=0; i<nb_words; ++i) {
		if (flash[addr] != data[i]) err_cnt++;
		addr++;
	}

	printf("%d error.\n\r", err_cnt);
}

int erase_and_program(unsigned byte_address, unsigned short *data, unsigned int nb_words) {
	unsigned addr = byte_address >> 1;
	int i, first_sect, last_sect;

	printf("erase_and_program(0x%x, 0x%x, %d)\n\r",
			byte_address, data, nb_words);

	// simple checking...
	if (nb_words == 0) {
		printf("0 words to program...\n\r");
		return 0;
	}
	
	if (addr + nb_words >= (512 * 1024)) {
		printf("Sorry, the flash is not big enough for data. Not programming.\n\r");
		return 1;
	}

	if (((unsigned) byte_address & 0x1) || ((unsigned) data&0x1)) {
		printf("data or destination address not aligned. Not programming.\n\r");
		return 2;
	}

	// find the 1st sector concerned
	for (first_sect = 0; SectorAddress[first_sect].end < addr; first_sect++);

	// find the last sector concerned
	for (last_sect=18; SectorAddress[last_sect].start >= (addr + nb_words); last_sect--);
	
	if (first_sect > last_sect) {
		printf("erase_and_program(): INTERNAL ERROR !\n\r");
		return 3;
	}
	
	printf("reprogramming sectors %d to %d (%d sectors)\r\n", first_sect,
			last_sect, last_sect-first_sect + 1);
	
	// mirror data
	for (i=SectorAddress[first_sect].start; i<=SectorAddress[last_sect].end; ++i)
		flashImage[i] = flash[i];

	// copy data to write into flash image
	for (i=0; i< nb_words; i++)
		flashImage[i] = data[i];

	// erase sectors
	printf("erasing sectors...\n\r");
	for (i=first_sect; i<=last_sect; ++i) {
		erase(i);
		printf("Sector %d erased.\n\r", i);
	}

	// program data
	printf("Programming data...\n\r");
	program( SectorAddress[first_sect].start << 1, 
			flashImage + (SectorAddress[first_sect].start << 1),
			SectorAddress[last_sect].end - SectorAddress[first_sect].start + 1);

	printf("ok.\n\r");
	return 0;
}
	
int printargs(int a, int b, int c, int d) {

	printf("a: 0x%x\n\r", a);
	printf("b: 0x%x\n\r", b);
	printf("c: 0x%x\n\r", c);
	printf("d: 0x%x\n\r", d);
	return 0xCAFE;
}

int main(int argc, char *argv[])
{
	unsigned int val;
	unsigned int val2;
	unsigned int i;
	
	// Send the Autoselect ID Read command
	flash[0x555] = 0xaa;
	flash[0x2aa] = 0x55;
	flash[0x555] = 0x90;
	val = (int) flash[1];	// read device code
	val2 = mem[0] >> 16;
	flash[0] = 0xF0; // back to Reset/Read

	printf("Flash device code is %x (%x)\n\r", val, val2);

	if (val != 0x225b) {
		printf("Wring flash device.\n\r");
	} else {
		printf("AS29LV800 flash detected.\n\r");
	}

	for (i=0; i<= 18; ++i) {
		printf("sector %d (0x%x - 0x%x) is %sprotected\n\r",
				i,
				SectorAddress[i].start << 1,
				SectorAddress[i].end << 1,
				is_sector_protected(i) ? "" : "not ");
	}
}