mvflash.c

Mavell AP32 无线模块驱动。VxWorks BSP BootRom源代码

                    FourthAddr = 0xaaaa;     /* Address for the Fourth Cycle */
                    FifthAddr  = 0x5555;     /* Address for the Fifth  Cycle */
                }
                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,0x20);
                MV_WRITE_CHAR((FLASH_BASE_ADDR + (sectorBaseAddress & 
                                                  0xffffff00)),0xd0);
                /* Poll on the flash */
                while(true)
                {
                    MV_WRITE_CHAR(FLASH_BASE_ADDR,0x70);
                    MV_READ_CHAR(FLASH_BASE_ADDR,&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,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,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,data70);
                    MV_READ_SHORT(FLASH_BASE_ADDR,&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,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 int mvFlashWriteBlock(unsigned int offset,unsigned int numOfByte,
                               char * blockAddress)
{
    register unsigned int flashWrite;
    register unsigned int align;
    register unsigned int num;
    register unsigned int 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;
}
/*******************************************************************************
* mvFlashReadBlock - Read block of chars from flash.
*
* DESCRIPTION:
*       This function read a whole block of data 憂umOfBytes