amd_flash.c

Freescale MCF5445evb 参考测试代码

#endif  /* defined(__GNUC__) */

void 
amd_flash_sector_erase(int n)
{
    AMD_FLASH_CELL status;

    pFlash[0x555] = AMD_FLASH_CMD_DATA(0xAA);
    pFlash[0xAAA] = AMD_FLASH_CMD_DATA(0x55);
    pFlash[0x555] = AMD_FLASH_CMD_DATA(0x80);
    pFlash[0x555] = AMD_FLASH_CMD_DATA(0xAA);
    pFlash[0xAAA] = AMD_FLASH_CMD_DATA(0x55);
    pFlash[SADDR(n)] = AMD_FLASH_CMD_DATA(0x30);

    do 
        status = pFlash[SADDR(n)];
    while (!(status & AMD_FLASH_CMD_DATA(0x80)));
}

/********************************************************************/
#ifdef __MWERKS__
__relocate_code__
#elif defined(__GNUC__)
int amd_flash_erase(ADDRESS start, int bytes, void (*putchar)(char))
    __attribute__ ((section(".code_relocation")));
#endif  /* defined(__GNUC__) */

int
amd_flash_erase(ADDRESS start, int bytes, void (*putchar)(char))
{   
    int i, ebytes = 0;
    
    if (bytes == 0)
        return 0;
    
    for (i = 0; i < AMD_FLASH_SECTORS; i++)
    {
        if (start >= (ADDRESS)((ADDRESS)pFlash + SOFFSET(i)) &&
            start <= (ADDRESS)((ADDRESS)pFlash + SOFFSET(i) + (SSIZE(i) - 1)))
        {
            break;
        }
    }
    
    while (ebytes < bytes)
    {
        if (putchar != NULL)
        {
            putchar('.');
        }
        amd_flash_sector_erase(i);
        ebytes += SSIZE(i);
        i++;
    }
    
    if (putchar != NULL)
    {
        putchar(0x0D);
        putchar(0x0A);
    }
    
    return ebytes;
}
/********************************************************************/
#ifdef __MWERKS__
__relocate_code__
#elif defined(__GNUC__)
int amd_flash_program_cell(AMD_FLASH_CELL *dst, AMD_FLASH_CELL data)
    __attribute__ ((section(".code_relocation")));
#endif  /* defined(__GNUC__) */

int
amd_flash_program_cell(AMD_FLASH_CELL *dst, AMD_FLASH_CELL data)
{
    AMD_FLASH_CELL status;
    int rval;

    pFlash[0x555] = AMD_FLASH_CMD_DATA(0xAA);
    pFlash[0xAAA] = AMD_FLASH_CMD_DATA(0x55);
    pFlash[0x555] = AMD_FLASH_CMD_DATA(0xA0);
    *dst = data;
    
    /* Data# Polling Algorithm */
    rval = 0;
    while (1)
    {
        status = *dst;
        if ((status & AMD_FLASH_CMD_DATA(0x80)) ==
            (data & AMD_FLASH_CMD_DATA(0x80)))
        {
            break;
        }
        if (status & AMD_FLASH_CMD_DATA(0x20))
        {
            status = *dst;
            if ((status & AMD_FLASH_CMD_DATA(0x80)) ==
                (data & AMD_FLASH_CMD_DATA(0x80)))
            {
                break;
            }
            else
            {
                rval = 1;
                break;
            }
        }
    }
    return rval;
}
/********************************************************************/
#ifdef __MWERKS__
__relocate_code__
#elif defined(__GNUC__)
int amd_flash_program(ADDRESS dest, ADDRESS source, 
					int bytes, int erase, 
                    void (*func)(void),
                    void (*putchar)(char))
    __attribute__ ((section(".code_relocation")));
#endif  /* defined(__GNUC__) */

