ocld.cpp

来自「SAMSUNG S3C6410 CPU BSP for winmobile6」· C++ 代码 · 共 1,751 行 · 第 1/5 页

static VOID
_ReadEmptyData(UINT32 pAddr, UINT32 nScts, UINT32 nSize)
{
    UINT32 nBytes;
    volatile UINT32 nTmp;

    while (nScts-- > 0)
    {
        for (nBytes = nSize; nBytes > 0; nBytes -= sizeof(UINT32))
        {
            nTmp = *(volatile UINT32 *)pAddr;
        }
    }
}

static VOID
_ReadData(volatile UINT32 pAddr, register UINT8 *pBuf, UINT32 nScts, UINT32 nSize)
{
    register UINT32 *pBuffer = (UINT32 *)pBuf;

#if (OND_TRANS_MODE == OND_POL)
    UINT32 nBytes;

    while (nScts-- > 0)
    {
        for (nBytes = nSize; nBytes > 0; nBytes -= sizeof(UINT32))
        {
            *pBuffer++ = *(volatile UINT32 *)pAddr;
        }
    }
#elif (OND_TRANS_MODE == OND_LDM)
	//OneNand4burstPageRead(pAddr, (UINT32)pBuffer, (UINT32)((nSize * nScts)/16));
	OneNand8burstPageRead(pAddr, (UINT32)pBuffer, (UINT32)((nSize * nScts)/32));
#endif  // OND_TRANS_MODE
}

#ifdef ONENANDCON_READ_FULL_SECTOR
static VOID
_WriteData1(UINT32 pAddr, register UINT8 *pBuf)
{
    register UINT32 *pBuffer = (UINT32 *)pBuf;

#if (OND_TRANS_MODE == OND_POL)
    UINT32 nBytes;
    UINT32 nSize = ONDC_MAINSPARE/4;

    for (nBytes = nSize; nBytes > 0; nBytes -= sizeof(UINT32))
    {
        *(volatile UINT32 *)pAddr = *pBuffer++;
    }
#elif (OND_TRANS_MODE == OND_LDM)
   // OneNand4burstPageWrite((UINT32)pBuffer, (UINT32)pAddr, (UINT32)(ONDC_MAINSPARE/16));
    OneNand8burstPageWrite((UINT32)pBuffer, (UINT32)pAddr, (UINT32)(ONDC_MAINSPARE/32));
#elif (OND_TRANS_MODE == OND_DMA)
	DMASetChannelTransSize_Write(g_nDMABufferPhyPage, pAddr, ONDC_MAINSPARE/4);
	DMAChannelStart();

	// Check transfer end
	while((g_pDMAC0Reg->DMACC3Configuration&CHANNEL_ENABLE));
#endif  // OND_TRANS_MODE
}

static VOID
_ReadData1(UINT32 pAddr, register UINT8 *pBuf)
{
    register UINT32 *pBuffer = (UINT32 *)pBuf;

#ifdef ONENAND_READ_LED_ON
	g_pGPIOReg->GPNDAT |= (1<<13);
#endif  // ONENAND_READ_LED_ON
#if (OND_TRANS_MODE == OND_POL)
    UINT32 nBytes;
    UINT32 nSize = ONDC_MAINSPARE/4;

    for (nBytes = nSize; nBytes > 0; nBytes -= sizeof(UINT32))
    {
        *pBuffer++ = *(volatile UINT32 *)pAddr;
    }
#elif (OND_TRANS_MODE == OND_LDM)
	//OneNand4burstPageRead((UINT32)pAddr, (UINT32)pBuffer, (UINT32)(ONDC_MAINSPARE/16));
	OneNand8burstPageRead((UINT32)pAddr, (UINT32)pBuffer, (UINT32)(ONDC_MAINSPARE/32));
#elif (OND_TRANS_MODE == OND_DMA)
	DMASetChannelTransSize_Read(pAddr, g_nDMABufferPhyPage, ONDC_MAINSPARE/4);
	DMAChannelStart();

	// Check transfer end
	while((g_pDMAC0Reg->DMACC3Configuration&CHANNEL_ENABLE));
#endif  // OND_TRANS_MODE
#ifdef ONENAND_READ_LED_ON
	g_pGPIOReg->GPNDAT &= ~(1<<13);
#endif  // ONENAND_READ_LED_ON
}
#endif  // ONENANDCON_READ_FULL_SECTOR

static VOID
_Read_M11_Data(UINT32 *pM11Addr, UINT32 *pBuf, UINT32 nScts, UINT32 nSize)
{
    UINT32 nBytes;
    
    while (nScts-- > 0)
    {
        for (nBytes = nSize; nBytes > 0; nBytes -= sizeof(UINT32))
        {
            *pBuf++ = (UINT32)*pM11Addr++;
        }
    }
}

