flashwriternor.c

OMAP1030 处理器的ARM 侧硬件测试代码 OMAP1030 是TI的双核处理器

    		}			
 			User_Flash_Erase_Block = INTEL_Flash_Erase_Block;
 			//Flash_Erase_All   = INTEL_Flash_Erase_All;
 			User_Flash_Write       = INTEL_Flash_Write;
			//Note W18 doesn't appear to support block writes!!!
			if ((flash_id != FLASH_INTEL_W18_16MB_TOP) && 
				(flash_id != FLASH_INTEL_W18_16MB_BOTTOM) &&
				(flash_id != FLASH_MICRON_16MB_TOP)) 
			{
				User_Flash_Optimized_Write = INTEL_Flash_Optimized_Write;
			}
			
    	} else	//Did not find any
    	{  			
        	return(FLASH_NOT_FOUND);
        }  

  	}       
  	return(flash_id);
}

ULONG GetNORFlashSize(enum NORFlashType flash_id)
{
    switch(flash_id) 
    {
        case FLASH_AMD_DL800_1MB_BOTTOM:
        case FLASH_AMD_DL800_1MB_TOP:
            return(0x100000);
        case FLASH_AMD_LV017_2MB:
        case FLASH_AMD_LV160_2MB_TOP:
        case FLASH_AMD_LV160_2MB_BOTTOM:
            return(0x200000);
        case FLASH_AMD_DL323_4MB_BOTTOM:
        case FLASH_AMD_DL323_4MB_TOP:
        case FLASH_INTEL_STRATA_J3_4MB:
        case FLASH_FUJITSU_DL323_4MB_BOTTOM:    
            return(0x400000);
        case FLASH_INTEL_BURST_8MB_BOTTOM:
        case FLASH_INTEL_BURST_8MB_TOP:
        case FLASH_INTEL_STRATA_J3_8MB:
        case FLASH_INTEL_STRATA_K3_8MB:
//modify by mjwu,start
		case FLASH_INTEL_L18_8MB_TOP_MUX:
//modify by mjwu,end    
            return(0x800000);
        case FLASH_INTEL_BURST_16MB_BOTTOM:
        case FLASH_INTEL_BURST_16MB_TOP:
        case FLASH_INTEL_STRATA_J3_16MB:
        case FLASH_INTEL_STRATA_K3_16MB:
        case FLASH_INTEL_W18_16MB_TOP:
        case FLASH_INTEL_W18_16MB_BOTTOM:
        case FLASH_INTEL_L18_16MB_TOP:
        case FLASH_INTEL_L18_16MB_BOTTOM:
        case FLASH_MICRON_16MB_TOP:
        case FLASH_SAMSUNG_16MB_TOP:
//modify by mjwu,start
		case FLASH_INTEL_L18_16MB_TOP_MUX:
//modify by mjwu,end   
//ahuo add 
        case S29NS128N:
		//ahuo add
            return(0x1000000);
        case FLASH_AMD_LV256M_32MB:
        case FLASH_INTEL_STRATA_K3_32MB:
        case FLASH_INTEL_L18_32MB_TOP_MUX: 
        case FLASH_INTEL_L18_32MB_TOP:
        case FLASH_INTEL_L18_32MB_BOTTOM:
        case FLASH_INTEL_K18_32MB_BOTTOM:
        case FLASH_SAMSUNG_32MB_TOP_MUX:    
            return(0x2000000);
        default:
	    return(0x0);             
                
    }
}



