env_flash.c.svn-base

u-boot loader common files, like cpu, clock, environment...etc...

			goto Done;
		}
	}
#endif
	{
		env_t * etmp = flash_addr;
		ulong ltmp = end_addr;

		flash_addr = flash_addr_new;
		flash_addr_new = etmp;

		end_addr = end_addr_new;
		end_addr_new = ltmp;
	}

	rc = 0;
Done:

	if (saved_data)
		free (saved_data);
	/* try to re-protect */
	(void) flash_sect_protect (1, (ulong)flash_addr, end_addr);
	(void) flash_sect_protect (1, (ulong)flash_addr_new, end_addr_new);

	return rc;
}
#endif /* CMD_SAVEENV */

#else /* ! CFG_ENV_ADDR_REDUND */

int  env_init(void)
{
	DECLARE_GLOBAL_DATA_PTR;

/*#if (CONFIG_MBA2440 | CONFIG_SMDK2443) */
#if (CONFIG_MBA2440 || CONFIG_SMDK2443)  //added by maddy220109
#if (CONFIG_NAND_BOOT != 1)
	volatile ushort value16;
	ushort *addr16;
	ulong *addr32;

	addr16 = addr32 = (void *)0;

	addr16[0x555] = (ushort)0xaaaa;
	addr16[0x2aa] = (ushort)0x5555;
	addr16[0x555] = (ushort)0x9090;
	value16 = addr16[0];

	switch(value16){
		case (ushort)AMD_MANUFACT:
			env_ptr = (env_t *)AMD_CFG_ENV_ADDR;
			flash_addr = (env_t *)AMD_CFG_ENV_ADDR;
			addr16[0] = (ushort)0xf0f0;
			amd_or_intel = 1;
			break;
		case (ushort)INTEL_MANUFACT:
			env_ptr = (env_t *)INTEL_CFG_ENV_ADDR;
			flash_addr = (env_t *)INTEL_CFG_ENV_ADDR;
			addr32[0] = (ulong)0x00ff00ff;
			amd_or_intel = 2;
			break;
	}
	
	if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
		gd->env_addr  = (ulong)&(env_ptr->data);
		gd->env_valid = 1;
	} else {
		gd->env_addr  = (ulong)&default_environment[0];
		gd->env_valid = 0;
	}

	return 0;
#else    /* CONFIG_NAND_BOOT = 1  */

	nand_env_blk = NAND_CFG_ENV_ADDR/NAND_BLOCK_SIZE;
	blockPage = (nand_env_blk * NAND_PAGES_IN_BLOCK)
	NFCONF = 0xfff0;

/*#if (CONFIG_S3C2440 | CONFIG_S3C2443)*/
#if (CONFIG_S3C2440 || CONFIG_S3C2443) //added by maddy220109
	NFCONT = 0x1;
	*(volatile unsigned *)0x56000054 = 0x70;
#endif
	{
		int i, j;
		uchar *tmp_ptr = CFG_MONITOR_BASE - CFG_ENV_SIZE;

		temp_env_ptr = (env_t *)tmp_ptr;

		for(i= 0; i<NAND_PAGES_IN_BLOCK; i++){
			blockPage += i;
#if CONFIG_S3C2410
			NFCONF &= ~(1<<11);
#elif CONFIG_S3C2440
			NFCONT &= ~(1<<1);
			NFSTAT |= (1<<2);
#elif  CONFIG_S3C2443  
			NFCONT &= ~(1<<1);
			NFSTAT |= (1<<4);
#endif
			NFCMD   = 0x0;	//NAND_CMD_READ0
			NFADDR = 0;
			NFADDR = blockPage & 0xff;
			NFADDR = (blockPage >> 8) & 0xff;
			NFADDR = (blockPage >> 16) & 0xff;

			for(j=0;j<10;j++);
#if CONFIG_S3C2410
			while(!(NFSTAT & (1<<0)));
			for(i=0; i<NAND_PAGE_SIZE; i++)     *tmp_ptr++ = NFDATA;
			NFCONF |=  (1<<11);
#elif CONFIG_S3C2440
			while(!(NFSTAT & (1<<2)));
			for(i=0; i<NAND_PAGE_SIZE; i++)     *tmp_ptr++ = NFDATA8;
			NFCONT |= (1<<1);
#elif CONFIG_S3C2443
			while(!(NFSTAT & (1<<4)));
			for(i=0; i<NAND_PAGE_SIZE; i++)     *tmp_ptr++ = NFDATA8;
			NFCONT |= (1<<1);
#endif
		}
	}

	if (crc32(0, temp_env_ptr->data, ENV_SIZE) == temp_env_ptr->crc) {
		gd->env_addr  = (ulong)&(temp_env_ptr->data);
		gd->env_valid = 1;
	} else {
		gd->env_addr  = (ulong)&default_environment[0];
		gd->env_valid = 0;
	}

	return 0;
#endif //(CONFIG_NAND_BOOT != 1)
#endif //(CONFIG_MBA2440 == 1)

	if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
		gd->env_addr  = (ulong)&(env_ptr->data);
		gd->env_valid = 1;
	} else {
		gd->env_addr  = (ulong)&default_environment[0];
		gd->env_valid = 0;
	}

	return (0);
}

#ifdef CMD_SAVEENV

