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

/*
 * (C) Copyright 2000-2003
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 *
 * Copyright (C) 2004-2007 Freescale Semiconductor, Inc.
 * TsiChung Liew (Tsi-Chung.Liew@freescale.com)
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>

#include <asm/immap.h>

#ifndef CONFIG_SYS_FLASH_CFI
typedef unsigned short FLASH_PORT_WIDTH;
typedef volatile unsigned short FLASH_PORT_WIDTHV;

#define FPW             FLASH_PORT_WIDTH
#define FPWV            FLASH_PORT_WIDTHV

#define FLASH_CYCLE1    0x5555
#define FLASH_CYCLE2    0x2aaa

#define SYNC			__asm__("nop")

/*-----------------------------------------------------------------------
 * Functions
 */

ulong flash_get_size(FPWV * addr, flash_info_t * info);
int flash_get_offsets(ulong base, flash_info_t * info);
int write_word(flash_info_t * info, FPWV * dest, u16 data);
void inline spin_wheel(void);

flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];

ulong flash_init(void)
{
	ulong size = 0;
	ulong fbase = 0;

	fbase = (ulong) CONFIG_SYS_FLASH_BASE;
	flash_get_size((FPWV *) fbase, &flash_info[0]);
	flash_get_offsets((ulong) fbase, &flash_info[0]);
	fbase += flash_info[0].size;
	size += flash_info[0].size;

	/* Protect monitor and environment sectors */
	flash_protect(FLAG_PROTECT_SET,
		      CONFIG_SYS_MONITOR_BASE,
		      CONFIG_SYS_MONITOR_BASE + monitor_flash_len - 1, &flash_info[0]);

	return size;
}

int flash_get_offsets(ulong base, flash_info_t * info)
{
	int i;

	if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) {

		info->start[0] = base;
		info->protect[0] = 0;
		for (i = 1; i < CONFIG_SYS_SST_SECT; i++) {
			info->start[i] = info->start[i - 1]
						+ CONFIG_SYS_SST_SECTSZ;
			info->protect[i] = 0;
		}
	}

	return ERR_OK;
}

