flashmem.c

vxworks的BSP开发配置文件

                   && (retVal == OK); pFA++)
                for (ix = 0; TRUE; ix++)
                    {
                    *pFA = FLASH28_CMD_ERASE_VERIFY;    /* verify */
                    sysFlashDelay (6);                  /* wait for verify */

                    if (*pFA == (FLASH_DEF) 0xffffffff) /* done? */
                        break;

                    if (ix == 1000)
                        {
                        retVal = ERROR;
                        break;
                        }

                    *pFA = FLASH28_CMD_ERASE_SETUP;     /* setup */
                    *pFA = FLASH28_CMD_ERASE;           /* erase */
                    sysFlashDelay (10000);
                    }

            pFA = FLASH_CAST (FLASH_ADRS);
            *pFA = FLASH28_CMD_RESET;
            *pFA = FLASH28_CMD_READ_MEM;
            sysFlashDelay (6);

            SYS_FLASH_WRITE_DISABLE_RTN ();             /* lower Vpp */
            break;
            }
        case (FLASH_29F010):
            {
            SYS_FLASH_WRITE_ENABLE_RTN ();              /* enable write */

            *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_FIRST;
            *(FLASH_CAST FLASH29_REG_SECOND_CYCLE) = FLASH29_CMD_SECOND;
            *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_CHIP_ERASE;
            *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_FOURTH;
            *(FLASH_CAST FLASH29_REG_SECOND_CYCLE) = FLASH29_CMD_FIFTH;
            *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_SIXTH;

            do {
                retVal = sysFlashDataPoll (pFA, (FLASH_DEF) 0xffffffff);
                } while ((*pFA != (FLASH_DEF) 0xffffffff) && (retVal == OK));

            *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_FIRST;
            *(FLASH_CAST FLASH29_REG_SECOND_CYCLE) = FLASH29_CMD_SECOND;
            *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_READ_RESET;

            SYS_FLASH_WRITE_DISABLE_RTN ();             /* disable enable */
            break;
            }
        case (FLASH_28F800B):
        case (FLASH_28F800T):
        case (FLASH_28F320B):
        case (FLASH_28F320T):
            {
            SYS_FLASH_WRITE_ENABLE_RTN ();              /* raise Vpp */

            *pFA = FLASH28_CMD_ERASE_SETUP;             /* setup */
            *pFA = FLASH28_CMD_ERASE_CONFIRM;           /* erase */

            /* wait for completion */
            for (ix = (FLASH_WIDTH/2)-1; ix >= 0; ix--) 
                {
                for (;;)
                    {
                    status = (*pFA) >> (ix * 16);
                    if (status & BIT(7))
                        break;
                    }
                if (status & (BIT(5) | BIT(4) | BIT(3) | BIT(1)))
                    {
                    retVal = ERROR;
                    break;
                    }
                }

            *pFA = FLASH28_CMD_RESET;                   /* read array */
            
            SYS_FLASH_WRITE_DISABLE_RTN ();             /* disable enable */
            break;
            }
        default:
            retVal = ERROR;
        }

    return (retVal);
    }

/******************************************************************************
*
* sysFlashWrite - write data to flash memory
*
* This routine copies specified data of a specified length, <size>, into a 
* specified offset, <offset>, in the flash memory.  Data is passed as a string,
* <pFB>, if not NULL.  If NULL, data is taken as a repeated sequence of
* <value>.
* The parameter <flashType> should be set to the flash device code.
* 
* Flash 28F\f2xxx\f1 devices are programmed by a sequence of operations: 
* .iP
* set up device to write
* .iP
* perform write
* .iP
* verify the write
* .LP
*
* Flash 29F\f2xxx\f1 devices are programmed by a sequence of operations: 
* .iP
* set up device to write
* .iP
* perform write
* .iP
* wait for the write to complete
* .LP
* 
* RETURNS: OK, or ERROR if the write operation fails.
* 
* SEE ALSO: sysFlashSet()
*/

