flash.c

华为 HI3510 BOOTLOADER HIBOOT 源码包

	return -1;

}

/*-----------------------------------------------------------------------
 * Check flash block erase status,returns:
 * 0 - Not erased
 * 1 - Erased
 */

int flash_erase_status(flash_info_t *info, int sect)
{
	ulong addr;
	ulong end_addr;

	if (sect == info->sector_count-1)
		end_addr = CFG_FLASH_BASE + info->size;
	else
		end_addr = info->start[sect+1]-1;

	for (addr = info->start[sect]; addr < end_addr; addr += (1 << FLASH_ADDR_SHIFT_BITS)) {
		if (*(FPWV *)addr != (FPW)0xFFFFFFFF){
			return 0;
		}
	}

	return 1;

}


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

int flash_erase (flash_info_t *info, int s_first, int s_last)
{
	FPWV *addr;
	int flag, prot, sect;
	int intel = (info->flash_id & FLASH_VENDMASK) == FLASH_MAN_INTEL;
	ulong start, now;
	int rcode = 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;
	}

	switch (info->flash_id & FLASH_VENDMASK) {
	case FLASH_MAN_INTEL:
		break;
	case FLASH_MAN_AMD:
		break;
	default:
		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);
	} 

	puts(" <Erase 00%>\b\b");
	/* Start erase on unprotected sectors */
	for (sect = s_first; sect<=s_last && rcode == 0; sect++) {
		WATCHDOG_RESET();		/* Trigger watchdog, if needed */
		if(ctrlc()) {
			printf("\nErase flash cancel ...\n");
			rcode = 1;
			break;
		}

		/* protected, skip it */
		/* erased, skip it */
		if ((info->protect[sect] != 0) || (flash_erase_status(info, sect) != 0)) {
			if(((sect - s_first + 1)*100/(s_last - s_first +1)) >= 100)
				putc('\b');
			printf("\b\b%02d", ((sect - s_first + 1)*100/(s_last - s_first +1)));	
			continue;
		}

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

		addr = (FPWV *)(info->start[sect]);
		if (intel) {
			*addr = (FPW)0x00500050; /* clear status register */
			*addr = (FPW)0x00200020; /* erase setup */
			*addr = (FPW)0x00D000D0; /* erase confirm */
		}
		else {
			/* must be AMD style if not Intel */

			MEM_FLASH_ADDR1 = (FPW)0x00AA00AA;	/* unlock */
			MEM_FLASH_ADDR2 = (FPW)0x00550055;	/* unlock */
			MEM_FLASH_ADDR1 = (FPW)0x00800080;	/* erase mode */
			MEM_FLASH_ADDR1 = (FPW)0x00AA00AA;	/* unlock */
			MEM_FLASH_ADDR2 = (FPW)0x00550055;	/* unlock */
			*addr = (FPW)0x00300030;	/* erase sector */
		}

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

		start = get_timer(0);

		/* wait at least 50us for AMD, 80us for Intel.
		 */
		udelay (200);

		while ((*addr & (FPW)0x00800080) != (FPW)0x00800080) {
			if ((now = get_timer(start)) > CFG_FLASH_ERASE_TOUT) {
				printf ("Timeout\n");

				if (intel) {
					/* suspend erase	*/
					*addr = (FPW)0x00B000B0;
				}

				flash_reset(info);	/* reset to read mode */
				rcode = 1;		/* failed */
				break;
			}

		}

		flash_reset(info);	/* reset to read mode	*/

		if(((sect - s_first + 1)*100/(s_last - s_first +1)) >= 100)
			putc('\b');
		printf("\b\b%02d", ((sect - s_first + 1)*100/(s_last - s_first +1)));	
	}
	puts("\b\b\b\b\b\b\b\b\b\b");
	puts("            ");
	puts("\b\b\b\b\b\b\b\b\b\b\b\b");


	return rcode;
}