void flash_print_info(flash_info_t * info)
{
	int i;

	switch (info->flash_id & FLASH_VENDMASK) {
	case FLASH_MAN_SST:
		printf("SST ");
		break;
	default:
		printf("Unknown Vendor ");
		break;
	}

	switch (info->flash_id & FLASH_TYPEMASK) {
	case FLASH_SST6401B:
		printf("SST39VF6401B\n");
		break;
	default:
		printf("Unknown Chip Type\n");
		return;
	}

	if (info->size > 0x100000) {
		int remainder;

		printf("  Size: %ld", info->size >> 20);

		remainder = (info->size % 0x100000);
		if (remainder) {
			remainder >>= 10;
			remainder = (int)((float)
					  (((float)remainder / (float)1024) *
					   10000));
			printf(".%d ", remainder);
		}

		printf("MB in %d Sectors\n", info->sector_count);
	} else
		printf("  Size: %ld KB in %d Sectors\n",
		       info->size >> 10, 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");
}

/*
 * The following code cannot be run from FLASH!
 */
ulong flash_get_size(FPWV * addr, flash_info_t * info)
{
	u16 value;

	addr[FLASH_CYCLE1] = (FPWV) 0x00AA00AA;	/* for Atmel, Intel ignores this */
	addr[FLASH_CYCLE2] = (FPWV) 0x00550055;	/* for Atmel, Intel ignores this */
	addr[FLASH_CYCLE1] = (FPWV) 0x00900090;	/* selects Intel or Atmel */

	switch (addr[0] & 0xffff) {
	case (u8) SST_MANUFACT:
		info->flash_id = FLASH_MAN_SST;
		value = addr[1];
		break;
	default:
		printf("Unknown Flash\n");
		info->flash_id = FLASH_UNKNOWN;
		info->sector_count = 0;
		info->size = 0;

		*addr = (FPW) 0x00F000F0;
		return (0);	/* no or unknown flash  */
	}

	switch (value) {
	case (u16) SST_ID_xF6401B:
		info->flash_id += FLASH_SST6401B;
		break;
	default:
		info->flash_id = FLASH_UNKNOWN;
		break;
	}

	info->sector_count = 0;
	info->size = 0;
	info->sector_count = CONFIG_SYS_SST_SECT;
	info->size = CONFIG_SYS_SST_SECT * CONFIG_SYS_SST_SECTSZ;

	/* reset ID mode */
	*addr = (FPWV) 0x00F000F0;

	if (info->sector_count > CONFIG_SYS_MAX_FLASH_SECT) {
		printf("** ERROR: sector count %d > max (%d) **\n",
		       info->sector_count, CONFIG_SYS_MAX_FLASH_SECT);
		info->sector_count = CONFIG_SYS_MAX_FLASH_SECT;
	}

	return (info->size);
}

int flash_erase(flash_info_t * info, int s_first, int s_last)
{
	FPWV *addr;
	int flag, prot, sect, count;
	ulong type, start;
	int rcode = 0, flashtype = 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);

	switch (type) {
	case FLASH_MAN_SST:
		flashtype = 1;
		break;
	default:
		type = (info->flash_id & FLASH_VENDMASK);
		printf("Can't erase unknown flash type %08lx - aborted\n",
		       info->flash_id);
		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");

	flag = disable_interrupts();

	start = get_timer(0);

	if ((s_last - s_first) == (CONFIG_SYS_SST_SECT - 1)) {
		if (prot == 0) {
			addr = (FPWV *) info->start[0];

			addr[FLASH_CYCLE1] = 0x00AA;	/* unlock */
			addr[FLASH_CYCLE2] = 0x0055;	/* unlock */
			addr[FLASH_CYCLE1] = 0x0080;	/* erase mode */
			addr[FLASH_CYCLE1] = 0x00AA;	/* unlock */
			addr[FLASH_CYCLE2] = 0x0055;	/* unlock */
			*addr = 0x0030;	/* erase chip */

			count = 0;
			start = get_timer(0);

			while ((*addr & 0x0080) != 0x0080) {
				if (count++ > 0x10000) {
					spin_wheel();
					count = 0;
				}

				if (get_timer(start) > CONFIG_SYS_FLASH_ERASE_TOUT) {
					printf("Timeout\n");
					*addr = 0x00F0;	/* reset to read mode */

					return 1;
				}
			}

			*addr = 0x00F0;	/* reset to read mode */

			printf("\b. done\n");

			if (flag)
				enable_interrupts();

			return 0;
		} else if (prot == CONFIG_SYS_SST_SECT) {
			return 1;
		}
	}

	/* Start erase on unprotected sectors */
	for (sect = s_first; sect <= s_last; sect++) {
		if (info->protect[sect] == 0) {	/* not protected */

			addr = (FPWV *) (info->start[sect]);

			printf(".");

			/* arm simple, non interrupt dependent timer */
			start = get_timer(0);

			switch (flashtype) {
			case 1:
				{
					FPWV *base;	/* first address in bank */

					flag = disable_interrupts();

					base = (FPWV *) (CONFIG_SYS_FLASH_BASE);	/* First sector */

					base[FLASH_CYCLE1] = 0x00AA;	/* unlock */
					base[FLASH_CYCLE2] = 0x0055;	/* unlock */
					base[FLASH_CYCLE1] = 0x0080;	/* erase mode */
					base[FLASH_CYCLE1] = 0x00AA;	/* unlock */
					base[FLASH_CYCLE2] = 0x0055;	/* unlock */
					*addr = 0x0050;	/* erase sector */

					if (flag)
						enable_interrupts();

					while ((*addr & 0x0080) != 0x0080) {
						if (get_timer(start) >
						    CONFIG_SYS_FLASH_ERASE_TOUT) {
							printf("Timeout\n");
							*addr = 0x00F0;	/* reset to read mode */

							rcode = 1;
							break;
						}
					}

					*addr = 0x00F0;	/* reset to read mode */
					break;
				}
			}	/* switch (flashtype) */
		}
	}
	printf(" done\n");

	if (flag)
		enable_interrupts();

	return rcode;
}

int write_buff(flash_info_t * info, uchar * src, ulong addr, ulong cnt)
{
	ulong wp, count;
	u16 data;
	int rc;

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

	/* get lower word aligned address */
	wp = addr;

	/* handle unaligned start bytes */
	if (wp & 1) {
		data = *((FPWV *) wp);
		data = (data << 8) | *src;

		if ((rc = write_word(info, (FPWV *) wp, data)) != 0)
			return (rc);

		wp++;
		cnt -= 1;
		src++;
	}

	while (cnt >= 2) {
		/*
		 * handle word aligned part
		 */
		count = 0;
		data = *((FPWV *) src);

		if ((rc = write_word(info, (FPWV *) wp, data)) != 0)
			return (rc);

		wp += 2;
		src += 2;
		cnt -= 2;

		if (count++ > 0x800) {
			spin_wheel();
			count = 0;
		}
	}
	/* handle word aligned part */
	if (cnt) {
		/* handle word aligned part */
		count = 0;
		data = *((FPWV *) wp);

		data = (data & 0x00FF) | (*src << 8);

		if ((rc = write_word(info, (FPWV *) wp, data)) != 0)
			return (rc);

		wp++;
		src++;
		cnt -= 1;
		if (count++ > 0x800) {
			spin_wheel();
			count = 0;
		}
	}

	if (cnt == 0)
		return ERR_OK;

	return ERR_OK;
}

/*-----------------------------------------------------------------------
 * Write a word to Flash
 * A word is 16 bits, whichever the bus width of the flash bank
 * (not an individual chip) is.
 *
 * returns:
 * 0 - OK
 * 1 - write timeout
 * 2 - Flash not erased
 */
int write_word(flash_info_t * info, FPWV * dest, u16 data)
{
	ulong start;
	int flag;
	int res = 0;		/* result, assume success */
	FPWV *base;		/* first address in flash bank */

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

	base = (FPWV *) (CONFIG_SYS_FLASH_BASE);

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

	base[FLASH_CYCLE1] = (u8) 0x00AA00AA;	/* unlock */
	base[FLASH_CYCLE2] = (u8) 0x00550055;	/* unlock */
	base[FLASH_CYCLE1] = (u8) 0x00A000A0;	/* selects program mode */

	*dest = data;		/* start programming the data */

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

	start = get_timer(0);

	/* data polling for D7 */
	while (res == 0
	       && (*dest & (u8) 0x00800080) != (data & (u8) 0x00800080)) {
		if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
			*dest = (u8) 0x00F000F0;	/* reset bank */
			res = 1;
		}
	}

	*dest++ = (u8) 0x00F000F0;	/* reset bank */

	return (res);
}

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

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

