oemioctl.c

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

          out = (PCIDeviceInfo *)lpOutBuf;

          if ((out->found = PCI_FindDevice(in->vendor, in->device,
                                           in->instance, &out->bus,
                                           &out->slot, &out->func)) == TRUE)
              /* device was found - get config header */
              GetPCIConfig(out->bus, out->slot, out->func,
                               &out->config);

          if (lpBytesReturned != NULL)
              *lpBytesReturned = sizeof(*out);

          return TRUE;
      }

      case IOCTL_HAL_SETPCIDEVICEINFO:
      {
          PCIDeviceInfo *in;

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

          in = (PCIDeviceInfo *)lpInBuf;
          SetPCIConfig(in->bus, in->slot, in->func, &in->config);

          return TRUE;
      }

      case IOCTL_HAL_SEND_UDP:
          if ((lpInBuf == NULL) || (nInBufSize < sizeof(EDBG_ADDR)))
          {
              SetLastError(ERROR_INVALID_PARAMETER);
              break;
          }

          pUDPPacket = (PUDP_PACKET)lpInBuf;

          // Send the packet
          DestAddr.dwIP = pUDPPacket->dwDestIP;
          memcpy((char *)DestAddr.wMAC, pUDPPacket->DestMAC,
                 sizeof(pUDPPacket->DestMAC));
          DestAddr.wPort = pUDPPacket->wDestPort;

          len = EdbgSendUDP(lpInBuf, &DestAddr, pUDPPacket->wSrcPort,
                            pUDPPacket->Packet, pUDPPacket->wPacketLen);

          // This returns 0 for success
          if (0 == len)
              retval = TRUE;

          break;

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

          // 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.CeshHostAddr);
                break;

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

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

          break;

      case IOCTL_EDBG_REGISTER_CLIENT:
          return EdbgRegisterClient(lpInBuf, lpOutBuf, (UCHAR)nInBufSize,
                                    (UCHAR)nOutBufSize,
                                    (UCHAR *)lpBytesReturned);

      case IOCTL_EDBG_DEREGISTER_CLIENT:
          return EdbgDeregisterClient((UCHAR)nInBufSize);

      case IOCTL_EDBG_REGISTER_DFLT_CLIENT:
          return EdbgRegisterDfltClient((UCHAR)nInBufSize, (UCHAR)nOutBufSize,
                                        (UCHAR **)lpInBuf,
                                        (UCHAR **)lpOutBuf);

      case IOCTL_EDBG_SEND:
          return EdbgSend((UCHAR)nInBufSize, lpInBuf, nOutBufSize);

      case IOCTL_EDBG_RECV:
          return EdbgRecv((UCHAR)nInBufSize, lpInBuf, lpOutBuf, nOutBufSize);

      case IOCTL_EDBG_SET_DEBUG:
          EdbgSetDebug(nInBufSize);
          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:
          //
          // We have a battery backed CMOS based clock.  Don't actually
          // do anything to the RTC unless it appears to have been
          // corrupted.  I guess the best way to detect corruption is by
          // checksumming CMOS
          //
          break;

      case IOCTL_HAL_REBOOT:
          //
          // Perform a warm reset of the device.
          //
          *(PUCHAR)(VA_SC_BASE + INTEGRATOR_SC_CTRLS_OFFSET) = 0x01;
          break;

      case IOCTL_QUERY_PHYSICALMEM:
      {
          // Return information about physical memory
          ((PPHYSICAL_BASIC_INFORMATION)lpOutBuf)->lpBaseAddress = (LPVOID)0;
          ((PPHYSICAL_BASIC_INFORMATION)lpOutBuf)->dwRegionSize = 0x00000000;
          ((PPHYSICAL_BASIC_INFORMATION)lpOutBuf)->dwType = PHYSICAL_UNKNOWN;

          return TRUE;

          break;
      }

#ifdef HALPROFILE
      case IOCTL_HAL_PROFILE:
          return HalProfileControl(lpInBuf, lpOutBuf,
                          nOutBufSize, lpBytesReturned);
        break;
#endif
      case IOCTL_HAL_ILTIMING:
      {
          if ((nInBufSize == sizeof(ILTIMING_MESSAGE)) && (lpInBuf != NULL))
          {
              extern DWORD PerfCountSinceTick();
              extern DWORD PerfCountFreq();

              PILTIMING_MESSAGE pITM = (PILTIMING_MESSAGE) lpInBuf;

              switch (pITM->wMsg)
              {
                case ILTIMING_MSG_ENABLE:
                {
                    dwIntrTimeCountdownRef = pITM->dwFrequency;
                    RETAILMSG(1,
                              (TEXT("ILTiming Enable (@ every %d ticks)\r\n"),
                               dwIntrTimeCountdownRef));

                    dwIntrTimeCountdown = dwIntrTimeCountdownRef;
                    wNumInterrupts = 0;
                    dwIsrTime1 = 0xFFFFFFFF;
                    fIntrTime = TRUE;

                    break;
                }

                case ILTIMING_MSG_DISABLE:
                {
                    RETAILMSG(1, (TEXT("ILTiming Disable\r\n")));
                    fIntrTime = FALSE;

                    break;
                }

                case ILTIMING_MSG_GET_TIMES:
                {
                    pITM->dwIsrTime1 = dwIsrTime1;
                    pITM->dwIsrTime2 = dwIsrTime2;
                    pITM->wNumInterrupts = wNumInterrupts;
                    pITM->dwSPC = dwSPC;
                    pITM->dwFrequency = PerfCountFreq();
                    wNumInterrupts = 0;

#if 0
                    RETAILMSG(1, (TEXT("ILTiming GetTime @ 0x%08X:%08X\r\n"),
                                  pITM->dwParam1, pITM->dwParam2));
#endif /* 0/1 */

                    break;
                }

                case ILTIMING_MSG_GET_PFN:
                {
                    pITM->pfnPerfCountSinceTick = (PVOID)PerfCountSinceTick;
                    RETAILMSG (1, (TEXT("ILTiming GetPFN\r\n")));

                    break;
                }

                default:
                {
                    RETAILMSG(1,
                              (TEXT("IOCTL_HAL_ILTIMING: BAD MESSAGE!\r\n")));

                    SetLastError(ERROR_INVALID_PARAMETER);
                    return FALSE;
                }
              }
          }
          else
          {
              RETAILMSG(1, (TEXT("IOCTL_HAL_ILTIMING: BAD PARAMETERS!\r\n")));

              SetLastError(ERROR_INVALID_PARAMETER);
              return FALSE;
          }

          return TRUE;
      }

