ioctl.c

Intel DBPXA27X评估板OAL层代码.

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
//------------------------------------------------------------------------------
//
//  File: ioctl.c           
//
//  This file implements the OEM's IO Control (IOCTL) functions and declares
//  global variables used by the IOCTL component.
//
#include <bsp.h>

#ifdef MODULE_CERTIFY
#include <secload.h>
#endif

//------------------------------------------------------------------------------
//
//  Global: g_oalIoctlPlatformType/OEM    
//
//  Platform Type/OEM
//
LPCWSTR g_oalIoCtlPlatformType = IOCTL_PLATFORM_TYPE;
LPCWSTR g_oalIoCtlPlatformOEM  = IOCTL_PLATFORM_OEM;

//------------------------------------------------------------------------------
//
//  Global: g_oalIoctlProcessorVendor/Name/Core
//
//  Processor information
//
LPCWSTR g_oalIoCtlProcessorVendor = IOCTL_PROCESSOR_VENDOR;
LPCWSTR g_oalIoCtlProcessorName   = IOCTL_PROCESSOR_NAME;
LPCWSTR g_oalIoCtlProcessorCore   = IOCTL_PROCESSOR_CORE;

//------------------------------------------------------------------------------
//
//  Global: g_oalIoctlInstructionSet
//
//  Processor instruction set identifier
//
UINT32 g_oalIoCtlInstructionSet = IOCTL_PROCESSOR_INSTRUCTION_SET;
UINT32 g_oalIoCtlClockSpeed     = IOCTL_PROCESSOR_CLOCK_SPEED;

//------------------------------------------------------------------------------
//
//  External: ARMCacheInfo
//
//  Processor cache information structure
//
extern const CacheInfo ARMCacheInfo;

//------------------------------------------------------------------------------
//
//  Function:  OALIoCtlHalGetCacheInfo
//
//  This function returns information about the CPU's instruction and data caches.
//
BOOL OALIoCtlHalGetCacheInfo(
    UINT32 code, VOID *pInpBuffer, UINT32 inpSize, VOID *pOutBuffer,
    UINT32 outSize, UINT32 *pOutSize)
{

    // Validate caller's arguments.
    //
    if (!pOutBuffer || (outSize < sizeof(CacheInfo)))
    {
        NKSetLastError(ERROR_INSUFFICIENT_BUFFER);
        return(FALSE);
    }

    // Copy the cache information into the caller's buffer.
    //
    memcpy(pOutBuffer, &ARMCacheInfo, sizeof(CacheInfo));
    if (pOutSize) *pOutSize = sizeof(CacheInfo);

    return(TRUE);
}

//------------------------------------------------------------------------------
//
//  Function:  OALIoCtlHalPostInit
//
//  This function is the next OAL routine called by the kernel after OEMInit and
//  provides a context for initializing other aspects of the device prior to
//  general boot.
//
BOOL OALIoCtlHalPostInit(
    UINT32 code, VOID *pInpBuffer, UINT32 inpSize, VOID *pOutBuffer,
    UINT32 outSize, UINT32 *pOutSize)
{
    
    // Do nothing for now.
    //
    return(TRUE);

}


//------------------------------------------------------------------------------
//
//  Function:  OALIoCtlHalReboot
//
//  This function hardware-reboots the MainstoneII platform.
//
BOOL OALIoCtlHalReboot(
    UINT32 code, VOID *pInpBuffer, UINT32 inpSize, VOID *pOutBuffer,
    UINT32 outSize, UINT32 *pOutSize)
{
    volatile MAINSTONEII_BLR_REGS *pBLRegs = (volatile MAINSTONEII_BLR_REGS *) OALPAtoVA(MAINSTONEII_BASE_REG_PA_FPGA, FALSE);    

    // For now, perform a hard reset - write to the FPGA system reset bit.
    while(TRUE)
    {
        pBLRegs->misc_wr = 1;
    }

    return(TRUE);

}

BOOL OALIoCtlUnknown(
    UINT32 code, VOID *pInpBuffer, UINT32 inpSize, VOID *pOutBuffer,
    UINT32 outSize, UINT32 *pOutSize)
{
    
    // Do nothing for now.
    //
    return(TRUE);

}