#endif
Commit	Line	Data
6d33c6ac TL	1	/*
	2	* (C) Copyright 2000-2003
	3	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
	4	*
	5	* Copyright (C) 2004-2007 Freescale Semiconductor, Inc.
	6	* TsiChung Liew (Tsi-Chung.Liew@freescale.com)
	7	*
1a459660	8	* SPDX-License-Identifier: GPL-2.0+
6d33c6ac TL	9	*/
	10
	11	#include <common.h>
	12
	13	#include <asm/immap.h>
	14
6d0f6bcf	15	#ifndef CONFIG_SYS_FLASH_CFI
6d33c6ac TL	16	typedef unsigned short FLASH_PORT_WIDTH;
	17	typedef volatile unsigned short FLASH_PORT_WIDTHV;
	18
	19	#define FPW FLASH_PORT_WIDTH
	20	#define FPWV FLASH_PORT_WIDTHV
	21
	22	#define FLASH_CYCLE1 0x5555
	23	#define FLASH_CYCLE2 0x2aaa
	24
	25	#define SYNC __asm__("nop")
	26
	27	/*-----------------------------------------------------------------------
	28	* Functions
	29	*/
	30
	31	ulong flash_get_size(FPWV * addr, flash_info_t * info);
	32	int flash_get_offsets(ulong base, flash_info_t * info);
	33	int write_word(flash_info_t * info, FPWV * dest, u16 data);
	34	void inline spin_wheel(void);
	35
