/*++

Copyright (c) Microsoft Corporation.  All rights reserved.

Module Name:

    msmddoal.cpp

Abstract:

    Handles OAL requirements for Microsoft Mobile Devices.

--*/

#include <windows.h>
#include <bldver.h>

//#if ( (CE_MAJOR_VER == 0x0003)  && (CE_MINOR_VER == 0x0000) )
#include "pehdr.h" //by digibuff 09-Jul-2003
//#endif

#include "romxip.h"
#include <PSIIMDDOAL.h>
#include "romldr.h"
#include "pkfuncs.h"

//#include <PSII.h>
#include <PSIIROMUpdate.h>	// added by SHYoon. 10-MAR-2003

#ifndef IOCTL_HAL_GET_BIN_CHAIN

#define IOCTL_HAL_GET_BIN_CHAIN  CTL_CODE(FILE_DEVICE_HAL, 65, METHOD_BUFFERED, FILE_ANY_ACCESS)

#endif

//#include "guts.h"
//#include "ehm.h"

#define NOT_FIXEDUP		   (DWORD*)-1
#undef	PS_DEBUG

extern "C" {

    //
    // FIXUP variables that are set in config.bib
    // You MUST declare these in the OAL
    //

    extern DWORD * pdwXIPLoc;
    extern DWORD   dwDontUseChain;
    
    // kernel declares these:
    extern ROMChain_t *OEMRomChain;

};

/*****************************************************************************/
/* Debug Definitions                                                         */
/*****************************************************************************/
#define MSMDD_ERR_MSG_ON             1
#define MSMDD_LOG_MSG_ON             1
#define MSMDD_INF_MSG_ON             1

#define MSMDD_RTL_PRINT(x)           RETAILMSG(1, x)

#if MSMDD_ERR_MSG_ON
#define MSMDD_ERR_PRINT(x)           RETAILMSG(1, x)
#else
#define MSMDD_ERR_PRINT(x)        
#endif /* #if MSMDD_ERR_MSG_ON */

#if MSMDD_LOG_MSG_ON
#define MSMDD_LOG_PRINT(x)           RETAILMSG(1, x)
#else
#define MSMDD_LOG_PRINT(x)        
#endif  /* #if MSMDD_LOG_MSG_ON */

#if MSMDD_INF_MSG_ON
#define MSMDD_INF_PRINT(x)           RETAILMSG(1, x)
#else
#define MSMDD_INF_PRINT(x)        
#endif  /* #if MSMDD_INF_MSG_ON */

#if ( (CE_MAJOR_VER == 0x0004)  && (CE_MINOR_VER >= 0x0014) && (CE_BUILD_VER >= 13100) )	// 2004-0309 lek

HRESULT
DoGetBinExtensions(XIPCHAIN_SUMMARY *pChain,
                   LPDWORD           pdwSize);

///////////////////////////////////////////////////////////////////////////////

BOOL 
IsMSMDDIoControl(DWORD   dwIoControlCode, 
                 LPVOID  lpInBuf,         DWORD nInBufSize, 
                 LPVOID  lpOutBuf,        DWORD nOutBufSize, 
                 LPDWORD lpBytesReturned, BOOL *pRetVal) 
{
    HRESULT hr = NOERROR;
    BOOL    bRet = TRUE;

    switch (dwIoControlCode) 
    {
    case IOCTL_HAL_GET_BIN_CHAIN:
        if ( (pdwXIPLoc != NOT_FIXEDUP) )
        {
            hr = DoGetBinExtensions((XIPCHAIN_SUMMARY *)lpInBuf,
                                    (lpInBuf) ? &nInBufSize : (LPDWORD)lpOutBuf);
            bRet = SUCCEEDED(hr);
        }
        
        break;
    
    default:
            //
            // DON'T change pRetVal, just bail
            //
            return FALSE;
	}

    if ( !SUCCEEDED(hr) )
    {
        SetLastError(hr);
    }

    if ( pRetVal )
    {
        //
        // Note: only set pRetVal when we have handled the IOCTL
        //
        *pRetVal = bRet;
    }

    return bRet;
} 
 

HRESULT
GetOSChain(XIPCHAIN_SUMMARY **pOSChain, LPDWORD pdwNumEntries)
{
    const CHAR szChainDesc[] = "chain information";

    ROMHDR              *pToc = (ROMHDR *)UserKInfo[KINX_PTOC]; 
    ROMPID              *pRomPid;
    DWORD               dwChainDescLen = strlen(szChainDesc);

    if ( pToc->pExtensions ) 
    {
        //
        // grab the kernel chain from the extensions
        //

        pRomPid = (ROMPID *)pToc->pExtensions;
        ROMPID *pItem = (ROMPID *)pRomPid->pNextExt;
        while ( pItem )
        {
            if ( (memcmp( pItem->name, szChainDesc, dwChainDescLen) == 0) && pItem->length )
            {
                *pOSChain = (XIPCHAIN_SUMMARY *) pItem->pdata;
                *pdwNumEntries = pItem->length / sizeof(XIPCHAIN_SUMMARY);
                return S_OK;
            }
            pItem = (ROMPID *)pItem->pNextExt;
        }
    }

    return E_FAIL;
}

