sysflash.c

WINDRIVER SBC7410 BSP

        s1 = ptr->l ;

        if ( !((s1 & 0x00000080)&&
               (s1 & 0x00800000)) )
            continue; /* wsm not ready */

        status = checkStatusIntel(s1);
        if ( status == -1 )
            {
            ptr->l = 0x00ff00ff;
            sysFlashDelay();
            return ERROR ;
            }
        else if ( status == 1 )
            continue;
        else if ( status == 0 )
            break;
        }

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

    return OK ;
    }


/******************************************************************************
*
* sysFlashSectorEraseIntel - erase the requested Intel Strataflash sector.
*
* RETURNS: OK, or ERROR if unable to erase the sector.
*
*/

STATUS sysFlashSectorEraseIntel
    (
    char * sectorAdrs
    )
    {
    FlashWord * ptr = (FlashWord *)sectorAdrs ;

    if ( sysFlashBlockLockStatusIntel((FlashWord*)ptr) == OK )
        {
        printf("sysFlashSectorEraseIntel: sectorAdrs 0x%x is locked.\n",(unsigned)sectorAdrs);
        return ERROR ;
        }

    ptr->l = 0x00200020 ;
    ptr->l = 0x00d000d0 ;

    if ( sysFlashPollDataIntel(ptr) != OK )
        {
        printf("sysFlashSectorEraseIntel: sysFlashPollDataIntel failure.\n");
        return ERROR ;
        }

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

    return OK ;
    }


/******************************************************************************
*
* sysFlashChipEraseIntel - Erase the entire Intel Strataflash chip.
*
* RETURNS: OK, or ERROR if unable to erase the entire chip.
*
*/

STATUS sysFlashChipEraseIntel(void)
    {
    int i ;
    FlashWord * ptr = (FlashWord *)INTEL28F640_BASE_ADRS ;

    /* no chip erase - loop through all blocks, note ptr math : FlashWord is 4 bytes
       so incrementing ptr will advance the address +4. That's why INTEL28F640_SECTOR_SZ
       is adjusted by dividing by 4 since it defines how many bytes are in a sector. */
    for ( i=0 ; i<INTEL28F640_NUM_SECTORS ; i++, ptr+=(INTEL28F640_SECTOR_SZ/4) )
        {
#if FLASH_DEBUG
        printf("sysFlashChipEraseIntel: erasing sector %d, adrs - 0x%x\n",i,(unsigned)ptr) ;
#else
        printf(".") ;
#endif
        if ( sysFlashSectorEraseIntel((char*)ptr)!=OK )
            {
            printf("sysFlashChipEraseIntel: Unable to erase sector @ 0x%x\n",(unsigned)ptr);
            return ERROR ;
            }
        }

    return OK ;
    }


/******************************************************************************
*
* sysFlashSectorWriteBufferIntel - this write routine uses write to buffer
* programming - faster than byte at a time programming. Note: max number of
* bytes per buffer is 16 for x16 mode. The caller must guarantee that the 
* data doesn't exceed flash sector boundaries.
*
* RETURNS: OK, or ERROR if unable to program the requested sector.
*
*/

