amd.c

嵌入式系统 EP93xx处理器

 		        AmdFlashEraseSector(pInfo,pulSectorBase);
                
	                //
	                //#if 1
			for(iIdx = 0; iIdx < ((pInfo->pQuery->sBlockInfo[i].block_size*2)>>2); iIdx++)
	             	{
	            	    if(*(ptr32 + (pulSectorBase >> 2) + iIdx) != 0xffffffff)
	            	    {
	              	    	return 1;
	            	    }
	 
	   	    	}
	   	    	//#endif
	   	    	     		
	 		pulSectorBase = pulSectorBase + pInfo->pQuery->sBlockInfo[i].block_size*2;

                    }
                 }
                 else if(i==piCurEraseRegionEnd)
                 {
              	    for(j = 0; j<= piCurEraseBlockEnd; j++) 
                    {
		
 		        AmdFlashEraseSector(pInfo,pulSectorBase);
                
	                //
	                //#if 1
			for(iIdx = 0; iIdx < ((pInfo->pQuery->sBlockInfo[i].block_size*2)>>2); iIdx++)
	             	{
	            	    if(*(ptr32 + (pulSectorBase >> 2) + iIdx) != 0xffffffff)
	            	    {
	              	    	return 1;
	            	    }
	 
	   	    	}
	   	    	//#endif
	   	    	     		
	 		pulSectorBase = pulSectorBase + pInfo->pQuery->sBlockInfo[i].block_size*2;

                    }            	
                 }
                 else
                 {
             	    for(j = 0; j< pInfo->pQuery->sBlockInfo[i].blocks; j++) 
                    {
		
 		        AmdFlashEraseSector(pInfo,pulSectorBase);
                
	                //
	                //#if 1
			for(iIdx = 0; iIdx < ((pInfo->pQuery->sBlockInfo[i].block_size*2)>>2); iIdx++)
	             	{
	            	    if(*(ptr32 + (pulSectorBase >> 2) + iIdx) != 0xffffffff)
	            	    {
	              	    	return 1;
	            	    }
	 
	   	    	}
	   	    	//#endif
	   	    	     		
	 		pulSectorBase = pulSectorBase + pInfo->pQuery->sBlockInfo[i].block_size*2;

                    }             
                 }
            }
        }
        else
        {
      	    for(j = piCurEraseBlockStart; j<= piCurEraseBlockEnd; j++) 
            {
	
	        AmdFlashEraseSector(pInfo,pulSectorBase);
        
                //
                //#if 1
		for(iIdx = 0; iIdx < ((pInfo->pQuery->sBlockInfo[piCurEraseRegionStart].block_size*2)>>2); iIdx++)
             	{
            	    if(*(ptr32 + (pulSectorBase >> 2) + iIdx) != 0xffffffff)
            	    {
              	    	return 1;
            	    }
 
   	    	}
   	    	//#endif
   	    	     		
 		pulSectorBase = pulSectorBase + pInfo->pQuery->sBlockInfo[piCurEraseRegionStart].block_size*2;

            }         	
        	
        }
        
        return 0; 
    }  
    else
    {
        // No such parameter.
        return 1;
    }

    return 0;
    
}
/*int AmdFlashErase(struct FlashInfo *pInfo, int iOffset, int len)
{
	unsigned short usByteWidth = pInfo->ByteWidth;
	int i, j;
        int iEraseLen = len;
	int iEraseBase = iOffset;
	
	if (usByteWidth == 1)
	{
            for(i = 0; i < pInfo->pQuery->NumEraseBlocks; i++) 
            {
                for(j = 0; j< pInfo->pQuery->sBlockInfo[i].blocks; j++)
                {
                    if(iEraseLen > pInfo->pQuery->sBlockInfo[i].block_size) 
                    {
                        iEraseLen = iEraseLen - pInfo->pQuery->sBlockInfo[i].block_size;
                    
                        if(AmdFlashEraseSector(pInfo,iEraseBase)!=0)
                        {
                            //program fail
                    	    return 1;
                        }
                        //program sucess
                        iEraseBase=iEraseBase + pInfo->pQuery->sBlockInfo[i].block_size;
                    } 
                    else 
                    {
			if(AmdFlashEraseSector(pInfo,iEraseBase)!=0)
			{
			    //program fail
			    return 1;
			}
			else
			{
			    //program sucess
			    return 0;
			}
		    }
		
		}
	    }
	} 
	else if (usByteWidth == 2)
	{
            for(i = 0; i < pInfo->pQuery->NumEraseBlocks; i++) 
            {
                for(j = 0; j< pInfo->pQuery->sBlockInfo[i].blocks; j++)
                {
                
                    if(iEraseLen > (pInfo->pQuery->sBlockInfo[i].block_size << 1))
                    {
                        iEraseLen = iEraseLen - (pInfo->pQuery->sBlockInfo[i].block_size << 1);
                    
                        if(AmdFlashEraseSector(pInfo,iEraseBase)!=0)
                        {
                            //program sucess
                            return 1;
                        }
                        //program sucess
                        iEraseBase=iEraseBase + (pInfo->pQuery->sBlockInfo[i].block_size << 1);
                    } 
                    else 
                    {
			if(AmdFlashEraseSector(pInfo,iEraseBase)!=0)
			{
			    return 1;
			}
			else
			{
			    return 0;
			}
		    }
		
	        }
	    }    
	} 
	else
	{
	    // No such parameter.
            return 1;
        }
    
        return 1;
}
*/
//****************************************************************************
// Name       : AmdFlashProgramSector
// Description: This routine program the specified sector of amd.
// Arguments  : iOffset - the offset address.
//              len  - the length.
// Return     : 0 - succuss.
//              1 - failure.
// Note(s)    :
//****************************************************************************
int AmdFlashProgramSector(struct FlashInfo *pInfo, int iOffset, void *data, int len)
{
    volatile unsigned short *ptr16 = (volatile unsigned short *)pInfo->FlashBase;
    volatile unsigned long *ptr32 = (volatile unsigned long *)pInfo->FlashBase;
    unsigned short *pusData16 =(unsigned short *)data;
    unsigned long *pulData32 =(unsigned long *)data;
	
	unsigned short usByteWidth = pInfo->ByteWidth;
	int iIdx;
	int iResult = FLASH_ERR_OK;
	int timeout = 50000;

	if (usByteWidth == 1){
	    for(iIdx = 0; iIdx < (len>>1); iIdx++){
    	    // Send program block command - four step sequence
            *(ptr16 + AMD_SETUP_ADDR1) = AMD_SETUP_CODE1;
            *(ptr16 + AMD_SETUP_ADDR2) = AMD_SETUP_CODE2;
            *(ptr16 + AMD_SETUP_ADDR1) = AMD_PROGRAM;
            *(ptr16 + (iOffset >> 1) + iIdx) = *(pusData16 + iIdx);
            
            timeout = 10000000;
            while (1) {
                if (*(pusData16 + iIdx) == *(ptr16 + (iOffset >> 1) + iIdx))
                    break;

                // Can't check for FLASH_Err since it'll fail in parallel
                // configurations.
                if (--timeout == 0) {
                    iResult = FLASH_ERR_DRV_TIMEOUT;
                    break;
                }
            }

            if (FLASH_ERR_OK != iResult)
                *ptr16 = AMD_RESET;
                
	    // Read-back verification after writing data to flash
            if (*(ptr16 + (iOffset >> 1) + iIdx) != *(pusData16 + iIdx)) {
                
                if (FLASH_ERR_OK == iResult) iResult = FLASH_ERR_DRV_VERIFY;
                break;
            }
        }
	} else if (usByteWidth == 2){
	    for(iIdx = 0; iIdx < (len>>2); iIdx++){
    	    // Send program block command - four step sequence
            *(ptr32 + AMD_SETUP_ADDR1) = (AMD_SETUP_CODE1 << 16) | AMD_SETUP_CODE1;
            *(ptr32 + AMD_SETUP_ADDR2) = (AMD_SETUP_CODE2 << 16) | AMD_SETUP_CODE2;
            *(ptr32 + AMD_SETUP_ADDR1) = (AMD_PROGRAM << 16) | AMD_PROGRAM;
            *(ptr32 + (iOffset >> 2) + iIdx) = *(pulData32 + iIdx);
            
            timeout = 10000000;
            while (1) {
                if (*(pulData32 + iIdx) == *(ptr32 + (iOffset >> 2) + iIdx))
                    break;

                // Can't check for FLASH_Err since it'll fail in parallel
                // configurations.
                if (--timeout == 0) {
                    iResult = FLASH_ERR_DRV_TIMEOUT;
                    break;
                }
            }

            if (FLASH_ERR_OK != iResult)
                *ptr32 =  (AMD_RESET << 16) | AMD_RESET;

	    // Read-back verification after writing data to flash
            if (*(ptr32 + (iOffset >> 2) + iIdx) != *(pulData32 + iIdx)) {
                
                if (FLASH_ERR_OK == iResult) iResult = FLASH_ERR_DRV_VERIFY;
                break;
            }
        }                
	} else{
	    // No such parameter.
        return 1;
    }
    		
	return iResult;
}

