oemioctl.c

来自「WinCE 3.0 BSP, 包含Inter SA1110, Intel_815」· C语言 代码 · 共 771 行 · 第 1/2 页

/* -*-C-*-
 *
 * $Revision: 1.7 $
 *   $Author: kwelton $
 *     $Date: 2000/08/08 21:45:52 $
 *
 * 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) 1995, 1996, 1997, 1998  Microsoft Corporation
 * 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 <arm_ddk.h>
#include <nkintr.h>
#include <halether.h>
#include <pkfuncs.h>
#include <iltiming.h>
#include <ethdbg.h>
#include <platform.h>
#include "drv_glob.h"
#include "dbt.h"   


#ifdef HALPROFILE
BOOL HalProfileControl(LPVOID pProfCtrl, LPVOID lpOutBuf,
                          DWORD nOutBufSize, LPDWORD lpBytesReturned);
#endif

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

#undef HAL_DVCM

#ifdef HAL_DVCM
extern HRESULT Ioctl_Register_DataCollector(LPVOID,DWORD,LPVOID,DWORD);
extern HRESULT Ioctl_Send_DataCollector(LPVOID,DWORD,LPVOID,DWORD);
extern HRESULT Ioctl_Unregister_DataCollector(LPVOID,DWORD,LPVOID,DWORD);
#endif

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

#define pDriverGlobals  ((PDRIVER_GLOBALS)DRIVER_GLOBALS_PHYSICAL_MEMORY_START)

ULONG PCIGetBusDataByOffset(IN ULONG BusNumber,
                            IN ULONG SlotNumber,
                            IN PVOID Buffer,
                            IN ULONG Offset,
                            IN ULONG Length);

ULONG PCISetBusDataByOffset(IN ULONG BusNumber,
                            IN ULONG SlotNumber,
                            IN PVOID Buffer,
                            IN ULONG Offset,
                            IN ULONG Length);

BOOL PCI_FindDevice(unsigned short vendor, unsigned short device,
                    unsigned int instance, unsigned char *bus,
                    unsigned char *slot, unsigned char *func);

int GetPCIConfig(ULONG bus, ULONG device, ULONG function,
                 PCI_COMMON_CONFIG *pConfig);

int SetPCIConfig(ULONG bus, ULONG device, ULONG function,
                 PCI_COMMON_CONFIG *pConfig);

ULONG OEMMapIntLogic2SysIntr(ULONG nLogical);
unsigned int strlenW(LPCWSTR str);
const WCHAR HALPlatformStr[] = L"ARM platform";
const WCHAR HALOEMStr[] = L"ARM";


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

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
ULONG OEMGetBusDataByOffset(IN BUS_DATA_TYPE BusDataType,
                            IN ULONG BusNumber,
                            IN ULONG SlotNumber,
                            IN PVOID Buffer,
                            IN ULONG Offset,
                            IN ULONG Length)
{
  switch ( BusDataType ) {

    case PCIConfiguration:
      return(PCIGetBusDataByOffset(BusNumber,SlotNumber,Buffer,Offset,Length));

    default:
        return (0);
    }
}



// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
ULONG OEMSetBusDataByOffset(
                     IN BUS_DATA_TYPE BusDataType,
                     IN ULONG BusNumber,
                     IN ULONG SlotNumber,
                     IN PVOID Buffer,
                     IN ULONG Offset,
                     IN ULONG Length)
{
  switch ( BusDataType ) {

    case PCIConfiguration:
      return(PCISetBusDataByOffset(BusNumber,SlotNumber,Buffer,Offset,Length));

    default:
      return(0);
  }
}

#ifdef NotYet

NEEDS TO BE LOOKED AT .....
// -----------------------------------------------------------------------------
//
//      @func   BOOL | OEMGetUUID | Get UUID
//      @rdesc  none
//      @comm   This function will attempt to find an assigned IP address and
//                      return a UUID based on this value.  Since this is a sample
//                      platform we can get away with this.  A released product should
//                      either have a ROM serial number or perhaps use the MAC address
//                      of an ether net adapter as the source of the UUID
//
// -----------------------------------------------------------------------------
BOOL OEMGetUUID(GUID *pGUID)
{
    DWORD   Index;
    HKEY    hKey;
    HKEY    hMiniportKey;
    HKEY    hTcpIpKey;
    TCHAR   szTemp[128];
    TCHAR   szBaseKey[128];
    TCHAR   MiniportName[32];
    DWORD   MiniportNameLength;
    DWORD   dwType;
    DWORD   dwSize;
    BOOL    RetVal = FALSE;

    memcpy(szBaseKey, TEXT("Comm"), sizeof(TEXT("Comm")));
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, szBaseKey, 0,
                     KEY_READ, &hKey) != ERROR_SUCCESS)
    {
        DEBUGMSG(1, (TEXT("OEMGetUUID: unable to open registry\r\n")));
        return FALSE;
    }

    for (Index = 0; TRUE; Index++)
    {
        MiniportNameLength = sizeof(MiniportName);
        if (RegEnumKeyEx(hKey, Index, MiniportName,
                         &MiniportNameLength, NULL, NULL,
                         NULL, NULL) != ERROR_SUCCESS)
            break;

        // Check if this is really an ndis driver.
        if (RegOpenKeyEx(hKey, MiniportName, 0, KEY_READ,
                         &hMiniportKey) != ERROR_SUCCESS)
            continue;

        // Check the group
        dwSize = sizeof(szTemp);
        if (RegQueryValueEx (hMiniportKey, TEXT("Group"), 0,
                             &dwType, (LPBYTE)szTemp, &dwSize))
        {
            DEBUGMSG(1, (TEXT(" OEMGetUUID: Couldn't find Group\r\n")));
            RegCloseKey(hMiniportKey);

            continue;
        }

        if (memcmp(szTemp, TEXT("NDIS"), sizeof(TEXT("NDIS"))))
        {
            DEBUGMSG (1, (TEXT(" OEMGetUUID: Group doesn't match\r\n")));
            RegCloseKey(hMiniportKey);

            continue;
        }

        if (RegOpenKeyEx(hMiniportKey, TEXT("Parms\\TcpIp"), 0, KEY_READ,
                         &hTcpIpKey) != ERROR_SUCCESS)
        {
            DEBUGMSG(1, (TEXT(" OEMGetUUID: Couldn't open TcpIp\r\n")));
            RegCloseKey(hMiniportKey);

            continue;
        }

        // Is there a DHCPIpAddress Key?
        dwSize = sizeof(szTemp);
        if (RegQueryValueEx(hTcpIpKey, TEXT("DhcpIPAddress"), 0,
                            &dwType, (LPBYTE)szTemp, &dwSize))
        {
            // Try to see if there is a IPAddress String.
            if (RegQueryValueEx(hTcpIpKey, TEXT("IPAddress"), 0,
                                &dwType, (LPBYTE)szTemp, &dwSize))
            {

                DEBUGMSG(1, (TEXT(" OEMGetUUID: Couldn't get IP Address \r\n")));
                RegCloseKey (hTcpIpKey);
                RegCloseKey (hMiniportKey);

                continue;
            }
        }

        RETAILMSG(1, (TEXT("IPAddress='%s'\r\n"), szTemp));

        if (memcmp(szTemp, TEXT("0.0.0.0"), sizeof(TEXT("0.0.0.0"))))
        {
            // Just copy the string on top of the GUID,
            memcpy((char *)pGUID, szTemp, sizeof(GUID));

            RetVal = TRUE;
            // RetVal = FALSE; // This crashes mstsc.exe
        }

        RegCloseKey(hTcpIpKey);
        RegCloseKey(hMiniportKey);

        if (RetVal)
            break;
    }

    RegCloseKey(hKey);

    return RetVal;
}
#endif /* NotYet */

