oemioctl.c

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

        }

        // 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, "ARMINT");
                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;

            extern DWORD PerfCountSinceTick();
            extern DWORD PerfCountFreq();

            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;
#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;
            }
        }
        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 IRQ -> SYSINTR (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;

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

        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;

    case IOCTL_HAL_WRITE_COMMON_REG:
        if (nInBufSize == sizeof(CommonRegStruct) && nOutBufSize == 0 && !lpOutBuf && lpInBuf) 
        {
            CommonRegStruct *psCommon = (CommonRegStruct *)lpInBuf;
            BOOL            fEnable;
            ULONG           ulCurValue;
            if(psCommon->ulCheckSum == (ULONG)psCommon->pulRegister + psCommon->ulMask + psCommon->ulValue +
                                      (ULONG)psCommon->pulLockRegister)
            {
                //
                // Disable interrupts so that we can perform a lock/read/modify/write.
                //   
                fEnable     = INTERRUPTS_ENABLE(FALSE);

                //
                // Read the current value of the register.
                //
                ulCurValue  = *psCommon->pulRegister;


                //  
                // Set the lock register if necessary.
                //
                if(psCommon->pulLockRegister)
                {
                     *psCommon->pulLockRegister = 0xAA;
                
                }
                
                //  
                // Write the value to the register.
                //
                *psCommon->pulRegister = (ulCurValue & ~psCommon->ulMask) | 
                                         (psCommon->ulValue & psCommon->ulMask);                   

                //  
                // Clear the register lock.
                //
                if(psCommon->pulLockRegister)
                {
                     *psCommon->pulLockRegister = 0x00;
                
                }
                INTERRUPTS_ENABLE(fEnable);
                break;
            }
        }

        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;

    case IOCTL_HAL_GET_MAC_ADDRESS:
        if (nInBufSize == 0 && nOutBufSize == 6 && lpOutBuf && !lpInBuf) 
        {
            if(gBoardInformationValid)
            {
                memcpy(lpOutBuf, &gBoardInformation.MACAddress, 6);
                *lpBytesReturned = 6;
                break;
            }
            // return FALSE;
        }
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;

    case IOCTL_HAL_IS_CS8950_USED_FOR_KITL:
        if (nInBufSize == 0 && nOutBufSize == 4 && lpOutBuf && !lpInBuf) 
        {
            *(ULONG *)lpOutBuf = gulCS8950KitlUsed;
            *lpBytesReturned = 4;
            break;
        }
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;

    case IOCTL_HAL_AUDIO_GET_POSITION:
        if (nInBufSize == sizeof(BOOL) && nOutBufSize == sizeof(ULONG) && lpOutBuf && lpInBuf) 
        {
            if(*(BOOL *)lpInBuf)
            {
                *(ULONG *)lpOutBuf  = (ULONG)sPlayBack.pulPosition;
            }
            else
            {
                *(ULONG *)lpOutBuf  = (ULONG)sRecord.pulPosition;
            }
            *lpBytesReturned        = sizeof(ULONG);
            break;
        }
        return FALSE;


    case IOCTL_HAL_AUDIO_SET_POSITION:
        if (nInBufSize == sizeof(SetPositionStruct) && nOutBufSize == 0 && !lpOutBuf && lpInBuf) 
        {
            SetPositionStruct *pAudio   = (SetPositionStruct *)lpInBuf;
            if(pAudio->bPlayback)
            {
                sPlayBack.pulPosition   = (PULONG)pAudio->ulPosition;
            }
            else
            {
                sRecord.pulPosition     = (PULONG)pAudio->ulPosition;
            }
            *lpBytesReturned    = 0;
            break;
        }
        return FALSE;

    case IOCTL_HAL_AUDIO_START_STOP:
        if (nInBufSize == sizeof(StartStopStruct) && nOutBufSize == 0 && !lpOutBuf && lpInBuf) 
        {
            StartStopStruct  * pAudio = (StartStopStruct *)lpInBuf;

            if(pAudio->bPlayback)
            {
                sPlayBack.bEnabled      = pAudio->bStartStop;
            }
            else
            {
                sRecord.bEnabled        = pAudio->bStartStop;
            }
            *lpBytesReturned    = 0;            

            break;
        }
        return FALSE;

    case IOCTL_HAL_CRUNCH_ENABLED:
        if(nInBufSize == 0 && nOutBufSize == sizeof(BOOL) && lpOutBuf && !lpInBuf)
        {
            *(BOOL *)lpOutBuf = fNKSaveCoProcReg;
            break;
        }
        return FALSE;
        
    //
    // The EP931x board does not have a PCI device so this shouldn't get called.
    //
    // Set-up PCI registry with EDBG NIC instance information
    //
    //case IOCTL_HAL_INITREGISTRY:
    //    return PCIReg(&g_KitlInfo);
    default:
#ifdef INTERNAL_HAL_TESTING
            if (!InternalHalTesting(dwIoControlCode, lpInBuf,
                                   nInBufSize, lpOutBuf,
                                   nOutBufSize, lpBytesReturned))
            {
                return(FALSE);
            }
            break;
#endif

        SetLastError(ERROR_NOT_SUPPORTED);
        return(FALSE);

    //
    // Post kernel-init initialization, good place to initialize critical sections
    //
    case IOCTL_HAL_POSTINIT:
        // Initialize critical sections
        InitializeCriticalSection(&csWakeIntMask);
        InitializeCriticalSection(&csPCIConfig);
        
        return TRUE;

#ifdef EP931X_SIMULAT_PS2_KBD

	case IOCTL_HAL_PS2_SEND:
		return SendDataToPS2( lpInBuf ,nInBufSize );
		break;
	case IOCTL_HAL_PS2_GET:
		return ReadPS2Data(lpOutBuf, nOutBufSize, lpBytesReturned );
		break;
#endif
    }

    return(TRUE);
}

/* EOF oemioctl.c */