flashmng.c

来自「好记星的控件,包括button,list,对文件操作」· C语言 代码 · 共 1,302 行 · 第 1/5 页

/********************************************************************************/
INT FlashMngReadPhyEraseUnit(INT dwPhysicalPage, INT dwLogicalPage)
{
    INT curEraseNum, dwOffset;
    INT retVal;

    // get erase unit number which contains "dwPhysicalPage"
    curEraseNum = dwPhysicalPage * NORMAL_PAGE_SIZE / g_pFlashPara->uDataPerBlock;
    dwOffset = (dwPhysicalPage % (g_pFlashPara->uDataPerBlock / NORMAL_PAGE_SIZE)) / (g_pFlashPara->uDataPerPage / NORMAL_PAGE_SIZE);

    if(curEraseNum != g_FlashPhyNum0){          // block update
        if(g_FlashPhyNum0 != -1){
            if((retVal = FlashMngBlockUpdate()) != NFLS_ERR_NO){
                return retVal;
            }
        }
        g_FlashPhyNum0 = curEraseNum;
        g_FlashPhyNum1 = -1;
        g_FlashPageOffset = dwOffset;
        g_FlashModify = FALSE;
        g_FlashDirty = FALSE;
    }else if(dwOffset != g_FlashPageOffset){    // page update
        if((retVal = FlashMngPageUpdate()) != NFLS_ERR_NO){
            return retVal;
        }
        g_FlashPageOffset = dwOffset;
        g_FlashModify = FALSE;
    }else{
        return (dwPhysicalPage % (g_pFlashPara->uDataPerPage / NORMAL_PAGE_SIZE)) * NORMAL_PAGE_SIZE;
    }

    if((retVal = FlashMngReadDriver(FLASH_IO_DATASPARE, g_FlashPhyNum0 * g_pFlashPara->uDataPerBlock + g_FlashPageOffset * g_pFlashPara->uDataPerPage,
        &g_FlashBuf[0], CURRENT_PAGE_SIZE + CURRENT_SPARE_SIZE)) != CURRENT_PAGE_SIZE + CURRENT_SPARE_SIZE){
        return retVal;
    }
    if((g_FlashDirty == TRUE) && !(PAGE_STATUS(g_pFlashSpareBuf) & PAGE_STATUS_AVAILABLE)){
        if((retVal = FlashMngReadDriver(FLASH_IO_DATASPARE, g_FlashPhyNum1 * g_pFlashPara->uDataPerBlock + g_FlashPageOffset * g_pFlashPara->uDataPerPage,
            &g_FlashBuf[0], CURRENT_PAGE_SIZE + CURRENT_SPARE_SIZE)) != CURRENT_PAGE_SIZE + CURRENT_SPARE_SIZE){
            return retVal;
        }
    }
    
    return (dwPhysicalPage % (g_pFlashPara->uDataPerPage / NORMAL_PAGE_SIZE)) * NORMAL_PAGE_SIZE;
}

/********************************************************************************/
/* FUNCTION：   FlashUpdate                                                     */
/* DESCRIPTION：Update buffer to flash, incorporate org block and swap block    */
/* INPUTS:                                                                      */
/* OUTPUTS：                                                                    */
/* RETURN：     NFLS_ERR_NO         ok                                          */
/*              return from FlashMngBlockUpdate                                 */
/********************************************************************************/
/*    NAME        DATE                REMARKS                                   */
/* ==========  ============   ==================================================*/
/*   Victor     2005-05-10      create                                          */
/********************************************************************************/
INT FlashUpdate()
{
    INT     retVal;
    
    if(g_FlashPhyNum0 != -1){
        if((retVal = FlashMngBlockUpdate()) != NFLS_ERR_NO){
            return retVal;
        }
    }
    g_FlashModify = FALSE;
    g_FlashDirty = FALSE;
    return NFLS_ERR_NO;
}

