private bool SetDevice(DeviceControlFlags deviceControlFlag, ushort vendorid, ushort productid)
        {
            Guid myGuid         = Guid.Empty;
            var  deviceInfoData = new UsbApi.SpDevinfoData1
            {
                CbSize    = 28,
                DevInst   = 0,
                ClassGuid = Guid.Empty,
                Reserved  = 0
            };
            UInt32        i          = 0;
            StringBuilder deviceName = new StringBuilder()
            {
                Capacity = UsbApi.MaxBufferSize
            };

            //The SetupDiGetClassDevs function returns a handle to a device information set that contains requested device information elements for a local machine.
            IntPtr theDevInfo = UsbApi.SetupDiGetClassDevs(ref myGuid, 0, 0, UsbApi.DigcfAllclasses | UsbApi.DigcfPresent | UsbApi.DigcfProfile);

            for (; UsbApi.SetupDiEnumDeviceInfo(theDevInfo, i, deviceInfoData);)
            {
                if (UsbApi.SetupDiGetDeviceRegistryProperty(theDevInfo, deviceInfoData, (uint)UsbApi.Spdrp.SpdrpHardwareid, 0, deviceName, UsbApi.MaxBufferSize, IntPtr.Zero))
                {
                    if (deviceName.ToString().Contains(@"USB\Vid_") && deviceName.ToString().Contains(vendorid.ToString("x")))
                    {
                        StateChange(
                            deviceControlFlag == DeviceControlFlags.Disable ? UsbApi.DicsDisable : UsbApi.DicsEnable,
                            (int)i, theDevInfo);

                        UsbApi.SetupDiDestroyDeviceInfoList(theDevInfo);
                        break;
                    }
                }
                i++;
            }

            return(true);
        }
        private void Initalise(uint index)
        {
            IntPtr ptr = IntPtr.Zero;
            IntPtr deviceInfoHandle = IntPtr.Zero;

            try
            {
                ptr = Marshal.AllocHGlobal(UsbApi.MaxBufferSize);
                deviceInfoHandle = UsbApi.SetupDiGetClassDevs(ref _guid, 0, IntPtr.Zero,
                                                              UsbApi.DigcfPresent | UsbApi.DigcfDeviceinterface);

                // Create a device interface data structure
                UsbApi.SpDeviceInterfaceData deviceInterfaceData = new UsbApi.SpDeviceInterfaceData();
                deviceInterfaceData.CbSize = Marshal.SizeOf(deviceInterfaceData);

                // Start the enumeration.
                Boolean success =
                    UsbApi.SetupDiEnumDeviceInterfaces(deviceInfoHandle, IntPtr.Zero, ref _guid, (int)index,
                                                       ref deviceInterfaceData);
                if (success)
                {
                    // Build a DevInfo data structure.
                    UsbApi.SpDevinfoData deviceInfoData = new UsbApi.SpDevinfoData();
                    deviceInfoData.CbSize = Marshal.SizeOf(deviceInfoData);

                    // Build a device interface detail data structure.
                    UsbApi.SpDeviceInterfaceDetailData deviceInterfaceDetailData =
                        new UsbApi.SpDeviceInterfaceDetailData
                    {
                        CbSize = UIntPtr.Size == 8 ? 8 : (int)(4 + (uint)Marshal.SystemDefaultCharSize)
                    };

                    // Now we can get some more detailed informations.
                    int nRequiredSize = 0;
                    int nBytes        = UsbApi.MaxBufferSize;

                    if (UsbApi.SetupDiGetDeviceInterfaceDetail(deviceInfoHandle, ref deviceInterfaceData,
                                                               ref deviceInterfaceDetailData, nBytes, ref nRequiredSize, ref deviceInfoData))
                    {
                        DevicePath = deviceInterfaceDetailData.DevicePath;

                        ParseDevicePath(DevicePath);

                        // Get the device description and driver key name.
                        int requiredSize = 0;
                        int regType      = UsbApi.RegSz;

                        if (UsbApi.SetupDiGetDeviceRegistryProperty(deviceInfoHandle, ref deviceInfoData,
                                                                    (int)UsbApi.Spdrp.SpdrpDevicedesc,
                                                                    ref regType,
                                                                    ptr,
                                                                    UsbApi.MaxBufferSize, ref requiredSize))
                        {
                            DeviceDescription = Marshal.PtrToStringAuto(ptr);
                        }

                        if (UsbApi.SetupDiGetDeviceRegistryProperty(
                                deviceInfoHandle,
                                ref deviceInfoData,
                                (int)UsbApi.Spdrp.SpdrpDriver,
                                ref regType,
                                ptr,
                                UsbApi.MaxBufferSize,
                                ref requiredSize))
                        {
                            DriverKey = Marshal.PtrToStringAuto(ptr);
                        }
                    }

                    IntPtr hostControllerHandle = IntPtr.Zero;

                    try
                    {
                        hostControllerHandle = KernelApi.CreateFile(deviceInterfaceDetailData.DevicePath,
                                                                    UsbApi.GenericWrite,
                                                                    UsbApi.FileShareWrite, IntPtr.Zero,
                                                                    UsbApi.OpenExisting, 0, IntPtr.Zero);

                        if (deviceInfoHandle.ToInt64() != UsbApi.InvalidHandleValue)
                        {
                            GetHostControllerPowerMap(hostControllerHandle);

                            GetHostControllerInfo(hostControllerHandle);
                        }
                    }
                    finally
                    {
                        if (hostControllerHandle != IntPtr.Zero ||
                            deviceInfoHandle.ToInt64() != UsbApi.InvalidHandleValue)
                        {
                            KernelApi.CloseHandle(hostControllerHandle);
                        }
                    }

                    try
                    {
                        Devices.Add(new UsbHub(null, DevicePath));
                    }
                    catch (Exception ex)
                    {
                        CoreTraceSource.Source.TraceEvent(TraceEventType.Error, CoreTraceSource.UsbControllerSourceId,
                                                          "Unhandled exception occurred: {0}", ex);

                        throw new UsbControllerException("Unhandled exception occurred", ex);
                    }
                }
                else
                {
                    throw new UsbControllerException("No usb controller found!");
                }
            }
            finally
            {
                if (ptr != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(ptr);
                }

                if (deviceInfoHandle != IntPtr.Zero)
                {
                    UsbApi.SetupDiDestroyDeviceInfoList(deviceInfoHandle);
                }
            }
        }
        private void GetComPort()
        {
            IntPtr regValue = IntPtr.Zero;
            IntPtr regKey   = IntPtr.Zero;
            IntPtr handle   = IntPtr.Zero;
            IntPtr ptr      = IntPtr.Zero;

            try
            {
                handle =
                    UsbApi.SetupDiGetClassDevs(0, UsbApi.RegstrKeyUsb, IntPtr.Zero, UsbApi.DigcfPresent | UsbApi.DigcfAllclasses);

                if (handle.ToInt64() != UsbApi.InvalidHandleValue)
                {
                    ptr = Marshal.AllocHGlobal(UsbApi.MaxBufferSize);
                    var success = true;

                    for (var i = 0; success; i++)
                    {
                        var deviceInfoData = new UsbApi.SpDevinfoData();
                        deviceInfoData.CbSize = Marshal.SizeOf(deviceInfoData);

                        success = UsbApi.SetupDiEnumDeviceInfo(handle, i, ref deviceInfoData);

                        if (success)
                        {
                            var requiredSize = -1;
                            var regType      = UsbApi.RegSz;
                            var driverKey    = string.Empty;

                            if (UsbApi.SetupDiGetDeviceRegistryProperty(handle, ref deviceInfoData,
                                                                        (int)UsbApi.Spdrp.SpdrpDriver,
                                                                        ref regType, ptr, UsbApi.MaxBufferSize, ref requiredSize))
                            {
                                driverKey = Marshal.PtrToStringAuto(ptr);
                            }

                            if (DriverKey == driverKey)
                            {
                                regKey = UsbApi.SetupDiOpenDevRegKey(handle, ref deviceInfoData, UsbApi.DicsFlag.Global, 0, UsbApi.DiReg.Dev, (uint)WinNtApi.KeyRead);

                                int size = 0;
                                Advapi32.RegValueKind kind = Advapi32.RegValueKind.None;

                                // Get the size of buffer we will need
                                uint retVal = Advapi32.RegQueryValueEx(regKey, "PortName", 0, ref kind, IntPtr.Zero, ref size);
                                if (size == 0)
                                {
                                    break;
                                }

                                regValue = Marshal.AllocHGlobal(size);

                                if (Advapi32.RegQueryValueEx(regKey, "PortName", 0, ref kind, regValue, ref size) == 0)
                                {
                                    if (kind == Advapi32.RegValueKind.Sz)
                                    {
                                        _comPort = Marshal.PtrToStringAnsi(regValue);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            finally
            {
                if (regValue != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(regValue);
                }

                if (regKey != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(regKey);
                }

                if (handle != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(ptr);
                }

                if (handle != IntPtr.Zero)
                {
                    UsbApi.SetupDiDestroyDeviceInfoList(handle);
                }
            }
        }