flash.c

适合KS8695X

			prot++;
		}
	}

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

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

	/* Start erase  n unprotected sectors */
	/*
	out8(addr + 0x555, 0xAA);
    iobarrier_rw();
    out8(addr + 0x2AA, 0x55);
    iobarrier_rw();
    out8(addr + 0x555, 0x80);
    iobarrier_rw();
    out8(addr + 0x555, 0xAA);
    iobarrier_rw();
    out8(addr + 0x2AA, 0x55);
    iobarrier_rw();
   */
    
	*((volatile unsigned short *)addr + 0x555) = 0xaa; 
	*((volatile unsigned short *)addr + 0x2aa) = 0x55;
    *((volatile unsigned short *)addr + 0x555) = 0x80; 
	*((volatile unsigned short *)addr + 0x555) = 0xaa; 
	*((volatile unsigned short *)addr + 0x2aa) = 0x55;
    
#ifdef DEL
	for (sect = s_first; sect <= s_last; sect++) {
		if (info->protect[sect] == 0) {	/* not protected */
			volatile unsigned char *addr;
			unsigned char status;

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

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

			addr = (volatile unsigned char *) (info->start[sect]);
			*addr = 0x50;	/* clear status register */
			*addr = 0x20;	/* erase setup */
			*addr = 0xD0;	/* erase confirm */

			while (((status = *addr) & 0x80) != 0x80) {
				if (get_timer_masked () >
				    CFG_FLASH_ERASE_TOUT) {
					printf ("Timeout\n");
					*addr = 0xB0;	/* suspend erase */
					*addr = 0xFF;	/* reset to read mode */
					rcode = 1;
					break;
				}
			}

			*addr = 0x50;	/* clear status register cmd */
			*addr = 0xFF;	/* resest to read mode */

			printf (" done\n");
		}
	}
	return rcode;
#endif

	/* Start erase on unprotected sectors */
	for (sect = s_first; sect<=s_last; sect++) {
		if (info->protect[sect] == 0) {	/* not protected */
			addr = info->start[sect];
			out8(addr, 0x30);
			iobarrier_rw();
			l_sect = sect;
		}
	}

	/* re-enable interrupts if necessary */
	if (flag)
		enable_interrupts();

	/* wait at least 80us - let's wait 1 ms */
	udelay (1000);

	/*
	 * We wait for the last triggered sector
	 */
	if (l_sect < 0)
		goto DONE;

	start = get_timer (0);
	last  = start;
	addr = info->start[l_sect];

//	debug("Start erase timeout: %d\n", CFG_FLASH_ERASE_TOUT);

	while ((in8(addr) & 0x80) != 0x80) {
		if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
			printf ("Timeout\n");
			flash_reset (info->start[0]);
			return 1;
		}
		/* show that we're waiting */
		if ((now - last) > 1000) {	/* every second */
			putc ('.');
			last = now;
		}
		iobarrier_rw();
	}

DONE:
	/* reset to read mode */
	flash_reset (info->start[0]);

	printf (" done\n");
	return 0;
}




int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
{

	ulong cLength,timeCounter,count;
	unsigned short data;

	ulong flashPtr=addr;	
	uchar *gBuffer;
	
	gBuffer = src;
	cLength = cnt/2;

	debug ("write_buff: from 0x%08lX to 0x%08lX (0x%08lX byte)\n",addr, addr+cnt,cnt);
	//debug ("cLength=0x%08lX\n", cLength);
	
	if (info->flash_id == FLASH_UNKNOWN)
		return 4;

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

	count = 0;
	while (cLength > 0) {
		data = 0;
		data = *gBuffer++;
		data |= ((*gBuffer++)<<8);
		//debug ("data[0x%08lX]=0x%04lX\n", cLength,data);
		
		*((volatile unsigned short *)PHYS_FLASH_1 + 0x555) = 0xaa; 
		*((volatile unsigned short *)PHYS_FLASH_1 + 0x2aa) = 0x55;
    	*((volatile unsigned short *)PHYS_FLASH_1 + 0x555) = 0xa0; 
		*((volatile unsigned short *)flashPtr) = data; 
					
		timeCounter =0x10000;		
		while (  (*((volatile unsigned short*)flashPtr)&0x8080) 
		!= (data & 0x8080) )	
		{
			if(timeCounter-- == 0)
			{	
				//debug ("write data timeCounter\n");					
				return (1);
			}
		}
		//debug ("Read data[0x%08lX]=0x%04lX\n", cLength,*((volatile unsigned short*)flashPtr));
		cLength--;
		flashPtr+=2;
		/*
		if (count++ > 0x800) {
			spin_wheel ();
			count = 0;
		}
		*/
	}

	return 0;
}


