sysflash.c

WINDRIVER SBC7410 BSP

    int newLen=0 ;
    UINT8 *memBuf ;
    int alignment ;
    int nBytes ;

#ifdef FLASH_DEBUG
    printf("sysFlashSectorWriteIntel: programming @ 0x%x.\n",(unsigned)adrs);
#endif

    if ( sysFlashBlockLockStatusIntel((FlashWord*)adrs) == OK )
        {
#ifdef FLASH_DEBUG
        printf("sysFlashSectorWriteIntel: sectorAdrs 0x%x is locked.\n",(unsigned)adrs);
#endif
        return ERROR ;
        }

    /* programming address must being on word boundary */
    switch ( ((UINT32)adrs&0x3) )
        {
        case 0:
            ptr = (FlashWord*)adrs ;
            newLen = len ;
            break;
        case 1:
            ptr = (FlashWord*)((UINT32)adrs-1) ;
            newLen = len+1 ;
            break;
        case 2:
            ptr = (FlashWord*)((UINT32)adrs-2) ;
            newLen = len+2 ;
            break;
        case 3:
            ptr = (FlashWord*)((UINT32)adrs-3) ;
            newLen = len+3 ;
            break;
        }

    /* make length a multiple of 4 */
    switch ( newLen%4 )
        {
        case 0:
            break;
        case 1:
            newLen += 3 ;
            break;
        case 2:
            newLen += 2 ;
            break;
        case 3:
            newLen += 1 ;
            break;
        }
    /* assumes that sector has been erased */

    memBuf = (UINT8*)cacheDmaMalloc(newLen) ;
    if ( memBuf == NULL )
        {
        logMsg("Unable to allocate memory size %d bytes.\n",newLen,2,3,4,5,6);
        return ERROR ;
        }

    /* copy existing secdtor data to memBuf */
    memcpy(memBuf,ptr,newLen);

    alignment = (UINT32)adrs & 0x3 ;
    /* copy buffer data to memBuf */
    memcpy(&memBuf[alignment],buf,len);
    nBytes = newLen ;

    src = (FlashWord *)memBuf ;
    dst = ptr ;

    for ( i=0 ; i < (nBytes/4); i++, src++, dst++ )
        {
        if ( src->l == 0xffffffff )
            continue;

        ptr->l = 0x00400040 ;
        dst->l = src->l ;

        if ( sysFlashPollDataIntel(ptr) != OK )
            {
            ptr->l = 0x00ff00ff ;
            sysFlashDelay();
            printf("sysFlashSectorWriteIntel: sysFlashPollDataIntel failure.\n");
            if ( memBuf != NULL )
                cacheDmaFree(memBuf);
            return ERROR ;
            }
        }

    if ( memBuf != NULL )
        cacheDmaFree(memBuf);

    ptr->l = 0x00ff00ff ;
    sysFlashDelay();

    return OK ;
    }


/******************************************************************************
*
* sysFlashEraseStrataflash - erase the requested Intel Strataflash sector.
*
* RETURNS: OK, or ERROR if input argument error failure to erase sector.
*
*/

STATUS sysFlashEraseStrataflash
    (
    UINT8 * sectorAdrs
    )
    {
    /* validate input arg */
    if ( ((UINT32)sectorAdrs) < INTEL28F640_BASE_ADRS )
        {
        printf("sysFlashEraseStrataflash: invalid sector adrs - 0x%x\n",(unsigned)sectorAdrs);
        return ERROR ;
        }
    if ( (((UINT32)sectorAdrs)) > (INTEL28F640_BASE_ADRS+INTEL28F640_SIZE) )
        {
        printf("sysFlashEraseStrataflash: invalid sector adrs - 0x%x\n",(unsigned)sectorAdrs);
        return ERROR ;
        }
    /* check device */
    if ( sysFlashReadIdIntel((FlashWord*)INTEL28F640_BASE_ADRS) != OK )
        {
        printf("sysFlashEraseStrataflash: can't read id from device\n");
        return ERROR ;
        }

    if ( sysFlashSectorEraseIntel((char*)sectorAdrs) != OK )
        {
        printf("sysFlashEraseStrataflash: sysFlashSectorEraseIntel failure.\n");
        return ERROR ;
        }

    return OK ;
    }