#ifdef HAL_DVCM
      case IOCTL_COLLECTOR_REGISTER:
          if (FAILED(Ioctl_Register_DataCollector(lpInBuf, nInBufSize,
                                                  lpOutBuf, nOutBufSize)))
              return FALSE;
          else
              retval = TRUE;

          break;

      case IOCTL_COLLECTOR_SEND:
          if (FAILED(Ioctl_Send_DataCollector(lpInBuf, nInBufSize,
                                              lpOutBuf, nOutBufSize)))
              return FALSE;
          else
              retval = TRUE;

          break;

      case IOCTL_COLLECTOR_UNREGISTER:
          if (FAILED(Ioctl_Unregister_DataCollector(lpInBuf, nInBufSize,
                                                    lpOutBuf, nOutBufSize)))
              return FALSE;
          else
              retval = TRUE;

          break;
#endif /* def HAL_DVCM */

        ////////////////////////////////////////////////////////////////////////
        //
        //  The support for VMini..
        //
#ifdef IMGSHAREETH
        case IOCTL_VBRIDGE_GET_TX_PACKET:
            return VBridgeUGetOneTxPacket((PUCHAR *)lpOutBuf);
            break;
    
        case IOCTL_VBRIDGE_GET_TX_PACKET_COMPLETE:
            VBridgeUGetOneTxPacketComplete((PUCHAR)lpInBuf, nInBufSize);
            return TRUE;
            break;
    
        case IOCTL_VBRIDGE_GET_RX_PACKET:
            return VBridgeUGetOneRxPacket((PUCHAR *)lpOutBuf, lpBytesReturned);
            break;
    
        case IOCTL_VBRIDGE_GET_RX_PACKET_COMPLETE:
            VBridgeUGetOneRxPacketComplete((PUCHAR)lpInBuf);
            return TRUE;
            break;
    
        case IOCTL_VBRIDGE_GET_ETHERNET_MAC:
            VBridgeUGetEDBGMac((PBYTE)lpOutBuf);
            return TRUE;
            break;
    
	case IOCTL_VBRIDGE_CURRENT_PACKET_FILTER:
	    ////////////////////////////////////////////////////////////////////
	    //	First, see if filter setting is implemented, then inform vbridge
	    //	on the new filtering.
	    //
            if (OEMEthCurrentPacketFilter((PDWORD)lpInBuf))
	    {
	        VBridgeUCurrentPacketFilter((PDWORD)lpInBuf);
	        return TRUE;
	    }
	    return FALSE;
            break;
	    	
	case IOCTL_VBRIDGE_802_3_MULTICAST_LIST:
            if (OEMEthMulticastList((PUCHAR)lpInBuf, nInBufSize))
		return TRUE;		
	    return FALSE;
            break;
            
        case IOCTL_VBRIDGE_SHARED_ETHERNET:
            ////////////////////////////////////////////////////////////////////
            //  Yes, this kernel supports shared ethernet port.
            //
            return TRUE;
            break;

#endif	// IMGSHAREETH
        ////////////////////////////////////////////////////////////////////////

      case IOCTL_HAL_GET_UUID:
          if (lpOutBuf && (nOutBufSize >= sizeof(GUID)))
          {
#if NotYet
NEEDS TO BE LOOKED AT
              if (lpBytesReturned)
                  *lpBytesReturned = sizeof(GUID);

              return OEMGetUUID(lpOutBuf);
#else /* NotYet */
              ERRORMSG(1,
                       (TEXT("Unsupported call to IOCTL_HAL_GET_UUID\r\n")));

              lpBytesReturned = 0;
#endif /* NotYet */
          }
          else
          {
              SetLastError(ERROR_INVALID_PARAMETER);
              return FALSE;
          }

          break;

        case IOCTL_HAL_TRANSLATE_IRQ:
        case IOCTL_HAL_MAP_INTERRUPT:
            // Translate a logical interrupt number to a SYSINTR value.
            //
            *(PULONG)lpOutBuf = OEMMapIntLogic2SysIntr(*(PULONG)lpInBuf);
            if (lpBytesReturned)
                *lpBytesReturned = sizeof(ULONG);
            retval = TRUE;
            break;


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

      default:
#ifdef INTERNAL_HAL_TESTING
          if (retval = InternalHalTesting(dwIoControlCode, lpInBuf,
                                          nInBufSize, lpOutBuf,
                                          nOutBufSize, lpBytesReturned))
              break;
#endif

          SetLastError(ERROR_NOT_SUPPORTED);
          return FALSE;
    }

    return TRUE;
}

/* EOF oemioctl.c */