oemioctl.c

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

    
        } else {
            RETAILMSG (1, (TEXT("IOCTL_HAL_ILTIMING : BAD PARAMETERS!!!\r\n")));
            SetLastError(ERROR_INVALID_PARAMETER);
            return (FALSE);
        }
        return (TRUE);
    }
    
    case IOCTL_HAL_GET_UUID :
        if (lpOutBuf && (nOutBufSize >= sizeof(GUID))) {
            if (lpBytesReturned) {
                *lpBytesReturned = sizeof(GUID);
            }
            // OEM's with unique ID hardware can return the value here.

            // The CEPC platform does not have any unique ID settings.
            // We'll use the Kernel Ethernet Debug address if non-zero
            if (wLocalMAC[0] | wLocalMAC[1] | wLocalMAC[2]) {
                memcpy(lpOutBuf, (char *)wLocalMAC, sizeof(GUID));
                return TRUE;
            } else {
                SetLastError (ERROR_NOT_SUPPORTED);
                return FALSE;
            }
        } else {
            SetLastError (ERROR_INVALID_PARAMETER);
            return FALSE;
        }
        break;

#ifdef HALPROFILE
    case IOCTL_HAL_PROFILE:
        return HalProfileControl(lpInBuf, lpOutBuf, 
                          nOutBufSize, lpBytesReturned);
        break;
#endif

        case IOCTL_HAL_GET_DEVICEID :
        if (!lpOutBuf || (nOutBufSize < sizeof(DEVICE_ID))) {
            SetLastError (ERROR_INVALID_PARAMETER);
            return FALSE;
        } else {
            PDEVICE_ID  pDeviceID = (PDEVICE_ID)lpOutBuf;
            
            // The CEPC doesn't have a real Preset ID or Platform ID
            // Normally this would be a ROM ID or some binary value
            // It's not required but I'm aligning all of the data at DWORD
            // offsets.
#define ROUNDUP(len)        ((len+3)&0xFFFFFFFC)
#define REQ_SIZE            (ROUNDUP(sizeof(DEVICE_ID)) + \
                            ROUNDUP(sizeof(HALOEMStr)) + \
                            ROUNDUP(sizeof(HALPlatformStr)))
            
            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 = sizeof(HALPlatformStr);
                memcpy ((PBYTE)lpOutBuf + pDeviceID->dwPlatformIDOffset,
                        (PBYTE)HALPlatformStr, sizeof(HALPlatformStr));
                
                if (lpBytesReturned) {
                    *lpBytesReturned = REQ_SIZE;
                }
                SetLastError(0);
                return TRUE;
                
            } else {
                // Tell them how much we actually need.
                pDeviceID->dwSize = REQ_SIZE;
                SetLastError (ERROR_INSUFFICIENT_BUFFER);
                return FALSE;
            }
        }
        break;

#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 // HAL_DVCM

#if IMGSHAREETH

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

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

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

    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_SHARED_ETHERNET:
        ////////////////////////////////////////////////////////////////////////
        //  Yes, this kernel supports shared ethernet port.
        //
        return TRUE;
#endif


    default:
#ifdef INTERNAL_HAL_TESTING
        if (retval = InternalHalTesting (dwIoControlCode, lpInBuf, nInBufSize, lpOutBuf, nOutBufSize, lpBytesReturned)) {
            break;
        }
#endif
        SetLastError(ERROR_NOT_SUPPORTED);
        return (FALSE);
    }
    return retval;
}


//+++
// Hardware Debug Register support 
//
__inline void CLEARDR0()
{
    __asm { 
        push eax
        xor eax,eax
        mov dr0, eax
        mov eax, dr7
        and eax,0xFFFFFFFC;
        mov dr7, eax
        pop eax
    }
}

__inline void CLEARDR1()
{
    __asm { 
        push eax
        xor eax,eax
        mov dr1, eax
        mov eax, dr7
        and eax,0xFFFFFFF3;
        mov dr7, eax
        pop eax
    }
}

__inline void CLEARDR2()
{
    __asm { 
        push eax
        xor eax,eax
        mov dr2, eax
        mov eax, dr7
        and eax,0xFFFFFFCF;
        mov dr7, eax
        pop eax
    }
}