//****************************************************************************
// Name       : AmdFlashProgramSector
// Description: This routine program the specified sector of amd.
// Arguments  : iOffset - the offset address.
//              len  - the length.
// Return     : 0 - succuss.
//              1 - failure.
// Note(s)    :
//****************************************************************************
int AmdFlashProgram(struct FlashInfo *pInfo, int iOffset, void *data, int len)
{
    volatile unsigned short *ptr16 = (volatile unsigned short *)pInfo->FlashBase;
    volatile unsigned long *ptr32 = (volatile unsigned long *)pInfo->FlashBase;
    unsigned short *pusData16 =(unsigned short *)data;
    unsigned long *pulData32 =(unsigned long *)data;
	
	unsigned short usByteWidth = pInfo->ByteWidth;
	int iIdx;
	int iResult = FLASH_ERR_OK;
	int timeout = 50000;

	if (usByteWidth == 1)
	{
	    for(iIdx = 0; iIdx < (len>>1); iIdx++)
	    {
    	    // Send program block command - four step sequence
            *(ptr16 + AMD_SETUP_ADDR1) = AMD_SETUP_CODE1;
            *(ptr16 + AMD_SETUP_ADDR2) = AMD_SETUP_CODE2;
            *(ptr16 + AMD_SETUP_ADDR1) = AMD_PROGRAM;
            *(ptr16 + (iOffset >> 1) + iIdx) = *(pusData16 + iIdx);
            
            timeout = 10000000;
            while (1) 
            {
                if (*(pusData16 + iIdx) == *(ptr16 + (iOffset >> 1) + iIdx))
                    break;

                // Can't check for FLASH_Err since it'll fail in parallel
                // configurations.
                if (--timeout == 0) 
                {
                    iResult = FLASH_ERR_DRV_TIMEOUT;
                    break;
                }
            }

            if (FLASH_ERR_OK != iResult)
                *ptr16 = AMD_RESET;
                
	    // Read-back verification after writing data to flash
            if (*(ptr16 + (iOffset >> 1) + iIdx) != *(pusData16 + iIdx)) 
            {
                
                if (FLASH_ERR_OK == iResult) 
                {
                    iResult = FLASH_ERR_DRV_VERIFY;
                }
                break;
            }
            
            }
	} else if (usByteWidth == 2){
	    for(iIdx = 0; iIdx < (len>>2); iIdx++){
    	    // Send program block command - four step sequence
            *(ptr32 + AMD_SETUP_ADDR1) = (AMD_SETUP_CODE1 << 16) | AMD_SETUP_CODE1;
            *(ptr32 + AMD_SETUP_ADDR2) = (AMD_SETUP_CODE2 << 16) | AMD_SETUP_CODE2;
            *(ptr32 + AMD_SETUP_ADDR1) = (AMD_PROGRAM << 16) | AMD_PROGRAM;
            *(ptr32 + (iOffset >> 2) + iIdx) = *(pulData32 + iIdx);
            
            timeout = 10000000;
            while (1) {
                if (*(pulData32 + iIdx) == *(ptr32 + (iOffset >> 2) + iIdx))
                    break;

                // Can't check for FLASH_Err since it'll fail in parallel
                // configurations.
                if (--timeout == 0) {
                    iResult = FLASH_ERR_DRV_TIMEOUT;
                    break;
                }
            }

            if (FLASH_ERR_OK != iResult)
                *ptr32 =  (AMD_RESET << 16) | AMD_RESET;

	    // Read-back verification after writing data to flash
            if (*(ptr32 + (iOffset >> 2) + iIdx) != *(pulData32 + iIdx)) {
                
                if (FLASH_ERR_OK == iResult) iResult = FLASH_ERR_DRV_VERIFY;
                break;
            }
        }                
	} else{
	    // No such parameter.
        return 1;
    }
    		
	return iResult;
}


