/// <summary>
/// Opens a WinUsb directly from the user supplied device path.
/// </summary>
/// <param name="devicePath">Device path (symbolic link) of the WinUsb device to open.</param>
/// <param name="usbDevice">Returns an opened WinUsb device on success, null on failure.</param>
/// <returns>True on success.</returns>
public static bool Open(string devicePath, out WinUsbDevice usbDevice)
{
usbDevice = null;
SafeFileHandle sfhDev;
bool bSuccess = WinUsbAPI.OpenDevice(out sfhDev, devicePath);
if (bSuccess)
{
SafeWinUsbInterfaceHandle handle = new SafeWinUsbInterfaceHandle();
bSuccess = WinUsbAPI.WinUsb_Initialize(sfhDev, ref handle);
if (bSuccess)
{
usbDevice = new WinUsbDevice(WinUsbApi, sfhDev, handle, devicePath);
}
else
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "Open:Initialize", typeof(UsbDevice));
}
}
else
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "Open", typeof(UsbDevice));
}
return(bSuccess);
}
///<summary>
/// Opens the USB device handle.
///</summary>
///<returns>
///True if the device is already opened or was opened successfully.
///False if the device does not exists or is no longer valid.
///</returns>
public override bool Open()
{
if (IsOpen)
{
return(true);
}
SafeFileHandle sfhDev;
bool bSuccess = WinUsbAPI.OpenDevice(out sfhDev, mDevicePath);
if (bSuccess)
{
SafeWinUsbInterfaceHandle handle = new SafeWinUsbInterfaceHandle();
if ((bSuccess = WinUsbAPI.WinUsb_Initialize(sfhDev, ref handle)))
{
mSafeDevHandle = sfhDev;
mUsbHandle = handle;
mPowerPolicies = new PowerPolicies(this);
}
else
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "Open:Initialize", typeof(UsbDevice));
}
}
else
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "Open", typeof(UsbDevice));
}
return(bSuccess);
}
internal bool SetPowerPolicy(PowerPolicyType policyType, int valueLength, IntPtr pBuffer)
{
bool bSuccess = WinUsbAPI.WinUsb_SetPowerPolicy(mUsbHandle, policyType, valueLength, pBuffer);
if (!bSuccess)
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "SetPowerPolicy", this);
}
return(bSuccess);
}
internal bool GetPipePolicy(PipePolicyType policyType, ref int valueLength, IntPtr pBuffer)
{
bool bSuccess = WinUsbAPI.WinUsb_GetPipePolicy(mUsbHandle, mEpNum, policyType, ref valueLength, pBuffer);
if (!bSuccess)
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "GetPipePolicy", this);
}
return(bSuccess);
}
///<summary>
///Executes the code required to free the <see cref="SafeWinUsbInterfaceHandle"/>.
///</summary>
///
///<returns>
///true if the <see cref="SafeWinUsbInterfaceHandle"/> is released successfully; otherwise, in the event of a catastrophic failure, false. In this case, it generates a ReleaseHandleFailed Managed Debugging Assistant.
///</returns>
///
protected override bool ReleaseHandle()
{
bool bSuccess = true;
if (!IsInvalid)
{
bSuccess = WinUsbAPI.WinUsb_Free(handle);
handle = IntPtr.Zero;
}
return(bSuccess);
}
/// <summary>
/// Gets a <see cref="IUsbInterfaceDescriptor"/> for the specified AlternateInterfaceNumber,
/// </summary>
/// <param name="alternateInterfaceNumber">The alternate interface index for the <see cref="IUsbInterfaceDescriptor"/> to retrieve. </param>
/// <param name="usbAltInterfaceDescriptor">The <see cref="IUsbInterfaceDescriptor"/> for the specified AlternateInterfaceNumber.</param>
/// <returns>True on success.</returns>
public bool QueryInterfaceSettings(byte alternateInterfaceNumber, ref IUsbInterfaceDescriptor usbAltInterfaceDescriptor)
{
bool bSuccess;
UsbInterfaceDescriptor usbInterfaceDescriptor = new UsbInterfaceDescriptor();
bSuccess = WinUsbAPI.WinUsb_QueryInterfaceSettings(Handle, alternateInterfaceNumber, usbInterfaceDescriptor);
if (!bSuccess)
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "QueryInterfaceSettings", this);
}
usbAltInterfaceDescriptor = usbInterfaceDescriptor;
return(bSuccess);
}
/// <summary>
/// sets the alternate interface number for the previously claimed interface. <see cref="IUsbDevice.ClaimInterface"/>
/// </summary>
/// <param name="alternateID">The alternate interface number.</param>
/// <returns>True on success.</returns>
public bool SetAltInterface(int alternateID)
{
bool bSuccess;
bSuccess = WinUsbAPI.WinUsb_SetCurrentAlternateSetting(mUsbHandle, (byte)alternateID);
if (!bSuccess)
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "SetCurrentAlternateSetting", this);
}
else
{
UsbAltInterfaceSettings[0] = (byte)alternateID;
}
return(bSuccess);
}
/// <summary>
/// Gets the device speed.
/// </summary>
/// <param name="deviceSpeed">The device speed.</param>
/// <returns>True on success.</returns>
public bool QueryDeviceSpeed(out DeviceSpeedTypes deviceSpeed)
{
deviceSpeed = DeviceSpeedTypes.Undefined;
byte[] buf = new byte[1];
int uTransferLength = 1;
bool bSuccess = WinUsbAPI.WinUsb_QueryDeviceInformation(mUsbHandle, DeviceInformationTypes.DeviceSpeed, ref uTransferLength, buf);
if (bSuccess)
{
deviceSpeed = (DeviceSpeedTypes)buf[0];
}
else
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "QueryDeviceInformation:QueryDeviceSpeed", this);
}
return(bSuccess);
}
/// <summary>
/// Gets an interface associated with this <see cref="WinUsbDevice"/>.
/// </summary>
/// <param name="associatedInterfaceIndex">The index to retrieve. (0 = next interface, 1= interface after next, etc.).</param>
/// <param name="usbDevice">A new <see cref="WinUsbDevice"/> class for the specified AssociatedInterfaceIndex.</param>
/// <returns>True on success.</returns>
public bool GetAssociatedInterface(byte associatedInterfaceIndex, out WinUsbDevice usbDevice)
{
usbDevice = null;
IntPtr pHandle = IntPtr.Zero;
bool bSuccess = WinUsbAPI.WinUsb_GetAssociatedInterface(mUsbHandle, associatedInterfaceIndex, ref pHandle);
if (bSuccess)
{
SafeWinUsbInterfaceHandle tempHandle = new SafeWinUsbInterfaceHandle(pHandle);
usbDevice = new WinUsbDevice(mUsbApi, null, tempHandle, mDevicePath);
}
if (!bSuccess)
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "GetAssociatedInterface", this);
}
return(bSuccess);
}
/// <summary>
/// Gets the alternate interface number for the previously claimed interface. <see cref="IUsbDevice.ClaimInterface"/>
/// </summary>
/// <param name="alternateID">The alternate interface number.</param>
/// <returns>True on success.</returns>
public bool GetAltInterface(out int alternateID)
{
bool bSuccess;
byte settingNumber;
alternateID = -1;
bSuccess = WinUsbAPI.WinUsb_GetCurrentAlternateSetting(mUsbHandle, out settingNumber);
if (!bSuccess)
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "GetCurrentAlternateSetting", this);
}
else
{
alternateID = settingNumber;
UsbAltInterfaceSettings[0] = settingNumber;
}
return(bSuccess);
}
/// <summary>
/// Gets a <see cref="UsbInterfaceDescriptor"/> for the specified AlternateInterfaceNumber,
/// </summary>
/// <param name="alternateInterfaceNumber">The alternate interface index for the <see cref="UsbInterfaceDescriptor"/> to retrieve. </param>
/// <param name="usbAltInterfaceDescriptor">The <see cref="UsbInterfaceDescriptor"/> for the specified AlternateInterfaceNumber.</param>
/// <returns>True on success.</returns>
public bool QueryInterfaceSettings(byte alternateInterfaceNumber, ref UsbInterfaceDescriptor usbAltInterfaceDescriptor)
{
bool bSuccess;
//if (mSemDeviceLock != null)
//{
// if (LockDevice() != ErrorCode.None) return false;
//}
//try
//{
bSuccess = WinUsbAPI.WinUsb_QueryInterfaceSettings(Handle, alternateInterfaceNumber, usbAltInterfaceDescriptor);
if (!bSuccess)
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "QueryInterfaceSettings", this);
}
//}
//finally
//{
// if (mSemDeviceLock != null) UnlockDevice();
//}
return(bSuccess);
}
/// <summary>
/// Gets the currently selected alternate settings number for the selected inteface.
/// </summary>
/// <param name="settingNumber">The selected AlternateSetting number.</param>
/// <returns>True on success.</returns>
public bool GetCurrentAlternateSetting(out byte settingNumber)
{
bool bSuccess;
//settingNumber = 0;
//if (LockDevice() != ErrorCode.None) return false;
//try
//{
bSuccess = WinUsbAPI.WinUsb_GetCurrentAlternateSetting(mUsbHandle, out settingNumber);
if (!bSuccess)
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "GetCurrentAlternateSetting", this);
}
//}
//finally
//{
// UnlockDevice();
//}
return(bSuccess);
}
