mvflash.c

此代码为烧制bios程序的源码

                MV_WRITE_WORD(FLASH_BASE_ADDR, FirstAddr * FLASH_WIDTH,
                           FirstData);
                MV_WRITE_WORD(FLASH_BASE_ADDR, SecondAddr * FLASH_WIDTH,
                           SecondData);
                MV_WRITE_WORD(FLASH_BASE_ADDR, ThirdAddr * FLASH_WIDTH,
                           ThirdData);
                MV_WRITE_WORD(FLASH_BASE_ADDR, FourthAddr * FLASH_WIDTH,
                           FourthData);
                MV_WRITE_WORD(FLASH_BASE_ADDR, FifthAddr * FLASH_WIDTH,
                           FifthData);
                MV_WRITE_WORD(FLASH_BASE_ADDR, 
                           (sectorBaseAddress & 0xffffff00) * FLASH_WIDTH,
                           SixthData);
                MV_WRITE_WORD(FLASH_BASE_ADDR,FirstAddr * FLASH_WIDTH + 4,
                           FirstData);
                MV_WRITE_WORD(FLASH_BASE_ADDR,SecondAddr * FLASH_WIDTH + 4,
                           SecondData);
                MV_WRITE_WORD(FLASH_BASE_ADDR,ThirdAddr * FLASH_WIDTH + 4,
                           ThirdData);
                MV_WRITE_WORD(FLASH_BASE_ADDR,FourthAddr * FLASH_WIDTH + 4,
                           FourthData);
                MV_WRITE_WORD(FLASH_BASE_ADDR,FifthAddr * FLASH_WIDTH + 4,
                           FifthData);
                MV_WRITE_WORD(FLASH_BASE_ADDR,(sectorBaseAddress & 0xffffff00) 
                           * FLASH_WIDTH + 4,SixthData);
                /* Poll on the flash */
                if (FLASH_MODE == X16) /* 4 devices , 16 bit each => 64bit */
                {
                    dataPoll = 0x00800080;
                }
                else /* (FLASH_MODE = 8) ==> 8 devices , 8 bit each => 64bit*/
                {
                    dataPoll = 0x80808080;
                }
                do
                {
                    MV_READ_WORD(FLASH_BASE_ADDR,  sectorBaseAddress * 
                                                       FLASH_WIDTH,&regValue);
                } while((regValue & dataPoll) != dataPoll);
                do
                {
                    MV_READ_WORD(FLASH_BASE_ADDR,  sectorBaseAddress * 
                                                   FLASH_WIDTH + 4,&regValue);
                } while((regValue & dataPoll) != dataPoll);
                break;
            default:
                return false;
        }
    } /* End of 'flash erase sector' for AMD/ST */
    else /* Intel/Micron */
    {
        switch(FLASH_WIDTH)
        {
            case 1:
                MV_WRITE_CHAR(FLASH_BASE_ADDR,0,0x20);
                MV_WRITE_CHAR(FLASH_BASE_ADDR, ((sectorBaseAddress & 
                                                  0xffffff00)),0xd0);
                /* Poll on the flash */
                while(true)
                {
                    MV_WRITE_CHAR(FLASH_BASE_ADDR,0,0x70);
                    MV_READ_CHAR(FLASH_BASE_ADDR,0,&regValue);
                    if((regValue & 0x80) == 0x80) 
                        break;
                }
                break;
            case 2:
                if (FLASH_MODE == X16)  /* 1 device 16 bit.  */
                {
                    data20 = 0x0020;;
                    dataD0 = 0x00d0;;
                }
                else /* (FLASH_MODE = 8) ==> 2 devices , 8 bit each => 16bit*/
                {
                    data20 = 0x2020;
                    dataD0 = 0xd0d0;
                }
                MV_WRITE_SHORT(FLASH_BASE_ADDR,0,data20);
                MV_WRITE_SHORT(FLASH_BASE_ADDR, (((sectorBaseAddress*2) & 
                             0xffffff00)),dataD0);
                /* Poll on the flash */
                if (FLASH_MODE == X16)
                {
                    dataPoll = 0x0080;
                    data70 = 0x0070;
                }
                else /* (FLASH_MODE = 8) */
                {
                    dataPoll = 0x8080;
                    data70 = 0x7070;
                }
                while(true)
                {
                    MV_WRITE_SHORT(FLASH_BASE_ADDR,sectorBaseAddress*2,data70);
                    MV_READ_SHORT(FLASH_BASE_ADDR,
                                  sectorBaseAddress*2,&regValue);
                    if((regValue & 0x0080) == 0x0080) 
                        break;
                }
                break;
            case 4:
                if (FLASH_MODE == X16)  /* 2 devices , 16 bit each => 32bit */
                {
                    data20 = 0x00200020;
                    dataD0 = 0x00d000d0;
                }
                else /* (FLASH_MODE = 8) ==> 4 devices , 8 bit each => 32bit*/
                {
                    data20 = 0x20202020;
                    dataD0 = 0xd0d0d0d0;
                }
                MV_WRITE_WORD(FLASH_BASE_ADDR,0,data20);
                MV_WRITE_WORD(FLASH_BASE_ADDR, (((sectorBaseAddress*4) & 
                                                  0xffffff00)),dataD0);
                /* Poll on the flash */
                if (FLASH_MODE == X16)
                {
                    dataPoll = 0x0080;
                    data70 = 0x0070;
                }
                else /* (FLASH_MODE = 8) */
                {
                    dataPoll = 0x8080;
                    data70 = 0x7070;
                }
                while(true)
                {
                    MV_WRITE_SHORT(FLASH_BASE_ADDR,0,data70);
                    MV_READ_SHORT(FLASH_BASE_ADDR,0,&regValue);
                    if((regValue & dataPoll) == dataPoll) break;
                }
                while(true)
                {
                    MV_WRITE_SHORT(FLASH_BASE_ADDR, 2,data70);
                    MV_READ_SHORT(FLASH_BASE_ADDR, 2,&regValue);
                    if((regValue & dataPoll) == dataPoll) break;
                }
                break;
            case 8:
                if (FLASH_MODE == X16)  /* 4 devices , 16 bit each => 64bit */
                {
                    data20 = 0x00200020;
                    dataD0 = 0x00d000d0;
                }
                else /* (FLASH_MODE = 8) ==> 8 devices , 8 bit each => 64bit*/
                {
                    data20 = 0x20202020;
                    dataD0 = 0xd0d0d0d0;
                }
                MV_WRITE_WORD(FLASH_BASE_ADDR,0,data20);
                MV_WRITE_WORD(FLASH_BASE_ADDR, (((sectorBaseAddress*8) & 
                                                  0xffffff00)),dataD0);
                MV_WRITE_WORD(FLASH_BASE_ADDR, 4,data20);
                MV_WRITE_WORD(FLASH_BASE_ADDR, (((sectorBaseAddress*8) & 
                                                  (0xffffff00 + 4))),dataD0);
                /* Poll on the flash */
                if (FLASH_MODE == X16)
                {
                    dataPoll = 0x0080;
                    data70 = 0x0070;
                }
                else /* (FLASH_MODE = 8) */ 
                {
                    dataPoll = 0x8080;
                    data70 = 0x7070;
                }
                while(true)
                {
                    MV_WRITE_SHORT(FLASH_BASE_ADDR, sectorBaseAddress*8,data70);
                    MV_READ_SHORT(FLASH_BASE_ADDR, sectorBaseAddress*8,
                               &regValue);
                    if((regValue & dataPoll) == dataPoll) break;
                }
                while(true)
                {
                    MV_WRITE_SHORT(FLASH_BASE_ADDR, 2,data70);
                    MV_READ_SHORT(FLASH_BASE_ADDR, 2,&regValue);
                    if((regValue & dataPoll) == dataPoll) break;
                }
                while(true)
                {
                    MV_WRITE_SHORT(FLASH_BASE_ADDR, 4,data70);
                    MV_READ_SHORT(FLASH_BASE_ADDR, 4,&regValue);
                    if((regValue & dataPoll) == dataPoll) break;
                }
                while(true)
                {
                    MV_WRITE_SHORT(FLASH_BASE_ADDR, 6,data70);
                    MV_READ_SHORT(FLASH_BASE_ADDR, 6,&regValue);
                    if((regValue & dataPoll) == dataPoll) break;
                }
                break;
            default:
                return false;
        }
    }
    mvFlashReset();
    return true;
}

