else if(id_man == AM29LV160DB_MAN_ID &&
		id_dev == AM29LV160DB_DEV_ID &&
		id_ade == AM29LV160DB_ADE_ID )
	{
		size = FlashSectorSize_AM29LV160DB(base_addr);
	}

	return size;
}
//*********************************************************************************************
 void FlashEraseChip_AM29LV160DB(unsigned int base_addr)
 {
    int i,k;
    uart_printf("now start to erase the whole norflash chip,please wait......\r\n"); 	
    /*
	*(volatile unsigned short *)(base_addr + (0x200554)) = 0xAA;
	*(volatile unsigned short *)(base_addr + (0x2AA)) = 0x55;
	*(volatile unsigned short *)(base_addr + (0x200554)) = 0x80;
	*(volatile unsigned short *)(base_addr + (0x200554)) = 0xAA;
	*(volatile unsigned short *)(base_addr + (0x2AA)) = 0x55;
	*(volatile unsigned short *)(base_addr + (0x200554)) = 0x10;
	
	*/
	*(volatile unsigned short *)(base_addr + (0x555<<1)) = 0xAA;
	*(volatile unsigned short *)(base_addr + (0x2AA<<1)) = 0x55;
	*(volatile unsigned short *)(base_addr + (0x555<<1)) = 0x80;
	*(volatile unsigned short *)(base_addr + (0x555<<1)) = 0xAA;
	*(volatile unsigned short *)(base_addr + (0x2AA<<1)) = 0x55;
	*(volatile unsigned short *)(base_addr + (0x555<<1)) = 0x10;
	// delay 
	for(k=0;k<100;k++)
	for(i=0; i<10000; i++)
		Flash_Delay();
		
	  uart_printf("erase the norflash chip sucessful!\r\n"); 	 	
 }
/*********************************************************************************************
* name:		FlashEraseChip
* func:		erase the whole flash Chip
* para:		unsigned int chip_base_addr      --  base_addr of flash
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void FlashEraseChip(unsigned int chip_base_addr)
{
	
	 if(id_man == AM29LV160DB_MAN_ID &&
		id_dev == AM29LV160DB_DEV_ID &&
		id_ade == AM29LV160DB_ADE_ID )
	{
		FlashEraseChip_AM29LV160DB(chip_base_addr);
	}
}



/*********************************************************************************************
* name:		FlashSectorBackup
* func:		backup data on flash's sector
* para:		unsigned int base_addr      --  base_addr of flash
*           unsigned char *buf          --  buf to backup data on flash's sector
* ret:		size of data  backuped & return the data's address by pointer buf
* modify:
* comment:		
*********************************************************************************************/
unsigned int FlashSectorBackup(unsigned int base_addr)
{
	unsigned int size;

	size = FlashSectorSize(base_addr);

	return size;
}

//************************************************************************************************
/*
void flash_prog(void)
{
	unsigned long write_addr=0x0000;
	unsigned int chip_base_addr=0x0;
//	char* pData=(char *)0xa0008000;
	int len=1024*10;
	
    const int array_size = 1024*5;
	// the array is used for testing  flash writing.
	
	unsigned short write_test_data[array_size];
	int k;
	unsigned short test_data = 0x66CC;
	
	for(k=0;k<array_size;k++)
	  
	  {
	  	write_test_data[k] = test_data;
	  //	test_data++;
	  }
	 

		if(FlashID(write_addr))
		{
			int write_ptr, offset_ptr, write_len, sector_size;
			char *data_ptr;
			
			//erase the whole flash
			FlashEraseChip(chip_base_addr);
			
			// data_ptr = pData;
			data_ptr =(char*)write_test_data;
			
			write_ptr = write_addr;
			while(write_ptr < write_addr+len)
			{
				sector_size = FlashSectorBackup(write_ptr, sector_buf);
				offset_ptr = (write_ptr & ~(0 - sector_size));
				write_len =  sector_size - offset_ptr;
				if(write_len > len - (write_ptr - write_addr))
					write_len = len - (write_ptr - write_addr);
				memcpy(&sector_buf[offset_ptr], data_ptr, write_len);
			//	FlashEraseSector(write_ptr);
				
				FlashProgram(write_ptr & (0 - sector_size), (unsigned short *)sector_buf, sector_size);
			//FlashProgram(write_ptr & (0 - sector_size), (unsigned short *)write_test_data, sector_size);
				
				data_ptr += write_len;
	            write_ptr += write_len;
			}
		}
		
	/*	
	  for(k=0;k<(1024*16/2);k++)
	    {
	    	unsigned short* p=(unsigned short *)write_test_data;
	    	unsigned short write_test_addr = 0x0;
	    	
	    	//if( (*p) == (*(volatile unsigned short*)write_test_addr))
	    	if( 0x6677 == (*(volatile unsigned short*)write_test_addr))
	    		
	    		 { 
	    		  p++;
	    		  write_test_addr +=2;
	    		 } 
		   else
		       break;
		 }    
	*/	  
//} 