__inline void CLEARDR3()
{
    __asm { 
        push eax
        xor eax,eax
        mov dr3, eax
        mov eax, dr7
        and eax,0xFFFFFF3F;
        mov dr7, eax
        pop eax
    }
}


int SetDataBP(ULONG ulAddress)
{
    ULONG ulHandle = 0;
    ULONG ulFlags = 0;
    __asm {
        mov eax,dr3
        cmp eax, 0
        jne  checkdr2
        mov eax,ulAddress
        mov dr3, eax
        mov eax, dr7
        or   eax, 0x100003C0 // 0001 0000 0000 0000 0000 0011 1100 0000
        mov ulFlags, eax
        mov dr7, eax
        mov ulHandle, 1
        jmp  done
checkdr2:       
        mov eax,dr2
        cmp eax, 0
        jne  checkdr1
        mov eax, ulAddress
        mov dr2, eax
        mov eax, dr7
        or   eax, 0x01000330 // 0000 0001 0000 0000 0000 0011 0011 0000
        mov ulFlags, eax
        mov dr7, eax
        mov ulHandle, 2
        jmp  done
checkdr1:
        mov eax,dr1
        cmp eax, 0
        jne  checkdr0
        mov eax, ulAddress
        mov dr1, eax
        mov eax, dr7
        or   eax, 0x0010030C // 0000 0000 0001 0000 0000 0011 0000 1100
        mov ulFlags, eax
        mov dr7, eax
        mov ulHandle, 3
        jmp  done
checkdr0:
        mov eax,dr0
        cmp eax, 0
        jne  checkdr1
        mov eax, ulAddress
        mov dr0, eax
        mov eax, dr7
        or   eax, 0x00010303 // 0000 0000 0000 0001 0000 0011 0000 00011
        mov ulFlags, eax
        mov dr7, eax
        mov ulHandle, 4
        jmp  done
    }
done:
    return ulHandle;
}

BOOL OEMKDIoControl( DWORD dwIoControlCode, LPVOID lpBuf, DWORD nBufSize)
{
    switch(dwIoControlCode) {
    case KD_IOCTL_INIT:
        CLEARDR0();
        CLEARDR1();
        CLEARDR2();
        CLEARDR3();
        return TRUE;
    case KD_IOCTL_SET_CBP:
    case KD_IOCTL_CLEAR_CBP:
    case KD_IOCTL_ENUM_CBP:
        break;
    case KD_IOCTL_QUERY_CBP:
        ((PKD_BPINFO)lpBuf)->ulCount = 0;
        return TRUE;
    case KD_IOCTL_SET_DBP:
        if (((PKD_BPINFO)lpBuf)->ulHandle = SetDataBP( ((PKD_BPINFO)lpBuf)->ulAddress))
            return TRUE;
        break;
    case KD_IOCTL_CLEAR_DBP:
        if (((PKD_BPINFO)lpBuf)->ulHandle == 1) {
            CLEARDR3();
            return TRUE;
        } 
        if (((PKD_BPINFO)lpBuf)->ulHandle == 2) {
            CLEARDR2();
            return TRUE;
        } 
        if (((PKD_BPINFO)lpBuf)->ulHandle == 3) {
            CLEARDR1();
            return TRUE;
        } 
        if (((PKD_BPINFO)lpBuf)->ulHandle == 4) {
            CLEARDR0();
            return TRUE;
        } 
        break;
    case KD_IOCTL_QUERY_DBP:
        ((PKD_BPINFO)lpBuf)->ulCount = 4;
        return TRUE;
    case KD_IOCTL_ENUM_DBP:
    case KD_IOCTL_MAP_EXCEPTION:
        if (((PKD_EXCEPTION_INFO)lpBuf)->ulExceptionCode == 0) {
            ((PKD_EXCEPTION_INFO)lpBuf)->ulExceptionCode = STATUS_BREAKPOINT;
            return TRUE;
        }
        break;      
    case KD_IOCTL_RESET:
    default:
        break;
    }
    return FALSE;
}

//+++