STATUS sysFlashWrite
    (
    char * pFB,         /* string to be copied; use <value> if NULL */
    int size,                   /* size to program in bytes */
    int offset,                 /* byte offset into flash memory */
    UINT8 flashType,            /* type of flash memory on-board */
    FLASH_DEF value             /* value to program */
    )
    {
    volatile FLASH_DEF * pFA;           /* flash address */
    STATUS retVal = OK;
    int ix, status;

    switch (flashType)
        {
        case (FLASH_28F256):
        case (FLASH_28F512):
        case (FLASH_28F010):
        case (FLASH_28F020):
            {
            SYS_FLASH_WRITE_ENABLE_RTN ();              /* raise Vpp */

            for (pFA = FLASH_CAST (FLASH_ADRS + offset); (pFA < FLASH_CAST
                (FLASH_ADRS + size + offset)) && (retVal == OK); pFA++)
                for (ix = 0; TRUE; ix++)
                    {
                    if (pFB != NULL)
                        {
                        value = readPtr(pFB);
                        pFB += FLASH_WIDTH;
                        }

                    *pFA = FLASH28_CMD_PROG_SETUP;      /* write setup */
                    *pFA = value;                       /* data to write */
                    sysFlashDelay (10);                 /* wait for write */

                    *pFA = FLASH28_CMD_PROG_VERIFY;     /* verify command */
                    sysFlashDelay (6);                  /* wait for verify */

                    if (*pFA == value)                  /* done? */
                        break;

                    if (ix == 25)                       /* error? */
                        {
                        retVal = ERROR;
                        break;
                        }
                    }

            pFA = FLASH_CAST (FLASH_ADRS);
            *pFA = FLASH28_CMD_RESET;
            *pFA = FLASH28_CMD_READ_MEM;
            sysFlashDelay (6);

            SYS_FLASH_WRITE_DISABLE_RTN ();             /* lower Vpp */
            break;
            }
        case (FLASH_29F010):
            {
            SYS_FLASH_WRITE_ENABLE_RTN ();              /* enable write */
            for (pFA = FLASH_CAST (FLASH_ADRS + offset); pFA < FLASH_CAST
                (FLASH_ADRS + size + offset) && (retVal == OK); pFA++)
                {
                *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_FIRST;
                *(FLASH_CAST FLASH29_REG_SECOND_CYCLE) = FLASH29_CMD_SECOND;
                *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_PROGRAM;
                if (pFB != NULL)
                    {
                    value = readPtr(pFB);
                    pFB += FLASH_WIDTH;
                    }

                *pFA = value;                           /* data to write */
                do {
                    retVal = sysFlashDataPoll (pFA, (FLASH_DEF) value);
                    } while ((*pFA != value) && (retVal == OK));
                }
 
            *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_FIRST;
            *(FLASH_CAST FLASH29_REG_SECOND_CYCLE) = FLASH29_CMD_SECOND;
            *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_READ_RESET;

            SYS_FLASH_WRITE_DISABLE_RTN ();             /* disable write */
            break;
            }

        case (FLASH_28F800B):
        case (FLASH_28F800T):
        case (FLASH_28F320B):
        case (FLASH_28F320T):
            {
            SYS_FLASH_WRITE_ENABLE_RTN ();              /* raise Vpp */

            for (pFA = FLASH_CAST (FLASH_ADRS + offset);
                 ((pFA < FLASH_CAST (FLASH_ADRS + size + offset)) &&
                  (retVal == OK));
                 pFA++)
                {
                 if (pFB != NULL)
                     {
                     value = readPtr(pFB);
                     pFB += FLASH_WIDTH;
                     }

                *pFA = FLASH28_CMD_PROG_SETUP;          /* write setup */
                *pFA = value;

                /* wait for completion */
                for (ix = (FLASH_WIDTH/2)-1; ix >= 0; ix--) 
                    {
                    for (;;)
                        {
                            status = (*pFA) >> (ix * 16);
                            if (status & BIT(7))
                                break;
                        }
                    if (status & (BIT(5) | BIT(4) | BIT(3) | BIT(1)))
                        {
                        retVal = ERROR;
                        break;
                        }
                    } /* end for ix */
                } /* end for pFA */
            
            *pFA = FLASH28_CMD_RESET;                   /* read array */
            
            SYS_FLASH_WRITE_DISABLE_RTN ();             /* disable enable */
            break;
            }

        default:
            retVal = ERROR;
        }
 
    return (retVal);
    }
 
