oemioctl.c

CIRRUS 公司EP93XX系列CPU的WINCE下的BSP

//
// 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.
//
/* -*-C-*-
 *
 *
 * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
 * ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
 * PARTICULAR PURPOSE.
 *
 * Copyright (c) 1999 ARM Limited
 * All Rights Reserved
 */
/*++

Module Name:

Abstract:
   NK Kernel Generic I/O Control Interface

Functions:


Notes:


    This file does not form part of the ARM template. It is included to
    show how iocontrol can be implemented in WindowsCE.

--*/
#define WINCEMACRO 1

#include <windows.h>
#include <ceddk.h>
#include <oalintr.h>
#include <halether.h>
#include <pkfuncs.h>
#include <iltiming.h>
#include <ethdbg.h>
#include <kitl.h>
//#include <platform.h>
#include <drv_glob.h>
#include <dbt.h>
#include <memorymap.h>
#include <nkintr.h>
#include <hwdefs.h>
#include <haluser.h>
#include <eeinfo.h>
#include <audiopio.h>

#ifdef EP931X_SIMULAT_PS2_KBD
	#include <ps2_ioctl.h>
#endif

#ifdef IMGSHAREETH
BOOL OEMEthCurrentPacketFilter(PDWORD pdwRequestedFilter);
BOOL OEMEthMulticastList(PUCHAR pucMulticastAddressList, DWORD dwNoOfAddresses);
#endif

#ifdef INTERNAL_HAL_TESTING
    #include "intioctl.h"
    #include "intioctl.c"
#endif


unsigned int strlenW(LPCWSTR str);
const WCHAR HALPlatformStr[] = L"EP931x Evaluation Board";
const WCHAR HALOEMStr[] = L"Cirrus";

void CreateDeviceName(EDBG_ADDR *pMyAddr, char *szBuf, LPSTR szPlatformString);

#ifdef EP931X_SIMULAT_PS2_KBD
	extern BOOL SendDataToPS2( PUCHAR  lpInBuf , int nInBufSize );
	extern BOOL ReadPS2Data( PUCHAR  lpOutBuf, int nOutBufSize, LPDWORD lpBytesReturned );
#endif
//extern PCI_REG_INFO g_KitlInfo;

// ILTIMING Globals
BOOL  fIntrTime;
WORD  wNumInterrupts;
DWORD dwIsrTime1, dwIsrTime2;
DWORD dwSPC;
DWORD dwIntrTimeCountdown;
DWORD dwIntrTimeCountdownRef;

// Wake from suspend interrupt mask
CRITICAL_SECTION csWakeIntMask;
extern DWORD g_dwWakeIntMask;

// PCI configuration access critical section
CRITICAL_SECTION csPCIConfig;
ULONG gulCS8950KitlUsed = 0;

DWORD OEMGetWakeupSource(void);
void OEMClearIntSources(void );
DWORD OEMResetWakeupSource( DWORD dwSources);
DWORD OEMSetWakeupSource( DWORD dwSources);
extern DWORD fNKSaveCoProcReg;





/*
 *      @func   BOOL | OEMIoControl | generic HAL request
 *
 *      @rdesc  none
 *
 *      @comm   OEMIoControl is called by the Kernel when a device driver or
 *              application program calls <f KernelIoControl>. The system is
 *              fully preemptible when this function is called. The kernel
 *              does no processing of this API. It is provided to allow an
 *              OEM device driver to communicate with kernel mode HAL code.
 *
 *      @xref   Overview.Windows CE Kernel OEM Interface   KernelIoControl
 */
