flash.c 16.6 KB
Newer Older
1 2 3 4
/*
 * (C) Copyright 2006
 * Stefan Roese, DENX Software Engineering, sr@denx.de.
 *
5
 * SPDX-License-Identifier:	GPL-2.0+
6 7 8 9 10
 */

#include <common.h>
#include <asm/processor.h>

11 12 13 14
#ifndef CONFIG_SYS_FLASH_READ0
#define CONFIG_SYS_FLASH_READ0		0x0000	/* 0 is standard			*/
#define CONFIG_SYS_FLASH_READ1		0x0001	/* 1 is standard			*/
#define CONFIG_SYS_FLASH_READ2		0x0002	/* 2 is standard			*/
15 16
#endif

17
flash_info_t	flash_info[CONFIG_SYS_MAX_FLASH_BANKS]; /* info for FLASH chips	*/
18 19 20 21 22 23 24 25 26 27 28 29 30 31

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

unsigned long flash_init(void)
{
	unsigned long size_b0, size_b1;
	int i;
	unsigned long base_b0, base_b1;

	/* Init: no FLASHes known */
32
	for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
		flash_info[i].flash_id = FLASH_UNKNOWN;
	}

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

	base_b0 = FLASH_BASE0_PRELIM;
	size_b0 = flash_get_size ((vu_long *) base_b0, &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);
	}

	base_b1 = FLASH_BASE1_PRELIM;
	size_b1 = flash_get_size ((vu_long *) base_b1, &flash_info[1]);

	return (size_b0 + size_b1);
}

