flash.c.svn-base

board type like smdk2443 ARM920T processor

		return 1;
	}

	if ((info->flash_id & FLASH_VENDMASK) != FLASH_MAN_AMD)
	{
		printf ("Can't erase: unknown flash type %08lx - aborted\n", info->flash_id);
		return 1;
	}else{
		printf("\nErasing AMD flash now...\n\n");
	}

	prot = 0;
	for (sect = s_first; sect <= s_last; ++sect) 
		if (info->protect[sect])	prot++;

	if (prot)	printf("- Warning: %d protected sectors will not be erased!\n", prot);
	else		printf("\n");
	
	disable_interrupts();

	for (sect = s_first; sect <= s_last; sect++) 
	{
		vu_short *addr = (vu_short *)(info->start[sect]);

		if(ctrlc()){
			printf("User Interrpt!\n");
			break;
		}

		printf("Erasing sector %2d ... ", sect);

		if(info->protect[sect] == 0){//no protected	
			reset_timer_masked();

			fwr16((base+(0x555<<1)), 0xaa);
			fwr16((base+(0x2aa<<1)), 0x55);
			fwr16((base+(0x555<<1)), 0x80);
			fwr16((base+(0x555<<1)), 0xaa);
			fwr16((base+(0x2aa<<1)), 0x55);
			fwr16(addr, 0x30);

			chip = 0;

			do{
				result = frd16(addr);
				// check time out
				if(get_timer_masked() > CFG_FLASH_ERASE_TOUT){
					chip = TMO;
					printf("time out!!\n");
					break;
				}

				// erase done
				if(!chip && (result  & 0x80))	chip = READY;
				// erase error
				if(!chip && (result & 0x20))	chip = ERR;
			}while(chip != READY);

			fwr16((base+(0x555<<1)), 0xf0);

			if(chip == TMO){
				rcode = 1;
				break;
			}

			if(chip == ERR){
				rcode = 2;
				break;
			}
			printf("complete\n");
		}else{
			printf("protected\n");
		}
	}
	
	enable_interrupts();

	return rcode;
}

int intel_flash_erase (flash_info_t *info, int s_first, int s_last)
{
	int prot, sect;
	ulong type, start, last;
	int rcode = 0;

	if ((s_first < 0) || (s_first > s_last)) 
	{
		if (info->flash_id == FLASH_UNKNOWN) {
			printf ("- missing\n");
		} else {
			printf ("- no sectors to erase\n");
		}
		return 1;
	}

	type = (info->flash_id & FLASH_VENDMASK);
	if ((type != FLASH_MAN_INTEL)) 
	{
		printf ("Can't erase: unknown flash type %08lx - aborted\n", info->flash_id);
		return 1;
	}else{
		printf("\nErasing INTEL flash now...\n\n");
	}

	prot = 0;
	for (sect = s_first; sect <= s_last; ++sect) 
		if (info->protect[sect]) 	prot++;
			
	if (prot)	printf("- Warning: %d protected sectors will not be erased!\n", prot);
	else		printf ("\n");

	start = get_timer(0);
	last = start;
	disable_interrupts();	

	for (sect = s_first; sect <= s_last; sect++) 
	{
		vu_long *addr = (vu_long *) (info->start[sect]);
		ulong status, a, b;

		if(ctrlc()){
			printf("User Interrpt!\n");
			break;
		}

		printf ("Erasing sector %3d ... ", sect);
	
		if(info->protect[sect] == 0){//no protected
			reset_timer_masked();

			*addr = (ulong)0x00200020;
			*addr = (ulong)0x00D000D0;

			*addr = (ulong)0x00700070;
			status = *addr;
			a = status & (1<<7);
			b = status & (1<<(7+16));
			while(!a | !b){
				*addr = (ulong)0x00700070;
				status = *addr;
				a = status & (1<<7);
				b = status & (1<<(7+16));
				
				if(get_timer_masked() > CFG_FLASH_ERASE_TOUT){
					printf("time out\n");
					*addr = (ulong)0x00b000b0;
					*addr = (ulong)0x00ff00ff;
					rcode = 1;
					break;
				}
			}
			printf("complete\n");
			*(addr+8) = (ulong)0x00ff00ff;
		}else{
			printf("protected\n");
		}
	}

	enable_interrupts();
	return rcode;
}



