[people/ms/u-boot.git] / board / cpu86 / flash.c

/*
 * (C) Copyright 2001, 2002
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 *
 * Flash Routines for Intel devices
 *
 *--------------------------------------------------------------------
 * SPDX-License-Identifier:	GPL-2.0+ 
 */

#include <common.h>
#include <mpc8xx.h>
#include "cpu86.h"

flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];

/*-----------------------------------------------------------------------
 */
ulong flash_int_get_size (volatile unsigned long *baseaddr,
					  flash_info_t * info)
{
	short i;
	unsigned long flashtest_h, flashtest_l;

	info->sector_count = info->size = 0;
	info->flash_id = FLASH_UNKNOWN;

	/* Write identify command sequence and test FLASH answer
	 */
	baseaddr[0] = 0x00900090;
	baseaddr[1] = 0x00900090;

	flashtest_h = baseaddr[0];	/* manufacturer ID	*/
	flashtest_l = baseaddr[1];

	if (flashtest_h != INTEL_MANUFACT || flashtest_l != INTEL_MANUFACT)
		return (0);		/* no or unknown flash	*/

	flashtest_h = baseaddr[2];	/* device ID	        */
	flashtest_l = baseaddr[3];

	if (flashtest_h != flashtest_l)
		return (0);

	switch (flashtest_h) {
	case INTEL_ID_28F160C3B:
		info->flash_id = FLASH_28F160C3B;
		info->sector_count = 39;
		info->size = 0x00800000;	/* 4 * 2 MB = 8 MB	*/
		break;
	case INTEL_ID_28F160F3B:
		info->flash_id = FLASH_28F160F3B;
		info->sector_count = 39;
		info->size = 0x00800000;	/* 4 * 2 MB = 8 MB      */
		break;
	default:
		return (0);			/* no or unknown flash	*/
	}

	info->flash_id |= INTEL_MANUFACT << 16; /* set manufacturer offset */

	if (info->flash_id & FLASH_BTYPE) {
		volatile unsigned long *tmp = baseaddr;

		/* set up sector start adress table (bottom sector type)
		 * AND unlock the sectors (if our chip is 160C3)
		 */
		for (i = 0; i < info->sector_count; i++) {
			if ((info->flash_id & FLASH_TYPEMASK) == FLASH_28F160C3B) {
				tmp[0] = 0x00600060;
				tmp[1] = 0x00600060;
				tmp[0] = 0x00D000D0;
				tmp[1] = 0x00D000D0;
			}
			info->start[i] = (uint) tmp;
			tmp += i < 8 ? 0x2000 : 0x10000; /* pointer arith       */
		}
	}

	memset (info->protect, 0, info->sector_count);

	baseaddr[0] = 0x00FF00FF;
	baseaddr[1] = 0x00FF00FF;

	return (info->size);
}

static ulong flash_amd_get_size (vu_char *addr, flash_info_t *info)
{
	short i;
	uchar vendor, devid;
	ulong base = (ulong)addr;

	/* Write auto select command: read Manufacturer ID */
	addr[0x0555] = 0xAA;
	addr[0x02AA] = 0x55;
	addr[0x0555] = 0x90;

	udelay(1000);

	vendor = addr[0];
	devid = addr[1] & 0xff;

	/* only support AMD */
	if (vendor != 0x01) {
		return 0;
	}

	vendor &= 0xf;
	devid &= 0xff;

	if (devid == AMD_ID_F040B) {
		info->flash_id     = vendor << 16 | devid;
		info->sector_count = 8;
		info->size         = info->sector_count * 0x10000;
	}
	else if (devid == AMD_ID_F080B) {
		info->flash_id     = vendor << 16 | devid;
		info->sector_count = 16;
		info->size         = 4 * info->sector_count * 0x10000;
	}
	else if (devid == AMD_ID_F016D) {
		info->flash_id     = vendor << 16 | devid;
		info->sector_count = 32;
		info->size         = 4 * info->sector_count * 0x10000;
	}
	else {
		printf ("## Unknown Flash Type: %02x\n", devid);
		return 0;
	}

	/* check for protected sectors */
	for (i = 0; i < info->sector_count; i++) {
		/* sector base address */
		info->start[i] = base + i * (info->size / info->sector_count);
		/* read sector protection at sector address, (A7 .. A0) = 0x02 */
		/* D0 = 1 if protected */
		addr = (volatile unsigned char *)(info->start[i]);
		info->protect[i] = addr[2] & 1;
	}

	/*
	 * Prevent writes to uninitialized FLASH.
	 */
	if (info->flash_id != FLASH_UNKNOWN) {
		addr = (vu_char *)info->start[0];
		addr[0] = 0xF0; /* reset bank */
	}

	return (info->size);
}


