wake.c

ir 驱动程序源代码,make成功了,有兴趣的朋友可以看看

    mbc.MasterReset = TRUE;
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_MASTER_BLOCK_CONTROL,
                         mbc.AsUChar);

    //
    // Clear the reset
    //
    mbc.AsUChar = 0;
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_MASTER_BLOCK_CONTROL,
                         mbc.AsUChar);


    //
    // Setup the standard stuff.
    //
    mbc.AsUChar = 0;
    mbc.RegisterBlockSelect = 2;
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_MASTER_BLOCK_CONTROL,
                         mbc.AsUChar);

    irCtrl.AsUChar     = 0;
    irCtrl.CarrierOff  = TRUE;
    irCtrl.ReceiveSync = TRUE;
    irCtrl.PMEWake     = TRUE;
    irCtrl.Frame       = TRUE;
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_CONSUMER_IR_CTRL,
                         irCtrl.AsUChar);

    //
    // Display the settings that we're going to arm with
    //
    DisplayArmingSettings(deviceData);


    //
    // And now setup the protocol specific registers
    //
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_CONSUMER_IR_CARRIER,
                         deviceData->ArmForWakeData.CarrierDivider);

    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_CONSUMER_IR_BIT_RATE,
                         deviceData->ArmForWakeData.BitRateDivider);

    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_CUSTOM_CODE,
                         deviceData->ArmForWakeData.CustomCode);

    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_CUSTOM_CODE_PRIME,
                         deviceData->ArmForWakeData.CustomCodePrime);

    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_DATA_CODE,
                         deviceData->ArmForWakeData.DataCode);

    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_CONSUMER_PROTOCOL_SELECT,
                         deviceData->ArmForWakeData.ProtocolSelect);

    mbc.AsUChar = 0;
    mbc.RegisterBlockSelect = 6;
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_MASTER_BLOCK_CONTROL,
                         mbc.AsUChar);

    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_HEADER_VALUE_AND_MASK,
                         deviceData->ArmForWakeData.HeaderValueAndMask); 
    
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_DATA_VALUE_1,
                         deviceData->ArmForWakeData.DataValue1);
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_DATA_MASK_1,
                         deviceData->ArmForWakeData.DataMask1);


    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_DATA_VALUE_2,
                         deviceData->ArmForWakeData.DataValue2);
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_DATA_MASK_2,
                         deviceData->ArmForWakeData.DataMask2);


    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_DATA_VALUE_3,
                         deviceData->ArmForWakeData.DataValue3);
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_DATA_MASK_3,
                         deviceData->ArmForWakeData.DataMask3);

    mbc.AsUChar = 0;
    mbc.RegisterBlockSelect = 7;
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_MASTER_BLOCK_CONTROL,
                         mbc.AsUChar);

    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_DATA_VALUE_4,
                         deviceData->ArmForWakeData.DataValue4);
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_DATA_MASK_4,
                         deviceData->ArmForWakeData.DataMask4);

    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_DATA_VALUE_5,
                         deviceData->ArmForWakeData.DataValue5);
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_DATA_MASK_5,
                         deviceData->ArmForWakeData.DataMask5);

    mbc.AsUChar = 0;
    mbc.RegisterBlockSelect = 0;
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_MASTER_BLOCK_CONTROL,
                         mbc.AsUChar);

    //
    // Enable the device for receive and get out!
    //
    lcb.AsUChar = 0;
    lcb.SCEModeBits = SCE_MODE_RECEIVE;
    WRITE_HARDWARE_UCHAR(deviceData,
                         CIRCC2_LINE_CONTROL_B,
                         lcb.AsUChar);

    WdfInterruptReleaseLock(deviceData->Interrupt);



    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("SmscIrEvtDeviceWakeArm: Exit."));

    return STATUS_SUCCESS;

}

BOOLEAN
SmscIrDeviceWokeSystem(
    IN PSMSCIR_DATA DeviceData
    ) {

/*++

Routine Description:

   This routine should be called every time the device powers up.
   It will return TRUE if the remote control was used to wake
   the system, FALSE otherwise.

Arguments:

    DeviceData - Our per device context


Return Value:

    TRUE  - Device woke the system

    FALSE - Device did NOT wake the system

--*/

    MASTER_BLOCK_CONTROL mbc;
    BOOLEAN              remoteWokeSystem = FALSE;

    //
    // The "was wake" bit is in register block 3. Note
    //  that we're not racing against the ISR or the 
    //  code that enables interrupts on our device. This
    //  code is called before the InterrupEnable code.
    //
    mbc.AsUChar = 0;
    mbc.RegisterBlockSelect = 3;
    WRITE_HARDWARE_UCHAR(DeviceData,
                         CIRCC2_MASTER_BLOCK_CONTROL, 
                         mbc.AsUChar);

    remoteWokeSystem = READ_HARDWARE_UCHAR(DeviceData,
                                           CIRCC2_WAS_REMOTE_WAKE);
    
    //
    // Return to block 0.
    //
    mbc.AsUChar = 0;
    WRITE_HARDWARE_UCHAR(DeviceData,
                         CIRCC2_MASTER_BLOCK_CONTROL, 
                         mbc.AsUChar);
    return remoteWokeSystem;

}


VOID
DisplayArmingSettings(
    PSMSCIR_DATA DeviceData
    ) {
    
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("DisplayArmingSettings: Will arm the device with the following:"));

    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tCarrierDivider == 0x%x", 
            DeviceData->ArmForWakeData.CarrierDivider));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tBitRateDivider == 0x%x", 
            DeviceData->ArmForWakeData.BitRateDivider));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tCustomCode == 0x%x", 
            DeviceData->ArmForWakeData.CustomCode));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tCustomCodePrime == 0x%x", 
            DeviceData->ArmForWakeData.CustomCodePrime));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tDataCode == 0x%x", 
            DeviceData->ArmForWakeData.DataCode));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tProtocolSelect  == 0x%x", 
            DeviceData->ArmForWakeData.ProtocolSelect));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tHeaderValueAndMask == 0x%x", 
            DeviceData->ArmForWakeData.HeaderValueAndMask));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tDataValue1 == 0x%x", 
            DeviceData->ArmForWakeData.DataValue1));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tDataMask1 == 0x%x", 
            DeviceData->ArmForWakeData.DataMask1));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tDataValue2 == 0x%x", 
            DeviceData->ArmForWakeData.DataValue2));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tDataMask2 == 0x%x", 
            DeviceData->ArmForWakeData.DataMask2));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tDataValue3 == 0x%x", 
            DeviceData->ArmForWakeData.DataValue3));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tDataMask3 == 0x%x", 
            DeviceData->ArmForWakeData.DataMask3));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tDataValue4 == 0x%x", 
            DeviceData->ArmForWakeData.DataValue4));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tDataMask4 == 0x%x", 
            DeviceData->ArmForWakeData.DataMask4));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tDataValue5 == 0x%x", 
            DeviceData->ArmForWakeData.DataValue5));
    SmscIrTracePrint(
        TRACE_LEVEL_VERBOSE,
        SMSCDBG_WAKE_INFO,
        ("\tDataMask5 == 0x%x", 
            DeviceData->ArmForWakeData.DataMask5));

    return;

}