amd29lvmtd.c.svn-base

realtek的8186芯片ADSL路由AP源代码

    if ((address & 0x01) != 0)
    {	
    	address--;
    	pFlash = (volatile UINT16*) pVol->map(pVol, address, 0);
    	data = (*pFlash&0xff00) | (*pBuffer&0xff);
    	flashProgram16Bits(pVol, pFlash, data);
    	pBuffer++;
    	address+=2;
    	length--;
    	
	}
	
    /* Program 'length' bytes (2 bytes each iterations) */
    for (i = 0; i < length; i+=2)
	{
		data = *(UINT16*)&pBuffer[i];
        /* Don't bother programming if buffer data == format value */
        if (data == 0xffff)
            continue;

		pFlash = (volatile UINT16*) pVol->map(pVol, address+i, 0);
        /* Program 16 bits */
        rc = flashProgram16Bits(pVol, pFlash, data);
        if (rc != OK)
            return ERROR;
        if (0==(i&0x0FFFF)) {
            printf(".");
        };
	}	

	if ((length & 0x01) != 0)
	{
		data = pBuffer[length-1];
		data = data << 8;
    	pFlash = (volatile UINT16*) pVol->map(pVol, address+length-1, 0);
    	data = data | (*pFlash  & 0xff);
        rc = flashProgram16Bits(pVol, pFlash, data);
        if (rc != OK)
            return(flTimedOut);
	}
    printf("\n\r");

    return(flOK);

}

/******************************************************************************
*
* amd29lvSectorRangeErase - MTD erase routine (see TrueFFS Programmer's Guide)
*
* RETURNS: FLStatus
*
*/

LOCAL FLStatus amd29lvSectorRangeErase(FLFlash* pVol, int sectorNum, int sectorCount)
{
    int i;
    STATUS rc;

    /* Check for valid range */


    if ((pVol->type&0xffff) == 0x22DA ||			/* amd29LV800BT */
    	(pVol->type&0xffff) == 0x225B)				/* amd29LV800BB */
	{
		if (sectorNum + sectorCount >  AMD29LV_800_LAST_SECTOR_NUM + 1)
	    {
	    DEBUG_PRINT(DEBUG_ALWAYS, ("Invalid sector range: %d - %d\n\r",
	                sectorNum, sectorCount));
			return (flSectorNotFound);
	    }
	}
	

    if ((pVol->type&0xffff) == 0x22C4 ||			/* amd29LV160BT */
    	(pVol->type&0xffff) == 0x2249)				/* amd29LV160BB */
	{
		if (sectorNum + sectorCount >  AMD29LV_160_LAST_SECTOR_NUM + 1)
	    {
	    DEBUG_PRINT(DEBUG_ALWAYS, ("Invalid sector range: %d - %d\n\r",
	                sectorNum, sectorCount));
			return (flSectorNotFound);
	    }
	}

    if ((pVol->type&0xffff) == 0x22A7 ||			/* amd29LV320BT */
    	(pVol->type&0xffff) == 0x22A8 ||				/* amd29LV320BB */
    	(pVol->type&0xffff) == 0x22F6 ||				/* SpansionS29AL032DT */
    	(pVol->type&0xffff) == 0x22F9 )				/* SpansionS29AL032DB */
	{
		if (sectorNum + sectorCount >  AMD29LV_320_LAST_SECTOR_NUM + 1)
	    {
	    DEBUG_PRINT(DEBUG_ALWAYS, ("Invalid sector range: %d - %d\n\r",
	                sectorNum, sectorCount));
			return (flSectorNotFound);
	    }
	}
//support mx29lv640 mt/b 
    if( (pVol->type&0xffff) == 0x227E			/* mx29lv640 mt/b */
    || (pVol->type&0xffff) == 0x22CB)			/* mx29lv640 bb */	
	{
		if (sectorNum + sectorCount >  AMD29LV_640_LAST_SECTOR_NUM + 1)
	    {
	    DEBUG_PRINT(DEBUG_ALWAYS, ("Invalid sector range: %d - %d\n\r",
	                sectorNum, sectorCount));
			return (flSectorNotFound);
	    }
	}
//support mx29lv640 mt/b
#if FLASH_SST_SUPPORT
    if ((pVol->type&0xffff) == 0x2780)			/* sst39vf400 */
    {
    	 if (sectorNum + sectorCount >  SST39VF_400_LAST_SECTOR_NUM + 1)
	 {
	     DEBUG_PRINT(DEBUG_ALWAYS, ("Invalid sector range: %d - %d\n\r", sectorNum, sectorCount));
	     return (flSectorNotFound);
	  } 	 
    }

    if ((pVol->type&0xffff) == 0x2781)			/* sst39vf800 */
    {
    	 if (sectorNum + sectorCount >  SST39VF_800_LAST_SECTOR_NUM + 1)
	 {
	     DEBUG_PRINT(DEBUG_ALWAYS, ("Invalid sector range: %d - %d\n\r", sectorNum, sectorCount));
	     return (flSectorNotFound);
	  } 	 
    }

     if ((pVol->type&0xffff) == 0x234B)			/* sst39vf1601 */
    {
    	 if (sectorNum + sectorCount >  SST39VF_1601_LAST_SECTOR_NUM + 1)
	 {
	     DEBUG_PRINT(DEBUG_ALWAYS, ("Invalid sector range: %d - %d\n\r", sectorNum, sectorCount));
	     return (flSectorNotFound);
	  } 	 
    }
	if ((pVol->type&0xffff) == 0x235B)			/* sst39vf3201 */
    {
    	 if (sectorNum + sectorCount >  SST39VF_3201_LAST_SECTOR_NUM + 1)
	 {
	     DEBUG_PRINT(DEBUG_ALWAYS, ("Invalid sector range: %d - %d\n\r", sectorNum, sectorCount));
	     return (flSectorNotFound);
	  } 	 
    }

#endif

	/* Last sector is really 8 seperately erasable sectors */

    for (i = 0; i < sectorCount; i++)
	{
        /* Erase lower half */
        rc = flashSectorErase(pVol, sectorNum + i);
        if (rc != OK)
            return(flTimedOut);
        printf(".");
	}
    return(flOK);
}