int saveenv(void)
{
	int	len, rc;
	ulong	end_addr;
	ulong	flash_sect_addr;
#if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE)
	ulong	flash_offset;
	uchar	env_buffer[CFG_ENV_SECT_SIZE];
#else
	uchar *env_buffer = (char *)env_ptr;
#endif	/* CFG_ENV_SECT_SIZE */
	int rcode = 0;

#if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE)

	flash_offset    = ((ulong)flash_addr) & (CFG_ENV_SECT_SIZE-1);
	flash_sect_addr = ((ulong)flash_addr) & ~(CFG_ENV_SECT_SIZE-1);

	debug ( "copy old content: "
		"sect_addr: %08lX  env_addr: %08lX  offset: %08lX\n",
		flash_sect_addr, (ulong)flash_addr, flash_offset);

	/* copy old contents to temporary buffer */
	memcpy (env_buffer, (void *)flash_sect_addr, CFG_ENV_SECT_SIZE);

	/* copy current environment to temporary buffer */
	memcpy ((uchar *)((unsigned long)env_buffer + flash_offset),
		env_ptr,
		CFG_ENV_SIZE);
#else
	flash_sect_addr = (ulong)flash_addr;
#if ((CONFIG_MBA2440 || CONFIG_smdk2443)  == 1)
	if(amd_or_intel == 1)		len = AMD_FLASH_SECT_SIZE;
	else if(amd_or_intel == 2)	len = INTEL_FLASH_SECT_SIZE;
	else						len = CFG_ENV_SIZE;
#else
	len	 = CFG_ENV_SIZE;
#endif //CONFIG_MBA2440 == 1
#endif	/* CFG_ENV_SECT_SIZE */

#ifndef CONFIG_INFERNO
	end_addr = flash_sect_addr + len - 1;
#else
	/* this is the last sector, and the size is hardcoded here */
	/* otherwise we will get stack problems on loading 128 KB environment */
	end_addr = flash_sect_addr + 0x20000 - 1;
#endif

#if (CONFIG_NAND_BOOT == 1)
	printf("Erasing NAND flash.. block[%d] address[0x%x]... \n", nand_env_blk, NAND_CFG_ENV_ADDR);
	NF_EraseBlock(nand_env_blk);

	printf("Writing to flash.. block[%d] address[0x%x]... ", nand_env_blk, NAND_CFG_ENV_ADDR);
	rc = NF_WriteBlock((u8 *)env_buffer, nand_env_blk);
	if (rc != 0) {
		flash_perror (rc);
		rcode = 1;
	} else {
		puts ("\bdone\n");
	}
#else
	debug ("Protect off %08lX ... %08lX\n",
		(ulong)flash_sect_addr, end_addr);

	if (flash_sect_protect (0, flash_sect_addr, end_addr))
		return 1;

	puts ("Erasing Flash...");
	if (flash_sect_erase (flash_sect_addr, end_addr))
		return 1;

	puts ("Writing to Flash... ");
//	rc = flash_write(env_buffer, flash_sect_addr, len);
	rc = flash_write(addr2info(flash_sect_addr), env_buffer, flash_sect_addr, len);
	if (rc != 0) {
		flash_perror (rc);
		rcode = 1;
	} else {
		puts ("done\n");
	}

	/* try to re-protect */
	(void) flash_sect_protect (1, flash_sect_addr, end_addr);
#endif	//(CONFIG_NAND_BOOT == 1)

	return rcode;
}

#endif /* CMD_SAVEENV */

#endif /* CFG_ENV_ADDR_REDUND */

void env_relocate_spec (void)
{
#if !defined(ENV_IS_EMBEDDED) || defined(CFG_ENV_ADDR_REDUND)
#ifdef CFG_ENV_ADDR_REDUND
	DECLARE_GLOBAL_DATA_PTR;

	if (gd->env_addr != (ulong)&(flash_addr->data)) {
		env_t * etmp = flash_addr;
		ulong ltmp = end_addr;

		flash_addr = flash_addr_new;
		flash_addr_new = etmp;

		end_addr = end_addr_new;
		end_addr_new = ltmp;
	}

	if (flash_addr_new->flags != OBSOLETE_FLAG &&
	    crc32(0, flash_addr_new->data, ENV_SIZE) ==
	    flash_addr_new->crc) {
		char flag = OBSOLETE_FLAG;

		gd->env_valid = 2;
		flash_sect_protect (0, (ulong)flash_addr_new, end_addr_new);
//		flash_write(&flag,
//			    (ulong)&(flash_addr_new->flags),
//			    sizeof(flash_addr_new->flags));
		flash_write(addr2info((ulong)&(flash_addr_new->flags)), &flag,
				(ulong)&(flash_addr_new->flags),
				sizeof(flash_addr_new->flags));
		flash_sect_protect (1, (ulong)flash_addr_new, end_addr_new);
	}

	if (flash_addr->flags != ACTIVE_FLAG &&
	    (flash_addr->flags & ACTIVE_FLAG) == ACTIVE_FLAG) {
		char flag = ACTIVE_FLAG;

		gd->env_valid = 2;
		flash_sect_protect (0, (ulong)flash_addr, end_addr);
//		flash_write(&flag,
//			    (ulong)&(flash_addr->flags),
//			    sizeof(flash_addr->flags));
		flash_write(addr2info((ulong)&(flash_addr->flags)), &flag,
                (ulong)&(flash_addr->flags),
                sizeof(flash_addr->flags));
		flash_sect_protect (1, (ulong)flash_addr, end_addr);
	}

	if (gd->env_valid == 2)
		puts ("*** Warning - some problems detected "
		      "reading environment; recovered successfully\n\n");
#endif /* CFG_ENV_ADDR_REDUND */
#if (CONFIG_NAND_BOOT == 1)
	NF_ReadBlock((u8 *)env_ptr, nand_env_blk);
#else
	memcpy (env_ptr, (void*)flash_addr, CFG_ENV_SIZE);
#endif
#endif /* ! ENV_IS_EMBEDDED || CFG_ENV_ADDR_REDUND */
}

#endif /* CFG_ENV_IS_IN_FLASH */