///////////////////////////////////////////////////////////////////////////////
//
// Erase Flash Block
//
// Description:
//   This routine checks erases flash blocks, if they haven't already been
//   erased, based on a start address, byte count, and flash type.  All counts
//
// Return:
//   status - SUCCESS
///////////////////////////////////////////////////////////////////////////////
int EraseNORFlash(ULONG start_address, ULONG size, enum NORFlashType flash_id)
{
	ULONG addr  = start_address;		//byte address
	ULONG range = start_address + size;	 	//end address
	ULONG block_size;
	ULONG addr_without_cs;

  	//Setup the Windows Progress bar
	user_setprogressrange(size);   			
  	user_message("Erasing the Flash\n");
  	while (addr < range)
  	{
	    addr_without_cs = (addr & 0x01FFFFFF);    	// address offset within a CS <32MB
	  	switch (flash_id)
	    {
			case FLASH_NOT_FOUND:				// return ERROR				
				return(0);
			case FLASH_AMD_DL323_4MB_BOTTOM:  	// chip size is 4MB (AM29DL323CB:  2MBx16bit)
			case FLASH_FUJITSU_DL323_4MB_BOTTOM:// chip size is 4MB (MBM29DL323BD:  2MBx16bit)
				if (addr_without_cs >= 0x00400000)	// return ERROR
				{
					return(0);
				}			
				if (addr_without_cs < 0x10000)
				{
					block_size = 0x2000;  // 8KB
					// Round down to the next block
					addr &= 0xFFFFE000;
				}
				else 
				{
					block_size = 0x10000;  // 64 KB
					// Must round down address range to 0x8000
					addr &= 0xFFFF0000;
				}			
				break;          				
			case FLASH_SAMSUNG_16MB_TOP:// chip size is 16MB 
				if (addr_without_cs >= 0x01000000)	// return ERROR
				{
					return(0);
				}			
				if (addr_without_cs >= 0xFF0000)
				{
					block_size = 0x2000;  // 8KB
					// Round down to the next block
					addr &= 0xFFFFE000;
				}
				else 
				{
					block_size = 0x10000;  // 64 KB
					// Must round down address range to 0x8000
					addr &= 0xFFFF0000;
				}			
				break; 
    ///ahuo  add       
             case S29NS128N:// chip size is 16MB 
				if (addr_without_cs >= 0x01000000)	// return ERROR
				{
					return(0);
				}			
				if (addr_without_cs >= 0x7F0000)
				{
					block_size = 0x8000;  // 16KB
					// Round down to the next block
					addr &= 0xFFFF8000;
				}
				else 
				{
					block_size = 0x20000;  // 64 KB
					// Must round down address range to 0x8000
					addr &= 0xFFFe0000;
				}			
				break; 

   //ahuo add

			case FLASH_SAMSUNG_32MB_TOP_MUX: // chip size is 32MB	
				if (addr_without_cs >= 0x1FF0000)
				{
					block_size = 0x2000;  // 8KB
					// Round down to the next block
					addr &= 0xFFFFE000;
				}
				else 
				{
					block_size = 0x10000;  // 64 KB
					// Must round down address range to 0x8000
					addr &= 0xFFFF0000;
				}			
				break; 
			
			case FLASH_AMD_LV160_2MB_BOTTOM:
				if (addr_without_cs >= 0x00200000) // return ERROR
				{
					return(0);
				}
				if (addr_without_cs < 0x4000)
				{
					block_size = 0x4000;  // 16KB
					// Round down to the next block
					addr &= 0xFFFFC000;
				}
				else if (addr_without_cs < 0x8000)
				{
					block_size = 0x2000;  // 8KB
					// Must round down address range to 0x4000
					addr &= 0xFFFFE000;
				}
				else if (addr_without_cs < 0x10000)
				{
					block_size = 0x8000;  // 32 KB
					// Must round down address range to 0x8000
					addr &= 0xFFFF8000;
				}
				else //  This case entered only if(addr_without_cs >= 0x10000)
				{
					block_size = 0x10000;  // 64 KB
					// Must round down address range to 0x8000
					addr &= 0xFFFF0000;
				}				
				break;       
			case FLASH_AMD_LV256M_32MB:                                  
				if (addr_without_cs >= 0x02000000)	// return ERROR          
				{                                                        
					return(0);                                           
				}			                                             
				block_size = 0x10000;  // uniform sector size (64 KB)    
				// Clear intra-sector byte addresses              
				// (round down to first byte address in sector)   
				addr &= 0xFFFF0000;                                      
				break;                                                   				   					                    	                    	
			case FLASH_INTEL_BURST_16MB_BOTTOM:  // 4 2MB devices=8MB total
				if (addr_without_cs >= 0x800000) // return ERROR
				{			
					return(0);
				}				
				if (addr_without_cs < 0x10000)
				{
					block_size = 0x2000;
					// round down to next block
					addr &= 0xFFFFE000;
				}
				else if (addr_without_cs < 0x200000)
				{
					block_size = 0x10000;			
					// round down to next block
					addr &= 0xFFFF0000;
				}
				else if (addr_without_cs < 0x210000)
				{
					block_size = 0x2000;
					// round down to next block
					addr &= 0xFFFFE000;
				}
				else if (addr_without_cs < 0x400000)
				{
					block_size = 0x10000;			
					// round down to next block
					addr &= 0xFFFF0000;
				}
				else if (addr_without_cs < 0x410000)
				{
					block_size = 0x2000;			
					// round down to next block
					addr &= 0xFFFFE000;
				}
				else if (addr_without_cs < 0x600000)
				{
					block_size = 0x10000;			
					// round down to next block
					addr &= 0xFFFF0000;
				}
				else if (addr_without_cs < 0x610000)
				{
					block_size = 0x2000;			
					// round down to next block
					addr &= 0xFFFFE000;
				}
				else if (addr_without_cs < 0x800000)
				{
					block_size = 0x10000;			
					// round down to next block
					addr &= 0xFFFF0000;
				}			
				break;			
			case FLASH_INTEL_STRATA_J3_4MB:  // 2 4MB devices=8MB
				if (addr_without_cs >= 0x800000)
				{// return ERROR
					return(0);
				}				
				// round down to next block  
				addr &= 0xFFFE0000;
				block_size = 0x20000;								
				break;				
			case FLASH_INTEL_STRATA_J3_8MB:  // 2 8MB devices=16MB  			
				if (addr_without_cs >= 0x1000000)	// return ERROR
				{
					return(0);
				}				
				// round down to the next block
				addr &= 0xFFFE0000;
				block_size = 0x20000;
				break;				
			case FLASH_INTEL_STRATA_J3_16MB:  // 2 16MB devices=32MB
				if (addr_without_cs >= 0x2000000)	// return ERROR
				{				
					return(0);
				}				
				// round down to next block
				addr &= 0xFFFE0000;
				block_size = 0x20000;
				break;			
			case FLASH_INTEL_STRATA_K3_16MB:  // 16MB devices=32MB
				if (addr_without_cs >= 0x2000000)  // return ERROR
				{
					return(0);
				}				
				// round down to next block
				addr &= 0xFFFE0000;
				block_size = 0x20000;
				break; 
			case FLASH_INTEL_W18_16MB_BOTTOM: 		
				if (addr_without_cs >= 0x1000000)	// return ERROR
				{
					return(0);
				}				
				if (addr_without_cs < 0x10000)
				{
					block_size = 0x2000;
					// round down to next block
					addr &= 0xFFFFE000;					
				} 
				else   
				{
					block_size = 0x10000;					
					// round down to next block
					addr &= 0xFFFF0000;					
				}
				break;
			case FLASH_INTEL_W18_16MB_TOP: 
				if (addr_without_cs >= 0x1000000)	// return ERROR
				{
					return(0);
				}				
				if (addr_without_cs > 0x7F7FFF)
				{
					block_size = 0x2000;
					// round down to next block
					addr &= 0xFFFFE000;
				} else   
				{
					block_size = 0x10000;					
					// round down to next block
					addr &= 0xFFFF0000;				
				}
				break;
	    	case FLASH_INTEL_L18_16MB_BOTTOM: 		
				if (addr_without_cs >= 0x1000000)	// return ERROR
				{
					return(0);
				}				
				if (addr_without_cs < 0x20000)
				{
					block_size = 0x8000;
					// round down to next block
					addr &= 0xFFFF8000;					
				} 
				else   
				{
					block_size = 0x10000;					
					// round down to next block
					addr &= 0xFFFF0000;					
				}
				break;
//modify by mjwu,2005-11-23,start
			case FLASH_INTEL_L18_8MB_TOP_MUX:
				if (addr_without_cs >= 0x800000)	// return ERROR
				{
					return(0);
				}				
				if (addr_without_cs >= 0x7E0000)
				{
					block_size = 0x8000;	//32 kBytes blocks
					// round down to next block
					addr &= 0xFFFF8000;					
				} 
				else   
				{
					block_size = 0x20000; 	//128 kBytes Blocks
					// round down to next block
					addr &= 0xFFFE0000;					
				}				
				break;			
			case FLASH_INTEL_L18_16MB_TOP:
			case FLASH_INTEL_L18_16MB_TOP_MUX:
				if (addr_without_cs >= 0x1000000)	// return ERROR
				{
					return(0);
				}				
				if (addr_without_cs >= 0xFE0000)
				{
					block_size = 0x8000;	//32 kBytes blocks
					// round down to next block
					addr &= 0xFFFF8000;					
				} 
				else   
				{
					block_size = 0x20000; 	//128 kBytes Blocks
					// round down to next block
					addr &= 0xFFFE0000;					
				}								
				break;