diff options
Diffstat (limited to 'serial/VirtualSerial/device.cpp')
| -rw-r--r-- | serial/VirtualSerial/device.cpp | 674 |
1 files changed, 674 insertions, 0 deletions
diff --git a/serial/VirtualSerial/device.cpp b/serial/VirtualSerial/device.cpp new file mode 100644 index 00000000..11d47775 --- /dev/null +++ b/serial/VirtualSerial/device.cpp @@ -0,0 +1,674 @@ +/*++ + +Copyright (C) Microsoft Corporation, All Rights Reserved. + +Module Name: + + Device.cpp + +Abstract: + + This module contains the implementation of the UMDF VirtualSerial sample + driver's device callback object. + + The VirtualSerial sample device does very little. It does not implement + either of the PNP interfaces so once the device is setup, it won't ever get + any callbacks until the device is removed. + +Environment: + + Windows User-Mode Driver Framework (WUDF) + +--*/ + +#include "internal.h" +#include "device.tmh" + +HRESULT +CMyDevice::CreateInstance( + _In_ IWDFDriver *FxDriver, + _In_ IWDFDeviceInitialize * FxDeviceInit, + _Out_ PCMyDevice *Device + ) +/*++ + + Routine Description: + + This method creates and initializs an instance of the VirtualSerial driver's + device callback object. + + Arguments: + + FxDeviceInit - the settings for the device. + + Device - a location to store the referenced pointer to the device object. + + Return Value: + + Status + +--*/ +{ + PCMyDevice device; + HRESULT hr; + + // + // Allocate a new instance of the device class. + // + + device = new CMyDevice(); + + if (NULL == device) + { + return E_OUTOFMEMORY; + } + + // + // Initialize the instance. + // + + hr = device->Initialize(FxDriver, FxDeviceInit); + + if (SUCCEEDED(hr)) + { + *Device = device; + } + else + { + device->Release(); + } + + return hr; +} + +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; + HRESULT hr; + + // + // Configure things like the locking model before we go to create our + // partner device. + // + FxDeviceInit->SetLockingConstraint(WdfDeviceLevel); + + // + // 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. + // + + { + IUnknown *unknown = this->QueryIUnknown(); + + hr = FxDriver->CreateDevice(FxDeviceInit, unknown, &fxDevice); + + unknown->Release(); + } + + // + // If that succeeded then set our FxDevice member variable. + // + + if (SUCCEEDED(hr)) + { + m_FxDevice = fxDevice; + + // + // 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(); + } + + return hr; +} + +HRESULT +CMyDevice::Configure( + VOID + ) +/*++ + + Routine Description: + + This method is called after the device callback object has been initialized + and returned to the driver. It would setup the device's queues and their + corresponding callback objects. + + Arguments: + + FxDevice - the framework device object for which we're handling events. + + Return Value: + + status + +--*/ +{ + IWDFPropertyStoreFactory *pPropertyStoreFactory = NULL; + IWDFNamedPropertyStore2 * pHardwarePropertyStore = NULL; + IWDFNamedPropertyStore2 * pLegacyHardwarePropertyStore = NULL; + WDF_PROPERTY_STORE_ROOT RootSpecifier; + PROPVARIANT comPortPV; + WCHAR portName[] = L"PortName"; + size_t comPortSuffixCch = 0; + WCHAR *comPortFullName = NULL; + size_t comPortFullNameCch = 0; + WCHAR *pdoName = NULL; + PCMyQueue defaultQueue; + +#ifdef _FAKE_MODEM + // + // Compiled as fake modem + // + LPGUID pGuid = (LPGUID) &GUID_DEVINTERFACE_MODEM; +#else + // + // Compiled as virtual serial port + // + LPGUID pGuid = (LPGUID) &GUID_DEVINTERFACE_COMPORT; +#endif + + HRESULT hr; + + PropVariantInit(&comPortPV); + + // + // Create device interface + // + hr = m_FxDevice->CreateDeviceInterface(pGuid, + NULL); + + if (FAILED(hr)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Cannot create device interface (%!GUID!)", + pGuid + ); + + goto Exit; + } + + hr = m_FxDevice->AssignDeviceInterfaceState(pGuid, + NULL, + TRUE); + + if (FAILED(hr)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Cannot enable device interface (%!GUID!)", + pGuid + ); + + goto Exit; + } + + // + // Create Symbolic Link + // + + // + // First we need to read the COM number from the registry + // + + hr = m_FxDevice->QueryInterface(IID_PPV_ARGS(&pPropertyStoreFactory)); + + if (FAILED(hr)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: QI for IWDFPropertyStoreFactory failed" + ); + + goto Exit; + } + + RootSpecifier.LengthCb = sizeof(WDF_PROPERTY_STORE_ROOT); + RootSpecifier.RootClass = WdfPropertyStoreRootClassHardwareKey; + RootSpecifier.Qualifier.HardwareKey.ServiceName = + WDF_PROPERTY_STORE_HARDWARE_KEY_ROOT; + + hr = pPropertyStoreFactory->RetrieveDevicePropertyStore( + &RootSpecifier, + WdfPropertyStoreNormal, + KEY_QUERY_VALUE, + NULL, + &pHardwarePropertyStore, + NULL + ); + + if (FAILED(hr)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Failed to retrieve device hardware key root" + ); + goto Exit; + } + + hr = pHardwarePropertyStore->GetNamedValue(portName, &comPortPV); + + if (FAILED(hr)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Failed to read value %ws", + portName + ); + goto Exit; + } + + // + // Then we need to construct the COM port name + // + hr = StringCchLength(comPortPV.pwszVal, + STRSAFE_MAX_CCH, + &comPortSuffixCch); + + if (FAILED(hr)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Overflow while calculating COM port suffix length" + ); + goto Exit; + } + + hr = SizeTAdd(ARRAYSIZE(SYMBOLIC_LINK_NAME_PREFIX), + comPortSuffixCch, + &comPortFullNameCch); + + if (FAILED(hr)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Overflow while calculating symbolic link length" + ); + goto Exit; + } + + comPortFullName = (WCHAR*) new WCHAR[comPortFullNameCch]; + + if (NULL == comPortFullName) + { + hr = E_OUTOFMEMORY; + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Unable to allocate memory for full port name" + ); + goto Exit; + } + + hr = StringCchPrintf(comPortFullName, + comPortFullNameCch, + L"%ws%ws", + SYMBOLIC_LINK_NAME_PREFIX, + comPortPV.pwszVal); + + if (FAILED(hr)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Cannot create full name for COM port" + ); + goto Exit; + } + + // + // Finally we create the symbolic link + // + hr = m_FxDevice->CreateSymbolicLink(comPortFullName); + + if (FAILED(hr)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Cannot create symbolic link %ws", + comPortFullName + ); + goto Exit; + } + + // + // Write the com name to the legacy hardware key + // + hr = GetPdoName(&pdoName); + + if (FAILED(hr) || (pdoName == NULL)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Cannot retrieve PDO name" + ); + goto Exit; + } + + // + // Write the name to the legacy hardware key + // + RootSpecifier.LengthCb = sizeof(WDF_PROPERTY_STORE_ROOT); + RootSpecifier.RootClass = WdfPropertyStoreRootClassLegacyHardwareKey; + RootSpecifier.Qualifier.LegacyHardwareKey.LegacyMapName = L"SERIALCOMM"; + + hr = pPropertyStoreFactory->RetrieveDevicePropertyStore( + &RootSpecifier, + WdfPropertyStoreCreateVolatile, + KEY_SET_VALUE, + NULL, + &pLegacyHardwarePropertyStore, + NULL + ); + + if (FAILED(hr)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Failed to retrieve device legacy hardware key" + ); + goto Exit; + } + + hr = pLegacyHardwarePropertyStore->SetNamedValue(pdoName, + &comPortPV); + + if (FAILED(hr)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Failed to write device name to legacy hardware key" + ); + goto Exit; + } + + m_CreatedLegacyHardwareKey = TRUE; + m_LegacyHardwarePropertyStore = pLegacyHardwarePropertyStore; + m_PdoName = pdoName; + + // + // Create and configure the queues + // + hr = CMyQueue::CreateInstance(this, m_FxDevice, &defaultQueue); + + if (FAILED(hr)) + { + Trace( + TRACE_LEVEL_ERROR, + L"ERROR: Failed to create default queue" + ); + goto Exit; + } + + defaultQueue->Release(); + + +Exit: + + if (m_CreatedLegacyHardwareKey == FALSE) + { + // + // If the legacy hardware key has been written, then the cleanup + // will happen, when the device is unloaded + // + SAFE_RELEASE(pLegacyHardwarePropertyStore); + if (pdoName != NULL) + { + delete[] pdoName; + } + } + + SAFE_RELEASE(pHardwarePropertyStore); + SAFE_RELEASE(pPropertyStoreFactory); + + PropVariantClear(&comPortPV); + + if (comPortFullName != NULL) + { + delete[] comPortFullName; + } + + return hr; +} + +HRESULT +CMyDevice::QueryInterface( + _In_ REFIID InterfaceId, + _Out_ PVOID *Object + ) +/*++ + + Routine Description: + + This method is called to get a pointer to one of the object's callback + interfaces. + + Arguments: + + InterfaceId - the interface being requested + + Object - a location to store the interface pointer if successful + + Return Value: + + S_OK or E_NOINTERFACE + +--*/ +{ + HRESULT hr; + + if(IsEqualIID(InterfaceId, __uuidof(IObjectCleanup))) + { + *Object = QueryIObjectCleanup(); + hr = S_OK; + } + else + { + hr = CUnknown::QueryInterface(InterfaceId, Object); + } + + return hr; +} + +VOID +CMyDevice::OnCleanup( + IWDFObject* pWdfObject +) +{ + UNREFERENCED_PARAMETER(pWdfObject); + + if ((m_CreatedLegacyHardwareKey == TRUE) && + (m_LegacyHardwarePropertyStore != NULL)) + { + m_LegacyHardwarePropertyStore->DeleteNamedValue(m_PdoName); + SAFE_RELEASE(m_LegacyHardwarePropertyStore); + delete[] m_PdoName; + } +} + +HRESULT +CMyDevice::GetPdoName( + _Out_ LPWSTR *PdoName + ) +{ + HRESULT hr = S_OK; + WCHAR *devInstId = NULL; + ULONG devInstIdLen; + HDEVINFO hDevInfoSet = INVALID_HANDLE_VALUE; + SP_DEVINFO_DATA devInfoData; + WCHAR *pdoName = NULL; + DWORD pdoNameCb = 0; + + WUDF_TEST_DRIVER_ASSERT(m_FxDevice); + + // + // First let's get the device instance ID + // + devInstIdLen = 0; + hr = m_FxDevice->RetrieveDeviceInstanceId(NULL, &devInstIdLen); + if (SUCCEEDED(hr)) + { + devInstId = (WCHAR*) new WCHAR[devInstIdLen]; + if (NULL == devInstId) + { + hr = E_OUTOFMEMORY; + } + } + if (SUCCEEDED(hr)) + { + hr = m_FxDevice->RetrieveDeviceInstanceId(devInstId, &devInstIdLen); + } + + // + // Now use the SetupDiXxx functions to get a handle to the device's + // hardware key + // + if (SUCCEEDED(hr)) + { + // + // Create a new device information set + // + hDevInfoSet = SetupDiCreateDeviceInfoList(NULL, NULL); + if (INVALID_HANDLE_VALUE == hDevInfoSet) + { + hr = HRESULT_FROM_WIN32(GetLastError()); + } + } + + if (SUCCEEDED(hr)) + { + // + // Add our device to this device information set + // + ZeroMemory(&devInfoData, sizeof(devInfoData)); + devInfoData.cbSize = sizeof(devInfoData); + if (!SetupDiOpenDeviceInfo(hDevInfoSet, + devInstId, + NULL, + 0, + &devInfoData)) + { + hr = HRESULT_FROM_WIN32(GetLastError()); + } + } + + if (SUCCEEDED(hr)) + { + // + // Get the length of the PDO name + // + if (!SetupDiGetDeviceRegistryProperty(hDevInfoSet, + &devInfoData, + SPDRP_PHYSICAL_DEVICE_OBJECT_NAME, + NULL, + (PBYTE)pdoName, + 0, + &pdoNameCb)) + { + // + // The only reason for this call is to get the length of the + // buffer. The only non acceptable reason for failure is, if we + // asked for invalid data. + // + if (GetLastError() == ERROR_INVALID_DATA) + { + hr = HRESULT_FROM_WIN32(GetLastError()); + } + } + } + + // + // Get the PDO name + // + if (SUCCEEDED(hr)) + { + pdoName = (WCHAR *)new BYTE[pdoNameCb]; + + if (pdoName == NULL) + { + hr = E_OUTOFMEMORY; + } + } + + if (SUCCEEDED(hr)) + { + if (!SetupDiGetDeviceRegistryProperty(hDevInfoSet, + &devInfoData, + SPDRP_PHYSICAL_DEVICE_OBJECT_NAME, + NULL, + (PBYTE)pdoName, + pdoNameCb, + NULL)) + { + hr = HRESULT_FROM_WIN32(GetLastError()); + } + + } + + if (SUCCEEDED(hr)) + { + *PdoName = pdoName; + } + + // + // clean up to be done regardless of success or failure + // + if (NULL != devInstId) + { + delete[] devInstId; + } + + if (INVALID_HANDLE_VALUE != hDevInfoSet) + { + SetupDiDestroyDeviceInfoList(hDevInfoSet); + } + + // + // clean up to be done in case of failure only + // + if (FAILED(hr)) + { + if (NULL != pdoName) + { + delete[] pdoName; + pdoName = NULL; + } + } + + return hr; +} |