const WCHAR HALOEMStr[] = L"MAINSTN" ;
#ifndef MS2_SMARTPHONE
// platform information for PPC
#define TOTALPLATFORMS          2
const DWORD HALTotalPlatforms = TOTALPLATFORMS;
const WCHAR HALPlatformStr[] = L"PocketPC\0SSDK\0";
const DWORD HALPlatformStrSize = sizeof(HALPlatformStr);
const PLATFORMVERSION HALPlatformVer[TOTALPLATFORMS] = {{4, 0}, {5, 0}};
#else
// platform information for Smartfon
#define TOTALPLATFORMS          1
const DWORD HALTotalPlatforms = TOTALPLATFORMS;
const WCHAR HALPlatformStr[] = L"SmartPhone\0";
const DWORD HALPlatformStrSize = sizeof(HALPlatformStr);
const PLATFORMVERSION HALPlatformVer[TOTALPLATFORMS] = {{4, 0}};
#endif
//-----------------------------------------------------------------------------
//
// Functio: 1
// OALGetDeviceInfo
//
BOOL OALGetDeviceInfo(
    UINT32 code, VOID *lpInBuf, UINT32 nInBufSize, VOID *lpOutBuf,
    UINT32 nOutBufSize, UINT32 *lpBytesReturned)
{
    BOOL retval= FALSE;
    DWORD len;
    if (code == IOCTL_HAL_GET_DEVICE_INFO ) {
        if (nInBufSize == 4 && lpInBuf ) {
            switch (*(LPDWORD)lpInBuf) {
            case SPI_GETPLATFORMTYPE:
                    len = sizeof(HALPlatformStr);
                    if (lpBytesReturned)
                        *lpBytesReturned = len;
                    if (nOutBufSize >= len && lpOutBuf) {
                            memcpy(lpOutBuf,HALPlatformStr,len);
                            retval = TRUE;
                    } else
                            NKSetLastError(ERROR_INSUFFICIENT_BUFFER);
                    break;
            case SPI_GETOEMINFO:
                    len = (strlenW(HALOEMStr)+1)*sizeof(WCHAR);
                    if (lpBytesReturned)
                        *lpBytesReturned = len;
                    if (nOutBufSize >= len && lpOutBuf) {
                            memcpy(lpOutBuf,HALOEMStr,len);
                            retval = TRUE;
                    } else
                            NKSetLastError(ERROR_INSUFFICIENT_BUFFER);
                    break;
                    
            case SPI_GETPLATFORMVERSION:
                len = sizeof(PLATFORMVERSION) * TOTALPLATFORMS;
                if (lpBytesReturned)
                    *lpBytesReturned = len;
                if (nOutBufSize < len)
                {
                    NKSetLastError(ERROR_INSUFFICIENT_BUFFER);
                    retval = FALSE;
                }
                else if (!lpOutBuf)
                {
                    NKSetLastError(ERROR_INVALID_PARAMETER);
                    retval = FALSE;
                }
                else
                {
                    memcpy(lpOutBuf, HALPlatformVer, len);
                    retval = TRUE;
                }
                break;
                
            default:
                    NKSetLastError(ERROR_INVALID_PARAMETER);
            }
        } else {
                NKSetLastError(ERROR_INVALID_PARAMETER);
        }
    }
    else {
        NKSetLastError(ERROR_INVALID_PARAMETER);
    }
    return retval;
}
#ifdef MODULE_CERTIFY
static BOOL
OALIoCtlModuleCertify(
    UINT32  code,
    VOID   *pInBuffer,
    UINT32  inSize,
    VOID   *pOutBuffer,
    UINT32  outSize,
    UINT32 *pOutSize
) {
    BOOL rc;

    (void)IsSecModuleIoControl(code, pInBuffer, inSize, pOutBuffer, outSize, pOutSize, &rc);

    return rc;
}
#endif


//------------------------------------------------------------------------------
//
//  Global: g_oalIoCtlTable[]    
//
//  IOCTL handler table. This table includes the IOCTL code/handler pairs  
//  defined in the IOCTL configuration file. This global array is exported 
//  via oal_ioctl.h and is used by the OAL IOCTL component.
//
const OAL_IOCTL_HANDLER g_oalIoCtlTable[] = {
#include "ioctl_tab.h"
};

//------------------------------------------------------------------------------