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

/*
 * (C) Copyright 2000-2004
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

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

#ifndef	CONFIG_ENV_ADDR
#define CONFIG_ENV_ADDR	(CONFIG_SYS_FLASH_BASE + CONFIG_ENV_OFFSET)
#endif

#define CONFIG_FLASH_16BIT

flash_info_t	flash_info[CONFIG_SYS_MAX_FLASH_BANKS]; /* info for FLASH chips	*/

/*-----------------------------------------------------------------------
 * Functions
 */
static ulong flash_get_size (vu_long *addr, flash_info_t *info);
static int write_word (flash_info_t *info, ulong dest, ulong data);

/*-----------------------------------------------------------------------
 */

unsigned long flash_init (void)
{
	volatile immap_t     *immap  = (immap_t *)CONFIG_SYS_IMMR;
	volatile memctl8xx_t *memctl = &immap->im_memctl;
	unsigned long size_b0;
	int i;

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

	/* Static FLASH Bank configuration here - FIXME XXX */

	size_b0 = flash_get_size((vu_long *)FLASH_BASE0_PRELIM, &flash_info[0]);

	if (flash_info[0].flash_id == FLASH_UNKNOWN) {
		printf ("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
			size_b0, size_b0<<20);
	}


	/* Remap FLASH according to real size */
	memctl->memc_or0 = CONFIG_SYS_OR_TIMING_FLASH | (-size_b0 & OR_AM_MSK);
	memctl->memc_br0 = (CONFIG_SYS_FLASH_BASE & BR_BA_MSK) | BR_MS_GPCM | BR_V | BR_PS_16;

	/* Re-do sizing to get full correct info */
	size_b0 = flash_get_size((vu_long *)CONFIG_SYS_FLASH_BASE, &flash_info[0]);

#if CONFIG_SYS_MONITOR_BASE >= CONFIG_SYS_FLASH_BASE
	/* monitor protection ON by default */
	flash_protect(FLAG_PROTECT_SET,
		      CONFIG_SYS_MONITOR_BASE,
		      CONFIG_SYS_MONITOR_BASE+monitor_flash_len-1,
		      &flash_info[0]);
#endif

#ifdef	CONFIG_ENV_IS_IN_FLASH
	/* ENV protection ON by default */
	flash_protect(FLAG_PROTECT_SET,
		      CONFIG_ENV_ADDR,
		      CONFIG_ENV_ADDR+CONFIG_ENV_SIZE-1,
		      &flash_info[0]);
#endif

	flash_info[0].size = size_b0;

	return (size_b0);
}

/*-----------------------------------------------------------------------
 */
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 & FLASH_VENDMASK) {
	case FLASH_MAN_AMD:	printf ("AMD ");		break;
	case FLASH_MAN_FUJ:	printf ("FUJITSU ");		break;
	default:		printf ("Unknown Vendor ");	break;
	}

	switch (info->flash_id & FLASH_TYPEMASK) {
	case FLASH_AM400B:	printf ("AM29LV400B (4 Mbit, bottom boot sect)\n");
				break;
	case FLASH_AM400T:	printf ("AM29LV400T (4 Mbit, top boot sector)\n");
				break;
	case FLASH_AM800B:	printf ("AM29LV800B (8 Mbit, bottom boot sect)\n");
				break;
	case FLASH_AM800T:	printf ("AM29LV800T (8 Mbit, top boot sector)\n");
				break;
	case FLASH_AM160B:	printf ("AM29LV160B (16 Mbit, bottom boot sect)\n");
				break;
	case FLASH_AM160T:	printf ("AM29LV160T (16 Mbit, top boot sector)\n");
				break;
	case FLASH_AM320B:	printf ("AM29LV320B (32 Mbit, bottom boot sect)\n");
				break;
	case FLASH_AM320T:	printf ("AM29LV320T (32 Mbit, top boot sector)\n");
				break;
	default:		printf ("Unknown Chip Type\n");
				break;
	}

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

/*-----------------------------------------------------------------------
 */


/*-----------------------------------------------------------------------
 */

/*
 * The following code cannot be run from FLASH!
 */

