system.c

s3c2450 bsp for wince 5.0 经验证,完全没问题

    return ERROR_SUCCESS;
}

/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*      SetDiskInfo                                                          */
/* DESCRIPTION                                                               */
/*      Set disk information to pDisk structure                              */
/* PARAMETERS                                                                */
/*      pDisk       BIBDRV_PS driver own structure pointer                    */
/*      pInfo       DISK Information structure pointer                       */
/* RETURN VALUES                                                             */
/*      it always returns ERROR_SUCCESS                                      */
/*                                                                           */
/*****************************************************************************/
static DWORD
SetDiskInfo(PDISK       pDisk,
            PDISK_INFO  pInfo)
{
    BIBDRV_LOG_PRINT((TEXT("[BIBDRV: IN] ++SetDiskInfo()\r\n")));

    pDisk->d_DiskInfo = *pInfo;

    BIBDRV_LOG_PRINT((TEXT("[BIBDRV:OUT] --SetDiskInfo()\r\n")));

    return ERROR_SUCCESS;
}

/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*      CreateDiskObject                                                     */
/* DESCRIPTION                                                               */
/*      Create a DISK structure, init some fields and link it.               */
/* PARAMETERS                                                                */
/*      none                                                                 */
/* RETURN VALUES                                                             */
/*      new DISK structure pointer                                           */
/*                                                                           */
/*****************************************************************************/
static PDISK
CreateDiskObject(VOID)
{
    PDISK pDisk;
    
    BIBDRV_LOG_PRINT((TEXT("[BIBDRV: IN] ++CreateDiskObject()\r\n")));
    
    pDisk = LocalAlloc(LPTR, sizeof(DISK));

    if (pDisk != NULL)
    {
        pDisk->hDevice      = NULL;
        pDisk->d_OpenCount  = 0;
        pDisk->nBaseVsn     = 0;
        pDisk->d_ActivePath = NULL;
        pDisk->bIsBMLOpen   = FALSE;
        
        /* Initialize CiriticalSection for Disk Object(NAND flash) */
        InitializeCriticalSection(&(pDisk->d_DiskCardCrit));

        EnterCriticalSection(&gDiskCrit);
        pDisk->pd_next      = gDiskList;
        gDiskList           = pDisk;
        LeaveCriticalSection(&gDiskCrit);
    }
    
    BIBDRV_LOG_PRINT((TEXT("[BIBDRV:OUT] --CreateDiskObject()\r\n")));

    return pDisk;
}


/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*      IsValidDisk                                                          */
/* DESCRIPTION                                                               */
/*      This function checks Disk validation                                 */
/* PARAMETERS                                                                */
/*      pDisk                                                                */
/*          Pointer to disk handle                                           */
/* RETURN VALUES                                                             */
/*      Return TRUE if pDisk is valid, FALSE if not.                         */
/*                                                                           */
/*****************************************************************************/
static BOOL
IsValidDisk(PDISK pDisk)
{
    PDISK   pd;
    BOOL    bRet = FALSE;

    BIBDRV_LOG_PRINT((TEXT("[BIBDRV: IN] ++IsValidDisk()\r\n")));
 
    EnterCriticalSection(&gDiskCrit);

    pd = gDiskList;
    while (pd) 
    {
        if (pd == pDisk)
        {
            bRet = TRUE;
            break;
        }
        pd = pd->pd_next;
    }

    LeaveCriticalSection(&gDiskCrit);

    BIBDRV_LOG_PRINT((TEXT("[BIBDRV:OUT] --IsValidDisk()\r\n")));

    return bRet;
}