// ***************************************************************************
//
//  Function Name: VerifyChain
// 
//  Purpose: verifies MDD chain against kernel chain
//
//  Arguments:
//
//  Return Values:
//
//      FALSE if verification fails
//
//  Description:  
//
//      The MDD chain and the kernel chain should be identical in order
//      and regions.  They are different in the following:
//      1. The first region of the kernel chain is the MDD chain.
//      2. The kernel chain has entries consisting of a subset of the MDD chain fields
//          
//      This function verifies that the ordering and contents of the two
//      chains are in sync.
//
//

BOOL
VerifyChain(XIPCHAIN_SUMMARY *pExtChain, DWORD dwNumExtEntries)
{
    XIPCHAIN_ENTRY      *pMDDChain = (XIPCHAIN_ENTRY *)(pdwXIPLoc+1);

    if ( dwNumExtEntries != ((*pdwXIPLoc)+1) )
    {
        return FALSE;
    }

    // walk through chain to verify

    for ( UINT i = 1; i < dwNumExtEntries; ++i )
    {
        if ( pExtChain[i].pvAddr != pMDDChain[i-1].pvAddr )
        {
            return FALSE;
        }

    }

    return TRUE;
}

static DWORD*
AllocXIPLoc(void)
{
	DWORD *pMem;
	DWORD dwBlockStart;
	DWORD dwBlockLen;
	
	FlashInit(TRUE);
	FlashGetBlockInfo((LPVOID)pdwXIPLoc, &dwBlockStart, &dwBlockLen);

	pMem = (DWORD *) malloc(dwBlockLen * sizeof(BYTE));
	if (NULL == pMem)
	{
		return 0;
	}

	FlashRead((LPVOID)pdwXIPLoc, (LPVOID)pMem, dwBlockLen);

	return pMem;
}

static BOOL
FreeXIPLoc(DWORD *pMem)
{
	free(pMem);

	return TRUE;
}

#if defined(PS_DEBUG)
static void
ViewXIPChain(DWORD	dwNumXIPs, PXIPCHAIN_ENTRY pEntry)
{
	UINT  i, j;
	wchar_t szXIPName[XIP_NAMELEN];

	NKDbgPrintfW(TEXT("dwNumXIPs       = %d\r\n"), dwNumXIPs);
	for (i = 0; i < dwNumXIPs; i ++)
	{
		MSMDD_RTL_PRINT(TEXT("[MSMDD:   ]  REGION[%d]\r\n"), i);
		MSMDD_RTL_PRINT(TEXT("[MSMDD:   ]  \t pvAddr[%d].pvAddr      = 0x%X\r\n"), i, (DWORD) pEntry[i].pvAddr);
		MSMDD_RTL_PRINT(TEXT("[MSMDD:   ]  \t pEntry[%d].dwLength    = 0x%X\r\n"), i, (DWORD) pEntry[i].dwLength);
		MSMDD_RTL_PRINT(TEXT("[MSMDD:   ]  \t pEntry[%d].dwMaxLength = 0x%X\r\n"), i, (DWORD) pEntry[i].dwMaxLength);
		MSMDD_RTL_PRINT(TEXT("[MSMDD:   ]  \t pEntry[%d].usOrder     = 0x%X\r\n"), i, (USHORT) pEntry[i].usOrder);
    	MSMDD_RTL_PRINT(TEXT("[MSMDD:   ]  \t pEntry[%d].usFlags     = 0x%X\r\n"), i, (USHORT) pEntry[i].usFlags);
    	MSMDD_RTL_PRINT(TEXT("[MSMDD:   ]  \t pEntry[%d].dwVersion   = 0x%X\r\n"), i, (DWORD) pEntry[i].dwVersion);

		for (j = 0; j < XIP_NAMELEN; j ++)
			szXIPName[j] = (TCHAR) (pEntry[i].szName[j]);

    	MSMDD_RTL_PRINT(TEXT("[MSMDD:   ]  \t pEntry[%d].szName      = %s\r\n"),   i, szXIPName);
		MSMDD_RTL_PRINT(TEXT("[MSMDD:   ]  \t pEntry[%d].dwAlgoFlags = 0x%x\r\n"), i, (DWORD) pEntry[i].dwAlgoFlags);
		MSMDD_RTL_PRINT(TEXT("[MSMDD:   ]  \t pEntry[%d].dwKeyLen    = 0x%x\r\n"), i, (DWORD) pEntry[i].dwKeyLen);
	}
}
#endif	//(PS_DEBUG)

BOOL
VerifyChainInPocketStore(XIPCHAIN_SUMMARY *pExtChain, DWORD dwNumExtEntries)
{
    XIPCHAIN_ENTRY      *pMDDChain;
    DWORD				dwNumOfXIPLoc;
    DWORD				*pNANDXIPLoc;


    MSMDD_LOG_PRINT((TEXT("[MSMDD: IN] ++VerifyChainInPocketStore()\r\n")));