void flash_print_info(flash_info_t *info)
{
	int i;
	int k;
	int size;
	int erased;
	volatile unsigned long *flash;

	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;
	case FLASH_MAN_SST:	printf ("SST ");		break;
69
	case FLASH_MAN_STM:	printf ("ST Micro");		break;
70
	case FLASH_MAN_EXCEL:	printf ("Excel Semiconductor "); break;
71
	case FLASH_MAN_MX:	printf ("MXIC "); break;
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
	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_AM040:	printf ("AM29LV040B (4 Mbit, uniform sector size)\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_AM320T:	printf ("AM29LV320T (32 M, top sector)\n");
		break;
	case FLASH_AM320B:	printf ("AM29LV320B (32 M, bottom sector)\n");
		break;
	case FLASH_AMDL322T:	printf ("AM29DL322T (32 M, top sector)\n");
		break;
	case FLASH_AMDL322B:	printf ("AM29DL322B (32 M, bottom sector)\n");
		break;
	case FLASH_AMDL323T:	printf ("AM29DL323T (32 M, top sector)\n");
		break;
	case FLASH_AMDL323B:	printf ("AM29DL323B (32 M, bottom sector)\n");
		break;
	case FLASH_SST020:	printf ("SST39LF/VF020 (2 Mbit, uniform sector size)\n");
		break;
	case FLASH_SST040:	printf ("SST39LF/VF040 (4 Mbit, uniform sector size)\n");
		break;
106 107
	case STM_ID_M29W040B:	printf ("ST Micro M29W040B (4 Mbit, uniform sector size)\n");
		break;
108 109 110 111 112 113 114 115 116
	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) {
117
#ifdef CONFIG_SYS_FLASH_EMPTY_INFO
118 119 120 121 122 123 124 125 126
		/*
		 * Check if whole sector is erased
		 */
		if (i != (info->sector_count-1))
			size = info->start[i+1] - info->start[i];
		else
			size = info->start[0] + info->size - info->start[i];
		erased = 1;
		flash = (volatile unsigned long *)info->start[i];
Wolfgang Denk's avatar
Wolfgang Denk committed
127
		size = size >> 2;	/* divide by 4 for longword access */
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
		for (k=0; k<size; k++) {
			if (*flash++ != 0xffffffff) {
				erased = 0;
				break;
			}
		}

		if ((i % 5) == 0)
			printf ("\n   ");
		/* print empty and read-only info */
		printf (" %08lX%s%s",
			info->start[i],
			erased ? " E" : "  ",
			info->protect[i] ? "RO " : "   ");
#else
		if ((i % 5) == 0)
			printf ("\n   ");
		printf (" %08lX%s",
			info->start[i],
			info->protect[i] ? " (RO)" : "     ");
#endif

	}
	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;
	short n;
162
	volatile CONFIG_SYS_FLASH_WORD_SIZE value;
163
	ulong base = (ulong)addr;
164
	volatile CONFIG_SYS_FLASH_WORD_SIZE *addr2 = (volatile CONFIG_SYS_FLASH_WORD_SIZE *)addr;
165 166

	/* Write auto select command: read Manufacturer ID */
167 168 169
	addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00AA00AA;
	addr2[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00550055;
	addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00900090;
170

171
	value = addr2[CONFIG_SYS_FLASH_READ0];
172 173

	switch (value) {
174
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_MANUFACT:
175 176
		info->flash_id = FLASH_MAN_AMD;
		break;
177
	case (CONFIG_SYS_FLASH_WORD_SIZE)FUJ_MANUFACT:
178 179
		info->flash_id = FLASH_MAN_FUJ;
		break;
180
	case (CONFIG_SYS_FLASH_WORD_SIZE)SST_MANUFACT:
181 182
		info->flash_id = FLASH_MAN_SST;
		break;
183
	case (CONFIG_SYS_FLASH_WORD_SIZE)STM_MANUFACT:
184 185
		info->flash_id = FLASH_MAN_STM;
		break;
186
	case (CONFIG_SYS_FLASH_WORD_SIZE)EXCEL_MANUFACT:
187 188
		info->flash_id = FLASH_MAN_EXCEL;
		break;
189
	case (CONFIG_SYS_FLASH_WORD_SIZE)MX_MANUFACT:
190 191
		info->flash_id = FLASH_MAN_MX;
		break;
192 193 194 195 196 197 198
	default:
		info->flash_id = FLASH_UNKNOWN;
		info->sector_count = 0;
		info->size = 0;
		return (0);			/* no or unknown flash	*/
	}

199
	value = addr2[CONFIG_SYS_FLASH_READ1];		/* device ID	*/
200 201

	switch (value) {
202
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV400T:
203 204 205
		info->flash_id += FLASH_AM400T;
		info->sector_count = 11;
		info->size = 0x00080000;
Wolfgang Denk's avatar
Wolfgang Denk committed
206
		break;				/* => 0.5 MB	*/
207

208
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV400B:
209 210 211
		info->flash_id += FLASH_AM400B;
		info->sector_count = 11;
		info->size = 0x00080000;
Wolfgang Denk's avatar
Wolfgang Denk committed
212
		break;				/* => 0.5 MB	*/
213

214
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV040B:
Wolfgang Denk's avatar
Wolfgang Denk committed
215 216 217 218
		info->flash_id += FLASH_AM040;
		info->sector_count = 8;
		info->size = 0x0080000;		/* => 0.5 MB	*/
		break;
219
	case (CONFIG_SYS_FLASH_WORD_SIZE)STM_ID_M29W040B:
220 221 222 223
		info->flash_id += FLASH_AM040;
		info->sector_count = 8;
		info->size = 0x0080000; /* => 0,5 MB */
		break;
224

225
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV800T:
226 227 228
		info->flash_id += FLASH_AM800T;
		info->sector_count = 19;
		info->size = 0x00100000;
Wolfgang Denk's avatar
Wolfgang Denk committed
229
		break;				/* => 1 MB	*/
230

231
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV800B:
232 233 234
		info->flash_id += FLASH_AM800B;
		info->sector_count = 19;
		info->size = 0x00100000;
Wolfgang Denk's avatar
Wolfgang Denk committed
235
		break;				/* => 1 MB	*/
236

237
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV160T:
238 239 240
		info->flash_id += FLASH_AM160T;
		info->sector_count = 35;
		info->size = 0x00200000;
Wolfgang Denk's avatar
Wolfgang Denk committed
241
		break;				/* => 2 MB	*/
242

243
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV160B:
244 245 246
		info->flash_id += FLASH_AM160B;
		info->sector_count = 35;
		info->size = 0x00200000;
Wolfgang Denk's avatar
Wolfgang Denk committed
247
		break;				/* => 2 MB	*/
248

249
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV320T:
250 251
		info->flash_id += FLASH_AM320T;
		info->sector_count = 71;
Wolfgang Denk's avatar
Wolfgang Denk committed
252 253
		info->size = 0x00400000;
		break;				/* => 4 MB	*/
254

255
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_LV320B:
256 257
		info->flash_id += FLASH_AM320B;
		info->sector_count = 71;
Wolfgang Denk's avatar
Wolfgang Denk committed
258 259
		info->size = 0x00400000;
		break;				/* => 4 MB	*/
260

261
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_DL322T:
262 263
		info->flash_id += FLASH_AMDL322T;
		info->sector_count = 71;
Wolfgang Denk's avatar
Wolfgang Denk committed
264 265
		info->size = 0x00400000;
		break;				/* => 4 MB	*/
266

267
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_DL322B:
268 269
		info->flash_id += FLASH_AMDL322B;
		info->sector_count = 71;
Wolfgang Denk's avatar
Wolfgang Denk committed
270 271
		info->size = 0x00400000;
		break;				/* => 4 MB	*/
272

273
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_DL323T:
274 275
		info->flash_id += FLASH_AMDL323T;
		info->sector_count = 71;
Wolfgang Denk's avatar
Wolfgang Denk committed
276 277
		info->size = 0x00400000;
		break;				/* => 4 MB	*/
278

279
	case (CONFIG_SYS_FLASH_WORD_SIZE)AMD_ID_DL323B:
280 281
		info->flash_id += FLASH_AMDL323B;
		info->sector_count = 71;
Wolfgang Denk's avatar
Wolfgang Denk committed
282 283
		info->size = 0x00400000;
		break;				/* => 4 MB	*/
284

285
	case (CONFIG_SYS_FLASH_WORD_SIZE)SST_ID_xF020:
286 287 288
		info->flash_id += FLASH_SST020;
		info->sector_count = 64;
		info->size = 0x00040000;
Wolfgang Denk's avatar
Wolfgang Denk committed
289
		break;				/* => 256 kB	*/
290

291
	case (CONFIG_SYS_FLASH_WORD_SIZE)SST_ID_xF040:
292 293 294
		info->flash_id += FLASH_SST040;
		info->sector_count = 128;
		info->size = 0x00080000;
Wolfgang Denk's avatar
Wolfgang Denk committed
295
		break;				/* => 512 kB	*/
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367

	default:
		info->flash_id = FLASH_UNKNOWN;
		return (0);			/* => no or unknown flash */

	}

	/* set up sector start address table */
	if (((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) ||
	    ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM640U)) {
		for (i = 0; i < info->sector_count; i++)
			info->start[i] = base + (i * 0x00001000);
	} else if ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM040) {
		for (i = 0; i < info->sector_count; i++)
			info->start[i] = base + (i * 0x00010000);
	} else if (((info->flash_id & FLASH_TYPEMASK) == FLASH_AMDL322B) ||
		   ((info->flash_id & FLASH_TYPEMASK) == FLASH_AMDL323B) ||
		   ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM320B) ||
		   ((info->flash_id & FLASH_TYPEMASK) == FLASH_AMDL324B)) {
		/* set sector offsets for bottom boot block type	*/
		for (i=0; i<8; ++i) {		/*  8 x 8k boot sectors	*/
			info->start[i] = base;
			base += 8 << 10;
		}
		while (i < info->sector_count) {	/* 64k regular sectors	*/
			info->start[i] = base;
			base += 64 << 10;
			++i;
		}
	} else if (((info->flash_id & FLASH_TYPEMASK) == FLASH_AMDL322T) ||
		   ((info->flash_id & FLASH_TYPEMASK) == FLASH_AMDL323T) ||
		   ((info->flash_id & FLASH_TYPEMASK) == FLASH_AM320T) ||
		   ((info->flash_id & FLASH_TYPEMASK) == FLASH_AMDL324T)) {
		/* set sector offsets for top boot block type		*/
		base += info->size;
		i = info->sector_count;
		for (n=0; n<8; ++n) {		/*  8 x 8k boot sectors	*/
			base -= 8 << 10;
			--i;
			info->start[i] = base;
		}
		while (i > 0) {			/* 64k regular sectors	*/
			base -= 64 << 10;
			--i;
			info->start[i] = base;
		}
	} else {
		if (info->flash_id & FLASH_BTYPE) {
			/* 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;
			}
		} else {
			/* set sector offsets for top boot block type		*/
			i = info->sector_count - 1;
			info->start[i--] = base + info->size - 0x00004000;
			info->start[i--] = base + info->size - 0x00006000;
			info->start[i--] = base + info->size - 0x00008000;
			for (; i >= 0; i--) {
				info->start[i] = base + i * 0x00010000;
			}
		}
	}

	/* 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 */