/******************************************************************************
*
* amd29lvMap - MTD map routine (see TrueFFS Programmer's Guide)
*
* RETURNS: FLStatus
*
*/
LOCAL void * amd29lvMap(FLFlash* pVol, CardAddress address, int length)
{
    UINT32 flashBaseAddr = (pVol->baseAddress << 12);
    void * pFlash = (void *) (flashBaseAddr + address);
    DEBUG_PRINT(DEBUG_MAP, ("Mapping 0x%08x bytes at 0x%08x to %p\n\r", length,
                (unsigned int) address, pFlash));
    return(pFlash);
}


/******************************************************************************
*
* flashProgram16Bits - Program 16 bits at 2 byte aligned address.
*
* RETURNS: OK or ERROR
*
*/

LOCAL inline STATUS flashProgram16Bits(FLFlash* pVol, volatile UINT16* pData, UINT16 data)
{
    int result;
    int retry = 10000;
    unsigned int time0;
	int i;

    DEBUG_PRINT(DEBUG_PROG16, ("Programming 0x%04x to %p\n\r",
                data, pData));

    for (retry = 0; retry < 3; retry ++) {
    flashReset(pVol);
    flashUnlock(pVol);
    flashRegWrite16Bits(pVol, 0x5555*2, 0xa0a0);
    *pData = data;
    CACHE_PIPE_FLUSH();
    
    time0 = get_sys_time();
    while ((get_sys_time()-time0) < FLASH_TIMEOUT) {
        //result = flashCheck16Bits(pVol, 0);
        if(*pData==data) 
        {
    	   flashReset(pVol);
	   return(OK);
	}
    }

	
    }
#if 0
	while(retry)
	{
		flashReset(pVol);
	    flashUnlock(pVol);
	    flashRegWrite16Bits(pVol, 0x5555*2, 0xa0a0);

		/* write data */
		*pData = data;
		CACHE_PIPE_FLUSH();
		
		result = flashCheck16Bits(pVol, 0);
	
		if(result==0)
		{
			for (i=0;i<0x600;i++) asm("	NOP");
		}

		if(*pData==data) 
		{
			flashReset(pVol);
			return(OK);
		}
		retry--;
	}	
#endif
	DEBUG_PRINT(DEBUG_ALWAYS, ("Program 0x%x Timeout %x %x\n\r", pData, *pData, data));
	flashReset(pVol);
	return(ERROR);

}

/******************************************************************************
*
* flashSectorErase - Erase sector.
*
* RETURNS: OK or ERROR
*
*/

