m29w160b.c

iar公司的s3c44b0x评估板的源程序

#include "m29w160b.h"

/* address offset of each block in boot flash */
const unsigned int M29W160B_Blk_Off[] =
{
      0x00000, /* Start of block 0 */
      0x02000, /* Start of block 1 */
      0x03000, /* Start of block 2 */
      0x04000, /* Start of block 3 */
      0x08000, /* Start of block 4 */
      0x10000, /* Start of block 5 */
      0x18000, /* Start of block 6 */
      0x20000, /* Start of block 7 */
      0x28000, /* Start of block 8 */
      0x30000, /* Start of block 9 */
      0x38000, /* Start of block 10 */
      0x40000, /* Start of block 11 */
      0x48000, /* Start of block 12 */
      0x50000, /* Start of block 13 */
      0x58000, /* Start of block 14 */
      0x60000, /* Start of block 15 */
      0x68000, /* Start of block 16 */
      0x70000, /* Start of block 17 */
      0x78000, /* Start of block 18 */
      0x80000, /* Start of block 19 */
      0x88000, /* Start of block 20 */
      0x90000, /* Start of block 21 */
      0x98000, /* Start of block 22 */
      0xA0000, /* Start of block 23 */
      0xA8000, /* Start of block 24 */
      0xB0000, /* Start of block 25 */
      0xB8000, /* Start of block 26 */
      0xC0000, /* Start of block 27 */
      0xC8000, /* Start of block 28 */
      0xD0000, /* Start of block 29 */
      0xD8000, /* Start of block 30 */
      0xE0000, /* Start of block 31 */
      0xE8000, /* Start of block 32 */
      0xF0000, /* Start of block 33 */
      0xF8000, /* Start of block 34 */
};

int BfBlockProtect (unsigned int u32BlkNum)
{
    unsigned short u16Attempt = 0;
    unsigned short u16Data;

    /* check for invalid block */
    if (u32BlkNum >= BFLASH_BLKNUM)
    {
        return -1;
    }

    /* setup phase */
    BFLASH_BASE[M29W160B_Blk_Off[u32BlkNum] | PROTECT_OFFSET] = PROTECT_SETUP;

    do
    {
        /* protect phase */
        BFLASH_BASE[M29W160B_Blk_Off[u32BlkNum] | PROTECT_OFFSET] = PROTECT_CMD;
        DM_WaitUs(100);

        /* verify phase */
        BFLASH_BASE[M29W160B_Blk_Off[u32BlkNum] | PROTECT_OFFSET] = PROTECT_VERIFY;
        DM_WaitUs(4);
        u16Data = BFLASH_BASE[M29W160B_Blk_Off[u32BlkNum] | PROTECT_OFFSET];

        /* if success or not */
        if (u16Data == BLK_PROTECTED)
        {
            /* reset to read mode */
            BFLASH_BASE[0] = READ_RESET;
            return 0;
        }
    }   while (++u16Attempt < 25);

    /* reset to read mode */
    BFLASH_BASE[0] = READ_RESET;
    return -1;
}

int BfChipProtect (void)
{
    unsigned int u32CurrBlk;

    /* protect all blocks */
    for (u32CurrBlk=0; u32CurrBlk<BFLASH_BLKNUM; u32CurrBlk++)
    {
        if (BfBlockProtect(u32CurrBlk) != 0)
        {
            return -1;
        }
    }

    return 0;
}

int BfChipUnprotect (void)
{
    unsigned int u32CurrBlk;
    unsigned short u16Data;
    unsigned short u16Attempt = 0;

    /* protect all blocks */
    for (u32CurrBlk=0; u32CurrBlk<BFLASH_BLKNUM; u32CurrBlk++)
    {
        if (BfBlockProtect(u32CurrBlk) != 0)
        {
            return -1;
        }
    }

    /* reset to read mode */
    BFLASH_BASE[0] = READ_RESET;

    /* setup phase */
    BFLASH_BASE[UNPROTECT_OFFSET] = UNPROTECT_SETUP;

    u32CurrBlk = 0;
    do
    {
        /* unprotect phase */
        BFLASH_BASE[UNPROTECT_OFFSET] = UNPROTECT_CMD;
        DM_WaitMs(10);

        do
        {
            /* verify phase */
            BFLASH_BASE[M29W160B_Blk_Off[u32CurrBlk] | UNPROTECT_OFFSET] = UNPROTECT_VERIFY;
            DM_WaitUs(4);
            u16Data = BFLASH_BASE[M29W160B_Blk_Off[u32CurrBlk] | UNPROTECT_OFFSET];

            /* if success or not */
            if (u16Data == BLK_UNPROTECTED)
            {
                /* if last block reached */
                if (u32CurrBlk == (BFLASH_BLKNUM - 1))
                {
                    /* reset to read mode */
                    BFLASH_BASE[0] = READ_RESET;
                    return 0;
                }
                else
                {
                    u32CurrBlk ++;
                }
            }
            else
            {
                break;
            }
        }   while (1);
    }   while (++u16Attempt < 1000);

    /* reset to read mode */
    BFLASH_BASE[0] = READ_RESET;
    return -1;
}