int flash_write(flash_info_t *info, ulong addr_src, ulong addr_dst, ulong size)
{

	switch(info->flash_id&FLASH_TYPEMASK){
		case FLASH_AM400T:
		case FLASH_AM400B:
		case FLASH_AM800T:
		case FLASH_AM800B:
			printf("AMD flash\n");
			break;
		case FLASH_28F320J3A:
		case FLASH_28F640J3A:
		case FLASH_28F128J3A:
			printf("INTEL flash\n");
			break;
		default:
			printf("unknown flash type\n");
			return;
	}
	
	printf("read from 0x%08lx and write to 0x%08lx ...  ", addr_src, addr_dst);
	if(write_buff(info, (uchar *)addr_src, addr_dst, size) == 0)
		printf("\nComplete write data!! size : 0x%x\n", size);
	printf("\n\n");
}

/*-----------------------------------------------------------------------
 * Copy memory to flash, returns:
 * 0 - OK
 * 1 - write timeout
 * 2 - Flash not erased
 * 4 - Flash not identified
 ------------------------------------------------------------------------*/

int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
{
	ulong cp, wp, data;
	int count, i, l, rc, port_width;

/* get lower word aligned address */
	switch(info->flash_id & FLASH_VENDMASK){
		case FLASH_MAN_INTEL:
			wp = (addr & ~3);
			port_width = 4;
			break;
		case FLASH_MAN_AMD:
			wp = (addr & ~1);
			port_width = 2;
			break;
		default:
			return 4;
	}

	/* handle unaligned start bytes */
	if ((l = addr - wp) != 0) {
		data = 0;
		for (i = 0, cp = wp; i < l; ++i, ++cp) {
			data = (data << 8) | (*(uchar *) cp);
		}
		for (; i < port_width && cnt > 0; ++i) {
			data = (data << 8) | *src++;
			--cnt;
			++cp;
		}
		for (; cnt == 0 && i < port_width; ++i, ++cp) {
			data = (data << 8) | (*(uchar *) cp);
		}

		if(port_width == 2){
			if ((rc = write_data (info, wp, __swab16(data))) != 0)	return (rc);
		}else{
			if ((rc = write_data (info, wp, __swab32(data))) != 0)	return (rc);
		}
		wp += port_width;
	}

	/* handle word aligned part */
	count = 0;
	while (cnt >= port_width) {
		data = 0;
		for (i = 0; i < port_width; ++i) {
			data = (data << 8) | *src++;
		}
		if(port_width == 2){
			if ((rc = write_data (info, wp, __swab16(data))) != 0) return (rc);
		}else if(port_width == 4){
			if ((rc = write_data (info, wp, __swab32(data))) != 0) return (rc);
		}
		wp += port_width;
		cnt -= port_width;
		if (count++ > 0x800) {
			spin_wheel ();
			count = 0;
		}
	}

	if (cnt == 0) {
		return (0);
	}

	/*
	 * handle unaligned tail bytes
	 */
	data = 0;
	for (i = 0, cp = wp; i < port_width && cnt > 0; ++i, ++cp) {
		data = (data << 8) | *src++;
		--cnt;
	}
	for (; i < port_width; ++i, ++cp) {
		data = (data << 8) | (*(uchar *) cp);
	}
	
	if(port_width == 2)			return (write_data (info, wp, __swab16(data)));
	else if(port_width == 4)	return (write_data (info, wp, __swab32(data)));
}

/*-----------------------------------------------------------------------
 * Write a word or halfword to Flash, returns:
 * 0 - OK	
 * 1 - write timeout
 * 2 - Flash not erased
 -----------------------------------------------------------------------*/