LOCAL STATUS flashSectorErase(FLFlash* pVol, int sectorNum)
{
    BOOL erased = FALSE;
    UINT32 offset;
    UINT32 size;
    volatile UINT16* pFlash;
    UINT32 sectorAddr;
    UINT32 sectorCnt;
    UINT32 sectorOffset[] = {0, 0x4000, 0x6000, 0x8000};
    UINT32 i, errorcounter=0;
    if ((pVol->type&0xffff) == 0x22DA)			/* amd29LV800BT */
	{
        offset = sectorNum * AMD29LV_MTD_SECTOR_SIZE;
        size = AMD29LV_MTD_SECTOR_SIZE;
        sectorAddr = offset;
		if(sectorNum == AMD29LV_800_LAST_SECTOR_NUM)
			sectorCnt = 4;
		else
			sectorCnt = 1;

	}
	else
    if ((pVol->type&0xffff) == 0x22C4)			/* amd29LV160BT */
	{
        offset = sectorNum * AMD29LV_MTD_SECTOR_SIZE;
        size = AMD29LV_MTD_SECTOR_SIZE;
        sectorAddr = offset;
		if(sectorNum == AMD29LV_160_LAST_SECTOR_NUM)
			sectorCnt = 4;
		else
			sectorCnt = 1;

	}
	else
    if ((pVol->type&0xffff) == 0x22A7 || (pVol->type&0xffff) == 0x22F6)			/* amd29LV320BT  or SpansionS29AL032DT*/
	{
        offset = sectorNum * AMD29LV_MTD_SECTOR_SIZE;
        size = AMD29LV_MTD_SECTOR_SIZE;
        sectorAddr = offset;
		if(sectorNum == AMD29LV_320_LAST_SECTOR_NUM)
			sectorCnt = 8;
		else
			sectorCnt = 1;

	}
    else 
    if ((pVol->type&0xffff) == 0x225B || 	/* amd29LV800BB */
    	(pVol->type&0xffff) == 0x2249) 		/* amd29LV160BB */    	
	{
        offset = sectorNum * AMD29LV_MTD_SECTOR_SIZE;
        size = AMD29LV_MTD_SECTOR_SIZE;
        sectorAddr = offset;
		if(sectorNum == 0)
			sectorCnt = 4;
		else
			sectorCnt = 1;
	}
    else 
    if ((pVol->type&0xffff) == 0x22A8  || (pVol->type&0xffff) == 0x22F9) 		/* amd29LV320BB or SpansionS29AL032DB*/
	{
        offset = sectorNum * AMD29LV_MTD_SECTOR_SIZE;
        size = AMD29LV_MTD_SECTOR_SIZE;
        sectorAddr = offset;
		if(sectorNum == 0)
			sectorCnt = 8;
		else
			sectorCnt = 1;
	}
//support mx29lv640m t/b  / mx29lv640bb
    else 
    if ((pVol->type&0xffff) == 0x227E) 		/* mx29lv640m t/b */
	{
        offset = sectorNum * AMD29LV_MTD_SECTOR_SIZE;
        size = AMD29LV_MTD_SECTOR_SIZE;
        sectorAddr = offset;
            if(DeviceID_cycle3 == 0x2200)	//mx29lv640m bottom
            {
		if(sectorNum == 0)
			sectorCnt = 8;
		else
			sectorCnt = 1;
            	
            } else 
            if (DeviceID_cycle3 == 0x2201)	//mx29lv640m top
            {
		if(sectorNum == AMD29LV_640_LAST_SECTOR_NUM)
			sectorCnt = 8;
		else
			sectorCnt = 1;
	    }
	}
    else
    	if((pVol->type&0xffff) == 0x22CB)
	{
	        offset = sectorNum * AMD29LV_MTD_SECTOR_SIZE;
       	 size = AMD29LV_MTD_SECTOR_SIZE;
	        sectorAddr = offset;
		if(sectorNum == 0)
			sectorCnt = 8;
		else
			sectorCnt = 1;
		
	}
#if FLASH_SST_SUPPORT
	else 
    	if ((pVol->type&0xffff) == 0x2780 || /* sst39LV400 */
    	     (pVol->type&0xffff) == 0x2781 || /* sst39LV800 */
    	     (pVol->type&0xffff) == 0x234B || /* sst39LV1601 */
    	     (pVol->type&0xffff) == 0x235B     /* sst39LV3201 */
    		) 		
	{
		offset = sectorNum * SST39VF_MTD_SECTOR_SIZE;
        	size = SST39VF_MTD_SECTOR_SIZE;
        	sectorAddr = offset;
        	sectorCnt = 1;	
	}
#endif