static ulong flash_get_size (vu_long *addr, flash_info_t *info)
{
	short i;
	ulong value;
	ulong base = (ulong)addr;

	/* Write auto select command: read Manufacturer ID */
	vu_short *s_addr=(vu_short*)addr;
	s_addr[0x5555] = 0x00AA;
	s_addr[0x2AAA] = 0x0055;
	s_addr[0x5555] = 0x0090;

	value = s_addr[0];
	value = value|(value<<16);

	switch (value) {
	case AMD_MANUFACT:
		info->flash_id = FLASH_MAN_AMD;
		break;
	case FUJ_MANUFACT:
		info->flash_id = FLASH_MAN_FUJ;
		break;
	default:
		info->flash_id = FLASH_UNKNOWN;
		info->sector_count = 0;
		info->size = 0;
		return (0);			/* no or unknown flash	*/
	}

	value = s_addr[1];
	value = value|(value<<16);

		switch (value) {
	case FUJI_ID_29F800BA:
		info->flash_id += FLASH_AM400T;
		info->sector_count = 19;
		info->size = 0x00100000;
		break;				/* => 1 MB		*/
	case AMD_ID_LV800T:
		info->flash_id += FLASH_AM800T;
		info->sector_count = 19;
		info->size = 0x00100000;
		break;				/* => 1 MB		*/
	case AMD_ID_LV800B:
		info->flash_id += FLASH_AM800B;
		info->sector_count = 19;
		info->size = 0x00100000;
		break;				/* => 1 MB		*/
	default:
		info->flash_id = FLASH_UNKNOWN;
		return (0);			/* => no or unknown flash */
	}

	/* set up sector start address table */
	/* set sector offsets for bottom boot block type	*/
	info->start[0] = base + 0x00000000;
	info->start[1] = base + 0x00004000;
	info->start[2] = base + 0x00006000;
	info->start[3] = base + 0x00008000;
	for (i = 4; i < info->sector_count; i++) {
		info->start[i] = base + (i * 0x00010000) - 0x00030000;
	}


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

	/*
	 * Prevent writes to uninitialized FLASH.
	 */
	if (info->flash_id != FLASH_UNKNOWN) {
		s_addr = (volatile unsigned short *)info->start[0];
		*s_addr = 0x00F0;	/* reset bank */
	}
	return (info->size);
}


/*-----------------------------------------------------------------------
 */


int	flash_erase (flash_info_t *info, int s_first, int s_last)
{
	vu_long *addr = (vu_long*)(info->start[0]);
	int flag, prot, sect;
	ulong start, now, last;
#ifdef CONFIG_FLASH_16BIT
	vu_short *s_addr = (vu_short*)addr;
#endif

	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;
	}
/*#ifndef CONFIG_FLASH_16BIT
	ulong type;
	type = (info->flash_id & FLASH_VENDMASK);
	if ((type != FLASH_MAN_SST) && (type != FLASH_MAN_STM)) {
		printf ("Can't erase unknown flash type %08lx - aborted\n",
			info->flash_id);
		return;
	}
#endif*/
	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;
	/* Start erase on unprotected sectors */
	for (sect = s_first; sect<=s_last; sect++) {
		if (info->protect[sect] == 0) {	/* not protected */
#ifdef CONFIG_FLASH_16BIT
			vu_short *s_sect_addr = (vu_short*)(info->start[sect]);
#else
			vu_long	*sect_addr = (vu_long*)(info->start[sect]);
#endif
			/* Disable interrupts which might cause a timeout here */
			flag = disable_interrupts();

#ifdef CONFIG_FLASH_16BIT

			/*printf("\ns_sect_addr=%x",s_sect_addr);*/
			s_addr[0x5555] = 0x00AA;
			s_addr[0x2AAA] = 0x0055;
			s_addr[0x5555] = 0x0080;
			s_addr[0x5555] = 0x00AA;
			s_addr[0x2AAA] = 0x0055;
			s_sect_addr[0] = 0x0030;
#else
			addr[0x5555] = 0x00AA00AA;
			addr[0x2AAA] = 0x00550055;
			addr[0x5555] = 0x00800080;
			addr[0x5555] = 0x00AA00AA;
			addr[0x2AAA] = 0x00550055;
			sect_addr[0] = 0x00300030;
#endif
			/* re-enable interrupts if necessary */
			if (flag)
				enable_interrupts();

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

#ifdef CONFIG_FLASH_16BIT
			while ((s_sect_addr[0] & 0x0080) != 0x0080) {
#else
			while ((sect_addr[0] & 0x00800080) != 0x00800080) {
#endif
				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 */
					putc ('.');
					last = now;
				}
			}
		}
	}

	/* reset to read mode */
	addr = (volatile unsigned long *)info->start[0];