/********************************************************************************/
/* FUNCTION：   FlashModInitial                                                 */
/* DESCRIPTION：Initial Flash manager model                                     */
/* INPUTS:                                                                      */
/* OUTPUTS：                                                                    */
/* RETURN：     NFLS_ERR_DRIVER     nucleus driver manager error                */
/*              return from FlashMngGetDriver                                   */
/*              retrun from FlashMngTableRead                                   */
/********************************************************************************/
/*    NAME        DATE                REMARKS                                   */
/* ==========  ============   ==================================================*/
/*   Victor     2005-05-10      create                                          */
/********************************************************************************/
INT FlashModInitial()
{
    INT     retVal;
    
    // Get flash device handle
    if ((g_pFlashDriver = GetIODriverFromName((UINT8*)DRV_NAME_NFLASH))== NULL){
        return NFLS_ERR_DRIVER;
    }

    // Get flash parameter
    if((retVal = FlashMngGetDriver(&g_pFlashPara)) != NFLS_ERR_NO){
        return retVal;
    }

    // initial global variable
    g_pFlashDataBuf = &g_FlashBuf[0];
    g_pFlashSpareBuf = &g_FlashBuf[CURRENT_PAGE_SIZE];
    g_FlashPhyNum0 = -1;
    g_FlashPhyNum1 = -1;
    g_FlashPageOffset = -1;
    g_FlashModify = FALSE;
    g_FlashDirty = FALSE;
    g_multiTest = 0;
    
    // load table of contrast between logical block to physical block
    return FlashMngTableRead();
}

/********************************************************************************/
/* FUNCTION：   FlashOpen                                                       */
/* DESCRIPTION：open flash device                                               */
/* INPUTS:      driveno             device number                               */
/* OUTPUTS：                                                                    */
/* RETURN：     TRUE                ;NFLS_ERR_NO         ok                     */
/********************************************************************************/
/*    NAME        DATE                REMARKS                                   */
/* ==========  ============   ==================================================*/
/*   Victor     2005-05-10      create                                          */
/********************************************************************************/
INT FlashOpen(UINT16 driveno)
{
    driveno = driveno;
    //return NFLS_ERR_NO;
    return TRUE;
}

/********************************************************************************/
/* FUNCTION：   FlashClose                                                      */
/* DESCRIPTION：close flash device                                              */
/* INPUTS:      driveno             device number                               */
/* OUTPUTS：                                                                    */
/* RETURN：     NFLS_ERR_NO         ok                                          */
/********************************************************************************/
/*    NAME        DATE                REMARKS                                   */
/* ==========  ============   ==================================================*/
/*   Victor     2005-05-10      create                                          */
/********************************************************************************/
INT FlashClose(UINT16 driveno)
{
    driveno = driveno;
    return NFLS_ERR_NO;
}

