oemioctl.c

此压缩包为杰得开发得z228的BSP的源代码,可以实现很多功能,尤其是视频解码有很好的效果.

        }

        // 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;

        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 0
        if (!lpInBuf || !lpBytesReturned || (nInBufSize < sizeof(SYSTEMTIME)))
        {
            SetLastError( ERROR_INVALID_PARAMETER );
            return(FALSE);
        }

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

    case IOCTL_HAL_ENABLE_WAKE:
    case IOCTL_HAL_DISABLE_WAKE:
        if (lpInBuf && nInBufSize == sizeof(DWORD)) 
        {
            DWORD dwReturn = (dwIoControlCode == IOCTL_HAL_ENABLE_WAKE ?
                        OEMSetWakeupSource( *(PDWORD)lpInBuf) : 
                        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.
        //
        
 
        // Tell system controller to perform reset
        ((pvstSP810Regs)VA_SC_BASE)->SCSYSSTAT = 1;
        break;

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

        // 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;

        break;

    case IOCTL_HAL_GET_DEVICEID :
        if (!lpOutBuf || !lpBytesReturned || (nOutBufSize < sizeof(DEVICE_ID))) 
        {
            SetLastError (ERROR_INVALID_PARAMETER);
            return(FALSE);
        }

        {
            PDEVICE_ID  pDeviceID = (PDEVICE_ID)lpOutBuf;

#define ROUNDUP(len)        ((len+3)&0xFFFFFFFC)
#define REQ_SIZE            (ROUNDUP(sizeof(DEVICE_ID)) + ROUNDUP(sizeof(HALOEMStr)) + ROUNDUP(KITL_MAX_DEV_NAMELEN))

            if (pDeviceID->dwSize >= REQ_SIZE) 
            {
                // Tell them how much we actually used.
                pDeviceID->dwSize = REQ_SIZE;

                pDeviceID->dwPresetIDOffset = ROUNDUP(sizeof(DEVICE_ID));
                pDeviceID->dwPresetIDBytes = sizeof(HALOEMStr);
                memcpy ((PBYTE)lpOutBuf + pDeviceID->dwPresetIDOffset, 
                        (PBYTE)HALOEMStr, sizeof(HALOEMStr));

                pDeviceID->dwPlatformIDOffset = pDeviceID->dwPresetIDOffset + 
                        ROUNDUP(pDeviceID->dwPresetIDBytes);
                pDeviceID->dwPlatformIDBytes = KITL_MAX_DEV_NAMELEN;
                CreateDeviceName(&pDriverGlobals->eth.EdbgAddr, 
                        (PBYTE)lpOutBuf + pDeviceID->dwPlatformIDOffset, 
                        PLATFORM_STRING);
                if (lpBytesReturned)
                {
                    *lpBytesReturned = REQ_SIZE;
                }

            } 
            else 
            {
                // Tell them how much we actually need.
                pDeviceID->dwSize = REQ_SIZE;
                SetLastError (ERROR_INSUFFICIENT_BUFFER);
                return(FALSE);
            }
        }
        break;
        
    case IOCTL_HAL_ILTIMING:
        {
            PILTIMING_MESSAGE pITM = (PILTIMING_MESSAGE) lpInBuf;

            if ((nInBufSize != sizeof(ILTIMING_MESSAGE)) || !lpInBuf) 
            {
                SetLastError(ERROR_INVALID_PARAMETER);
                return(FALSE);
            }

            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;
                //RETAILMSG(1, (TEXT("ILTiming GetTime @ 0x%08X:%08X\r\n"),
                //              pITM->dwParam1, pITM->dwParam2));

                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;
            }
        }
        break;

#if IMGSHAREETH

        ////////////////////////////////////////////////////////////////////////
        //  The support for VMini..
        //
    case IOCTL_VBRIDGE_GET_TX_PACKET:
        if (lpOutBuf)
            return VBridgeUGetOneTxPacket((PUCHAR *)lpOutBuf, nInBufSize);

        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;

    case IOCTL_VBRIDGE_GET_TX_PACKET_COMPLETE:
        VBridgeUGetOneTxPacketComplete((PUCHAR)lpInBuf, nInBufSize);
        return TRUE;

    case IOCTL_VBRIDGE_GET_RX_PACKET:
        if (lpOutBuf) 
        {
            return VBridgeUGetOneRxPacket((PUCHAR *)lpOutBuf, lpBytesReturned);
        }

        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
        
    case IOCTL_VBRIDGE_GET_RX_PACKET_COMPLETE:
        VBridgeUGetOneRxPacketComplete((PUCHAR)lpInBuf);
        return TRUE;

    case IOCTL_VBRIDGE_GET_ETHERNET_MAC:
        VBridgeUGetEDBGMac((PBYTE)lpOutBuf);
        return TRUE;

    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;

    case IOCTL_VBRIDGE_802_3_MULTICAST_LIST:
        if (OEMEthMulticastList((PUCHAR)lpInBuf, nInBufSize))
            return TRUE;
        return FALSE;

    case IOCTL_VBRIDGE_WILD_CARD:
        return VBridgeUWildCard(lpInBuf, nInBufSize, lpOutBuf, nOutBufSize, 
                                lpBytesReturned);

    case IOCTL_VBRIDGE_SHARED_ETHERNET:
        ////////////////////////////////////////////////////////////////////////
        //  Yes, this kernel supports shared ethernet port.
        //
        return TRUE;
#endif  // IMGSHAREETH

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

        ////////////////////////////////////////////////////////////////////////
        //      Translate interrupt into SYSINTR
        // 
        // Translate IRQSYSINTR (or request new SYSINTR)
        case IOCTL_HAL_TRANSLATE_IRQ:
        case IOCTL_HAL_REQUEST_SYSINTR:
            if (nInBufSize >= sizeof(DWORD) && nOutBufSize >= sizeof(DWORD) && 
                lpOutBuf && lpInBuf) 
            {
                *(PDWORD)lpOutBuf = OEMRequestSysIntr(*(PDWORD)lpInBuf);

                if (lpBytesReturned) 
                {
                    *lpBytesReturned = sizeof(DWORD);
                }
                return TRUE;
            }

            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;

        // Release previously requested SYSINTR
        case IOCTL_HAL_RELEASE_SYSINTR:
            if (nInBufSize >= sizeof(DWORD) && lpInBuf) 
            {
                DWORD Success = OEMReleaseSysIntr(*(PDWORD)lpInBuf);

                if (lpBytesReturned) 
                {
                  *lpBytesReturned = 0;
                }

                if (Success == ERROR_SUCCESS) 
                {
                  return TRUE;
                } 
                else 
                {
                  SetLastError(Success);
                  return FALSE;
                }
            }
  
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
  
  
        // Provide interrupt number based on device location
        case IOCTL_HAL_REQUEST_IRQ:
            if (nInBufSize >= sizeof(DEVICE_LOCATION) && 
                nOutBufSize >= sizeof(DWORD) && lpOutBuf && lpInBuf) 
            {
                if(!OEMGetInterrupt((PDEVICE_LOCATION)lpInBuf, (PDWORD)lpOutBuf))
                    return(FALSE);

                if (lpBytesReturned) 
                {
                    *lpBytesReturned = sizeof(DWORD);
                }

                break;
            }