/*-----------------------------------------------------------------------
 */
unsigned long flash_init (void)
{
	unsigned long size_b0 = 0;
	unsigned long size_b1 = 0;
	int i;

	/* Init: no FLASHes known
	 */
	for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
		flash_info[i].flash_id = FLASH_UNKNOWN;
	}

	/* Disable flash protection */
	CPU86_BCR |= (CPU86_BCR_FWPT | CPU86_BCR_FWRE);

	/* Static FLASH Bank configuration here (only one bank) */

	size_b0 = flash_int_get_size ((ulong *) CONFIG_SYS_FLASH_BASE, &flash_info[0]);
	size_b1 = flash_amd_get_size ((uchar *) CONFIG_SYS_BOOTROM_BASE, &flash_info[1]);

	if (size_b0 > 0 || size_b1 > 0) {

		printf("(");

		if (size_b0 > 0) {
			puts ("Bank#1 - ");
			print_size (size_b0, (size_b1 > 0) ? ", " : ") ");
		}

		if (size_b1 > 0) {
			puts ("Bank#2 - ");
			print_size (size_b1, ") ");
		}
	}
	else {
		printf ("## No FLASH found.\n");
		return 0;
	}
	/* protect monitor and environment sectors
	 */

#if CONFIG_SYS_MONITOR_BASE >= CONFIG_SYS_BOOTROM_BASE
	if (size_b1) {
		/* If U-Boot is booted from ROM the CONFIG_SYS_MONITOR_BASE > CONFIG_SYS_FLASH_BASE
		 * but we shouldn't protect it.
		 */

		flash_protect  (FLAG_PROTECT_SET,
				CONFIG_SYS_MONITOR_BASE,
				CONFIG_SYS_MONITOR_BASE + monitor_flash_len - 1, &flash_info[1]
		);
	}
#else
#if CONFIG_SYS_MONITOR_BASE >= CONFIG_SYS_FLASH_BASE
	flash_protect (FLAG_PROTECT_SET,
		       CONFIG_SYS_MONITOR_BASE,
		       CONFIG_SYS_MONITOR_BASE + monitor_flash_len - 1, &flash_info[0]
	);
#endif
#endif

#if defined(CONFIG_ENV_IS_IN_FLASH) && defined(CONFIG_ENV_ADDR)
# ifndef  CONFIG_ENV_SIZE
#  define CONFIG_ENV_SIZE	CONFIG_ENV_SECT_SIZE
# endif
# if CONFIG_ENV_ADDR >= CONFIG_SYS_BOOTROM_BASE
	if (size_b1) {
		flash_protect (FLAG_PROTECT_SET,
				CONFIG_ENV_ADDR,
				CONFIG_ENV_ADDR + CONFIG_ENV_SIZE - 1, &flash_info[1]);
	}
# else
	flash_protect (FLAG_PROTECT_SET,
		       CONFIG_ENV_ADDR,
		       CONFIG_ENV_ADDR + CONFIG_ENV_SIZE - 1, &flash_info[0]);
# endif
#endif

	return (size_b0 + size_b1);
}

/*-----------------------------------------------------------------------
 */
void flash_print_info (flash_info_t * info)
{
	int i;

	if (info->flash_id == FLASH_UNKNOWN) {
		printf ("missing or unknown FLASH type\n");
		return;
	}

	switch ((info->flash_id >> 16) & 0xff) {
	case 0x89:
		printf ("INTEL ");
		break;
	case 0x1:
		printf ("AMD ");
		break;
	default:
		printf ("Unknown Vendor ");
		break;
	}

	switch (info->flash_id & FLASH_TYPEMASK) {
	case FLASH_28F160C3B:
		printf ("28F160C3B (16 Mbit, bottom sector)\n");
		break;
	case FLASH_28F160F3B:
		printf ("28F160F3B (16 Mbit, bottom sector)\n");
		break;
	case AMD_ID_F040B:
		printf ("AM29F040B (4 Mbit)\n");
		break;
	default:
		printf ("Unknown Chip Type\n");
		break;
	}

	if (info->size < 0x100000)
		printf ("  Size: %ld KB in %d Sectors\n",
				info->size >> 10, info->sector_count);
	else
		printf ("  Size: %ld MB in %d Sectors\n",
				info->size >> 20, info->sector_count);

	printf ("  Sector Start Addresses:");
	for (i = 0; i < info->sector_count; ++i) {
		if ((i % 5) == 0)
			printf ("\n   ");
		printf (" %08lX%s",
			info->start[i],
			info->protect[i] ? " (RO)" : "     "
		);
	}
	printf ("\n");
}

