/// <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>
/// Refreshes the <see cref="MonoUsbProfile"/> list.
/// </summary>
/// <remarks>
/// <para>This is your entry point into finding a USB device to operate.</para>
/// <para>This return value of this function indicates the number of devices in the resultant list.</para>
/// <para>The <see cref="MonoUsbProfileList"/> has a crude form of built-in device notification that works on all platforms. By adding an event handler to the <see cref="AddRemoveEvent"/> changes in the device profile list are reported when <see cref="Refresh"/> is called.</para>
/// </remarks>
/// <param name="sessionHandle">A valid <see cref="MonoUsbSessionHandle"/>.</param>
/// <returns>The number of devices in the outputted list, or <see cref="MonoUsbError.ErrorNoMem"/> on memory allocation failure.</returns>
/// <example>
/// <code source="..\MonoLibUsb\MonoUsb.ShowInfo\ShowInfo.cs" lang="cs"/>
/// </example>
public int Refresh(MonoUsbSessionHandle sessionHandle)
{
lock (LockProfileList)
{
MonoUsbProfileList newList = new MonoUsbProfileList();
MonoUsbProfileListHandle monoUSBProfileListHandle;
int ret = MonoUsbApi.GetDeviceList(sessionHandle, out monoUSBProfileListHandle);
if (ret < 0 || monoUSBProfileListHandle.IsInvalid)
{
#if LIBUSBDOTNET
UsbError.Error(ErrorCode.MonoApiError, ret, "Refresh:GetDeviceList Failed", this);
#else
System.Diagnostics.Debug.Print("libusb_get_device_list failed:{0} {1}",
(MonoUsbError)ret,
MonoUsbApi.StrError((MonoUsbError)ret));
#endif
return(ret);
}
int stopCount = ret;
foreach (MonoUsbProfileHandle deviceProfileHandle in monoUSBProfileListHandle)
{
newList.mList.Add(new MonoUsbProfile(deviceProfileHandle));
stopCount--;
if (stopCount <= 0)
{
break;
}
}
syncWith(newList);
monoUSBProfileListHandle.Close();
return(ret);
}
}
/// <summary>
/// Sets the USB devices active configuration value.
/// </summary>
/// <param name="config">The active configuration value. A zero value means the device is not configured and a non-zero value indicates the device is configured.</param>
/// <returns>True on success.</returns>
/// <remarks>
/// A USB device can have several different configurations, but only one active configuration.
/// </remarks>
public bool SetConfiguration(byte config)
{
int uTransferLength;
UsbSetupPacket setupPkt = new UsbSetupPacket();
setupPkt.RequestType = (byte)UsbEndpointDirection.EndpointOut | (byte)UsbRequestType.TypeStandard | (byte)UsbRequestRecipient.RecipDevice;
setupPkt.Request = (byte)UsbStandardRequest.SetConfiguration;
setupPkt.Value = config;
setupPkt.Index = 0;
setupPkt.Length = 0;
bool bSuccess = ControlTransfer(ref setupPkt, null, 0, out uTransferLength);
if (bSuccess)
{
mCurrentConfigValue = config;
}
else
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "SetConfiguration", this);
}
return(bSuccess);
}
/// <summary>
/// Submits the transfer.
/// </summary>
/// <remarks>
/// This functions submits the USB transfer and return immediately.
/// </remarks>
/// <returns>
/// <see cref="ErrorCode.Success"/> if the submit succeeds,
/// otherwise one of the other <see cref="ErrorCode"/> codes.
/// </returns>
public override ErrorCode Submit()
{
if (mTransferCancelEvent.WaitOne(0))
{
return(ErrorCode.IoCancelled);
}
if (!mTransferCompleteEvent.WaitOne(0))
{
return(ErrorCode.ResourceBusy);
}
mTransfer.PtrBuffer = NextBufPtr;
mTransfer.Length = RequestCount;
mTransferCompleteEvent.Reset();
int ret = (int)mTransfer.Submit();
if (ret < 0)
{
mTransferCompleteEvent.Set();
UsbError usbErr = UsbError.Error(ErrorCode.MonoApiError, ret, "SubmitTransfer", EndpointBase);
return(usbErr.ErrorCode);
}
return(ErrorCode.Success);
}
///<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);
}
public override ErrorCode Submit()
{
int iTransferred;
ErrorCode eReturn = ErrorCode.Success;
if (mTransferCancelEvent.WaitOne(0, false))
{
return(ErrorCode.IoCancelled);
}
if (!mTransferCompleteEvent.WaitOne(0, UsbConstants.EXIT_CONTEXT))
{
return(ErrorCode.ResourceBusy);
}
mHasWaitBeenCalled = false;
mTransferCompleteEvent.Reset();
Overlapped.ClearAndSetEvent(mTransferCompleteEvent.SafeWaitHandle.DangerousGetHandle());
int ret = EndpointBase.PipeTransferSubmit(NextBufPtr,
RequestCount,
out iTransferred,
mIsoPacketSize,
Overlapped.GlobalOverlapped);
if (ret != 0 && ret != (int)UsbStatusClodes.ErrorIoPending)
{
mTransferCompleteEvent.Set();
UsbError usbErr = UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "PipeTransferSubmit", EndpointBase);
eReturn = usbErr.ErrorCode;
}
return(eReturn);
}
/// <summary>
/// Gets a descriptor from the device. See <see cref="DescriptorType"/> for more information.
/// </summary>
/// <param name="descriptorType">The descriptor type ID to retrieve; this is usually one of the <see cref="DescriptorType"/> enumerations.</param>
/// <param name="index">Descriptor index.</param>
/// <param name="langId">Descriptor language id.</param>
/// <param name="buffer">Memory to store the returned descriptor in.</param>
/// <param name="bufferLength">Length of the buffer parameter in bytes.</param>
/// <param name="transferLength">The number of bytes transferred to buffer upon success.</param>
/// <returns>True on success.</returns>
public override bool GetDescriptor(byte descriptorType, byte index, short langId, IntPtr buffer, int bufferLength, out int transferLength)
{
transferLength = 0;
bool bSuccess = false;
bool wasOpen = IsOpen;
if (!wasOpen)
{
Open();
}
if (!IsOpen)
{
return(false);
}
int ret = MonoUsbApi.GetDescriptor((MonoUsbDeviceHandle)mUsbHandle, descriptorType, index, buffer, (ushort)bufferLength);
if (ret < 0)
{
UsbError.Error(ErrorCode.MonoApiError, ret, "GetDescriptor Failed", this);
}
else
{
bSuccess = true;
transferLength = ret;
}
if (!wasOpen && IsOpen)
{
Close();
}
return(bSuccess);
}
private void UsbDeviceOnUsbErrorEvent(object sender, UsbError usbError)
{
Main.SendDebug(String.Format("A USB Error Occured: {0}", usbError));
if (Device == null || !Device.IsOpen)
{
throw new DeviceError(DeviceError.ErrorLevels.DeviceCrashed);
}
}
private void UsbDevice_UsbErrorEvent(object sender, UsbError e)
{
LogLine("usb error: " + e.ToString());
if (Settings.Default.UsbErrorIcon != MessageBoxIcon.None)
{
MessageBox.Show("UsbError: " + e.ToString(), "Error", MessageBoxButtons.OK, Settings.Default.UsbErrorIcon);
}
}
/// <summary>
/// Gets a list of <see cref="WinUsbRegistry"/> classes for the specified interface guid.
/// </summary>
/// <param name="deviceInterfaceGuid">The DeviceInterfaceGUID to search for.</param>
/// <param name="deviceRegistryList">A list of device paths associated with the <paramref name="deviceInterfaceGuid"/>.</param>
/// <returns>True of one or more device paths was found.</returns>
/// <remarks>
/// Each <see cref="WinUsbRegistry"/> in the <paramref name="deviceRegistryList"/> represents a seperate WinUSB device (interface).
/// </remarks>
public static bool GetWinUsbRegistryList(Guid deviceInterfaceGuid, out List <WinUsbRegistry> deviceRegistryList)
{
deviceRegistryList = new List <WinUsbRegistry>();
int devicePathIndex = 0;
SetupApi.SP_DEVICE_INTERFACE_DATA interfaceData = SetupApi.SP_DEVICE_INTERFACE_DATA.Empty;
SetupApi.DeviceInterfaceDetailHelper detailHelper;
SetupApi.SP_DEVINFO_DATA devInfoData = SetupApi.SP_DEVINFO_DATA.Empty;
// [1]
IntPtr deviceInfo = SetupApi.SetupDiGetClassDevs(ref deviceInterfaceGuid, null, IntPtr.Zero, SetupApi.DICFG.PRESENT | SetupApi.DICFG.DEVICEINTERFACE);
if (deviceInfo != IntPtr.Zero)
{
while ((SetupApi.SetupDiEnumDeviceInterfaces(deviceInfo, null, ref deviceInterfaceGuid, devicePathIndex, ref interfaceData)))
{
int length = 1024;
detailHelper = new SetupApi.DeviceInterfaceDetailHelper(length);
bool bResult = SetupApi.SetupDiGetDeviceInterfaceDetail(deviceInfo, ref interfaceData, detailHelper.Handle, length, out length, ref devInfoData);
if (bResult)
{
WinUsbRegistry regInfo = new WinUsbRegistry();
SetupApi.getSPDRPProperties(deviceInfo, ref devInfoData, regInfo.mDeviceProperties);
// Use the actual winusb device path for SYMBOLIC_NAME_KEY. This will be used to open the device.
regInfo.mDeviceProperties.Add(SYMBOLIC_NAME_KEY, detailHelper.DevicePath);
#if VERY_DEBUG
Debug.WriteLine(detailHelper.DevicePath);
#endif
regInfo.mDeviceInterfaceGuids = new Guid[] { deviceInterfaceGuid };
StringBuilder sbDeviceID = new StringBuilder(1024);
if (SetupApi.CM_Get_Device_ID(devInfoData.DevInst, sbDeviceID, sbDeviceID.Capacity, 0) == SetupApi.CR.SUCCESS)
{
regInfo.mDeviceProperties[DEVICE_ID_KEY] = sbDeviceID.ToString();
}
deviceRegistryList.Add(regInfo);
}
devicePathIndex++;
}
}
if (devicePathIndex == 0)
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "GetDevicePathList", typeof(SetupApi));
}
if (deviceInfo != IntPtr.Zero)
{
SetupApi.SetupDiDestroyDeviceInfoList(deviceInfo);
}
return(devicePathIndex > 0);
}
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);
}
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);
}
/// <summary>
/// Sets an alternate interface for the most recent claimed interface.
/// </summary>
/// <param name="alternateID">The alternate interface to select for the most recent claimed interface See <see cref="ClaimInterface"/>.</param>
/// <returns>True on success.</returns>
public bool SetAltInterface(int alternateID)
{
int ret = MonoUsbApi.SetInterfaceAltSetting((MonoUsbDeviceHandle)mUsbHandle, mClaimedInteface, alternateID);
if (ret != 0)
{
UsbError.Error(ErrorCode.MonoApiError, ret, "SetAltInterface Failed", this);
return(false);
}
return(true);
}
/// <summary>
/// Releases an interface that was previously claimed with <see cref="ClaimInterface"/>.
/// </summary>
/// <param name="interfaceID">The interface to release.</param>
/// <returns>True on success.</returns>
public bool ReleaseInterface(int interfaceID)
{
int ret = MonoUsbApi.ReleaseInterface((MonoUsbDeviceHandle)mUsbHandle, interfaceID);
if (ret != 0)
{
UsbError.Error(ErrorCode.MonoApiError, ret, "ReleaseInterface Failed", this);
return(false);
}
return(true);
}
void OnUsbError(object sender, UsbError e)
{
if (suppressErrors)
{
return;
}
string prefix = String.Format("Driver.OnUsbError: sender {0}", sender.GetType());
if (sender is UsbEndpointBase)
{
logger.error("{0} [UsbEndPointBase]: Win32ErrorNumber {1} ({2}): {3}",
prefix, e.Win32ErrorNumber, e.Win32ErrorString, e.Description);
// Magic number 31 came from here: http://libusbdotnet.sourceforge.net/V2/html/718df290-f19a-9033-3a26-1e8917adf15d.htm
if (e.Win32ErrorNumber == 31)
{
UsbDevice usb = sender as UsbDevice;
if (usb.IsOpen)
{
UsbEndpointBase baseDevice = sender as UsbEndpointBase;
// UsbEndpointInfo uei = baseDevice.EndpointInfo;
// LibUsbDotNet.Descriptors.UsbEndpointDescriptor ued = uei.Descriptor;
logger.error("{0} [UsbEndPointBase]: usb device still open on endpoint {1}", prefix, baseDevice.EpNum);
if (baseDevice.Reset())
{
// docs say to set e.Handled = true here, but UsbError has no such field;
// was commented out here:
// https://github.com/GeorgeHahn/LibUsbDotNet/blob/master/LibWinUsb/UsbDevice.Error.cs#L49
return;
}
}
}
}
else if (sender is UsbTransfer)
{
logger.error("{0} [UsbTransfer]: Win32ErrorNumber {1} ({2}): {3}",
prefix, e.Win32ErrorNumber, e.Win32ErrorString, e.Description);
UsbEndpointBase ep = ((UsbTransfer)sender).EndpointBase;
logger.error("{0} [UsbTransfer]: Endpoint = 0x{1:x2}", prefix, ep.EpNum);
}
else if (sender is Type)
{
Type t = sender as Type;
logger.error("{0} [Type]: type = {1}", prefix, t.Name);
}
else
{
logger.error("{0} [other]: {1}", prefix, e.ToString());
// is there anything we should DO here, other than logging it?
}
}
/// <summary>
/// Claims the specified interface of the device.
/// </summary>
/// <param name="interfaceID">The interface to claim.</param>
/// <returns>True on success.</returns>
public bool ClaimInterface(int interfaceID)
{
int ret = MonoUsbApi.ClaimInterface((MonoUsbDeviceHandle)mUsbHandle, interfaceID);
if (ret != 0)
{
UsbError.Error(ErrorCode.MonoApiError, ret, "ClaimInterface Failed", this);
return(false);
}
mClaimedInteface = interfaceID;
return(true);
}
/// <summary>
/// Sets the USB devices active configuration value.
/// </summary>
/// <param name="config">The active configuration value. A zero value means the device is not configured and a non-zero value indicates the device is configured.</param>
/// <returns>True on success.</returns>
/// <remarks>
/// A USB device can have several different configurations, but only one active configuration.
/// </remarks>
public bool SetConfiguration(byte config)
{
int ret = MonoUsbApi.SetConfiguration((MonoUsbDeviceHandle)mUsbHandle, config);
if (ret != 0)
{
UsbError.Error(ErrorCode.MonoApiError, ret, "SetConfiguration Failed", this);
return(false);
}
mCurrentConfigValue = config;
return(true);
}
/// <summary>
/// Sets an alternate interface for the most recent claimed interface.
/// </summary>
/// <param name="alternateID">The alternate interface to select for the most recent claimed interface See <see cref="ClaimInterface"/>.</param>
/// <returns>True on success.</returns>
public bool SetAltInterface(int interfaceID, int alternateID)
{
int ret = MonoUsbApi.SetInterfaceAltSetting((MonoUsbDeviceHandle)mUsbHandle, interfaceID, alternateID);
if (ret != 0)
{
UsbError.Error(ErrorCode.MonoApiError, ret, "SetAltInterface Failed", this);
return(false);
}
UsbAltInterfaceSettings[interfaceID & (UsbConstants.MAX_DEVICES - 1)] = (byte)alternateID;
return(true);
}
internal static UsbError Error(ErrorCode errorCode, int ret, string description, object sender)
{
string win32Error = String.Empty;
if (errorCode == ErrorCode.MonoApiError)
{
win32Error = ((Error)ret) + ":" + MonoUsbApi.StrError((Error)ret);
}
UsbError err = new UsbError(errorCode, ret, win32Error, description, sender);
return(err);
}
public override ErrorCode Wait(out int transferredCount, bool cancel)
{
if (mHasWaitBeenCalled)
{
throw new UsbException(this, "Repeated calls to wait with a submit is not allowed.");
}
transferredCount = 0;
bool bSuccess;
// Temporarily release the transfer lock while we wait for something to happen.
int iWait = WaitHandle.WaitAny(new WaitHandle[] { mTransferCompleteEvent, mTransferCancelEvent }, mTimeout, UsbConstants.EXIT_CONTEXT);
if (iWait == WaitHandle.WaitTimeout && !cancel)
{
return(ErrorCode.IoTimedOut);
}
mHasWaitBeenCalled = true;
if (iWait != 0)
{
bSuccess = EndpointBase.mUsbApi.AbortPipe(EndpointBase.Handle, EndpointBase.EpNum);
bool bTransferComplete = mTransferCompleteEvent.WaitOne(100, UsbConstants.EXIT_CONTEXT);
mTransferCompleteEvent.Set();
if (!bSuccess || !bTransferComplete)
{
ErrorCode ec = bSuccess ? ErrorCode.Win32Error : ErrorCode.CancelIoFailed;
UsbError.Error(ec, Marshal.GetLastWin32Error(), "Wait:AbortPipe Failed", this);
return(ec);
}
if (iWait == WaitHandle.WaitTimeout)
{
return(ErrorCode.IoTimedOut);
}
return(ErrorCode.IoCancelled);
}
try
{
bSuccess = EndpointBase.mUsbApi.GetOverlappedResult(EndpointBase.Handle, Overlapped.GlobalOverlapped, out transferredCount, true);
if (!bSuccess)
{
UsbError usbErr = UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "GetOverlappedResult", EndpointBase);
return(usbErr.ErrorCode);
}
return(ErrorCode.None);
}
catch
{
return(ErrorCode.UnknownError);
}
}
internal static bool UsbIOSync(SafeHandle dev, int code, Object inBuffer, int inSize, IntPtr outBuffer, int outSize, out int ret)
{
SafeOverlapped deviceIoOverlapped = new SafeOverlapped();
ManualResetEvent hEvent = new ManualResetEvent(false);
deviceIoOverlapped.Init(hEvent.GetSafeWaitHandle().DangerousGetHandle());
ret = 0;
if (!Kernel32.DeviceIoControlAsObject(dev, code, inBuffer, inSize, outBuffer, outSize, ref ret, deviceIoOverlapped.GlobalOverlapped))
{
int iError = Marshal.GetLastWin32Error();
if (iError != ERROR_IO_PENDING)
{
// Don't log errors for these control codes.
do
{
if (code == LibUsbIoCtl.GET_REG_PROPERTY)
{
break;
}
if (code == LibUsbIoCtl.GET_CUSTOM_REG_PROPERTY)
{
break;
}
UsbError.Error(ErrorCode.Win32Error, iError, String.Format("DeviceIoControl code {0:X8} failed:{1}", code, Kernel32.FormatSystemMessage(iError)), typeof(LibUsbDriverIO));
} while (false);
#if !NETSTANDARD1_5 && !NETSTANDARD1_6
hEvent.Close();
#else
hEvent.Dispose();
#endif
return(false);
}
}
if (Kernel32.GetOverlappedResult(dev, deviceIoOverlapped.GlobalOverlapped, out ret, true))
{
#if !NETSTANDARD1_5 && !NETSTANDARD1_6
hEvent.Close();
#else
hEvent.Dispose();
#endif
return(true);
}
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "GetOverlappedResult failed.\nIoCtlCode:" + code, typeof(LibUsbDriverIO));
#if !NETSTANDARD1_5 && !NETSTANDARD1_6
hEvent.Close();
#else
hEvent.Dispose();
#endif
return(false);
}
internal static void Error(object sender, string description, string functionName, int ret)
{
UsbError e = new UsbError(sender, description, functionName, ret);
EventHandler <UsbError> temp = OnUsbError;
if (temp != null)
{
temp(sender, e);
}
else
{
Debug.Print(e.ToString());
}
}
/// <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>
/// 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);
}
mUsbHandle = LibUsbDriverIO.OpenDevice(mDeviceFilename);
if (!IsOpen)
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "LibUsbDevice.Open Failed", this);
return(false);
}
return(true);
}
/// <summary>
/// Wait for the transfer to complete, timeout, or get cancelled.
/// </summary>
/// <param name="transferredCount">The number of bytes transferred on <see cref="ErrorCode.Success"/>.</param>
/// <param name="cancel">Not used for libusb-1.0. Transfers are always cancelled on timeout or error.</param>
/// <returns><see cref="ErrorCode.Success"/> if the transfer completes successfully, otherwise one of the other <see cref="ErrorCode"/> codes.</returns>
public override ErrorCode Wait(out int transferredCount, bool cancel)
{
transferredCount = 0;
int ret = 0;
MonoUsbError monoError;
ErrorCode ec;
int iWait = WaitHandle.WaitAny(new WaitHandle[] { mTransferCompleteEvent, mTransferCancelEvent },
Timeout.Infinite,
UsbConstants.EXIT_CONTEXT);
switch (iWait)
{
case 0: // TransferCompleteEvent
if (mTransfer.Status == MonoUsbTansferStatus.TransferCompleted)
{
transferredCount = mTransfer.ActualLength;
return(ErrorCode.Success);
}
string s;
monoError = MonoUsbApi.MonoLibUsbErrorFromTransferStatus(mTransfer.Status);
ec = MonoUsbApi.ErrorCodeFromLibUsbError((int)monoError, out s);
UsbError.Error(ErrorCode.MonoApiError, (int)monoError, "Wait:" + s, EndpointBase);
return(ec);
case 1: // TransferCancelEvent
ret = (int)mTransfer.Cancel();
bool bTransferComplete = mTransferCompleteEvent.WaitOne(100, UsbConstants.EXIT_CONTEXT);
mTransferCompleteEvent.Set();
if (ret != 0 || !bTransferComplete)
{
ec = ret == 0 ? ErrorCode.CancelIoFailed : ErrorCode.MonoApiError;
UsbError.Error(ec, ret, String.Format("Wait:Unable to cancel transfer or the transfer did not return after it was cancelled. Cancelled:{0} TransferCompleted:{1}", (MonoUsbError)ret, bTransferComplete), EndpointBase);
return(ec);
}
return(ErrorCode.IoCancelled);
default: // Critical failure timeout
mTransfer.Cancel();
ec = ((EndpointBase.mEpNum & (byte)UsbCtrlFlags.Direction_In) > 0) ? ErrorCode.ReadFailed : ErrorCode.WriteFailed;
mTransferCompleteEvent.Set();
UsbError.Error(ec, ret, String.Format("Wait:Critical timeout failure! The transfer callback function was not called within the allotted time."), EndpointBase);
return(ec);
}
}
private MonoUsbError GetDeviceDescriptor(out MonoUsbDeviceDescriptor monoUsbDeviceDescriptor)
{
MonoUsbError ec = MonoUsbError.Success;
monoUsbDeviceDescriptor = new MonoUsbDeviceDescriptor();
//Console.WriteLine("MonoUsbProfile:GetDeviceDescriptor");
ec = (MonoUsbError)MonoUsbApi.GetDeviceDescriptor(mMonoUSBProfileHandle, monoUsbDeviceDescriptor);
if (ec != MonoUsbError.Success)
{
#if LIBUSBDOTNET
UsbError.Error(ErrorCode.MonoApiError, (int)ec, "GetDeviceDescriptor Failed", this);
#endif
monoUsbDeviceDescriptor = null;
}
return(ec);
}
/// <summary>
/// Cancels pending transfers and clears the halt condition on an enpoint.
/// </summary>
/// <returns>True on success.</returns>
public override bool Reset()
{
if (IsDisposed)
{
throw new ObjectDisposedException(GetType().Name);
}
Abort();
int ret = MonoUsbApi.ClearHalt((MonoUsbDeviceHandle)Device.Handle, EpNum);
if (ret < 0)
{
UsbError.Error(ErrorCode.MonoApiError, ret, "Endpoint Reset Failed", this);
return(false);
}
return(true);
}
/// <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>
/// Creates, fills and submits an asynchronous <see cref="UsbTransfer"/> context.
/// </summary>
/// <remarks>
/// <note type="tip">This is a non-blocking asynchronous transfer function. This function returns immediately after the context is created and submitted.</note>
/// </remarks>
/// <param name="buffer">A caller-allocated buffer for the data that is transferred.</param>
/// <param name="offset">Position in buffer that transferring begins.</param>
/// <param name="length">Number of bytes, starting from thr offset parameter to transfer.</param>
/// <param name="timeout">Maximum time to wait for the transfer to complete.</param>
/// <param name="transferContext">On <see cref="ErrorCode.Success"/>, a new transfer context.</param>
/// <returns><see cref="ErrorCode.Success"/> if the transfer context was created and <see cref="UsbTransfer.Submit"/> succeeded.</returns>
/// <seealso cref="SubmitAsyncTransfer(object,int,int,int,out LibUsbDotNet.Main.UsbTransfer)"/>
/// <seealso cref="NewAsyncTransfer"/>
public virtual ErrorCode SubmitAsyncTransfer(IntPtr buffer, int offset, int length, int timeout, out UsbTransfer transferContext)
{
transferContext = CreateTransferContext();
transferContext.Fill(buffer, offset, length, timeout);
ErrorCode ec = transferContext.Submit();
if (ec != ErrorCode.None)
{
transferContext.Dispose();
transferContext = null;
UsbError.Error(ec, 0, "SubmitAsyncTransfer Failed", this);
}
return(ec);
}
/// <summary>
/// Resets the data toggle and clears the stall condition on an enpoint.
/// </summary>
/// <returns>True on success.</returns>
public virtual bool Reset()
{
if (mIsDisposed)
{
throw new ObjectDisposedException(GetType().Name);
}
bool bSuccess = mUsbApi.ResetPipe(mUsbHandle, EpNum);
if (!bSuccess)
{
UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "ResetPipe", this);
}
return(bSuccess);
}