368
		addr2 = (volatile CONFIG_SYS_FLASH_WORD_SIZE *)(info->start[i]);
369 370 371
		if ((info->flash_id & FLASH_VENDMASK) != FLASH_MAN_AMD)
			info->protect[i] = 0;
		else
372
			info->protect[i] = addr2[CONFIG_SYS_FLASH_READ2] & 1;
373 374 375 376 377 378
	}

	/*
	 * Prevent writes to uninitialized FLASH.
	 */
	if (info->flash_id != FLASH_UNKNOWN) {
379 380
		addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *)info->start[0];
		*addr2 = (CONFIG_SYS_FLASH_WORD_SIZE)0x00F000F0;	/* reset bank */
381 382 383 384 385 386 387 388
	}

	return (info->size);
}


int flash_erase(flash_info_t *info, int s_first, int s_last)
{
389 390
	volatile CONFIG_SYS_FLASH_WORD_SIZE *addr = (CONFIG_SYS_FLASH_WORD_SIZE *)(info->start[0]);
	volatile CONFIG_SYS_FLASH_WORD_SIZE *addr2;
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
	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;
	}

	if (info->flash_id == FLASH_UNKNOWN) {
		printf ("Can't erase unknown flash type - aborted\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");

	l_sect = -1;

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

	/* Start erase on unprotected sectors */
	for (sect = s_first; sect<=s_last; sect++) {
		if (info->protect[sect] == 0) {	/* not protected */
425
			addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *)(info->start[sect]);
426
			if ((info->flash_id & FLASH_VENDMASK) == FLASH_MAN_SST) {
427 428 429 430 431 432
				addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00AA00AA;
				addr[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00550055;
				addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080;
				addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00AA00AA;
				addr[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00550055;
				addr2[0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00300030;  /* sector erase */
433 434 435 436 437 438 439 440 441

				/* re-enable interrupts if necessary */
				if (flag) {
					enable_interrupts();
					flag = 0;
				}

				/* data polling for D7 */
				start = get_timer (0);
442 443 444
				while ((addr2[0] & (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080) !=
				       (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080) {
					if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT)
445 446 447 448
						return (1);
				}
			} else {
				if (sect == s_first) {
449 450 451 452 453
					addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00AA00AA;
					addr[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00550055;
					addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080;
					addr[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00AA00AA;
					addr[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00550055;
454
				}
455
				addr2[0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00300030;  /* sector erase */
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
			}
			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;
476 477 478
	addr = (CONFIG_SYS_FLASH_WORD_SIZE *)(info->start[l_sect]);
	while ((addr[0] & (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080) != (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080) {
		if ((now = get_timer(start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
479 480 481 482 483 484 485 486 487 488 489 490
			printf ("Timeout\n");
			return 1;
		}
		/* show that we're waiting */
		if ((now - last) > 1000) {	/* every second */
			putc ('.');
			last = now;
		}
	}

DONE:
	/* reset to read mode */
491 492
	addr = (CONFIG_SYS_FLASH_WORD_SIZE *)info->start[0];
	addr[0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00F000F0;	/* reset bank */
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571

	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)
{
572 573 574
	volatile CONFIG_SYS_FLASH_WORD_SIZE *addr2 = (CONFIG_SYS_FLASH_WORD_SIZE *)(info->start[0]);
	volatile CONFIG_SYS_FLASH_WORD_SIZE *dest2 = (CONFIG_SYS_FLASH_WORD_SIZE *)dest;
	volatile CONFIG_SYS_FLASH_WORD_SIZE *data2 = (CONFIG_SYS_FLASH_WORD_SIZE *)&data;
575 576 577 578 579 580 581 582 583 584 585
	ulong start;
	int flag;
	int i;

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

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

586 587 588 589
	for (i=0; i<4/sizeof(CONFIG_SYS_FLASH_WORD_SIZE); i++) {
		addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00AA00AA;
		addr2[CONFIG_SYS_FLASH_ADDR1] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00550055;
		addr2[CONFIG_SYS_FLASH_ADDR0] = (CONFIG_SYS_FLASH_WORD_SIZE)0x00A000A0;
590 591 592 593 594 595 596 597 598

		dest2[i] = data2[i];

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

		/* data polling for D7 */
		start = get_timer (0);
599 600 601
		while ((dest2[i] & (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080) !=
		       (data2[i] & (CONFIG_SYS_FLASH_WORD_SIZE)0x00800080)) {
			if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT)
602 603 604 605 606 607
				return (1);
		}
	}

	return (0);
}