/*-----------------------------------------------------------------------
 */
int flash_erase (flash_info_t * info, int s_first, int s_last)
{
	vu_char *addr = (vu_char *)(info->start[0]);
	int flag, prot, sect, l_sect;
	ulong start, now, last;

	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;
	}

	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");
	}

	/* Check the type of erased flash
	 */
	if (info->flash_id >> 16 == 0x1) {
		/* Erase AMD flash
		 */
		l_sect = -1;

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

		addr[0x0555] = 0xAA;
		addr[0x02AA] = 0x55;
		addr[0x0555] = 0x80;
		addr[0x0555] = 0xAA;
		addr[0x02AA] = 0x55;

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

		/* Start erase on unprotected sectors */
		for (sect = s_first; sect<=s_last; sect++) {
			if (info->protect[sect] == 0) { /* not protected */
				addr = (vu_char *)(info->start[sect]);
				addr[0] = 0x30;
				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 AMD_DONE;

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

AMD_DONE:
		/* reset to read mode */
		addr = (volatile unsigned char *)info->start[0];
		addr[0] = 0xF0;     /* reset bank */

	} else {
		/* Erase Intel flash
		 */

		/* Start erase on unprotected sectors
		 */
		for (sect = s_first; sect <= s_last; sect++) {
			volatile ulong *addr =
				(volatile unsigned long *) info->start[sect];

			start = get_timer (0);
			last = start;
			if (info->protect[sect] == 0) {
			/* Disable interrupts which might cause a timeout here
			 */
				flag = disable_interrupts ();

				/* Erase the block
				 */
				addr[0] = 0x00200020;
				addr[1] = 0x00200020;
				addr[0] = 0x00D000D0;
				addr[1] = 0x00D000D0;

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

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

				last = start;
				while ((addr[0] & 0x00800080) != 0x00800080 ||
				   (addr[1] & 0x00800080) != 0x00800080) {
					if ((now = get_timer (start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
						printf ("Timeout (erase suspended!)\n");
						/* Suspend erase
						 */
						addr[0] = 0x00B000B0;
						addr[1] = 0x00B000B0;
						goto DONE;
					}
					/* show that we're waiting
					 */
					if ((now - last) > 1000) {	/* every second */
						serial_putc ('.');
						last = now;
					}
				}
				if (addr[0] & 0x00220022 || addr[1] & 0x00220022) {
					printf ("*** ERROR: erase failed!\n");
					goto DONE;
				}
			}
			/* Clear status register and reset to read mode
			 */
			addr[0] = 0x00500050;
			addr[1] = 0x00500050;
			addr[0] = 0x00FF00FF;
			addr[1] = 0x00FF00FF;
		}
	}

	printf (" done\n");

DONE:
	return 0;
}

static int write_word (flash_info_t *, volatile unsigned long *, ulong);
static int write_byte (flash_info_t *info, ulong dest, uchar data);

/*-----------------------------------------------------------------------
 * Copy memory to flash, returns:
 * 0 - OK
 * 1 - write timeout
 * 2 - Flash not erased
 */
int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
{
	ulong v;
	int i, l, rc, cc = cnt, res = 0;

	if (info->flash_id >> 16 == 0x1) {

		/* Write to AMD 8-bit flash
		 */
		while (cnt > 0) {
			if ((rc = write_byte(info, addr, *src)) != 0) {
				return (rc);
			}
			addr++;
			src++;
			cnt--;
		}

		return (0);
	} else {

		/* Write to Intel 64-bit flash
		 */
		for (v=0; cc > 0; addr += 4, cc -= 4 - l) {
			l = (addr & 3);
			addr &= ~3;

			for (i = 0; i < 4; i++) {
				v = (v << 8) + (i < l || i - l >= cc ?
					*((unsigned char *) addr + i) : *src++);
			}

			if ((res = write_word (info, (volatile unsigned long *) addr, v)) != 0)
				break;
		}
	}

	return (res);
}

/*-----------------------------------------------------------------------
 * Write a word to Flash, returns:
 * 0 - OK
 * 1 - write timeout
 * 2 - Flash not erased
 */
static int write_word (flash_info_t * info, volatile unsigned long *addr,
					   ulong data)
{
	int flag, res = 0;
	ulong start;

	/* Check if Flash is (sufficiently) erased
	 */
	if ((*addr & data) != data)
		return (2);

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

	*addr = 0x00400040;
	*addr = data;

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

	start = get_timer (0);
	while ((*addr & 0x00800080) != 0x00800080) {
		if (get_timer (start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
			/* Suspend program
			 */
			*addr = 0x00B000B0;
			res = 1;
			goto OUT;
		}
	}

	if (*addr & 0x00220022) {
		printf ("*** ERROR: program failed!\n");
		res = 1;
	}

OUT:
	/* Clear status register and reset to read mode
	 */
	*addr = 0x00500050;
	*addr = 0x00FF00FF;

	return (res);
}

/*-----------------------------------------------------------------------
 * Write a byte to Flash, returns:
 * 0 - OK
 * 1 - write timeout
 * 2 - Flash not erased
 */
static int write_byte (flash_info_t *info, ulong dest, uchar data)
{
	vu_char *addr = (vu_char *)(info->start[0]);
	ulong start;
	int flag;

	/* Check if Flash is (sufficiently) erased */
	if ((*((vu_char *)dest) & data) != data) {
		return (2);
	}
	/* Disable interrupts which might cause a timeout here */
	flag = disable_interrupts();

	addr[0x0555] = 0xAA;
	addr[0x02AA] = 0x55;
	addr[0x0555] = 0xA0;

	*((vu_char *)dest) = data;

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

	/* data polling for D7 */
	start = get_timer (0);
	while ((*((vu_char *)dest) & 0x80) != (data & 0x80)) {
		if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
			return (1);
		}
	}
	return (0);
}

/*-----------------------------------------------------------------------
 */
Commit	Line	Data
cc1c8a13 WD	1	/*
	2	* (C) Copyright 2001, 2002
	3	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
	4	*
	5	* Flash Routines for Intel devices
	6	*
	7	*--------------------------------------------------------------------
1a459660	8	* SPDX-License-Identifier: GPL-2.0+
cc1c8a13 WD	9	*/
	10
	11	#include <common.h>
	12	#include <mpc8xx.h>
	13	#include "cpu86.h"
	14
6d0f6bcf	15	flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];
cc1c8a13 WD	16
	17	/*-----------------------------------------------------------------------
	18	*/
	19	ulong flash_int_get_size (volatile unsigned long *baseaddr,
	20	flash_info_t * info)
	21	{
	22	short i;
	23	unsigned long flashtest_h, flashtest_l;
	24
	25	info->sector_count = info->size = 0;
	26	info->flash_id = FLASH_UNKNOWN;
	27
efa329cb	28	/* Write identify command sequence and test FLASH answer
cc1c8a13	29	*/
efa329cb WD	30	baseaddr[0] = 0x00900090;
efa329cb WD	31	baseaddr[1] = 0x00900090;
cc1c8a13 WD	32
	33	flashtest_h = baseaddr[0]; /* manufacturer ID */
	34	flashtest_l = baseaddr[1];
	35
	36	if (flashtest_h != INTEL_MANUFACT \|\| flashtest_l != INTEL_MANUFACT)
	37	return (0); /* no or unknown flash */
	38
	39	flashtest_h = baseaddr[2]; /* device ID */
	40	flashtest_l = baseaddr[3];
	41
	42	if (flashtest_h != flashtest_l)
	43	return (0);
	44
	45	switch (flashtest_h) {
	46	case INTEL_ID_28F160C3B:
	47	info->flash_id = FLASH_28F160C3B;
	48	info->sector_count = 39;
	49	info->size = 0x00800000; /* 4 * 2 MB = 8 MB */
	50	break;
	51	case INTEL_ID_28F160F3B:
	52	info->flash_id = FLASH_28F160F3B;
	53	info->sector_count = 39;
	54	info->size = 0x00800000; /* 4 * 2 MB = 8 MB */
	55	break;
	56	default:
	57	return (0); /* no or unknown flash */
	58	}
	59
	60	info->flash_id \|= INTEL_MANUFACT << 16; /* set manufacturer offset */
	61
	62	if (info->flash_id & FLASH_BTYPE) {
	63	volatile unsigned long *tmp = baseaddr;
	64
	65	/* set up sector start adress table (bottom sector type)
	66	* AND unlock the sectors (if our chip is 160C3)
	67	*/
	68	for (i = 0; i < info->sector_count; i++) {
	69	if ((info->flash_id & FLASH_TYPEMASK) == FLASH_28F160C3B) {
	70	tmp[0] = 0x00600060;
	71	tmp[1] = 0x00600060;
	72	tmp[0] = 0x00D000D0;
	73	tmp[1] = 0x00D000D0;
	74	}
	75	info->start[i] = (uint) tmp;
	76	tmp += i < 8 ? 0x2000 : 0x10000; /* pointer arith */
	77	}
	78	}
	79
	80	memset (info->protect, 0, info->sector_count);
	81
	82	baseaddr[0] = 0x00FF00FF;
	83	baseaddr[1] = 0x00FF00FF;
	84
	85	return (info->size);
	86	}
	87
	88	static ulong flash_amd_get_size (vu_char addr, flash_info_t info)
	89	{
	90	short i;
	91	uchar vendor, devid;
	92	ulong base = (ulong)addr;
	93
	94	/* Write auto select command: read Manufacturer ID */
	95	addr[0x0555] = 0xAA;
96	addr[0x02AA] = 0x55;
97	addr[0x0555] = 0x90;
98
99	udelay(1000);
100
101	vendor = addr[0];
102	devid = addr[1] & 0xff;
103
104	/* only support AMD */
105	if (vendor != 0x01) {
106	return 0;
107	}
108
109	vendor &= 0xf;
110	devid &= 0xff;
111
112	if (devid == AMD_ID_F040B) {
113	info->flash_id = vendor << 16 \| devid;
114	info->sector_count = 8;
115	info->size = info->sector_count * 0x10000;
116	}
117	else if (devid == AMD_ID_F080B) {
118	info->flash_id = vendor << 16 \| devid;
119	info->sector_count = 16;
120	info->size = 4 * info->sector_count * 0x10000;
121	}
122	else if (devid == AMD_ID_F016D) {
123	info->flash_id = vendor << 16 \| devid;
124	info->sector_count = 32;
125	info->size = 4 * info->sector_count * 0x10000;
126	}
127	else {
128	printf ("## Unknown Flash Type: %02x\n", devid);
129	return 0;
130	}
131
132	/* check for protected sectors */
133	for (i = 0; i < info->sector_count; i++) {
134	/* sector base address */
135	info->start[i] = base + i * (info->size / info->sector_count);
136	/* read sector protection at sector address, (A7 .. A0) = 0x02 */
137	/* D0 = 1 if protected */
138	addr = (volatile unsigned char *)(info->start[i]);
139	info->protect[i] = addr[2] & 1;
140	}
141
142	/*
143	* Prevent writes to uninitialized FLASH.
144	*/
145	if (info->flash_id != FLASH_UNKNOWN) {
146	addr = (vu_char *)info->start[0];
147	addr[0] = 0xF0; /* reset bank */
148	}
149
150	return (info->size);
151	}
152
153
154	/*-----------------------------------------------------------------------
155	*/
156	unsigned long flash_init (void)
157	{
158	unsigned long size_b0 = 0;
159	unsigned long size_b1 = 0;
160	int i;
161
162	/* Init: no FLASHes known
163	*/
6d0f6bcf	164	for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
cc1c8a13 WD	165	flash_info[i].flash_id = FLASH_UNKNOWN;
	166	}
	167
	168	/* Disable flash protection */
	169	CPU86_BCR \|= (CPU86_BCR_FWPT \| CPU86_BCR_FWRE);
	170
	171	/* Static FLASH Bank configuration here (only one bank) */
	172
6d0f6bcf JCPV	173	size_b0 = flash_int_get_size ((ulong *) CONFIG_SYS_FLASH_BASE, &flash_info[0]);
6d0f6bcf JCPV	174	size_b1 = flash_amd_get_size ((uchar *) CONFIG_SYS_BOOTROM_BASE, &flash_info[1]);
cc1c8a13 WD	175
	176	if (size_b0 > 0 \|\| size_b1 > 0) {
	177
	178	printf("(");
	179
	180	if (size_b0 > 0) {
	181	puts ("Bank#1 - ");
	182	print_size (size_b0, (size_b1 > 0) ? ", " : ") ");
	183	}
	184
	185	if (size_b1 > 0) {
	186	puts ("Bank#2 - ");
	187	print_size (size_b1, ") ");
	188	}
	189	}
	190	else {
	191	printf ("## No FLASH found.\n");
	192	return 0;
	193	}
	194	/* protect monitor and environment sectors
	195	*/
	196
6d0f6bcf	197	#if CONFIG_SYS_MONITOR_BASE >= CONFIG_SYS_BOOTROM_BASE
cc1c8a13	198	if (size_b1) {
6d0f6bcf	199	/* If U-Boot is booted from ROM the CONFIG_SYS_MONITOR_BASE > CONFIG_SYS_FLASH_BASE
cc1c8a13 WD	200	* but we shouldn't protect it.
	201	*/
	202
	203	flash_protect (FLAG_PROTECT_SET,
6d0f6bcf JCPV	204	CONFIG_SYS_MONITOR_BASE,
6d0f6bcf JCPV	205	CONFIG_SYS_MONITOR_BASE + monitor_flash_len - 1, &flash_info[1]
cc1c8a13 WD	206	);
	207	}
	208	#else
6d0f6bcf	209	#if CONFIG_SYS_MONITOR_BASE >= CONFIG_SYS_FLASH_BASE
cc1c8a13	210	flash_protect (FLAG_PROTECT_SET,
6d0f6bcf JCPV	211	CONFIG_SYS_MONITOR_BASE,
6d0f6bcf JCPV	212	CONFIG_SYS_MONITOR_BASE + monitor_flash_len - 1, &flash_info[0]
cc1c8a13 WD	213	);
	214	#endif
	215	#endif
	216
0e8d1586 JCPV	217	#if defined(CONFIG_ENV_IS_IN_FLASH) && defined(CONFIG_ENV_ADDR)
	218	# ifndef CONFIG_ENV_SIZE
	219	# define CONFIG_ENV_SIZE CONFIG_ENV_SECT_SIZE
cc1c8a13	220	# endif
6d0f6bcf	221	# if CONFIG_ENV_ADDR >= CONFIG_SYS_BOOTROM_BASE
cc1c8a13 WD	222	if (size_b1) {
cc1c8a13 WD	223	flash_protect (FLAG_PROTECT_SET,
0e8d1586 JCPV	224	CONFIG_ENV_ADDR,
0e8d1586 JCPV	225	CONFIG_ENV_ADDR + CONFIG_ENV_SIZE - 1, &flash_info[1]);
cc1c8a13 WD	226	}
	227	# else
	228	flash_protect (FLAG_PROTECT_SET,
0e8d1586 JCPV	229	CONFIG_ENV_ADDR,
0e8d1586 JCPV	230	CONFIG_ENV_ADDR + CONFIG_ENV_SIZE - 1, &flash_info[0]);
cc1c8a13 WD	231	# endif
	232	#endif
	233
	234	return (size_b0 + size_b1);
	235	}
	236
	237	/*-----------------------------------------------------------------------
	238	*/
	239	void flash_print_info (flash_info_t * info)
	240	{
	241	int i;
	242
	243	if (info->flash_id == FLASH_UNKNOWN) {
	244	printf ("missing or unknown FLASH type\n");
	245	return;
	246	}
	247
	248	switch ((info->flash_id >> 16) & 0xff) {
	249	case 0x89:
	250	printf ("INTEL ");
	251	break;
	252	case 0x1:
	253	printf ("AMD ");
	254	break;
	255	default:
	256	printf ("Unknown Vendor ");
	257	break;
	258	}
	259
	260	switch (info->flash_id & FLASH_TYPEMASK) {
	261	case FLASH_28F160C3B:
	262	printf ("28F160C3B (16 Mbit, bottom sector)\n");
	263	break;
	264	case FLASH_28F160F3B:
	265	printf ("28F160F3B (16 Mbit, bottom sector)\n");
	266	break;
	267	case AMD_ID_F040B:
	268	printf ("AM29F040B (4 Mbit)\n");
	269	break;
	270	default:
	271	printf ("Unknown Chip Type\n");
	272	break;
	273	}
	274
	275	if (info->size < 0x100000)
	276	printf (" Size: %ld KB in %d Sectors\n",
	277	info->size >> 10, info->sector_count);
	278	else
	279	printf (" Size: %ld MB in %d Sectors\n",
	280	info->size >> 20, info->sector_count);
	281
	282	printf (" Sector Start Addresses:");
	283	for (i = 0; i < info->sector_count; ++i) {
	284	if ((i % 5) == 0)
	285	printf ("\n ");
	286	printf (" %08lX%s",
	287	info->start[i],
	288	info->protect[i] ? " (RO)" : " "
	289	);
	290	}
	291	printf ("\n");
	292	}
	293
	294	/*-----------------------------------------------------------------------
295	*/
296	int flash_erase (flash_info_t * info, int s_first, int s_last)
297	{
298	vu_char addr = (vu_char )(info->start[0]);
299	int flag, prot, sect, l_sect;
300	ulong start, now, last;
301
302	if ((s_first < 0) \|\| (s_first > s_last)) {
303	if (info->flash_id == FLASH_UNKNOWN) {
304	printf ("- missing\n");
305	} else {
306	printf ("- no sectors to erase\n");
307	}
308	return 1;
309	}
310
311	prot = 0;
312	for (sect = s_first; sect <= s_last; sect++) {
313	if (info->protect[sect])
314	prot++;
315	}
316
317	if (prot) {
318	printf ("- Warning: %d protected sectors will not be erased!\n",
319	prot);
320	} else {
321	printf ("\n");
322	}
323
324	/* Check the type of erased flash
325	*/
326	if (info->flash_id >> 16 == 0x1) {
327	/* Erase AMD flash
328	*/
329	l_sect = -1;
330
331	/* Disable interrupts which might cause a timeout here */
332	flag = disable_interrupts();
333
334	addr[0x0555] = 0xAA;
335	addr[0x02AA] = 0x55;
336	addr[0x0555] = 0x80;
337	addr[0x0555] = 0xAA;
338	addr[0x02AA] = 0x55;
339
340	/* wait at least 80us - let's wait 1 ms */
341	udelay (1000);
342
343	/* Start erase on unprotected sectors */
344	for (sect = s_first; sect<=s_last; sect++) {
345	if (info->protect[sect] == 0) { /* not protected */
346	addr = (vu_char *)(info->start[sect]);
347	addr[0] = 0x30;
348	l_sect = sect;
349	}
350	}
351
352	/* re-enable interrupts if necessary */
353	if (flag)
354	enable_interrupts();
355
356	/* wait at least 80us - let's wait 1 ms */
357	udelay (1000);
358
359	/*
360	* We wait for the last triggered sector
361	*/
362	if (l_sect < 0)
363	goto AMD_DONE;
364
365	start = get_timer (0);
366	last = start;
367	addr = (vu_char *)(info->start[l_sect]);
368	while ((addr[0] & 0x80) != 0x80) {
6d0f6bcf	369	if ((now = get_timer(start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
cc1c8a13 WD	370	printf ("Timeout\n");
	371	return 1;
	372	}
	373	/* show that we're waiting */
	374	if ((now - last) > 1000) { /* every second */
	375	serial_putc ('.');
	376	last = now;
	377	}
	378	}
	379
	380	AMD_DONE:
	381	/* reset to read mode */
	382	addr = (volatile unsigned char *)info->start[0];
	383	addr[0] = 0xF0; /* reset bank */
	384
	385	} else {
	386	/* Erase Intel flash
	387	*/
	388
	389	/* Start erase on unprotected sectors
	390	*/
	391	for (sect = s_first; sect <= s_last; sect++) {
	392	volatile ulong *addr =
	393	(volatile unsigned long *) info->start[sect];
	394
	395	start = get_timer (0);
	396	last = start;
	397	if (info->protect[sect] == 0) {
	398	/* Disable interrupts which might cause a timeout here
	399	*/
	400	flag = disable_interrupts ();
	401
	402	/* Erase the block
	403	*/
	404	addr[0] = 0x00200020;
	405	addr[1] = 0x00200020;
	406	addr[0] = 0x00D000D0;
	407	addr[1] = 0x00D000D0;
	408
	409	/* re-enable interrupts if necessary
	410	*/
	411	if (flag)
	412	enable_interrupts ();
	413
	414	/* wait at least 80us - let's wait 1 ms
	415	*/
	416	udelay (1000);
	417
	418	last = start;
	419	while ((addr[0] & 0x00800080) != 0x00800080 \|\|
	420	(addr[1] & 0x00800080) != 0x00800080) {
6d0f6bcf	421	if ((now = get_timer (start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
cc1c8a13 WD	422	printf ("Timeout (erase suspended!)\n");
	423	/* Suspend erase
	424	*/
	425	addr[0] = 0x00B000B0;
	426	addr[1] = 0x00B000B0;
	427	goto DONE;
	428	}
	429	/* show that we're waiting
	430	*/
	431	if ((now - last) > 1000) { /* every second */
	432	serial_putc ('.');
	433	last = now;
	434	}
	435	}
	436	if (addr[0] & 0x00220022 \|\| addr[1] & 0x00220022) {
	437	printf ("*** ERROR: erase failed!\n");
	438	goto DONE;
	439	}
	440	}
	441	/* Clear status register and reset to read mode
	442	*/
	443	addr[0] = 0x00500050;
	444	addr[1] = 0x00500050;
	445	addr[0] = 0x00FF00FF;
	446	addr[1] = 0x00FF00FF;
	447	}
	448	}
	449
	450	printf (" done\n");
	451
	452	DONE:
	453	return 0;
	454	}
	455
	456	static int write_word (flash_info_t , volatile unsigned long , ulong);
	457	static int write_byte (flash_info_t *info, ulong dest, uchar data);
	458
	459	/*-----------------------------------------------------------------------
	460	* Copy memory to flash, returns:
	461	* 0 - OK
	462	* 1 - write timeout
	463	* 2 - Flash not erased
	464	*/
	465	int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
	466	{
	467	ulong v;
	468	int i, l, rc, cc = cnt, res = 0;
	469
	470	if (info->flash_id >> 16 == 0x1) {
	471
	472	/* Write to AMD 8-bit flash
	473	*/
	474	while (cnt > 0) {
	475	if ((rc = write_byte(info, addr, *src)) != 0) {
	476	return (rc);
	477	}
	478	addr++;
	479	src++;
	480	cnt--;
	481	}
	482
	483	return (0);
	484	} else {
	485
486	/* Write to Intel 64-bit flash
487	*/
488	for (v=0; cc > 0; addr += 4, cc -= 4 - l) {
489	l = (addr & 3);
490	addr &= ~3;
491
492	for (i = 0; i < 4; i++) {
493	v = (v << 8) + (i < l \|\| i - l >= cc ?
494	((unsigned char ) addr + i) : *src++);
495	}
496
497	if ((res = write_word (info, (volatile unsigned long *) addr, v)) != 0)
498	break;
499	}
500	}
501
502	return (res);
503	}
504
505	/*-----------------------------------------------------------------------
506	* Write a word to Flash, returns:
507	* 0 - OK
508	* 1 - write timeout
509	* 2 - Flash not erased
510	*/
511	static int write_word (flash_info_t * info, volatile unsigned long *addr,
512	ulong data)
513	{
514	int flag, res = 0;
515	ulong start;
516
517	/* Check if Flash is (sufficiently) erased
518	*/
519	if ((*addr & data) != data)
520	return (2);
521
522	/* Disable interrupts which might cause a timeout here
523	*/
524	flag = disable_interrupts ();
525
526	*addr = 0x00400040;
527	*addr = data;
528
529	/* re-enable interrupts if necessary
530	*/
531	if (flag)
532	enable_interrupts ();
533
534	start = get_timer (0);
535	while ((*addr & 0x00800080) != 0x00800080) {
6d0f6bcf	536	if (get_timer (start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
cc1c8a13 WD	537	/* Suspend program
	538	*/
	539	*addr = 0x00B000B0;
	540	res = 1;
	541	goto OUT;
	542	}
	543	}
	544
	545	if (*addr & 0x00220022) {
	546	printf ("*** ERROR: program failed!\n");
	547	res = 1;
	548	}
	549
	550	OUT:
	551	/* Clear status register and reset to read mode
	552	*/
	553	*addr = 0x00500050;
	554	*addr = 0x00FF00FF;
	555
	556	return (res);
	557	}
	558
	559	/*-----------------------------------------------------------------------
	560	* Write a byte to Flash, returns:
	561	* 0 - OK
	562	* 1 - write timeout
	563	* 2 - Flash not erased
	564	*/
	565	static int write_byte (flash_info_t *info, ulong dest, uchar data)
	566	{
	567	vu_char addr = (vu_char )(info->start[0]);
	568	ulong start;
	569	int flag;
	570
	571	/* Check if Flash is (sufficiently) erased */
	572	if ((((vu_char )dest) & data) != data) {
	573	return (2);
	574	}
	575	/* Disable interrupts which might cause a timeout here */
	576	flag = disable_interrupts();
	577
	578	addr[0x0555] = 0xAA;
	579	addr[0x02AA] = 0x55;
	580	addr[0x0555] = 0xA0;
	581
	582	((vu_char )dest) = data;
	583
	584	/* re-enable interrupts if necessary */
	585	if (flag)
	586	enable_interrupts();
	587
	588	/* data polling for D7 */
	589	start = get_timer (0);
	590	while ((((vu_char )dest) & 0x80) != (data & 0x80)) {
6d0f6bcf	591	if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
cc1c8a13 WD	592	return (1);
	593	}
	594	}
	595	return (0);
	596	}
	597
	598	/*-----------------------------------------------------------------------
	599	*/