BOOL OEMIoControl
(
    DWORD   dwIoControlCode, 
    LPVOID  lpInBuf, 
    DWORD   nInBufSize,
    LPVOID  lpOutBuf, 
    DWORD   nOutBufSize, 
    LPDWORD lpBytesReturned
)
{
    DWORD len;
    PIP_INFO pIPInfo;
    EDBG_ADDR *pEdbgAddr;
    ULONG       ulTemp;


    DEBUGMSG(0, (TEXT("+OEMIoControl %X\r\n"), dwIoControlCode));

    switch (dwIoControlCode)  {
    
    case IOCTL_HAL_GET_DEVICE_INFO:
        if (!lpOutBuf || !lpBytesReturned)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return(FALSE);
        }

        switch (*(LPDWORD)lpInBuf) {
        case SPI_GETPLATFORMTYPE:
            len = (strlenW(HALPlatformStr)+1)*sizeof(WCHAR);
            if (nOutBufSize >= len) {
                memcpy(lpOutBuf,HALPlatformStr,len);
                *lpBytesReturned = len;
            } else
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
            break;

        case SPI_GETOEMINFO:
            len = (strlenW(HALOEMStr)+1)*sizeof(WCHAR);
            if (nOutBufSize >= len) {
                memcpy(lpOutBuf,HALOEMStr,len);
                *lpBytesReturned = len;
            } else
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
            break;

        default:
            SetLastError(ERROR_INVALID_PARAMETER);
        }

        break;

    case IOCTL_PROCESSOR_INFORMATION:
        if (!lpOutBuf) {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }

        if (sizeof(PROCESSOR_INFO) > nOutBufSize) {
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            return FALSE;
        } else {
            const WCHAR OEMProcCore[] = L"ARM";
            const WCHAR OEMProcName[] = L"ARM920T";
            const WCHAR OEMProcVendor[] = L"ARM Ltd.";
            PPROCESSOR_INFO pProcInfo = (PPROCESSOR_INFO)lpOutBuf;

            if (lpBytesReturned) *lpBytesReturned = sizeof(PROCESSOR_INFO);
            memset(pProcInfo, 0, *lpBytesReturned);

            pProcInfo->wVersion = 1;

            memcpy(pProcInfo->szProcessCore, OEMProcCore, (strlenW(OEMProcCore) + 1) * sizeof(WCHAR));
            memcpy(pProcInfo->szProcessorName, OEMProcName, (strlenW(OEMProcName) + 1) * sizeof(WCHAR));
            memcpy(pProcInfo->szVendor, OEMProcVendor, (strlenW(OEMProcVendor) + 1 ) * sizeof(WCHAR));

            pProcInfo->dwInstructionSet = PROCESSOR_16BITINSTRUCTION;

            return TRUE;
        }
        
    case IOCTL_HAL_DDK_CALL:
        if (!lpInBuf || (nInBufSize != sizeof(BUSDATA_PARMS)) || !lpBytesReturned)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return(FALSE);
        }

        //
        // I hope by setting the return code to zero fails the PCI bus configuration
        // stuff.
        //
        if (*(DWORD *)lpInBuf == IOCTL_HAL_SETBUSDATA) 
        {
            ((PBUSDATA_PARMS)lpInBuf)->ReturnCode = 0;
            return TRUE;
        } 
        else if (*(DWORD *)lpInBuf == IOCTL_HAL_GETBUSDATA) 
        {
            ((PBUSDATA_PARMS)lpInBuf)->ReturnCode = 0;
            return TRUE;
        } 
        else 
        {
            //
            // Oops, parameter list isn't what we expected.
            //
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }

        break;