/******************************************************************************
*
* sysFlashWriteStrataflash - program the requested sector using the byte program
* algorithm. The data buffer must fit in the requested Intel Strataflash sector.
*
* RETURNS: OK, or ERROR if input argument error failure to program sector.
*
*/

STATUS sysFlashWriteStrataflash
    (
    UINT8 * sectorAdrs, 
    UINT8 * buffer, 
    int length
    )
    {
    /* validate input arg */
    if ( ((UINT32)sectorAdrs) < INTEL28F640_BASE_ADRS )
        {
        printf("sysFlashWriteStrataflash: invalid sector adrs - 0x%x\n",(unsigned)sectorAdrs);
        return ERROR ;
        }
    if ( (((UINT32)sectorAdrs)+length) > (INTEL28F640_BASE_ADRS+INTEL28F640_SIZE) )
        {
        printf("sysFlashWriteStrataflash: invalid sector adrs - 0x%x\n",(unsigned)sectorAdrs);
        return ERROR ;
        }
    /* check device */
    if ( sysFlashReadIdIntel((FlashWord*)INTEL28F640_BASE_ADRS) != OK )
        {
        printf("sysFlashWriteStrataflash: can't read id from device\n");
        return ERROR ;
        }
    if ( sysFlashSectorWriteIntel(sectorAdrs, buffer, length)!=OK )
        {
        printf("sysFlashWriteStrataflash: sysFlashSectorWriteIntel failure.\n");
        return ERROR ;
        }
    return OK ;
    }

/******************************************************************************
*
* sysFlashWriteBufferStrataflash - program using the write buffer algorithm
* the Intel strataflash sector. The data buffer must fit in the requested sector.
*
* RETURNS: OK, or ERROR if input argument error failure to program sector.
*
*/

STATUS sysFlashWriteBufferStrataflash
    (
    UINT8 * sectorAdrs, 
    UINT8 * buffer, 
    int length
    )
    {
    /* validate input arg */
    if ( ((UINT32)sectorAdrs) < INTEL28F640_BASE_ADRS )
        {
        printf("sysFlashWriteBufferStrataflash: invalid sector adrs - 0x%x\n",(unsigned)sectorAdrs);
        return ERROR ;
        }
    if ( (((UINT32)sectorAdrs)+length) > (INTEL28F640_BASE_ADRS+INTEL28F640_SIZE) )
        {
        printf("sysFlashWriteBufferStrataflash: invalid sector adrs - 0x%x\n",(unsigned)sectorAdrs);
        return ERROR ;
        }
    /* check device */
    if ( sysFlashReadIdIntel((FlashWord*)INTEL28F640_BASE_ADRS) != OK )
        {
        printf("sysFlashWriteBufferStrataflash: can't read id from device\n");
        return ERROR ;
        }

    if ( sysFlashSectorWriteBufferIntel((FlashWord*)(sectorAdrs), buffer, length)!=OK )
        {
        printf("sysFlashWriteBufferStrataflash: sysFlashSectorWriteIntel failure.\n");
        return ERROR ;
        }
    return OK ;
    }