#ifdef CONFIG_FLASH_16BIT
	s_addr[0] = 0x00F0;	/* reset bank */
#else
	addr[0] = 0x00F000F0;	/* reset bank */
#endif

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


/*-----------------------------------------------------------------------
 * 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 cp, wp, data;
	int i, l, rc;

	wp = (addr & ~3);	/* get lower word aligned address */

	/*
	 * 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<4 && cnt>0; ++i) {
			data = (data << 8) | *src++;
			--cnt;
			++cp;
		}
		for (; cnt==0 && i<4; ++i, ++cp) {
			data = (data << 8) | (*(uchar *)cp);
		}

		if ((rc = write_word(info, wp, data)) != 0) {
			return (rc);
		}
		wp += 4;
	}

	/*
	 * handle word aligned part
	 */
	while (cnt >= 4) {
		data = 0;
		for (i=0; i<4; ++i) {
			data = (data << 8) | *src++;
		}
		if ((rc = write_word(info, wp, data)) != 0) {
			return (rc);
		}
		wp  += 4;
		cnt -= 4;
	}

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

	/*
	 * handle unaligned tail bytes
	 */
	data = 0;
	for (i=0, cp=wp; i<4 && cnt>0; ++i, ++cp) {
		data = (data << 8) | *src++;
		--cnt;
	}
	for (; i<4; ++i, ++cp) {
		data = (data << 8) | (*(uchar *)cp);
	}

	return (write_word(info, wp, data));
}


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

#ifdef CONFIG_FLASH_16BIT
	vu_short high_data;
	vu_short low_data;
	vu_short *s_addr = (vu_short*)addr;
#endif
	ulong start;
	int flag;

	/* Check if Flash is (sufficiently) erased */
	if ((*((vu_long *)dest) & data) != data) {
		return (2);
	}

#ifdef CONFIG_FLASH_16BIT
	/* Write the 16 higher-bits */
	/* Disable interrupts which might cause a timeout here */
	flag = disable_interrupts();

	high_data = ((data>>16) & 0x0000ffff);

	s_addr[0x5555] = 0x00AA;
	s_addr[0x2AAA] = 0x0055;
	s_addr[0x5555] = 0x00A0;

	*((vu_short *)dest) = high_data;


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

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


	/* Write the 16 lower-bits */
#endif

	/* Disable interrupts which might cause a timeout here */
	flag = disable_interrupts();
#ifdef CONFIG_FLASH_16BIT
	dest += 0x2;
	low_data = (data & 0x0000ffff);

	s_addr[0x5555] = 0x00AA;
	s_addr[0x2AAA] = 0x0055;
	s_addr[0x5555] = 0x00A0;
	*((vu_short *)dest) = low_data;

#else
	addr[0x5555] = 0x00AA00AA;
	addr[0x2AAA] = 0x00550055;
	addr[0x5555] = 0x00A000A0;
	*((vu_long *)dest) = data;
#endif

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

	/* data polling for D7 */
	start = get_timer (0);

#ifdef CONFIG_FLASH_16BIT
	while ((*((vu_short *)dest) & 0x0080) != (low_data & 0x0080)) {
#else
	while ((*((vu_long *)dest) & 0x00800080) != (data & 0x00800080)) {
#endif

		if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
			return (1);
		}
	}
	return (0);
}
Commit	Line	Data
56f94be3	1	/*
0608e04d	2	* (C) Copyright 2000-2004
56f94be3 WD	3	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
56f94be3 WD	4	*
1a459660	5	* SPDX-License-Identifier: GPL-2.0+
56f94be3 WD	6	*/
	7
	8	#include <common.h>
	9	#include <mpc8xx.h>
	10
0e8d1586	11	#ifndef CONFIG_ENV_ADDR
6d0f6bcf	12	#define CONFIG_ENV_ADDR (CONFIG_SYS_FLASH_BASE + CONFIG_ENV_OFFSET)
56f94be3 WD	13	#endif
	14
	15	#define CONFIG_FLASH_16BIT
	16