static int write_data(flash_info_t *info, ulong dest, ulong data)
{
	switch(info->flash_id & FLASH_TYPEMASK)
	{
		case FLASH_AM400T:
		case FLASH_AM400B:
		case FLASH_AM800T:
		case FLASH_AM800B:
			return amd_write_data(info, dest, (ushort)data);
		case FLASH_28F320J3A:
		case FLASH_28F640J3A:
		case FLASH_28F128J3A:
			return intel_write_data(info, dest, data);
		default:
			printf("writing error.. unknown chip type\n");
	}
	
	return 1;
}

static int amd_write_data (flash_info_t *info, ulong dest, ushort data)
{
	vu_short *addr = (vu_short *)dest;
	ushort result;
	int chip;
	ulong base = info->base_addr;

	if((frd16(addr) & data) != data){
		printf("not erased at %08lx (%lx)\n", (ulong)addr, frd16(addr));
		return 2;
	}

	disable_interrupts();

	fwr16((base+(0x555<<1)), 0xaa);
	fwr16((base+(0x2aa<<1)), 0x55);
	fwr16((base+(0x555<<1)), 0x20);
	fwr16(addr, 0xa0);
	fwr16(addr, data);

	reset_timer_masked();

	// wait until flash is ready
	chip = 0;
	do{
		result = frd16(addr);
		// check timeout
		if(get_timer_masked() > CFG_FLASH_WRITE_TOUT){
			chip = ERR | TMO;
			return 1;
		}
		// chip is ready
		if(!chip && ((result & 0x80) == (data & 0x80)))	chip = READY;
		// program error
		if(!chip && ((result & 0xffff) & 0x20)){
			result = frd16(addr);
			if((result & 0x80) == (data & 0x80))	chip = READY;
			else									chip = ERR;
		}
	}while(!chip);

//	fwr16(addr, 0xf0);

	if(chip == ERR | frd16(addr) != data){
		enable_interrupts();
		return 4;
	}

	enable_interrupts();
	return 0;
}

static int intel_write_data (flash_info_t *info, ulong dest, ulong data)
{
	vu_long *addr = (vu_long *) dest;
	ulong status;

	if ((frd32(addr) & data) != data) {
		printf ("not erased at %08lx (%lx)\n", (ulong) addr, frd32(addr));
		return (2);
	}

	// Disable interrupts which might cause a timeout here
	disable_interrupts ();

	fwr32(addr, 0x00400040);	// write setup
	fwr32(addr, data);

	// arm simple, non interrupt dependent timer
	reset_timer_masked ();

	// wait while polling the status register
	do{
		fwr32(addr, 0x00700070);
		status = frd32(addr);
		if(get_timer_masked() > CFG_FLASH_WRITE_TOUT){
			fwr32(addr, 0x00ff00ff);
			enable_interrupts();
			return 1;
		}
	}while((status & 0x00800080) != 0x00800080);

	fwr32(addr, 0x00ff00ff);	// restore read mode
	enable_interrupts();
	return (0);
}



int flash_read(flash_info_t *info, ulong addr_src, ulong addr_dst, ulong size)
{
	int flash_width = 0;
	ulong data_size = size;
	volatile ushort *u16_src, *u16_dst;
	volatile ulong  *u32_src, *u32_dst;

	switch(info->flash_id&FLASH_TYPEMASK){
		case FLASH_AM400T:
		case FLASH_AM400B:
		case FLASH_AM800T:
		case FLASH_AM800B:
			printf("AMD flash\n");
			flash_width = 2;
			u16_src = (ushort *)addr_src;
			u16_dst = (ushort *)addr_dst;
			break;
		case FLASH_28F320J3A:
		case FLASH_28F640J3A:
		case FLASH_28F128J3A:
			printf("INTEL flash\n");
			flash_width = 4;
			u32_src = (ulong *)addr_src;
			u32_dst = (ulong *)addr_dst;
			break;
		default:
			printf("unknown flash type\n");
			return;
	}
	

	printf("read from 0x%08lx and copy to 0x%08lx ...  ", addr_src, addr_dst);
	while((data_size -= flash_width) > 0){
		if(flash_width == 2)	*u16_dst++ = *u16_src++;
		else					*u32_dst++ = *u32_src++;

		if(data_size%2000 == 0)	spin_wheel();
	}
	
	printf("\nComplete read data!! size : 0x%x\n\n\n", size);

}