/*-----------------------------------------------------------------------
 * 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)
{
	FPW data = 0; 	  /* 16 or 32 bit word, matches flash bus width */
	int bytes;	  /* number of bytes to program in current word	*/
	int left;	  /* number of bytes left to program		*/
	int i, res, count =0;
	int start_sect, end_sect;

	if(cnt == 0)
		return 2;

	start_sect = flash_get_sect(info, addr);
	end_sect   = flash_get_sect(info, addr + cnt - 1);

	if(flash_erase(info, start_sect, end_sect))
		return 2;
	
	puts(" <Write 00%>\b\b");
	for (left = cnt, res = 0;
		 left > 0 && res == 0;
		 addr += sizeof(data), left -= sizeof(data) - bytes) {

		bytes = addr & (sizeof(data) - 1);
		addr &= ~(sizeof(data) - 1);

		/* combine source and destination data so can program
		 * an entire word of 16 or 32 bits
		 */
		data = 0;
		for (i = 0; i < sizeof(data); i++) {
			if (i < bytes || i - bytes >= left )
				data += (*((uchar *)addr + i)) << i*8;
			else
				data += (*src++) << i*8;
		}

		/* write one word to the flash */
		switch (info->flash_id & FLASH_VENDMASK) {
		case FLASH_MAN_AMD:
			res = write_word_amd(info, (FPWV *)addr, data);
			break;
		case FLASH_MAN_INTEL:
			res = write_word_intel(info, (FPWV *)addr, data);
			break;
		default:
			/* unknown flash type, error! */
			printf ("missing or unknown FLASH type\n");
			res = 1;	/* not really a timeout, but gives error */
			break;
		}

		if (((cnt-left-1)*100/cnt) != count)
		{
			WATCHDOG_RESET();		/* Trigger watchdog, if needed */
			if(ctrlc()) {
				printf("\nWrite flash aboart ...\n");
				break;
			}

			count = (cnt-left)*100/cnt;
			if(count >= 100)
				putc('\b');
			printf("\b\b%02d", count);
		}
	}

	puts("\b\b\b\b\b\b\b\b\b\b");
	puts("            ");
	puts("\b\b\b\b\b\b\b\b\b\b\b\b");

	return (res);
}

/*-----------------------------------------------------------------------
 * Write a word to Flash for AMD FLASH
 * A word is 16 or 32 bits, whichever the bus width of the flash bank
 * (not an individual chip) is.
 *
 * returns:
 * 0 - OK
 * 1 - write timeout
 * 2 - Flash not erased
 */
static int write_word_amd (flash_info_t *info, FPWV *dest, FPW data)
{
	ulong start;
	int flag;
	int res = 0;	/* result, assume success	*/
	FPWV *addr;		
	
	/* Check if Flash is (sufficiently) erased */
	if ((*dest & data) != data) {
		return (2);
	}


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

	addr = (FPWV *)dest;
	MEM_FLASH_ADDR1 = (FPW)0x00AA00AA;	/* unlock */
	MEM_FLASH_ADDR2 = (FPW)0x00550055;	/* unlock */
	MEM_FLASH_ADDR1 = (FPW)0x00A000A0;	/* selects program mode */

	*addr = 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 & (FPW)0x00800080) != (data & (FPW)0x00800080)) {
		if (get_timer(start) > CFG_FLASH_WRITE_TOUT) {
			*dest = (FPW)0x00F000F0;	/* reset bank */
			res = 1;
		}
	}

	return (res);
}

/*-----------------------------------------------------------------------
 * Write a word to Flash for Intel FLASH
 * A word is 16 or 32 bits, whichever the bus width of the flash bank
 * (not an individual chip) is.
 *
 * returns:
 * 0 - OK
 * 1 - write timeout
 * 2 - Flash not erased
 */
static int write_word_intel (flash_info_t *info, FPWV *dest, FPW data)
{
	ulong start;
	int flag;
	int res = 0;	/* result, assume success	*/

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

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

	*dest = (FPW)0x00500050;	/* clear status register	*/
	*dest = (FPW)0x00FF00FF;	/* make sure in read mode	*/
	*dest = (FPW)0x00400040;	/* program setup		*/

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

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

	start = get_timer (0);

	while (res == 0 && (*dest & (FPW)0x00800080) != (FPW)0x00800080) {
		if (get_timer(start) > CFG_FLASH_WRITE_TOUT) {
			*dest = (FPW)0x00B000B0;	/* Suspend program	*/
			res = 1;
		}
	}

	if (res == 0 && (*dest & (FPW)0x00100010)) {
		res = 1;	/* write failed, time out error is close enough	*/
	}

	*dest = (FPW)0x00500050;	/* clear status register	*/
	*dest = (FPW)0x00FF00FF;	/* make sure in read mode	*/

	return (res);
}