#ifdef FLASH_TEST
/* The following are test routines to illustrate flash driver function usage. */
STATUS testFlashIntel(UINT32 adrs)
    {
    char buffer[256];

    if ( adrs < FLASH_BASE_ADRS || adrs > ROM_BASE_ADRS )
        {
        printf("Attempting to test an invalid flash address 0x%x\n",adrs);
        return ERROR ;
        }

    memset(buffer,0xff,256);
    strcpy(buffer, "The quick brown fox jumps over the lazy dog.\n");

    if ( sysFlashSectorLockIntel((char*)adrs) != OK )
        {
        printf("1a-unable to lock block\n");
        return ERROR ;
        }
    if ( sysFlashSectorLockIntel((char*)adrs) != OK )
        {
        printf("1b-unable to lock block\n");
        }

    if ( sysFlashEraseStrataflash((char *)adrs)!=OK )
        {
        printf("1-can't erase sector\n");
        }
    if ( sysFlashWriteStrataflash((char*)adrs,buffer,sizeof(buffer))!=OK )
        {
        printf("1-can't write chip\n");
        }

    if ( sysFlashSectorUnlockIntel() != OK )
        {
        printf("1c-unable to unlock blocks\n");
        return ERROR ;
        }
    if ( sysFlashSectorUnlockIntel() != OK )
        {
        printf("1d-unable to unlock blocks\n");
        }
    if ( sysFlashChipEraseIntel()!= OK )
        {
        printf("2-can't erase chip\n");
        return ERROR ;
        }
    if ( sysFlashEraseStrataflash((char *)adrs)!=OK )
        {
        printf("2-can't erase sector\n");
        return ERROR ;
        }
    if ( sysFlashWriteStrataflash((char*)adrs,buffer,sizeof(buffer))!=OK )
        {
        printf("2-can't write chip\n");
        return ERROR ;
        }
    if ( sysFlashWriteStrataflash((char*)(adrs+0x41),buffer,sizeof(buffer))!=OK )
        {
        printf("2-can't write chip\n");
        return ERROR ;
        }
    if ( sysFlashWriteStrataflash((char*)(adrs+0x82),buffer,sizeof(buffer))!=OK )
        {
        printf("2-can't write chip\n");
        return ERROR ;
        }
    if ( sysFlashWriteStrataflash((char*)(adrs+0xc3),buffer,sizeof(buffer))!=OK )
        {
        printf("2-can't write chip\n");
        return ERROR ;
        }

    return OK ;
    }


STATUS testFlashBufferIntel(UINT32 adrs)
    {
    char buffer[256];

    if ( adrs < FLASH_BASE_ADRS || adrs > ROM_BASE_ADRS )
        {
        printf("Attempting to test an invalid flash address 0x%x\n",adrs);
        return ERROR ;
        }

    memset(buffer,0xff,256);
    strcpy(buffer, "The quick brown fox jumps over the lazy dog. The rain in Spain falls mainly on the plain.\n");

    if ( sysFlashSectorLockIntel((char*)adrs) != OK )
        {
        printf("1a-unable to lock block\n");
        return ERROR ;
        }
    if ( sysFlashSectorLockIntel((char*)adrs) != OK )
        {
        printf("1b-unable to lock block\n");
        }
    if ( sysFlashEraseStrataflash((char *)adrs)!=OK )
        {
        printf("1-can't erase sector\n");
        }
    if ( sysFlashWriteBufferStrataflash((char*)adrs,buffer,sizeof(buffer))!=OK )
        {
        printf("1-can't write chip\n");
        }
    if ( sysFlashSectorUnlockIntel() != OK )
        {
        printf("1c-unable to unlock blocks\n");
        return ERROR ;
        }
    if ( sysFlashSectorUnlockIntel() != OK )
        {
        printf("1d-unable to unlock blocks\n");
        }
    printf("all blocks unlocked...\n");

    /* test chip erase */

    if ( sysFlashChipEraseIntel()!= OK )
        {
        printf("2-can't erase chip\n");
        return ERROR ;
        }
    if ( sysFlashEraseStrataflash((char *)adrs)!=OK )
        {
        printf("2-can't erase sector\n");
        return ERROR ;
        }
    if ( sysFlashWriteBufferStrataflash((char*)adrs,buffer,sizeof(buffer))!=OK )
        {
        printf("2-can't write chip\n");
        return ERROR ;
        }
    if ( sysFlashWriteBufferStrataflash((char*)(adrs+0x101),buffer,sizeof(buffer))!=OK )
        {
        printf("2-can't write chip\n");
        return ERROR ;
        }
    if ( sysFlashWriteBufferStrataflash((char*)(adrs+0x202),buffer,sizeof(buffer))!=OK )
        {
        printf("2-can't write chip\n");
        return ERROR ;
        }
    if ( sysFlashWriteBufferStrataflash((char*)(adrs+0x303),buffer,sizeof(buffer))!=OK )
        {
        printf("2-can't write chip\n");
        return ERROR ;
        }

    return OK ;
    }
#endif