UINT32
_SetRWBlock(UINT32 nDev, UINT32 nSUbn, UINT32 nUBlks)
{
#if !defined(XSR_NBL2)
    UINT32 nBAddr;
    UINT32 nCAddr;

    ONLD_DBG_PRINT((TEXT("[ONLD : OUT] ++ONLD_SetRWArea()\r\n")));

    /* IOBE bit of pONENANDReg->MEM_CFG should be enabled for M10 execution. */

    nBAddr = GET_DEV_BADDR(nDev);
    nCAddr = GET_ONENANDCON_BADDR(nBAddr);

    /* Clear INT */
    OCLD_REG_INT_ERR_STAT(nCAddr) = (UINT16)CINT_CLEAR;

    /* Set start address to be unlocked */
    if (nUBlks > 1) ONLD_WRITE_CMD(nDev, nBAddr, nSUbn, 0, 0x08);

    /* Set unlock end address and initiate the unlock */
    ONLD_WRITE_CMD(nDev, nBAddr, nSUbn + nUBlks -1, 0, 0x09);

    /* wait until command is completed */
	while ((OCLD_REG_INT_ERR_STAT(nCAddr) & CPEND_INT) != (UINT16)CPEND_INT)
	{
        /* Wait until device ready */
        OAM_Idle();	
    }

    while ((OCLD_REG_INT_ERR_STAT(nCAddr) & BIT_LOCKED_BLK) == (UINT16)BIT_LOCKED_BLK)
    {
       /* Wait until device UnLock */
       OAM_Idle();
    } 

    ONLD_DBG_PRINT((TEXT("[ONLD : OUT] --ONLD_SetRWArea()\r\n")));
    return ONLD_SUCCESS;
#endif /* #if !defined(XSR_NBL2) */
}

static UINT32
_LockBlock (UINT32  nDev, UINT8  *pBufI, UINT32 nLenI)
{
    UINT32    nBAddr;
    UINT32    nSbn;
    UINT32    nBlks;
    UINT32    nCAddr;

    ONLD_DBG_PRINT((TEXT("[ONLD : OUT] ++_LockBlock()\r\n")));

    nSbn  = *(UINT32*)pBufI;
    nBlks = *((UINT32*)(pBufI+4));

    nBAddr = GET_DEV_BADDR(nDev);
    nCAddr = GET_ONENANDCON_BADDR(nBAddr);

    for (; nBlks > 0; nBlks--, nSbn++)
    {
        /* IOBE bit of pONENANDReg->MEM_CFG should be enabled for M10 execution. */

        /* Clear INT */
        OCLD_REG_INT_ERR_STAT(nCAddr) = (UINT16)CINT_CLEAR;

        /* Set lock end address and initiate the lock */
        ONLD_WRITE_CMD(nDev, nBAddr, nSbn, 0, 0x0B);

        /* wait until command is completed */
        while ((OCLD_REG_INT_ERR_STAT(nCAddr) & CPEND_INT) != (UINT16)CPEND_INT)
        {
		 /* Wait until device ready */
		 	OAM_Idle();
        }

        while((OCLD_REG_INT_ERR_STAT(nCAddr) & BIT_LOCKED_BLK) != (UINT16)BIT_LOCKED_BLK)
        {
         /* Wait until device Lock-tight */
         	OAM_Idle();
        }             
    }

    ONLD_DBG_PRINT((TEXT("[ONLD : OUT] --_LockBlock()\r\n")));
    return ONLD_SUCCESS;
}

static UINT32
_LockTigBlock (UINT32  nDev, UINT8  *pBufI, UINT32 nLenI)
{
    UINT32 nBAddr;
    UINT32 nSbn;
    UINT32 nBlks;
    UINT32 nCAddr;

    ONLD_DBG_PRINT((TEXT("[ONLD : OUT] ++_LockTigBlock()\r\n")));

    nBAddr = GET_DEV_BADDR(nDev);
    nCAddr = GET_ONENANDCON_BADDR(nBAddr);

    nSbn  = *(UINT32*)pBufI;
    nBlks = *((UINT32*)(pBufI+4));

    /* Clear INT */
    OCLD_REG_INT_ERR_STAT(nCAddr) = (UINT16)CINT_CLEAR;

    /* Set lock-tight start address */
	ONLD_WRITE_CMD(nDev, nBAddr, nSbn, 0, 0x0C);

    /* Set lock-tight end address and initiate the lock */
	ONLD_WRITE_CMD(nDev, nBAddr, nSbn + nBlks - 1, 0, 0x0D);

    // wait until command is completed
        while ((OCLD_REG_INT_ERR_STAT(nCAddr) & CPEND_INT) != (UINT16)CPEND_INT)
        {
		 /* Wait until device ready */
		 	OAM_Idle();
        }

        while((OCLD_REG_INT_ERR_STAT(nCAddr) & BIT_LOCKED_BLK) != (UINT16)BIT_LOCKED_BLK)
        {
         /* Wait until device Lock-tight */
         	OAM_Idle();
        }             

    ONLD_DBG_PRINT((TEXT("[ONLD : OUT] --_LockTigBlock()\r\n")));
    return ONLD_SUCCESS;
}