6d0f6bcf	17	flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS]; /* info for FLASH chips */
56f94be3 WD	18
	19	/*-----------------------------------------------------------------------
	20	* Functions
	21	*/
	22	static ulong flash_get_size (vu_long addr, flash_info_t info);
	23	static int write_word (flash_info_t *info, ulong dest, ulong data);
	24
	25	/*-----------------------------------------------------------------------
	26	*/
	27
	28	unsigned long flash_init (void)
	29	{
6d0f6bcf	30	volatile immap_t immap = (immap_t )CONFIG_SYS_IMMR;
56f94be3 WD	31	volatile memctl8xx_t *memctl = &immap->im_memctl;
	32	unsigned long size_b0;
	33	int i;
	34
	35	/* Init: no FLASHes known */
6d0f6bcf	36	for (i=0; i<CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
56f94be3 WD	37	flash_info[i].flash_id = FLASH_UNKNOWN;
	38	}
	39
	40	/* Static FLASH Bank configuration here - FIXME XXX */
	41
	42	size_b0 = flash_get_size((vu_long *)FLASH_BASE0_PRELIM, &flash_info[0]);
	43
	44	if (flash_info[0].flash_id == FLASH_UNKNOWN) {
	45	printf ("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
	46	size_b0, size_b0<<20);
	47	}
	48
	49
	50	/* Remap FLASH according to real size */
6d0f6bcf JCPV	51	memctl->memc_or0 = CONFIG_SYS_OR_TIMING_FLASH \| (-size_b0 & OR_AM_MSK);
6d0f6bcf JCPV	52	memctl->memc_br0 = (CONFIG_SYS_FLASH_BASE & BR_BA_MSK) \| BR_MS_GPCM \| BR_V \| BR_PS_16;
56f94be3 WD	53
56f94be3 WD	54	/* Re-do sizing to get full correct info */
6d0f6bcf	55	size_b0 = flash_get_size((vu_long *)CONFIG_SYS_FLASH_BASE, &flash_info[0]);
56f94be3	56
6d0f6bcf	57	#if CONFIG_SYS_MONITOR_BASE >= CONFIG_SYS_FLASH_BASE
56f94be3 WD	58	/* monitor protection ON by default */
56f94be3 WD	59	flash_protect(FLAG_PROTECT_SET,
6d0f6bcf JCPV	60	CONFIG_SYS_MONITOR_BASE,
6d0f6bcf JCPV	61	CONFIG_SYS_MONITOR_BASE+monitor_flash_len-1,
56f94be3 WD	62	&flash_info[0]);
	63	#endif
	64
5a1aceb0	65	#ifdef CONFIG_ENV_IS_IN_FLASH
56f94be3 WD	66	/* ENV protection ON by default */
56f94be3 WD	67	flash_protect(FLAG_PROTECT_SET,
0e8d1586 JCPV	68	CONFIG_ENV_ADDR,
0e8d1586 JCPV	69	CONFIG_ENV_ADDR+CONFIG_ENV_SIZE-1,
56f94be3 WD	70	&flash_info[0]);
	71	#endif
	72
	73	flash_info[0].size = size_b0;
	74
	75	return (size_b0);
	76	}
	77
	78	/*-----------------------------------------------------------------------
	79	*/
	80	void flash_print_info (flash_info_t *info)
	81	{
	82	int i;
	83
	84	if (info->flash_id == FLASH_UNKNOWN) {
	85	printf ("missing or unknown FLASH type\n");
	86	return;
	87	}
	88
	89	switch (info->flash_id & FLASH_VENDMASK) {
	90	case FLASH_MAN_AMD: printf ("AMD "); break;
	91	case FLASH_MAN_FUJ: printf ("FUJITSU "); break;
	92	default: printf ("Unknown Vendor "); break;
	93	}
	94
	95	switch (info->flash_id & FLASH_TYPEMASK) {
	96	case FLASH_AM400B: printf ("AM29LV400B (4 Mbit, bottom boot sect)\n");
	97	break;
	98	case FLASH_AM400T: printf ("AM29LV400T (4 Mbit, top boot sector)\n");
	99	break;
	100	case FLASH_AM800B: printf ("AM29LV800B (8 Mbit, bottom boot sect)\n");
	101	break;
	102	case FLASH_AM800T: printf ("AM29LV800T (8 Mbit, top boot sector)\n");
	103	break;
	104	case FLASH_AM160B: printf ("AM29LV160B (16 Mbit, bottom boot sect)\n");
	105	break;
	106	case FLASH_AM160T: printf ("AM29LV160T (16 Mbit, top boot sector)\n");
	107	break;
	108	case FLASH_AM320B: printf ("AM29LV320B (32 Mbit, bottom boot sect)\n");
	109	break;
	110	case FLASH_AM320T: printf ("AM29LV320T (32 Mbit, top boot sector)\n");
	111	break;
	112	default: printf ("Unknown Chip Type\n");
	113	break;
	114	}
	115
	116	printf (" Size: %ld MB in %d Sectors\n",
	117	info->size >> 20, info->sector_count);
	118
	119	printf (" Sector Start Addresses:");
	120	for (i=0; i<info->sector_count; ++i) {
	121	if ((i % 5) == 0)
	122	printf ("\n ");
	123	printf (" %08lX%s",
	124	info->start[i],
	125	info->protect[i] ? " (RO)" : " "
	126	);
	127	}
	128	printf ("\n");
	129	return;
	130	}
	131
	132	/*-----------------------------------------------------------------------
	133	*/