/******************************************************************************
*
* sysFlashTypeGet - determine the device type of on-board flash memory 
*
* This routine uses the `autoselect' command to determine the device type of
* on-board flash memory for flash 29F\f2xxx\f1 devices.
*
* RETURNS: An integer indicating the device type of on-board flash memory.
*/

UINT8 sysFlashTypeGet (void)
    {
    volatile FLASH_DEF * pFA = FLASH_CAST (FLASH_ADRS); /* flash address */
    UINT8 retVal;

    SYS_FLASH_WRITE_ENABLE_RTN ();                      /* enable writes */

    *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_FIRST;
    *(FLASH_CAST FLASH29_REG_SECOND_CYCLE) = FLASH29_CMD_SECOND;
    *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_AUTOSELECT;

    retVal = (UINT8) *++pFA;

    *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_FIRST;
    *(FLASH_CAST FLASH29_REG_SECOND_CYCLE) = FLASH29_CMD_SECOND;
    *(FLASH_CAST FLASH29_REG_FIRST_CYCLE)  = FLASH29_CMD_READ_RESET;

    SYS_FLASH_WRITE_DISABLE_RTN ();                     /* disable writes */

    return (retVal);
    }

/******************************************************************************
*
* sysFlashSet - write to flash memory
*
* This routine copies a specified string into flash memory after calling 
* sysFlashErase() and clearing flash memory.
*
* If the specified string must be overlaid on the contents of flash memory, 
* undefine FLASH_NO_OVERLAY.
*
* RETURNS: OK, or ERROR if the write fails or the input parameters are 
* out of range.
*
* SEE ALSO: sysFlashErase(), sysFlashGet(), sysFlashTypeGet(), sysFlashWrite()
*
* INTERNAL
* If multiple tasks are calling sysFlashSet() and sysFlashGet(),
* they should use a semaphore to ensure mutually exclusive access to flash
* memory.
*/

STATUS sysFlashSet
    (
    char *string,     /* string to be copied into flash memory */
    int strLen,       /* maximum number of bytes to copy       */
    int offset        /* byte offset into flash memory         */
    )
    {
    int flashSize = FLASH_SIZE;

    static UINT8 flashType = FLASH_MEM_TYPE;

#ifndef FLASH_NO_OVERLAY
    static char tempBuffer [FLASH_MEM_SIZE];
    flashSize = FLASH_MEM_SIZE;
#endif  /* FLASH_NO_OVERLAY */

    if ((offset < 0) || (strLen < 0) || ((offset + strLen) > flashSize))
        return (ERROR);

    /* see if contents are actually changing */

    if (bcmp ((char *) (FLASH_ADRS + offset), string, strLen) == 0)
        return (OK);

    /* first read existing data */

#ifndef FLASH_NO_OVERLAY
    bcopyBytes ((char *) FLASH_ADRS, tempBuffer, flashSize);
    bcopyBytes (string, (tempBuffer + offset), strLen);
#endif  /* FLASH_NO_OVERLAY */

    if (flashType == 0)
        flashType = sysFlashTypeGet ();

    if (sysFlashErase (flashType) == ERROR)             /* erase device */
        return (ERROR);

#ifndef FLASH_NO_OVERLAY                                /* program device */
    if (sysFlashWrite (tempBuffer, flashSize, 0, flashType, 0) ==
        ERROR)
#else   /* FLASH_NO_OVERLAY */
    if (sysFlashWrite (string, strLen, offset, flashType, 0) ==
        ERROR)
#endif  /* FLASH_NO_OVERLAY */
        return (ERROR);

    return (OK);
    }