Exemplo n.º 1
0
HRESULT
CMyDevice::Initialize(
    __in IWDFDriver           * FxDriver,
    __in IWDFDeviceInitialize * FxDeviceInit
    )
/*++
 
  Routine Description:

    This method initializes the device callback object and creates the
    partner device object.

    The method should perform any device-specific configuration that:
        *  could fail (these can't be done in the constructor)
        *  must be done before the partner object is created -or-
        *  can be done after the partner object is created and which aren't 
           influenced by any device-level parameters the parent (the driver
           in this case) might set.

  Arguments:

    FxDeviceInit - the settings for this device.

  Return Value:

    status.

--*/
{
    IWDFDevice *fxDevice = NULL;

    HRESULT hr = S_OK;

    
    //
    // TODO: If you're writing a filter driver then indicate that here. 
    //
    // FxDeviceInit->SetFilter();
    //

    //
    // Set no locking unless you need an automatic callbacks synchronization
    //

    FxDeviceInit->SetLockingConstraint(None);

    //
    // Only one driver in the stack can be the Power policy owner (PPO).
    //
    // NOTE: If we want UMDF to be the PPO we also ask WinUsb.sys 
    // to not set itself as the PPO by setting the
    // WinUsbPowerPolicyOwnershipDisabled key through 
    // an AddReg in the INF.
    //     
#if defined(_NOT_POWER_POLICY_OWNER_)
    FxDeviceInit->SetPowerPolicyOwnership(FALSE);        
#else
    FxDeviceInit->SetPowerPolicyOwnership(TRUE);        
#endif
    
    //
    // TODO: Any per-device initialization which must be done before 
    //       creating the partner object.
    //

    //
    // Create a new FX device object and assign the new callback object to 
    // handle any device level events that occur.
    //

    //
    // QueryIUnknown references the IUnknown interface that it returns
    // (which is the same as referencing the device).  We pass that to 
    // CreateDevice, which takes its own reference if everything works.
    //

    if (SUCCEEDED(hr)) 
    {
        IUnknown *unknown = this->QueryIUnknown();

        hr = FxDriver->CreateDevice(FxDeviceInit, unknown, &fxDevice);

        unknown->Release();
    }

    //
    // If that succeeded then set our FxDevice member variable.
    //

    if (SUCCEEDED(hr)) 
    {
        //
        // Drop the reference we got from CreateDevice.  Since this object
        // is partnered with the framework object they have the same 
        // lifespan - there is no need for an additional reference.
        //
        
        fxDevice->Release();

        IWDFDevice2 *fxDevice2 = NULL;
        
        HRESULT hrQI = fxDevice->QueryInterface(__uuidof(IWDFDevice2), (void**) &fxDevice2);  
        
        WUDF_TEST_DRIVER_ASSERT(SUCCEEDED(hrQI) && fxDevice2);

        m_FxDevice = fxDevice2;
        
        //
        // Drop the reference we got from QueryInterface(). Since this object
        // is partnered with the framework object they have the same 
        // lifespan - there is no need for an additional reference.
        //
        
        fxDevice2->Release();        
    }

    return hr;
}
Exemplo n.º 2
0
HRESULT 
CDriver::OnDeviceAdd(
     __in IWDFDriver* pDriver,
     __in IWDFDeviceInitialize* pDeviceInit
    )
/*++

Routine Description:

    The framework calls this function when a device is being added to
    the driver stack.

Arguments:

    IWDFDriver           - Framework interface.  The driver uses this
                           interface to create device objects.
    IWDFDeviceInitialize - Framework interface.  The driver uses this
                           interface to set device parameters before
                           creating the device obeject.

Return Value:

   HRESULT S_OK - Device added successfully

--*/
{
    IUnknown    *pDeviceCallback  = NULL;
    IWDFDevice  *pIWDFDevice      = NULL;
    IWDFDevice2 *pIWDFDevice2     = NULL;
    IUnknown    *pIUnkQueue       = NULL;    
	
    //
    // UMDF Toaster is a function driver so set is as the power policy owner (PPO)
    //
       pDeviceInit->SetPowerPolicyOwnership(TRUE);     

    //
    // Create our device callback object.
    //
    HRESULT hr = CDevice::CreateInstance(&pDeviceCallback);
    
    //
    // Ask the framework to create a device object for us.
    // We pass in the callback object and device init object
    // as creation parameters.
    //
    if (SUCCEEDED(hr)) 
    {
        hr = pDriver->CreateDevice(pDeviceInit, 
                                   pDeviceCallback,
                                   &pIWDFDevice);
    }

    //
    // Create the queue callback object.
    //

    if (SUCCEEDED(hr)) 
    {
        hr = CQueue::CreateInstance(&pIUnkQueue);
    }

    //
    // Configure the default queue.  We pass in our queue callback
    // object to inform the framework about the callbacks we want.
    //

    if (SUCCEEDED(hr)) 
    {
        IWDFIoQueue * pDefaultQueue = NULL;
        hr = pIWDFDevice->CreateIoQueue(
                          pIUnkQueue,
                          TRUE,                        // bDefaultQueue
                          WdfIoQueueDispatchParallel,
                          TRUE,                        // bPowerManaged
                          FALSE,                       // bAllowZeroLengthRequests
                          &pDefaultQueue);
        SAFE_RELEASE(pDefaultQueue);
    }

    //
    // Enable the device interface.
    //

    if (SUCCEEDED(hr)) 
    {
        hr = pIWDFDevice->CreateDeviceInterface(&GUID_DEVINTERFACE_TOASTER,
                                                NULL);
    }
             
    //
    // IWDFDevice2 interface is an extension of IWDFDevice interface that enables
    // Idle and Wake support. 
    // 

    //
    // Get a pointer to IWDFDevice2 interface
    //
    
    if (SUCCEEDED(hr)) 
    {
        hr = pIWDFDevice->QueryInterface(__uuidof(IWDFDevice2), (void**) &pIWDFDevice2);  
    }	 

    //
    // Since this is a virtual device we tell the framework that we cannot wake 
    // ourself if we sleep in S0. Only way the device can be brought to D0 is if 
    // the device recieves an I/O from the system.
    //

    if (SUCCEEDED(hr)) 
    {
     
       hr = pIWDFDevice2->AssignS0IdleSettings(
                            IdleCannotWakeFromS0,   
                            PowerDeviceD3,          //the lowest-powered device sleeping state
                            IDLEWAKE_TIMEOUT_MSEC,  //idle timeout
                            IdleAllowUserControl,   //user can control the device's idle behavior. 
                            WdfTrue);       
      
    }

    //
    // TODO: Add the Idle and Wake suupport specific for your hardware
    //

    SAFE_RELEASE(pDeviceCallback);
    SAFE_RELEASE(pIWDFDevice);
    SAFE_RELEASE(pIWDFDevice2);
    SAFE_RELEASE(pIUnkQueue);    

    return hr;
}