int BfDataToggle (void)
{
    unsigned short u16Data1, u16Data2;

    while (1)
    {
        /* read DQ5 and DQ6 */
        u16Data2 = BFLASH_BASE[0];
        /* read DQ6 again */
        u16Data1 = BFLASH_BASE[0];

        /* if DQ6 did not toggle between the two reads, success */
        if ((u16Data1 & TOGGLE_BIT) == (u16Data2 & TOGGLE_BIT))
        {
            return 0;
        }

        /* else if DQ5 is zero, then operation is not yet complete */
        if ((u16Data2 & ERROR_BIT) != ERROR_BIT)
        {
            continue;
        }

        /* if DQ5 has been set, read DQ6 twice */
        u16Data1 = BFLASH_BASE[0];
        u16Data2 = BFLASH_BASE[0];

        /* if DQ6 did not toggle between the last two reads, success */
        if ((u16Data1 & TOGGLE_BIT) == (u16Data2 & TOGGLE_BIT))
        {
            return 0;
        }
        /* failed */
        else
        {
            return -1;
        }
    }
}

int BfBlockErase (unsigned int u32BlkNum)
{
    int iRetVal = 0;

    /* check for invalid block */
    if (u32BlkNum >= BFLASH_BLKNUM)
    {
        return -1;
    }

    /* issue block erase command sequence */
    BFLASH_BASE[FIRST_ADDR]     = FIRST_DATA;
    BFLASH_BASE[SECOND_ADDR]    = SECOND_DATA;
    BFLASH_BASE[THIRD_ADDR]     = ERASE_SETUP;
    BFLASH_BASE[FOURTH_ADDR]    = FIRST_DATA;
    BFLASH_BASE[FIFTH_ADDR]     = SECOND_DATA;
    BFLASH_BASE[M29W160B_Blk_Off[u32BlkNum]] = BLOCK_ERASE;

    /* wait for erase timer bit (DQ3) to be set */
    while ((BFLASH_BASE[M29W160B_Blk_Off[u32BlkNum]] & ERASE_TIMER_BIT) != ERASE_TIMER_BIT);

    /* data toggle */
    if (BfDataToggle() != 0)
    {
        iRetVal = -1;
    }

    /* reset to read mode */
    BFLASH_BASE[0] = READ_RESET;
    return iRetVal;
}

int BfProgram (unsigned int u32AddrOff, unsigned int u32SizeInWord, unsigned short *pu16Buf)
{
    int i;
    int iRetVal = 0;

    /* check if the data to be programmed are within the boot flash memory space */
    if ((u32AddrOff >= BFLASH_SIZE) || (u32SizeInWord > (BFLASH_SIZE - u32AddrOff)))
    {
        return -1;
    }

    /* issue unlock bypass command sequence */
    BFLASH_BASE[FIRST_ADDR]     = FIRST_DATA;
    BFLASH_BASE[SECOND_ADDR]    = SECOND_DATA;
    BFLASH_BASE[THIRD_ADDR]     = UNLOCK_BYPASS;

    for (i=0; i<u32SizeInWord; i++)
    {
        /* program the next word */
        BFLASH_BASE[0] = UNLOCK_BYPASS_PROGRAM;
        BFLASH_BASE[u32AddrOff++] = *pu16Buf++;

        /* data toggle */
        if (BfDataToggle() != 0)
        {
            iRetVal = -1;
            /* reset to read mode */
            BFLASH_BASE[0] = READ_RESET;
            break;
        }
    }

    /* unlock bypass reset */
    BFLASH_BASE[0] = UNLOCK_BYPASS_RESET1;
    BFLASH_BASE[0] = UNLOCK_BYPASS_RESET2;
    return iRetVal;
}