6d0f6bcf	36	flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];
6d33c6ac TL	37
	38	ulong flash_init(void)
	39	{
	40	ulong size = 0;
	41	ulong fbase = 0;
	42
6d0f6bcf	43	fbase = (ulong) CONFIG_SYS_FLASH_BASE;
6d33c6ac TL	44	flash_get_size((FPWV *) fbase, &flash_info[0]);
	45	flash_get_offsets((ulong) fbase, &flash_info[0]);
	46	fbase += flash_info[0].size;
	47	size += flash_info[0].size;
	48
	49	/* Protect monitor and environment sectors */
	50	flash_protect(FLAG_PROTECT_SET,
6d0f6bcf JCPV	51	CONFIG_SYS_MONITOR_BASE,
6d0f6bcf JCPV	52	CONFIG_SYS_MONITOR_BASE + monitor_flash_len - 1, &flash_info[0]);
6d33c6ac TL	53
	54	return size;
	55	}
	56
	57	int flash_get_offsets(ulong base, flash_info_t * info)
	58	{
61f06b14	59	int i;
6d33c6ac TL	60
	61	if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) {
	62
	63	info->start[0] = base;
61f06b14 MY	64	info->protect[0] = 0;
	65	for (i = 1; i < CONFIG_SYS_SST_SECT; i++) {
	66	info->start[i] = info->start[i - 1]
	67	+ CONFIG_SYS_SST_SECTSZ;
	68	info->protect[i] = 0;
6d33c6ac TL	69	}
	70	}
	71
	72	return ERR_OK;
	73	}
	74
	75	void flash_print_info(flash_info_t * info)
	76	{
	77	int i;
	78
	79	switch (info->flash_id & FLASH_VENDMASK) {
	80	case FLASH_MAN_SST:
	81	printf("SST ");
	82	break;
	83	default:
	84	printf("Unknown Vendor ");
	85	break;
	86	}
	87
	88	switch (info->flash_id & FLASH_TYPEMASK) {
	89	case FLASH_SST6401B:
	90	printf("SST39VF6401B\n");
	91	break;
	92	default:
	93	printf("Unknown Chip Type\n");
	94	return;
	95	}
	96
	97	if (info->size > 0x100000) {
	98	int remainder;
	99
	100	printf(" Size: %ld", info->size >> 20);
	101
	102	remainder = (info->size % 0x100000);
	103	if (remainder) {
	104	remainder >>= 10;
	105	remainder = (int)((float)
	106	(((float)remainder / (float)1024) *
	107	10000));
	108	printf(".%d ", remainder);
	109	}
	110
	111	printf("MB in %d Sectors\n", info->sector_count);
	112	} else
	113	printf(" Size: %ld KB in %d Sectors\n",
	114	info->size >> 10, info->sector_count);
	115
	116	printf(" Sector Start Addresses:");
	117	for (i = 0; i < info->sector_count; ++i) {
	118	if ((i % 5) == 0)
	119	printf("\n ");
	120	printf(" %08lX%s",
	121	info->start[i], info->protect[i] ? " (RO)" : " ");
	122	}
	123	printf("\n");
	124	}
	125
	126	/*
	127	* The following code cannot be run from FLASH!
	128	*/
	129	ulong flash_get_size(FPWV * addr, flash_info_t * info)
	130	{
	131	u16 value;
	132
133	addr[FLASH_CYCLE1] = (FPWV) 0x00AA00AA; /* for Atmel, Intel ignores this */
134	addr[FLASH_CYCLE2] = (FPWV) 0x00550055; /* for Atmel, Intel ignores this */
135	addr[FLASH_CYCLE1] = (FPWV) 0x00900090; /* selects Intel or Atmel */
136
137	switch (addr[0] & 0xffff) {
138	case (u8) SST_MANUFACT:
139	info->flash_id = FLASH_MAN_SST;
140	value = addr[1];
141	break;
142	default:
143	printf("Unknown Flash\n");
144	info->flash_id = FLASH_UNKNOWN;
145	info->sector_count = 0;
146	info->size = 0;
147
148	*addr = (FPW) 0x00F000F0;
149	return (0); /* no or unknown flash */
150	}
151
152	switch (value) {
153	case (u16) SST_ID_xF6401B:
154	info->flash_id += FLASH_SST6401B;
155	break;
156	default:
157	info->flash_id = FLASH_UNKNOWN;
158	break;
159	}
160
161	info->sector_count = 0;
162	info->size = 0;
6d0f6bcf JCPV	163	info->sector_count = CONFIG_SYS_SST_SECT;
6d0f6bcf JCPV	164	info->size = CONFIG_SYS_SST_SECT * CONFIG_SYS_SST_SECTSZ;
6d33c6ac TL	165
	166	/* reset ID mode */
	167	*addr = (FPWV) 0x00F000F0;
	168
6d0f6bcf	169	if (info->sector_count > CONFIG_SYS_MAX_FLASH_SECT) {
6d33c6ac	170	printf(" ERROR: sector count %d > max (%d) \n",
6d0f6bcf JCPV	171	info->sector_count, CONFIG_SYS_MAX_FLASH_SECT);
6d0f6bcf JCPV	172	info->sector_count = CONFIG_SYS_MAX_FLASH_SECT;
6d33c6ac TL	173	}
	174
	175	return (info->size);
	176	}
	177
	178	int flash_erase(flash_info_t * info, int s_first, int s_last)
	179	{
	180	FPWV *addr;
	181	int flag, prot, sect, count;
e6af3859	182	ulong type, start;
6d33c6ac TL	183	int rcode = 0, flashtype = 0;
	184
	185	if ((s_first < 0) \|\| (s_first > s_last)) {
	186	if (info->flash_id == FLASH_UNKNOWN)
	187	printf("- missing\n");
	188	else
	189	printf("- no sectors to erase\n");
	190	return 1;
	191	}
	192
	193	type = (info->flash_id & FLASH_VENDMASK);
	194
	195	switch (type) {
	196	case FLASH_MAN_SST:
	197	flashtype = 1;
	198	break;
	199	default:
	200	type = (info->flash_id & FLASH_VENDMASK);
	201	printf("Can't erase unknown flash type %08lx - aborted\n",
	202	info->flash_id);
	203	return 1;
	204	}
	205
	206	prot = 0;
	207	for (sect = s_first; sect <= s_last; ++sect) {
	208	if (info->protect[sect]) {
	209	prot++;
	210	}
	211	}
	212
	213	if (prot)
	214	printf("- Warning: %d protected sectors will not be erased!\n",
	215	prot);
	216	else
	217	printf("\n");
	218
	219	flag = disable_interrupts();
	220
	221	start = get_timer(0);
6d33c6ac	222
6d0f6bcf	223	if ((s_last - s_first) == (CONFIG_SYS_SST_SECT - 1)) {
6d33c6ac TL	224	if (prot == 0) {
	225	addr = (FPWV *) info->start[0];
	226
	227	addr[FLASH_CYCLE1] = 0x00AA; /* unlock */
	228	addr[FLASH_CYCLE2] = 0x0055; /* unlock */
	229	addr[FLASH_CYCLE1] = 0x0080; /* erase mode */
	230	addr[FLASH_CYCLE1] = 0x00AA; /* unlock */
	231	addr[FLASH_CYCLE2] = 0x0055; /* unlock */
	232	addr = 0x0030; / erase chip */
	233
	234	count = 0;
	235	start = get_timer(0);
	236
	237	while ((*addr & 0x0080) != 0x0080) {
	238	if (count++ > 0x10000) {
	239	spin_wheel();
	240	count = 0;
	241	}
	242
6d0f6bcf	243	if (get_timer(start) > CONFIG_SYS_FLASH_ERASE_TOUT) {
6d33c6ac TL	244	printf("Timeout\n");
	245	addr = 0x00F0; / reset to read mode */
	246
	247	return 1;
	248	}
	249	}
	250
	251	addr = 0x00F0; / reset to read mode */
	252
	253	printf("\b. done\n");
	254
	255	if (flag)
	256	enable_interrupts();
	257
	258	return 0;
6d0f6bcf	259	} else if (prot == CONFIG_SYS_SST_SECT) {
6d33c6ac TL	260	return 1;
	261	}
	262	}
	263
	264	/* Start erase on unprotected sectors */
	265	for (sect = s_first; sect <= s_last; sect++) {
	266	if (info->protect[sect] == 0) { /* not protected */
	267
	268	addr = (FPWV *) (info->start[sect]);
	269
	270	printf(".");
	271
	272	/* arm simple, non interrupt dependent timer */
	273	start = get_timer(0);
	274
	275	switch (flashtype) {
	276	case 1:
	277	{
	278	FPWV base; / first address in bank */
	279
	280	flag = disable_interrupts();
	281
6d0f6bcf	282	base = (FPWV ) (CONFIG_SYS_FLASH_BASE); / First sector */
6d33c6ac TL	283
	284	base[FLASH_CYCLE1] = 0x00AA; /* unlock */
	285	base[FLASH_CYCLE2] = 0x0055; /* unlock */
	286	base[FLASH_CYCLE1] = 0x0080; /* erase mode */
	287	base[FLASH_CYCLE1] = 0x00AA; /* unlock */
	288	base[FLASH_CYCLE2] = 0x0055; /* unlock */
	289	addr = 0x0050; / erase sector */
	290
	291	if (flag)
	292	enable_interrupts();
	293
	294	while ((*addr & 0x0080) != 0x0080) {
	295	if (get_timer(start) >
6d0f6bcf	296	CONFIG_SYS_FLASH_ERASE_TOUT) {
6d33c6ac TL	297	printf("Timeout\n");
	298	addr = 0x00F0; / reset to read mode */
	299
	300	rcode = 1;
	301	break;
	302	}
	303	}
	304
	305	addr = 0x00F0; / reset to read mode */
	306	break;
	307	}
	308	} /* switch (flashtype) */
	309	}
	310	}
	311	printf(" done\n");
	312
	313	if (flag)
	314	enable_interrupts();
	315
	316	return rcode;
	317	}
	318
	319	int write_buff(flash_info_t * info, uchar * src, ulong addr, ulong cnt)
	320	{
	321	ulong wp, count;
	322	u16 data;
e6af3859	323	int rc;
6d33c6ac TL	324
	325	if (info->flash_id == FLASH_UNKNOWN)
	326	return 4;
	327
	328	/* get lower word aligned address */
	329	wp = addr;
6d33c6ac TL	330
	331	/* handle unaligned start bytes */
	332	if (wp & 1) {
	333	data = ((FPWV ) wp);
	334	data = (data << 8) \| *src;
	335
	336	if ((rc = write_word(info, (FPWV *) wp, data)) != 0)
	337	return (rc);
	338
	339	wp++;
	340	cnt -= 1;
	341	src++;
	342	}
	343
	344	while (cnt >= 2) {
	345	/*
	346	* handle word aligned part
	347	*/
	348	count = 0;
	349	data = ((FPWV ) src);
	350
	351	if ((rc = write_word(info, (FPWV *) wp, data)) != 0)
	352	return (rc);
	353
	354	wp += 2;
	355	src += 2;
	356	cnt -= 2;
	357
	358	if (count++ > 0x800) {
	359	spin_wheel();
	360	count = 0;
	361	}
	362	}
	363	/* handle word aligned part */
	364	if (cnt) {
	365	/* handle word aligned part */
	366	count = 0;
	367	data = ((FPWV ) wp);
	368
	369	data = (data & 0x00FF) \| (*src << 8);
	370
	371	if ((rc = write_word(info, (FPWV *) wp, data)) != 0)
	372	return (rc);
	373
	374	wp++;
	375	src++;
	376	cnt -= 1;
	377	if (count++ > 0x800) {
	378	spin_wheel();
	379	count = 0;
	380	}
	381	}
	382
	383	if (cnt == 0)
	384	return ERR_OK;
	385
	386	return ERR_OK;
	387	}
	388
	389	/*-----------------------------------------------------------------------
	390	* Write a word to Flash
	391	* A word is 16 bits, whichever the bus width of the flash bank
	392	* (not an individual chip) is.
	393	*
394	* returns:
395	* 0 - OK
396	* 1 - write timeout
397	* 2 - Flash not erased
398	*/
399	int write_word(flash_info_t * info, FPWV * dest, u16 data)
400	{
401	ulong start;
402	int flag;
403	int res = 0; /* result, assume success */
404	FPWV base; / first address in flash bank */
405
406	/* Check if Flash is (sufficiently) erased */
407	if ((*dest & (u8) data) != (u8) data) {
408	return (2);
409	}
410
6d0f6bcf	411	base = (FPWV *) (CONFIG_SYS_FLASH_BASE);
6d33c6ac TL	412
	413	/* Disable interrupts which might cause a timeout here */
	414	flag = disable_interrupts();
	415
	416	base[FLASH_CYCLE1] = (u8) 0x00AA00AA; /* unlock */
	417	base[FLASH_CYCLE2] = (u8) 0x00550055; /* unlock */
	418	base[FLASH_CYCLE1] = (u8) 0x00A000A0; /* selects program mode */
	419
	420	dest = data; / start programming the data */
	421
	422	/* re-enable interrupts if necessary */
	423	if (flag)
	424	enable_interrupts();
	425
	426	start = get_timer(0);
	427
	428	/* data polling for D7 */
	429	while (res == 0
	430	&& (*dest & (u8) 0x00800080) != (data & (u8) 0x00800080)) {
6d0f6bcf	431	if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
6d33c6ac TL	432	dest = (u8) 0x00F000F0; / reset bank */
	433	res = 1;
	434	}
	435	}
	436
	437	dest++ = (u8) 0x00F000F0; / reset bank */
	438
	439	return (res);
	440	}
	441
	442	void inline spin_wheel(void)
	443	{
	444	static int p = 0;
	445	static char w[] = "\\/-";
	446
	447	printf("\010%c", w[p]);
	448	(++p == 3) ? (p = 0) : 0;
	449	}
	450
	451	#endif