#if 0

/*-----------------------------------------------------------------------
 * 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;
	unsigned short data,ex_data;
	int count, i, l, rc, port_width;

	if (info->flash_id == FLASH_UNKNOWN)
		return 4;

	wp = addr;
	port_width = 2;

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


	/*
	 * handle unaligned start bytes
	 */
	if ((l = addr - wp) != 0) {
		data = 0;
		ex_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);
		}
		ex_data = ((data&0xFF00) >>8)|((data&0xFF)<<8);
		if ((rc = write_data (info, wp, ex_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++;
		}
		ex_data=0;
		ex_data = ((data&0xFF00) >>8)|((data&0xFF)<<8);
		if ((rc = write_data (info, wp, ex_data)) != 0) {
			return (rc);
		}
		wp += port_width;
		cnt -= port_width;
		if (count++ > 0x800) {
			spin_wheel ();
			count = 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);
	}
		ex_data=0;
	ex_data = ((data&0xFF00) >>8)|((data&0xFF)<<8);
	return (write_data (info, wp, ex_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, unsigned short data)
{
	volatile unsigned short *addr = (volatile unsigned short *) dest;
	ulong status, start,timeCounter;

	timeCounter =0x1000000;
	/* Check if Flash is (sufficiently) erased */
	
	if ((*addr & data) != data) {
		printf ("not erased at %08lx (%lx)\n", (ulong) addr,
			(ulong) * addr);
		return (2);
	}


	volatile unsigned short *data_ch = (volatile unsigned short *)&data;
	int flag = disable_interrupts();

	*((volatile unsigned short *)addr + 0x555) = 0xaa; 
	*((volatile unsigned short *)addr + 0x2aa) = 0x55;
    *((volatile unsigned short *)addr + 0x555) = 0xa0; 
	*((volatile unsigned short *)addr) = data; 

	/* re-enable interrupts if necessary */
	//if (flag)
	//	enable_interrupts();

	/* data polling for D7 */
	//start = get_timer (0);
	while (  (*((volatile unsigned short*)dest)&0x8080) 
	!= (data & 0x8080) )	
	{
		/*
		if (get_timer(start) > CFG_FLASH_WRITE_TOUT) {
			flash_reset (addr);
			return (1);
		}
		*/
		if(timeCounter-- == 0)
		    break;
	}

	//flash_reset (addr);
	return (0);
}



/*-----------------------------------------------------------------------
 * 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;
	unsigned char data;
	int count, i, l, rc, port_width;

	if (info->flash_id == FLASH_UNKNOWN)
		return 4;

	wp = addr;
	port_width = 1;

	/*
	 * 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 ((rc = write_data (info, wp, 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 ((rc = write_data (info, wp, 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);
	}

	return (write_data (info, wp, 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, unsigned char data)
{
	volatile unsigned char *addr = (volatile unsigned char *) dest;
	ulong status, start;
	int flag, i=0;

	/* Check if Flash is (sufficiently) erased */
	/*
	if ((*addr & data) != data) {
		printf ("not erased at %08lx (%lx)\n", (ulong) addr,
			(ulong) * addr);
		return (2);
	}
	*/

	/* write each byte out */
//	for (i = 0; i < 4; i++) 
	{
		char *data_ch = (char *)&data;
		int flag = disable_interrupts();

		out8(addr + 0x555, 0xAA);
		iobarrier_rw();
		out8(addr + 0x2AA, 0x55);
		iobarrier_rw();
		out8(addr + 0x555, 0xA0);
		iobarrier_rw();
		out8(dest+i, data_ch[i]);
		
		iobarrier_rw();

		/* re-enable interrupts if necessary */
		if (flag)
			enable_interrupts();

		/* data polling for D7 */
		start = get_timer (0);
		while ((in8(dest+i) & 0x80) != (data_ch[i] & 0x80)) {
			if (get_timer(start) > CFG_FLASH_WRITE_TOUT) {
				flash_reset (addr);
				return (1);
			}
			iobarrier_rw();
		}
	}

	flash_reset (addr);
	return (0);
}
#endif


void inline spin_wheel (void)
{
	static int p = 0;
	static char w[] = "\\/-";

	printf ("\010%c", w[p]);
	(++p == 3) ? (p = 0) : 0;
}