//***************************************************************************************************************
void flash_write_from_buffer(unsigned char* buffer_addr,unsigned int need_write_len,unsigned int write_base_addr)
{
 
    unsigned int writeen_len = 0;
    unsigned int sector_size = 0;
    unsigned int use_sector_size = 0;
    unsigned int offset_sector = 0;
    
    //save the function parameters
 	unsigned char* read_source_addr = buffer_addr;
 	unsigned int want_write_len = need_write_len;
 	unsigned int flash_write_base_addr = write_base_addr;

 //  if(FlashID(flash_write_base_addr))
 //  {
   		
   		
   		
   		while(writeen_len < need_write_len)
   		{
   			// get the  usable size of the current sector;
   			sector_size = FlashSectorBackup(flash_write_base_addr);
   			offset_sector = (flash_write_base_addr &~ (0-sector_size));
   			use_sector_size = sector_size - offset_sector;
   			
   			if ( want_write_len < use_sector_size)
   		  	  {
   				
   				FlashProgram(flash_write_base_addr, (unsigned short *)read_source_addr,want_write_len);
   				writeen_len += want_write_len;
   				flash_write_base_addr += want_write_len;
   			    read_source_addr += want_write_len;
   			  
   			  }
   			  
   			else if(want_write_len >= use_sector_size)
   			 {
   			 	FlashProgram(flash_write_base_addr, (unsigned short *)read_source_addr,use_sector_size);
   			 	writeen_len += use_sector_size;
   				flash_write_base_addr += use_sector_size;
   				read_source_addr += use_sector_size;
   			    want_write_len -= use_sector_size;
   			 }
   			  
   		}
  
  //  }

}


//***************************************************************************************************************************

//雙字節(jié)比較
int flash_prog_check(unsigned char* source_addr,unsigned int data_len,unsigned int write_flash_base_addr)

{	
	int source_data,flash_data;
	int len=0;
	int state = 0;
 	unsigned short* data_addr = (unsigned short*)source_addr;
 	unsigned short* flash_addr = (unsigned short*)write_flash_base_addr;
 	
 	
 uart_printf("now start to check the writeen bytes.... \r\n");
 	while(len < data_len/2)
 	{
 		 source_data = *data_addr;
 		 flash_data  = *flash_addr;
 		 len++;
 		 data_addr++;
 		 flash_addr++;
 		 if(source_data==flash_data)
 		    state= 1;
 		  else 
 		    {state = 0;break;
 		    }  
 	}
 	
 	if(state ==1) 
 	  uart_printf("norflash program sucessful!\r\n");
 	else  
 	 uart_printf("norflash program failed,try again!\r\n"); 
 	 
 return state;	
}	
 	 
//********************************************************************************************************************* 	
void flash_prog(unsigned char* source_addr,unsigned int data_len,unsigned int write_flash_base_addr,unsigned int chip_base_addr)
{
  unsigned int need_write_data_len = data_len;
  unsigned char* data_ptr = source_addr;
  unsigned int flash_base_addr = write_flash_base_addr;
  unsigned int writeen_data_len = 0;
  
  if(FlashID(flash_base_addr))      // 檢查Flash ID;

          
  	 {       
   		
   		// FlashEraseChip(chip_base_addr); //整片 Flash 擦除,時間較長;
   		    //erase 256K
   		 #if 1
   		 uart_printf("now start to erase 256k sector size of norflash.......\r\n");
   		  FlashEraseSector(0x0);        //16k
   		   FlashEraseSector(0x4000);    //8k
   		    FlashEraseSector(0x6000);   //8k
   		     FlashEraseSector(0x8000);  //32k
   		      FlashEraseSector(0x10000);  //64k
   		       FlashEraseSector(0x20000);  //64k
   		        FlashEraseSector(0x30000); //64k
   		       
   		 #endif
   		 
   		 uart_printf("now start to write %d bytes from 0x%x to Ox%x,please wait......\r\n",data_len,(unsigned int)source_addr,(unsigned int)write_flash_base_addr); 	 
           
    	 while(writeen_data_len < data_len)   //燒寫指定長度(字節(jié))數(shù)據(jù);
       
     	 { 
      		 if(need_write_data_len >= buffer_len)
           
       			 { 
       		 		 memcpy(sector_buf, data_ptr, buffer_len);
         
        			 flash_write_from_buffer(sector_buf,buffer_len,flash_base_addr);
         
         			need_write_data_len -= buffer_len;
       			    data_ptr += buffer_len;
        			  writeen_data_len += buffer_len;
        			 flash_base_addr += buffer_len;
       			 }   
      
     		 else if(need_write_data_len < buffer_len)
           
       			 { 
       			 	memcpy(sector_buf, data_ptr, need_write_data_len);
         
      			   flash_write_from_buffer(sector_buf,need_write_data_len,flash_base_addr);
          
         			 data_ptr += need_write_data_len;
         			 flash_base_addr += need_write_data_len;
         
         			 writeen_data_len += need_write_data_len;
        
       			  }       
	
     	 }	
     	   uart_printf("write norfalsh complete!\r\n");
         flash_prog_check((unsigned char*)source_addr,data_len,write_flash_base_addr);  // check the programmer
	
     }
     
   
     
}
//*********************************************************************************************************************

void norflash_sector_write_test()
{
	int i,j,k=0;
	unsigned int sector_addr = 0x40000;
	unsigned int flash_base_addr = 0x0;
	unsigned short* mem_addr = (unsigned short*)0xa0030000;
	if(FlashID(flash_base_addr)) 
	 {
	     uart_printf("start to erase the sector address 0x%x of the norflash...\r\n",sector_addr);
	     FlashEraseSector(sector_addr);
	    for(k=0;k<10;k++)
	     for(i=0;i<10000;i++)
	      for(j=0;j<200;j++);
	 
	 //now 
	 for(i=0;i<68;i+=2)
	 {
	   *mem_addr++ = i;
	 }
	  
	  //write to norflash
	  FlashProgram(sector_addr,(unsigned short *)0xa0030000,(unsigned int)68);
	  flash_prog_check((unsigned char*)0xa0030000,(unsigned int)68,sector_addr);
	 
	  }
}