/*
 *      @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)
{
    BOOL retval = FALSE;
    DWORD len;
    PIP_INFO pIPInfo;
    PUDP_PACKET pUDPPacket;
    EDBG_ADDR *pEdbgAddr;
    EDBG_ADDR DestAddr;


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

    switch (dwIoControlCode)
    {
      case IOCTL_HAL_GET_DEVICE_INFO:
          if (nInBufSize == 4)
          {
              switch (*(LPDWORD)lpInBuf)
              {
                case SPI_GETPLATFORMTYPE:
                    len = (strlenW(HALPlatformStr)+1)*sizeof(WCHAR);
                    if (nOutBufSize >= len)
                    {
                        memcpy(lpOutBuf,HALPlatformStr,len);
                        retval = TRUE;
                    }
                    else
                        SetLastError(ERROR_INSUFFICIENT_BUFFER);

                    break;

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

                    break;

                default:
                    SetLastError(ERROR_INVALID_PARAMETER);
              }

          }
          else
              SetLastError(ERROR_INVALID_PARAMETER);

          break;

      case IOCTL_HAL_DDK_CALL:
          // For now, the only ddk ioctls in CEPC are SetBusData & GetBusData
          if ((nInBufSize != sizeof(BUSDATA_PARMS)) ||
              (!lpInBuf))
              // Oops, parameter list isn't what we expected.
              return FALSE;

          if (*(DWORD *)lpInBuf == IOCTL_HAL_SETBUSDATA )
          {
              ((PBUSDATA_PARMS)lpInBuf)->ReturnCode = OEMSetBusDataByOffset(
                  ((PBUSDATA_PARMS)lpInBuf)->BusDataType,
                  ((PBUSDATA_PARMS)lpInBuf)->BusNumber,
                  ((PBUSDATA_PARMS)lpInBuf)->SlotNumber,
                  ((PBUSDATA_PARMS)lpInBuf)->Buffer,
                  ((PBUSDATA_PARMS)lpInBuf)->Offset,
                  ((PBUSDATA_PARMS)lpInBuf)->Length);

              return TRUE;
          }
          else if (*(DWORD *)lpInBuf == IOCTL_HAL_GETBUSDATA)
          {
              ((PBUSDATA_PARMS)lpInBuf)->ReturnCode = OEMGetBusDataByOffset(
                  ((PBUSDATA_PARMS)lpInBuf)->BusDataType,
                  ((PBUSDATA_PARMS)lpInBuf)->BusNumber,
                  ((PBUSDATA_PARMS)lpInBuf)->SlotNumber,
                  ((PBUSDATA_PARMS)lpInBuf)->Buffer,
                  ((PBUSDATA_PARMS)lpInBuf)->Offset,
                  ((PBUSDATA_PARMS)lpInBuf)->Length);

              return TRUE;
          }
          else
              // Oops, parameter list isn't what we expected.
              return FALSE;

          break;

      case IOCTL_HAL_GETPCIDEVICEINFO:
      {
          PCIDeviceInfo *in;
          PCIDeviceInfo *out;

          if ((lpInBuf == NULL || (nInBufSize < sizeof(PCIDeviceInfo))) ||
              (lpOutBuf == NULL || (nOutBufSize < sizeof(PCIDeviceInfo))))
          {
              SetLastError(ERROR_INVALID_PARAMETER);
              return FALSE;
          }

          in = (PCIDeviceInfo *)lpInBuf;