/********************************************************************************/
/* FUNCTION：   FlashIo                                                         */
/* DESCRIPTION：reads or writes data from or to the flash based on the          */
/*              'reading' parameter.                                            */
/* INPUTS:      driveno             device number                               */
/*              dwLogicalPage       The page number to read or write            */
/*              buffer              'reading' == 0: data write to flash         */
/*              uPages              Number of pages to be read or written       */
/*              reading             Indicates reading or writing                */
/* OUTPUTS：    buffer              'reading' == 1: data read from flash        */
/* RETURN：     0                   some error occur                            */
/*              >0                  read or write data length                   */
/********************************************************************************/
/*    NAME        DATE                REMARKS                                   */
/* ==========  ============   ==================================================*/
/*   Victor     2005-05-10      create                                          */
/********************************************************************************/
INT FlashIo(UINT16 driveno, UINT32 dwLogicalPage, VOID *buffer, UINT16 uPages, INT reading)
{
    INT         dwPhysicalPage;
    INT         offset;
    INT         dwTotalLen;
    UINT8       *pB;

    dwLogicalPage += FLASH_RESERVE_SECTOR;
    
    if(g_multiTest == 1){
        GraphDrawText(0x10, 0x90, 0, 0, (UINT8 *)"Device over run!");
    }
    g_multiTest = 1;
    
    /* We don't use drive no. You could have multiple drives if wanted */
    driveno = driveno;
    pB = buffer;
    dwTotalLen = 0;

    while (uPages){
        
        // logical page to physical page
        dwPhysicalPage = FlashMngGetPhysicalPage((INT)dwLogicalPage);
        if(dwPhysicalPage < 0){
            return 0;               // address is out of range
        }

        // buffer current page
        offset = FlashMngReadPhyEraseUnit(dwPhysicalPage, dwLogicalPage);
        if(offset < 0)
            return 0;

        if (reading){
            memcpy(pB, g_pFlashDataBuf + offset, NORMAL_PAGE_SIZE);
        }else{
            memcpy(g_pFlashDataBuf + offset, pB, NORMAL_PAGE_SIZE);
            g_FlashModify = TRUE;
            
            // get a swap block
            if((!g_FlashDirty) && (!(PAGE_STATUS(g_pFlashSpareBuf) & PAGE_STATUS_NODIRTY))){
                g_FlashDirty = TRUE;
                g_FlashPhyNum1 = g_FlashTablePrepare[0];
                if(FlashMngEraseDriver(g_FlashPhyNum1*g_pFlashPara->uDataPerBlock) != NFLS_ERR_NO){
                    return 0;
                }
                memset(g_pFlashOnlySpareBuf, 0xff, CURRENT_SPARE_SIZE);
                BLOCK_STATUS(g_pFlashOnlySpareBuf) = FLASH_STATUS_SWAP;
                BLOCK_LOGIC(g_pFlashOnlySpareBuf) = dwLogicalPage / (g_pFlashPara->uDataPerBlock / NORMAL_PAGE_SIZE);
                if(FlashMngWriteDriver(FLASH_IO_ONLYSPARE, g_FlashPhyNum1 * g_pFlashPara->uDataPerBlock, 
                    g_pFlashOnlySpareBuf, CURRENT_SPARE_SIZE) != CURRENT_SPARE_SIZE){
                    return 0;
                }
            }
        }
        uPages--;
        dwLogicalPage++;
        pB += NORMAL_PAGE_SIZE;
        dwTotalLen += NORMAL_PAGE_SIZE;
    }

    g_multiTest = 0;
    
    return dwTotalLen;
}

INT FlashIoEx(UINT16 driveno, UINT32 dwLogicalPage, VOID *buffer, UINT16 uPages, INT reading)
{
    dwLogicalPage -= FLASH_RESERVE_SECTOR;
    return FlashIo(driveno, dwLogicalPage, buffer, uPages, reading);
}

/********************************************************************************/
/* FUNCTION：   FlashIoCtrl                                                     */
/* DESCRIPTION：device format and special parameter return                      */
/* INPUTS:      driveno             device number                               */
/*              command             FLASH_COMMAND_FORMAT: device format         */
/*                                  FLASH_COMMAND_GETINFO:get flash parameter   */
/* OUTPUTS：    buffer              command == FLASH_COMMAND_GETINFO: pointer   */
/*                                  to flash infor pointer                      */
/* RETURN：     NFLS_ERR_NO         ok                                          */
/*              NFLS_ERR_COMMAND    illegal command                             */
/*              retrun from FlashMngTableCreate                                 */
/*              return from FlashMngTableRead                                   */
/********************************************************************************/
/*    NAME        DATE                REMARKS                                   */
/* ==========  ============   ==================================================*/
/*   Victor     2005-05-10      create                                          */
/********************************************************************************/
INT FlashIoCtrl(UINT16 driveno, UINT16 command, VOID *buffer)
{
    INT     retVal;

    driveno = driveno;

    switch(command){
        case FLASH_COMMAND_FORMAT:
            if((retVal = FlashMngTableCreate((FP_FORMAT_UI)NULL, (VOID *)NULL)) != NFLS_ERR_NO){