int 
amd_flash_program(ADDRESS dest, ADDRESS source, 
                    int bytes, int erase, 
                    void (*func)(void),
                    void (*putchar)(char))
{
    AMD_FLASH_CELL *src, *dst;
    int hashi=1,hashj=0;
    char hash[5];
    
    hash[0]=8;  /* Backspace */
    hash[1]=124;/* "|" */
    hash[2]=47; /* "/" */
    hash[3]=45; /* "-" */
    hash[4]=92; /* "\" */

    src = (AMD_FLASH_CELL *)source;
    dst = (AMD_FLASH_CELL *)dest;

    /*
     * Place device in read mode 
     */
    pFlash[0] = AMD_FLASH_CMD_DATA(0xAA);
    pFlash[0] = AMD_FLASH_CMD_DATA(0x55);
    pFlash[0] = AMD_FLASH_CMD_DATA(0xF0);
    
    /*
     * Erase device if necessary
     */
    if (erase)
    {
        amd_flash_erase(dest, bytes, putchar);
    }
    
    /*
     * Program device
     */
    while (bytes > 0)
    {
        amd_flash_program_cell(dst,*src);
        
        /* Verify Write */
        if (*dst == *src)
        {
            bytes -= AMD_FLASH_CELL_BYTES;
            *dst++, *src++;

            if ((putchar != NULL))
            {   
                /* Hash marks to indicate progress */
                if (hashj == 0x1000)
                {
                    hashj = -1;
                    putchar(hash[0]);
                    putchar(hash[hashi]);
                            
                    hashi++;
                    if (hashi == 5) 
                    {
                        hashi=1;                
                    }
        
                }
                hashj++;
            }
        }
        else
            break;
    }
    
    /*
     * Place device in read mode 
     */
    pFlash[0] = AMD_FLASH_CMD_DATA(0xAA);
    pFlash[0] = AMD_FLASH_CMD_DATA(0x55);
    pFlash[0] = AMD_FLASH_CMD_DATA(0xF0);
    
    if (putchar != NULL)
    {
        putchar(hash[0]);
    }
    
    /* 
     * If a function was passed in, call it now
     */
    if ((func != NULL))
    {
        func();
    }

    return ((int)src - (int)source);
}

/********************************************************************/
#ifdef __MWERKS__
__relocate_code__
#elif defined(__GNUC__)
ADDRESS amd_flash_sector_number(ADDRESS addr)
    __attribute__ ((section(".code_relocation")));
#endif  /* defined(__GNUC__) */

int
amd_flash_sector_number(ADDRESS addr)
{
    int i;

    /* Returns the number of the sector containing addr */
    for (i = 0; i < AMD_FLASH_SECTORS; i++)
    {
        if (addr >= (ADDRESS)((ADDRESS)pFlash + SOFFSET(i)) &&
            addr <= (ADDRESS)((ADDRESS)pFlash + SOFFSET(i) + (SSIZE(i) - 1)))
        {
            break;
        }
    }
    ASSERT(i != AMD_FLASH_SECTORS);
    return i;
}
/********************************************************************/
#ifdef __MWERKS__
__relocate_code__
#elif defined(__GNUC__)
ADDRESS amd_flash_sector_start(ADDRESS addr)
    __attribute__ ((section(".code_relocation")));
#endif  /* defined(__GNUC__) */

ADDRESS 
amd_flash_sector_start(ADDRESS addr)
{   
    /* 
     * Returns beginning of sector containing ADDRESS 
     */
    int i;
    
    for (i = 0; i < AMD_FLASH_SECTORS; i++)
    {
        if (addr >= (ADDRESS)((ADDRESS)pFlash + SOFFSET(i)) &&
            addr <= (ADDRESS)((ADDRESS)pFlash + SOFFSET(i) + (SSIZE(i) - 1)))
        {
            return (ADDRESS)((ADDRESS)pFlash + SOFFSET(i));
        }
    }
    return NULL;
}

/********************************************************************/
#ifdef __MWERKS__
__relocate_code__
#elif defined(__GNUC__)
ADDRESS amd_flash_sector_end(ADDRESS addr)
    __attribute__ ((section(".code_relocation")));
#endif  /* defined(__GNUC__) */

ADDRESS 
amd_flash_sector_end(ADDRESS addr)
{
    /* Returns end of sector containing ADDRESS */
    int i;
    
    for (i = 0; i < AMD_FLASH_SECTORS; i++)
    {
        if (addr >= (ADDRESS)((ADDRESS)pFlash + SOFFSET(i)) &&
            addr <= (ADDRESS)((ADDRESS)pFlash + SOFFSET(i) + (SSIZE(i) - 1)))
        {
            return (ADDRESS)((ADDRESS)pFlash + SOFFSET(i) + (SSIZE(i) - 1));
        }
    }                                    
    return NULL;
}

/********************************************************************/