#if 0
    //
    // This will get handled by the default case since we don't
    // have a pci device.
    //
    case IOCTL_HAL_GETPCIDEVICEINFO:
        //
        // Oops, parameter list isn't what we expected.
        //
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
        
    case IOCTL_HAL_SETPCIDEVICEINFO:
        //
        // Oops, parameter list isn't what we expected.
        //
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
#endif // 0

    case IOCTL_HAL_GET_IP_ADDR:
        if ((lpOutBuf == NULL) || (NULL == lpBytesReturned) ||
            (nOutBufSize < sizeof(IP_INFO))) 
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return(FALSE);
        }

        // Default address to download is IPINFO_DOWNLOAD
        len = IPINFO_DOWNLOAD;

        if ((NULL != lpInBuf) && (nInBufSize == sizeof(len)))
            len = *((DWORD *)lpInBuf);

        switch (len) 
        {
        case IPINFO_ODO:
            pEdbgAddr = &(pDriverGlobals->eth.EdbgAddr);
            break;

        case IPINFO_DEBUGMSG:
            pEdbgAddr = &(pDriverGlobals->eth.DbgHostAddr);
            break;

        case IPINFO_KDEBUG:
            pEdbgAddr = &(pDriverGlobals->eth.KdbgHostAddr);
            break;

        case IPINFO_ESHELL:
            pEdbgAddr = &(pDriverGlobals->eth.PpshHostAddr);
            break;

        case IPINFO_DOWNLOAD:
        default:
            pEdbgAddr = &(pDriverGlobals->eth.EshellHostAddr);
        }

        pIPInfo = (PIP_INFO)lpOutBuf;
        pIPInfo->dwIP = pEdbgAddr->dwIP;
        memcpy(pIPInfo->MAC, (char *)pEdbgAddr->wMAC, sizeof(pIPInfo->MAC));
        *lpBytesReturned = sizeof(IP_INFO);
        break;

    case IOCTL_SET_KERNEL_COMM_DEV:
        //
        // Routine to change underlying communications device for
        // kernel services
        //
        return SetKernelCommDev((UCHAR)nInBufSize,(UCHAR)nOutBufSize);

    case IOCTL_HAL_INIT_RTC:
        if (!lpInBuf || !lpBytesReturned || (nInBufSize < sizeof(SYSTEMTIME)))
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return(FALSE);
        }

        if (OEMSetRealTime((LPSYSTEMTIME)lpInBuf))
            *lpBytesReturned = sizeof(SYSTEMTIME);

        break;

    case IOCTL_HAL_ENABLE_WAKE:
        if (lpInBuf && nInBufSize == sizeof(DWORD)) 
        {
            DWORD dwReturn;
            dwReturn = OEMSetWakeupSource( *(PDWORD)lpInBuf);
            if (dwReturn)
            {
                return TRUE;
            }
        }
        SetLastError (ERROR_INVALID_PARAMETER);
        return FALSE;

    case IOCTL_HAL_DISABLE_WAKE:
        if (lpInBuf && nInBufSize == sizeof(DWORD)) 
        {
            DWORD dwReturn;
            dwReturn = OEMResetWakeupSource( *(PDWORD)lpInBuf);
            if (dwReturn)
            {
                return TRUE;
            }
        }
        SetLastError (ERROR_INVALID_PARAMETER);
        return FALSE;


    case IOCTL_HAL_GET_WAKE_SOURCE:
        if (lpOutBuf && nOutBufSize>=sizeof(DWORD)) 
        {
            *(PDWORD)lpOutBuf= OEMGetWakeupSource();
            if (lpBytesReturned)
                *lpBytesReturned=sizeof(DWORD);
            return TRUE;
        }
        SetLastError (ERROR_INVALID_PARAMETER);
        return FALSE;

    case IOCTL_HAL_PRESUSPEND:
        OEMClearIntSources();
        return TRUE;

    case IOCTL_HAL_REBOOT:
        //
        // Perform a warm reset of the device.
        //
        RETAILMSG(1, (TEXT("Performing warm reset.\r\n")));
        ulTemp = *CSC_DEVCFG;
        *CSC_SYSLOCK    = 0xAA;
        *CSC_DEVCFG     = ulTemp | DEVCFG_SWRST;
        *CSC_SYSLOCK    = 0xAA;
        *CSC_DEVCFG     = ulTemp & ~DEVCFG_SWRST;
        
        return FALSE;
        break;

    case IOCTL_QUERY_PHYSICALMEM:
        if (!lpOutBuf || nOutBufSize < sizeof(PHYSICAL_BASIC_INFORMATION))
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return(FALSE);