//****************************************************************************
// Name       : AmdFlashProgram
// Description: This routine program the amd flash.
// Arguments  : iOffset - the offset address.
//              data - the data pointer.
//              len  - the length.
// Return     : 1 - succuss.
//              0 - failure.
// Note(s)    :
//****************************************************************************
int AmdFlashProgram_old(struct FlashInfo *pInfo, int iOffset, void *data, int len)
{
    unsigned short usByteWidth = pInfo->ByteWidth;
	int i, j;
    int iProgramLen = len;
	int iProgramBase = 0;

	if (usByteWidth == 1){
        for(i = 0; i < pInfo->pQuery->NumEraseBlocks; i++) {
            for(j = 0; j< pInfo->pQuery->sBlockInfo[i].blocks; j++) {
                
                if(iProgramLen > pInfo->pQuery->sBlockInfo[i].block_size) {
                    iProgramLen = iProgramLen - pInfo->pQuery->sBlockInfo[i].block_size;
                    AmdFlashProgramSector(pInfo, iOffset,
                        (void *)((unsigned char *)data + iProgramBase),
                        pInfo->pQuery->sBlockInfo[i].block_size);
                    iProgramBase=iProgramBase + pInfo->pQuery->sBlockInfo[i].block_size;
                } else {
                    AmdFlashProgramSector(pInfo, iOffset,
                        (void *)((unsigned char *)data + iProgramBase),
                        iProgramLen);
					return 0;
				}
		
			}
		}
	} else if (usByteWidth == 2){
        for(i = 0; i < pInfo->pQuery->NumEraseBlocks; i++) {
            for(j = 0; j< pInfo->pQuery->sBlockInfo[i].blocks; j++) {
                
                if(iProgramLen > (pInfo->pQuery->sBlockInfo[i].block_size << 1)) {
                    iProgramLen = iProgramLen - (pInfo->pQuery->sBlockInfo[i].block_size << 1);
                    AmdFlashProgramSector(pInfo, iOffset,
                        (void *)((unsigned char *)data + iProgramBase),
                        pInfo->pQuery->sBlockInfo[i].block_size);
                    iProgramBase=iProgramBase + (pInfo->pQuery->sBlockInfo[i].block_size << 1);
                } else {
                    AmdFlashProgramSector(pInfo, iOffset,
                        (void *)((unsigned char *)data + iProgramBase),
                        iProgramLen);
					return 0;
				}
		
			}
		}  
	} else{
	    // No such parameter.
        return 1;
    }
    
    return 1;
}

//****************************************************************************
// End
//****************************************************************************