/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*      BIBDrv_Entry                                                         */
/* DESCRIPTION                                                               */
/*      This function is BIBDRV_PS.dll Entry Point                            */
/* PARAMETERS                                                                */
/*      DllInstance                                                          */
/*      Reason                                                               */
/*      Reserved                                                             */
/* RETURN VALUES                                                             */
/*      it always returns TRUE                                               */
/*                                                                           */
/*****************************************************************************/
BOOL WINAPI
BIBDrv_Entry(HINSTANCE    DllInstance, 
             INT          Reason, 
             LPVOID       Reserved)
{
    BIBDRV_LOG_PRINT((TEXT("[BIBDRV: IN] ++BIBDRVEntry()\r\n")));

    switch(Reason) {
        case DLL_PROCESS_ATTACH:
            BIBDRV_INF_PRINT((TEXT("[BIBDRV:INF]  DLL_PROCESS_ATTACH\r\n")));
            DEBUGREGISTER(DllInstance);
            break;
    
        case DLL_PROCESS_DETACH:
            BIBDRV_INF_PRINT((TEXT("[BIBDRV:INF]  DLL_PROCESS_DETACH\r\n")));
            DeleteCriticalSection(&gDiskCrit);
            break;
    }

    BIBDRV_LOG_PRINT((TEXT("[BIBDRV:OUT] --BIBDRVEntry()\r\n")));
    return TRUE;
}


/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*      InitializeNAND                                                       */
/* DESCRIPTION                                                               */
/*      This function initializes NAND Disk Handle                           */
/* PARAMETERS                                                                */
/*      pDisk                                                                */
/*          Disk handle                                                      */
/* RETURN VALUES                                                             */
/*      Return TRUE if pDisk is valid, FALSE if not.                         */
/* NOTE                                                                      */
/*      call from InitDisk from DSK_Init                                     */
/*                                                                           */
/*****************************************************************************/
static BOOL 
InitializeNAND(PDISK pDisk)
{
#if defined(_SUPPORT_HAL_WRAPPER_)
    VFLPacket   stPacket;
    INT         nResult;
#endif    
    BOOL        bRet = FALSE;

    BIBDRV_LOG_PRINT((TEXT("[BIBDRV: IN] ++InitializeNAND()\r\n")));

#if defined(_SUPPORT_HAL_WRAPPER_)
    do {
        /*--------------------*/
        /* BML Volume Setting */
        /*--------------------*/
        stPacket.nVol      = pDisk->nVol;  

        /* BML Init */
        stPacket.nCtrlCode = PM_HAL_VFL_INIT;
    
        KernelIoControl(IOCTL_POCKETSTOREII_CMD,  /* Io Control Code */
                        &stPacket,              /* Input buffer (Additional Control Code) */
                        sizeof(stPacket),       /* Size of Input buffer */
                        NULL,                   /* Output buffer */
                        0,                      /* Size of Output buffer */
                        &nResult);              /* Error Return */
    
        if (nResult != VFL_SUCCESS)
        {
            BIBDRV_ERR_PRINT((TEXT("[BIBDRV:ERR]  BML_Init() failure. ERR Code=%x\r\n"), nResult));
    
            break;
        }

        /* BML Open */
        stPacket.nCtrlCode = PM_HAL_VFL_OPEN;
    
        KernelIoControl(IOCTL_POCKETSTOREII_CMD,  /* Io Control Code */
                        &stPacket,              /* Input buffer (Additional Control Code */
                        sizeof(stPacket),       /* Size of Input buffer */
                        NULL,                   /* Output buffer */
                        0,                      /* Size of Output buffer */
                        &nResult);              /* Error Return */
    
        if (nResult != VFL_SUCCESS)
        {
            BIBDRV_ERR_PRINT((TEXT("[BIBDRV:ERR]  BML_Open() failure. ERR Code=%x\r\n"), nResult));
    
            break;
        }

        bRet = TRUE;
        
    } while(0);

#else   //_SUPPORT_HAL_WRAPPER_

	do {
		BIBDRV_LOG_PRINT((TEXT("[BIBDRV: IN] not _SUPPORT_HAL_WRAPPER_\r\n")));

		if (FIL_Init() != VFL_SUCCESS)
		{
			BIBDRV_ERR_PRINT((TEXT("[BIBDRV:ERR]  FIL_Init() failure.\r\n")));
			break;
		}

		if (VFL_Init() != VFL_SUCCESS)
		{
			BIBDRV_ERR_PRINT((TEXT("[BIBDRV:ERR]  VFL_Init() failure.\r\n")));
			break;
		}

		if (VFL_Open() != VFL_SUCCESS)
		{
			BIBDRV_ERR_PRINT((TEXT("[BIBDRV:ERR]  VFL_Open() failure.\r\n")));
			break;
		}

		GetNandInfo(&stNandInfo);

		BIBDRV_RTL_PRINT((TEXT("[BIBDRV:INF]  stNandInfo.dwPagesPerSuBlk      = 0x%X\r\n"), stNandInfo.dwPagesPerSuBlk));
		BIBDRV_RTL_PRINT((TEXT("[BIBDRV:INF]  stNandInfo.dwSectorsPerSuPage   = 0x%X\r\n"), stNandInfo.dwSectorsPerSuPage));
		BIBDRV_RTL_PRINT((TEXT("[BIBDRV:INF]  stNandInfo.dwSpecialAreaSize    = 0x%X\r\n"), stNandInfo.dwSpecialAreaSize));
		BIBDRV_RTL_PRINT((TEXT("[BIBDRV:INF]  stNandInfo.dwSpecialAreaStart   = 0x%X\r\n"), stNandInfo.dwSpecialAreaStart));

		bRet = TRUE;
	} while(0);

#endif  //_SUPPORT_HAL_WRAPPER_

    BIBDRV_LOG_PRINT((TEXT("[BIBDRV:OUT] --InitializeNAND()\r\n")));

    return bRet;
}