134
135
136	/*-----------------------------------------------------------------------
137	*/
138
139	/*
140	* The following code cannot be run from FLASH!
141	*/
142
143	static ulong flash_get_size (vu_long addr, flash_info_t info)
144	{
145	short i;
146	ulong value;
147	ulong base = (ulong)addr;
148
149	/* Write auto select command: read Manufacturer ID */
150	vu_short s_addr=(vu_short)addr;
151	s_addr[0x5555] = 0x00AA;
152	s_addr[0x2AAA] = 0x0055;
153	s_addr[0x5555] = 0x0090;
154
155	value = s_addr[0];
156	value = value\|(value<<16);
157
158	switch (value) {
682011ff WD	159	case AMD_MANUFACT:
	160	info->flash_id = FLASH_MAN_AMD;
	161	break;
56f94be3 WD	162	case FUJ_MANUFACT:
	163	info->flash_id = FLASH_MAN_FUJ;
	164	break;
	165	default:
	166	info->flash_id = FLASH_UNKNOWN;
	167	info->sector_count = 0;
	168	info->size = 0;
	169	return (0); /* no or unknown flash */
	170	}
	171
	172	value = s_addr[1];
	173	value = value\|(value<<16);
	174
	175	switch (value) {
	176	case FUJI_ID_29F800BA:
	177	info->flash_id += FLASH_AM400T;
	178	info->sector_count = 19;
	179	info->size = 0x00100000;
	180	break; /* => 1 MB */
682011ff WD	181	case AMD_ID_LV800T:
	182	info->flash_id += FLASH_AM800T;
	183	info->sector_count = 19;
0608e04d WD	184	info->size = 0x00100000;
0608e04d WD	185	break; /* => 1 MB */
682011ff WD	186	case AMD_ID_LV800B:
	187	info->flash_id += FLASH_AM800B;
	188	info->sector_count = 19;
0608e04d WD	189	info->size = 0x00100000;
0608e04d WD	190	break; /* => 1 MB */
56f94be3 WD	191	default:
	192	info->flash_id = FLASH_UNKNOWN;
	193	return (0); /* => no or unknown flash */
	194	}
	195
	196	/* set up sector start address table */
	197	/* set sector offsets for bottom boot block type */
	198	info->start[0] = base + 0x00000000;
	199	info->start[1] = base + 0x00004000;
	200	info->start[2] = base + 0x00006000;
	201	info->start[3] = base + 0x00008000;
	202	for (i = 4; i < info->sector_count; i++) {
	203	info->start[i] = base + (i * 0x00010000) - 0x00030000;
	204	}
	205
	206
	207	/* check for protected sectors */
	208	for (i = 0; i < info->sector_count; i++) {
	209	/* read sector protection at sector address, (A7 .. A0) = 0x02 */
	210	/* D0 = 1 if protected */
	211	s_addr = (volatile unsigned short *)(info->start[i]);
	212	info->protect[i] = s_addr[2] & 1;
	213	}
	214
	215	/*
	216	* Prevent writes to uninitialized FLASH.
	217	*/
	218	if (info->flash_id != FLASH_UNKNOWN) {
	219	s_addr = (volatile unsigned short *)info->start[0];
	220	s_addr = 0x00F0; / reset bank */
	221	}
	222	return (info->size);
	223	}
	224
	225
	226	/*-----------------------------------------------------------------------
	227	*/
	228
	229
	230	int flash_erase (flash_info_t *info, int s_first, int s_last)
	231	{
	232	vu_long addr = (vu_long)(info->start[0]);
	233	int flag, prot, sect;
	234	ulong start, now, last;
	235	#ifdef CONFIG_FLASH_16BIT
	236	vu_short s_addr = (vu_short)addr;
	237	#endif
	238
	239	if ((s_first < 0) \|\| (s_first > s_last)) {
	240	if (info->flash_id == FLASH_UNKNOWN) {
	241	printf ("- missing\n");
	242	} else {
	243	printf ("- no sectors to erase\n");
	244	}
	245	return 1;
	246	}
	247	/*#ifndef CONFIG_FLASH_16BIT
	248	ulong type;
	249	type = (info->flash_id & FLASH_VENDMASK);
	250	if ((type != FLASH_MAN_SST) && (type != FLASH_MAN_STM)) {
	251	printf ("Can't erase unknown flash type %08lx - aborted\n",
	252	info->flash_id);
	253	return;
	254	}
255	#endif*/
256	prot = 0;
257	for (sect=s_first; sect<=s_last; ++sect) {
258	if (info->protect[sect]) {
259	prot++;
260	}
261	}
262
263	if (prot) {
264	printf ("- Warning: %d protected sectors will not be erased!\n",
265	prot);
266	} else {
267	printf ("\n");
268	}
269
270	start = get_timer (0);
271	last = start;
272	/* Start erase on unprotected sectors */
273	for (sect = s_first; sect<=s_last; sect++) {
274	if (info->protect[sect] == 0) { /* not protected */
275	#ifdef CONFIG_FLASH_16BIT
276	vu_short s_sect_addr = (vu_short)(info->start[sect]);
277	#else
278	vu_long sect_addr = (vu_long)(info->start[sect]);
279	#endif
280	/* Disable interrupts which might cause a timeout here */
281	flag = disable_interrupts();
282
283	#ifdef CONFIG_FLASH_16BIT
284
285	/printf("\ns_sect_addr=%x",s_sect_addr);/
286	s_addr[0x5555] = 0x00AA;
287	s_addr[0x2AAA] = 0x0055;
288	s_addr[0x5555] = 0x0080;
289	s_addr[0x5555] = 0x00AA;
290	s_addr[0x2AAA] = 0x0055;
291	s_sect_addr[0] = 0x0030;
292	#else
293	addr[0x5555] = 0x00AA00AA;
294	addr[0x2AAA] = 0x00550055;
295	addr[0x5555] = 0x00800080;
296	addr[0x5555] = 0x00AA00AA;
297	addr[0x2AAA] = 0x00550055;
298	sect_addr[0] = 0x00300030;
299	#endif
300	/* re-enable interrupts if necessary */
301	if (flag)
302	enable_interrupts();
303
304	/* wait at least 80us - let's wait 1 ms */
305	udelay (1000);
306
307	#ifdef CONFIG_FLASH_16BIT
308	while ((s_sect_addr[0] & 0x0080) != 0x0080) {
309	#else
310	while ((sect_addr[0] & 0x00800080) != 0x00800080) {
311	#endif
6d0f6bcf	312	if ((now = get_timer(start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
56f94be3 WD	313	printf ("Timeout\n");
	314	return 1;
	315	}
	316	/* show that we're waiting */
	317	if ((now - last) > 1000) { /* every second */
	318	putc ('.');
	319	last = now;
	320	}
	321	}
	322	}
	323	}
	324
	325	/* reset to read mode */
	326	addr = (volatile unsigned long *)info->start[0];
	327	#ifdef CONFIG_FLASH_16BIT
	328	s_addr[0] = 0x00F0; /* reset bank */
	329	#else
	330	addr[0] = 0x00F000F0; /* reset bank */
	331	#endif
	332
	333	printf (" done\n");
	334	return 0;
	335	}
	336
	337
	338	/*-----------------------------------------------------------------------
	339	* Copy memory to flash, returns:
	340	* 0 - OK
	341	* 1 - write timeout
	342	* 2 - Flash not erased
	343	*/
	344
	345	int write_buff (flash_info_t info, uchar src, ulong addr, ulong cnt)
	346	{
	347	ulong cp, wp, data;
	348	int i, l, rc;
	349
	350	wp = (addr & ~3); /* get lower word aligned address */
	351
	352	/*
	353	* handle unaligned start bytes
	354	*/
	355	if ((l = addr - wp) != 0) {
	356	data = 0;
	357	for (i=0, cp=wp; i<l; ++i, ++cp) {
	358	data = (data << 8) \| ((uchar )cp);
	359	}
	360	for (; i<4 && cnt>0; ++i) {
	361	data = (data << 8) \| *src++;
	362	--cnt;
	363	++cp;
	364	}
	365	for (; cnt==0 && i<4; ++i, ++cp) {
	366	data = (data << 8) \| ((uchar )cp);
	367	}
	368
	369	if ((rc = write_word(info, wp, data)) != 0) {
	370	return (rc);
	371	}
	372	wp += 4;
	373	}
	374
	375	/*
	376	* handle word aligned part
377	*/
378	while (cnt >= 4) {
379	data = 0;
380	for (i=0; i<4; ++i) {
381	data = (data << 8) \| *src++;
382	}
383	if ((rc = write_word(info, wp, data)) != 0) {
384	return (rc);
385	}
386	wp += 4;
387	cnt -= 4;
388	}
389
390	if (cnt == 0) {
391	return (0);
392	}
393
394	/*
395	* handle unaligned tail bytes
396	*/
397	data = 0;
398	for (i=0, cp=wp; i<4 && cnt>0; ++i, ++cp) {
399	data = (data << 8) \| *src++;
400	--cnt;
401	}
402	for (; i<4; ++i, ++cp) {
403	data = (data << 8) \| ((uchar )cp);
404	}
405
406	return (write_word(info, wp, data));
407	}
408
409
410	/*-----------------------------------------------------------------------
411	* Write a word to Flash, returns:
412	* 0 - OK
413	* 1 - write timeout
414	* 2 - Flash not erased
415	*/
416	static int write_word (flash_info_t *info, ulong dest, ulong data)
417	{
418	vu_long addr = (vu_long)(info->start[0]);
419
420	#ifdef CONFIG_FLASH_16BIT
421	vu_short high_data;
422	vu_short low_data;
423	vu_short s_addr = (vu_short)addr;
424	#endif
425	ulong start;
426	int flag;
427
428	/* Check if Flash is (sufficiently) erased */
429	if ((((vu_long )dest) & data) != data) {
430	return (2);
431	}
432
433	#ifdef CONFIG_FLASH_16BIT
434	/* Write the 16 higher-bits */
435	/* Disable interrupts which might cause a timeout here */
436	flag = disable_interrupts();
437
438	high_data = ((data>>16) & 0x0000ffff);
439
440	s_addr[0x5555] = 0x00AA;
441	s_addr[0x2AAA] = 0x0055;
442	s_addr[0x5555] = 0x00A0;
443
444	((vu_short )dest) = high_data;
445
446
447	/* re-enable interrupts if necessary */
448	if (flag)
449	enable_interrupts();
450
451	/* data polling for D7 */
452	start = get_timer (0);
453	while ((((vu_short )dest) & 0x0080) != (high_data & 0x0080)) {
6d0f6bcf	454	if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
56f94be3 WD	455	return (1);
	456	}
	457	}
	458
	459
	460	/* Write the 16 lower-bits */
	461	#endif
	462
	463	/* Disable interrupts which might cause a timeout here */
	464	flag = disable_interrupts();
	465	#ifdef CONFIG_FLASH_16BIT
	466	dest += 0x2;
	467	low_data = (data & 0x0000ffff);
	468
	469	s_addr[0x5555] = 0x00AA;
	470	s_addr[0x2AAA] = 0x0055;
	471	s_addr[0x5555] = 0x00A0;
	472	((vu_short )dest) = low_data;
	473
	474	#else
	475	addr[0x5555] = 0x00AA00AA;
	476	addr[0x2AAA] = 0x00550055;
	477	addr[0x5555] = 0x00A000A0;
	478	((vu_long )dest) = data;
	479	#endif
	480
	481	/* re-enable interrupts if necessary */
	482	if (flag)
	483	enable_interrupts();
	484
	485	/* data polling for D7 */
	486	start = get_timer (0);
	487
	488	#ifdef CONFIG_FLASH_16BIT
	489	while ((((vu_short )dest) & 0x0080) != (low_data & 0x0080)) {
	490	#else
	491	while ((((vu_long )dest) & 0x00800080) != (data & 0x00800080)) {
	492	#endif
	493
6d0f6bcf	494	if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
56f94be3 WD	495	return (1);
	496	}
	497	}
	498	return (0);
	499	}