static VOID
_InitDevInfo(UINT32 nDev, UINT16 *pDID, UINT16 *pVID)
{
    UINT32 nBAddr;
    nBAddr = GET_DEV_BADDR(nDev);

    if(pDID == NULL || pVID == NULL)
    {
        ONLD_ERR_PRINT((TEXT("[ONLD : ERR] (_InitDevInfo) Illeagal Access\r\n")));
        return;
    }

    astONLDInfo[nDev].nBufSelSft       = 2;
    astONLDInfo[nDev].nSctSelSft       = 3;
    astONLDInfo[nDev].nBlkSelSft       = 8;
    astONLDInfo[nDev].nPgSelSft        = 2;
    astONLDInfo[nDev].nDDPSelSft       = 6;
    astONLDInfo[nDev].nFPASelSft       = 0;
    astONLDInfo[nDev].nFSAMask         = 3;
    astONLDInfo[nDev].nSctsPerPG       = 4;
    ONLD_CMD_LOCK_NAND                 = 0x002A;
    ONLD_CMD_LOCK_TIGHT                = 0x002C;
    astONLDInfo[nDev].MRead            = _M01_MRead;

    if (((*pDID & 0x00F0) == CHIP_256M) || ((*pDID & 0x00F0) == CHIP_128M))
    {
        astONLDInfo[nDev].nBufSelSft    = 1;
        astONLDInfo[nDev].nSctSelSft    = 1;
        astONLDInfo[nDev].nBlkSelSft    = 7;
        astONLDInfo[nDev].nPgSelSft     = 1;
        astONLDInfo[nDev].nFPASelSft    = 1;

        astONLDInfo[nDev].nFSAMask   = 1;
        astONLDInfo[nDev].nSctsPerPG = 2;

        if ((*pVID & 0x0F00) == M_DIE)
        {
            ONLD_CMD_LOCK_NAND       = 0x002B;
            ONLD_CMD_LOCK_TIGHT      = 0x002D;
        }
        astONLDInfo[nDev].MRead      = _M01_MRead;
    }

    if ((*pDID & 0x00F0) == CHIP_512M)
    {
        if ((*pVID & 0x0F00) == M_DIE || (*pVID & 0x0F00) == A_DIE)
        {
            astONLDInfo[nDev].MRead  = _M01_MRead;
        }
    }
    if ((*pDID & 0x00F0) == CHIP_1G)
    {
        if ((*pVID & 0x0F00) == M_DIE)
        {
            astONLDInfo[nDev].MRead  = _M01_MRead;
        }
    }

    if ((*pDID & 0x00F0) == CHIP_2G)
    {
        astONLDInfo[nDev].nDDPSelSft    = 5;

        if ((*pDID & 0x0008) == DDP_CHIP)
        {
            if ((*pVID & 0x0F00) == M_DIE)
            {
                astONLDInfo[nDev].MRead  = _M01_MRead;
            }
        }
    }
    else if ((*pDID & 0x00F0) == CHIP_4G)
    {
        astONLDInfo[nDev].nDDPSelSft    = 4;
    }

    if (astONLDDev[nDev].pstDevSpec->nLKFlag == BLK_LK)
    {
        astONLDInfo[nDev].SetRWArea = _SetRWBlock;
#ifdef LOCK_TIGHT
        astONLDInfo[nDev].LockTight = _LockTigBlock;
#else
        /* for erase refresh, lock-tight is disabled */
        astONLDInfo[nDev].LockTight = _LockBlock;
#endif
    }
    else if (astONLDDev[nDev].pstDevSpec->nLKFlag == RNG_LK)
    {
        astONLDInfo[nDev].SetRWArea = _SetRWRange;
        astONLDInfo[nDev].LockTight = _LockTigRange;
    }
    else
    {
        astONLDInfo[nDev].SetRWArea = NULL;
        astONLDInfo[nDev].LockTight = NULL;
    }
}

/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*      _StrictChk                                                           */
/* DESCRIPTION                                                               */
/*      This function performs strict checks                                 */
/* PARAMETERS                                                                */
/*      nDev                                                                 */
/*          Physical Device Number (0 ~ 7)                                   */
/*      nPsn                                                                 */
/*          Physical Sector Number                                           */
/*      nScts                                                                */
/*          Number of Sectors                                                */
/* RETURN VALUES                                                             */
/*      TRUE32                                                               */
/*          Strict Check OK                                                  */
/*      FALSE32                                                              */
/*          Strcit Check Failure                                             */
/* NOTES                                                                     */