#if 0
/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*      CheckSamsungNANDFlashMemory                                          */
/* DESCRIPTION                                                               */
/*      This function checks if Samsung NAND flash memory is                 */
/* PARAMETERS                                                                */
/*      pDisk                                                                */
/*          Disk handle                                                      */
/* RETURN VALUES                                                             */
/*      Return TRUE if device id is samsung code, FALSE if not.              */
/* NOTE                                                                      */
/*      call from InitDisk from DSK_Init                                     */
/*                                                                           */
/*****************************************************************************/
#define SAMSUNG_DEVICE_ID           0xEC

static BOOL 
CheckSamsungNANDFlashMemory(PDISK pDisk)
{
    UCHAR aXID[512];    
    BOOL  bRet = FALSE;

#if defined(_SUPPORT_HAL_WRAPPER_)
    VFLPacket   stPacket;
    INT         nResult;
#else   //_SUPPORT_HAL_WRAPPER_
    BMLVolSpec  stVolSpec;
#endif  //_SUPPORT_HAL_WRAPPER_

    BIBDRV_LOG_PRINT((TEXT("[BIBDRV: IN] ++CheckSamsungNANDFlashMemory()\r\n")));

    do {

#if defined(_SUPPORT_HAL_WRAPPER_)

        /* BML Volume Setting */
        stPacket.nVol = pDisk->nVol;
        
        /* BML Read XID */
        stPacket.nCtrlCode = PS_HAL_BML_READXID;
    
        KernelIoControl(IOCTL_POCKETSTOREII_CMD, 
                        &stPacket, 
                        sizeof(stPacket), 
                        aXID, 
                        512, 
                        &nResult);
                        
        if (nResult != BML_SUCCESS)
        {
            BIBDRV_ERR_PRINT((TEXT("[BIBDRV:ERR] READXID failure. ERRNO=%d\r\n"), nResult));
            break;
        }
    
#else   //_SUPPORT_HAL_WRAPPER_

        if (BML_GetVolInfo(pDisk->nVol, &stVolSpec) != BML_SUCCESS)
        {
            BDRV_ERR_PRINT((TEXT("[BDRV