#define INTEL_28F640_WRITE_TO_BUFFER_COUNT 16 /* in x16 mode */
#define INTEL_28F640_WRITE_TO_BUFFER_TIMEOUT 5 /* 5 seconds */
STATUS sysFlashSectorWriteBufferIntel
    (
    FlashWord *adrs, 
    char * buf, 
    int len
    )
    {
    int i ;
    int longsToWrite ;
    /* assumes that adrs is 32 bit aligned */
    volatile FlashWord * ptr=NULL ;
    volatile FlashWord *dst ;
    volatile FlashWord *src ;
    volatile UINT32 s1 ;
    UINT32 endTicks ;
    FlashWord f ;
    int newLen=0 ;
    UINT8 *memBuf ;
    int alignment ;
    int nBytes ;

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

    longsToWrite = ((len-1)/4)+1 ;

    /* check to see if block is locked */
    if ( sysFlashBlockLockStatusIntel((FlashWord*)adrs) == OK )
        {
        printf("sysFlashSectorWriteBufferIntel: sectorAdrs 0x%x is locked.\n",(unsigned)adrs);
        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 sector data to memBuf */
    memcpy((void*)memBuf,(const void*)ptr,newLen);

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

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

    while ( longsToWrite > 0 )
        {
        /* we want about 5 second timeout */
        endTicks = tickGet() + (sysClkRateGet()*5);
        while ( 1 )
            {
            do
                {
                ptr->l = 0x00500050 ; /* clear status register */
                ptr->l = 0x00700070 ;
                s1 = ptr->l ;
                } while ( !(s1&0x00800000) || !(s1&0x00000080) ) ;

            ptr->l = 0x00e800e8 ; /* set write to buffer mode */
            s1 = ptr->l ;   /* read extended status register */

            if ( tickGet() < endTicks )
                {
                if ( !(s1&0x00800000) || !(s1&0x00000080) )
                    {
                    /* continue waiting for buffer, not available, and timeout not expired */
                    continue; 
                    }
                }
            else if ( tickGet() >= endTicks )
                {
                /* timeout waiting for buffer to be available */
                do
                    {
                    ptr->l = 0x00500050 ; /* clear status register */
                    ptr->l = 0x00700070 ;
                    s1 = ptr->l ;
                    } while ( !(s1&0x00800000) || !(s1&0x00000080) ) ;
                printf("sysFlashSectorWriteBufferIntel: timeout trying to get write buffer!\n");
                ptr->l = 0x00ff00ff ;
                sysFlashDelay();
                return ERROR ;
                }
#ifdef DEBUG
            /* write word count (0 = 1) */
            printf("longs to write - 0%d\n",longsToWrite) ;
#endif
            /* load word count into each x16 chip */
            f.s[0] = f.s[1] = (longsToWrite > 16) ? 15 : longsToWrite-1 ;
            ptr->l = f.l ;

            /* buffer is available */
            for ( i=0 ; (i < INTEL_28F640_WRITE_TO_BUFFER_COUNT) && 
                (longsToWrite > 0) ; i++, src++, dst++, longsToWrite-- )
                dst->l = src->l ;

            ptr->l = 0x00d000d0 ; /* confirm */
            break;
            }
        }

    /* read reset */
    do
        {
        ptr->l = 0x00500050 ; /* clear status register */
        ptr->l = 0x00700070 ;
        s1 = ptr->l ;
        } while ( !(s1&0x00800000) || !(s1&0x00000080) ) ;

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

    return OK ;
    }




/******************************************************************************
*
* sysFlashSectorLockIntel - Lock the requested Intel Stratflash sector.
*
* RETURNS: OK, or ERROR if unable to lock the sector.
*
*/

STATUS sysFlashSectorLockIntel
    (
    char *adrs
    )
    {
    FlashWord * ptr = (FlashWord *)adrs;
    volatile UINT32 s1 ;

    ptr->l = 0x00600060 ;
    ptr->l = 0x00010001 ;

    do
        {
        s1 = ptr->l ;
        } while ( !(s1 & 0x00800000) ||
                  !(s1 & 0x00000080) );

    ptr->l = 0x00700070 ;
    s1 = ptr->l ;

    if ( (s1 & 0x00100000) ||
         (s1 & 0x00000010) )
        {
        printf("sysFlashSectorLockIntel: Unable to set lock bit for sector 0x%x\n", (unsigned)adrs);

        ptr->l = 0x00500050 ;
        ptr->l = 0x00ff00ff ;
        sysFlashDelay();
        return ERROR ;
        }

    ptr->l = 0x00ff00ff ;
    sysFlashDelay();
    return OK ;
    }

/******************************************************************************
*
* sysFlashSectorUnlockIntel - unlock the requested Intel Strataflash sector.
*
* RETURNS: OK, or ERROR if unable to unlock sector.
*
*/

STATUS sysFlashSectorUnlockIntel(void)
    {
    FlashWord * ptr =  (FlashWord *)INTEL28F640_BASE_ADRS ;
    volatile UINT32 s1 ;

    ptr->l = 0x00600060 ;
    ptr->l = 0x00d000d0 ;

    do
        {
        s1 = ptr->l ;

        } while ( !(s1 & 0x00800000) ||
                  !(s1 & 0x00000080) );

    ptr->l = 0x00700070 ;
    s1 = ptr->l ;

    if ( (s1 & 0x00200000) ||
         (s1 & 0x00000020) )
        {
        printf("sysFlashSectorUnlockIntel: Unable to clear lock bits\n");
        ptr->l = 0x00500050 ;
        ptr->l = 0x00ff00ff ;
        sysFlashDelay();
        return ERROR ;
        }

    ptr->l = 0x00ff00ff ;
    sysFlashDelay();
    return OK ;
    }



/******************************************************************************
*
* sysFlashSectorWriteIntel - this write routine uses byte programming.
* to program an Intel Strataflash sector. Allows any alignment for
* adrs and buf. Assumes that the flash region has been erased before
* this function is called.
*
* RETURNS: OK, or ERROR 
*
*/

STATUS sysFlashSectorWriteIntel
    (
    char * adrs, 
    char * buf, 
    int len
    )
    {
    int i ;
    FlashWord * ptr=NULL ;
    FlashWord *dst ;
    FlashWord *src ;