/*******************************************************************************
* mvFlashWriteBlock - Write block of chars to the flash.
*
* DESCRIPTION:
*       This function writes a block of data to the Flash memory. Neither the 
*       offset nor the block base address needs to be aligned.
*
* INPUT:
*       offset       - Offset relative to flash memory's base address.
*       numOfByte    - Size of the block in bytes.
*       blockAddress - Pointer to a block of data.
*
* OUTPUT:
*       None.
*
* RETURN:
*       Number of bytes actually written to the flash.
*
*******************************************************************************/
unsigned long mvFlashWriteBlock(unsigned long offset,unsigned long numOfByte,
                               char * blockAddress)
{
    register unsigned long flashWrite;
    register unsigned long align;
    register unsigned long num;
    register unsigned long i;

    if ((offset + numOfByte) >  mvFlashGetSize())
        numOfByte = mvFlashGetSize() - offset; /* getting to flash boundary.*/
    num = numOfByte;
    align = offset % 4;                      /* alignment toward flash.    */
    /* writes chars until the offset toward flash will be align. */
    for(i = align ; (i < 4) && (numOfByte > 0) && (align != 0); i++)
    {
        mvFlashWriteChar(offset,blockAddress[0]);
        numOfByte--;
        offset++;
        blockAddress++;
    }
    while(numOfByte > 3)
    {
        #ifdef LE
        flashWrite = (0xff & blockAddress[0]) | 
            ((0xff & blockAddress[1]) << 8) | 
            ((0xff & blockAddress[2]) << 16) | ((0xff & blockAddress[3]) << 24);
        #else 
        flashWrite = (0xff & blockAddress[3]) | 
            ((0xff & blockAddress[2]) << 8) | 
            ((0xff & blockAddress[1]) << 16) | ((0xff & blockAddress[0]) << 24);
        #endif
        if( flashWrite != 0xffffffff) /* for optimization. */
            mvFlashWriteWord(offset,flashWrite);
        if((offset%0x10000) == 0)
        {
            printf(".");
        }
        numOfByte -= 4;
        blockAddress += 4;
        offset += 4;
    }
    while(numOfByte > 0)
    {
        mvFlashWriteChar(offset,blockAddress[0]);
        numOfByte--;
        blockAddress++;
        offset++;
    }
    return num;
}
/*******************************************************************************
* mvFlashReset - Resets the Flash memory (FLASH`s internal protocol reset).
*
* DESCRIPTION:
*       To perform a write action to a flash device, a certain sequence of 
*       writing (realized using a state machine) operation is needed to be 
*       accomplished  prior to the real data write according to protocol of the
*       flash device manufacture. This function resets ( FLASH`s internal 
*       protocol reset ) the internal state machine incorporated within the 
*       flash needed to perform a write action .
*
* INPUT:
*       Flash memory's internal state machine is reset.
*
* OUTPUT:
*       None.
*
* RETURN:
*       None.
*
*******************************************************************************/