void Setup()
{
if (UsbDev != null)
{
return;
}
UsbDev = FindDevice();
if (!UsbDev.SetConfiguration(1))
{
throw new M4ATXException("Failed to set device config");
}
if (!UsbDev.ClaimInterface(0))
{
throw new M4ATXException("Failed to claim interface #0");
}
if (!UsbDev.SetAltInterface(0))
{
throw new M4ATXException("Failed to set alternate interface to 0");
}
Writer = UsbDev.OpenEndpointWriter(WriteEndpointID.Ep01);
Reader = UsbDev.OpenEndpointReader(ReadEndpointID.Ep01);
}
public override void Close()
{
try {
write_lock.WaitOne ();
if (ep_reader != null) {
// detach read event
ep_reader.DataReceivedEnabled = false;
ep_reader.DataReceived -= (read_usb);
}
ep_reader = null;
ep_writer = null;
if (IsOpen ()) {
// close devices
usb_device.Close ();
wholeUsbDevice.ReleaseInterface (1);
wholeUsbDevice.Close ();
}
// release devices
usb_device = null;
wholeUsbDevice = null;
UsbDevice.Exit();
} catch (Exception) {
// Ignore everything
} finally {
write_lock.ReleaseMutex();
}
}
internal DeviceCommand(DeviceCommand dev)
{
this.usb = dev.UsbDevice;
this.parentDevice = dev;
logs = new List <Log>();
commands = new List <Command>();
}
public static void Close(UsbDevice usbDevice)
{
if (usbDevice != null)
{
if (usbDevice.IsOpen)
{
// If this is a "whole" usb device (libusb-win32, linux libusb-1.0)
// it exposes an IUsbDevice interface. If not (WinUSB) the
// 'wholeUsbDevice' variable will be null indicating this is
// an interface of a device; it does not require or support
// configuration and interface selection.
IUsbDevice wholeUsbDevice = usbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface
wholeUsbDevice.ReleaseInterface(1);
}
usbDevice.Close();
}
usbDevice = null;
// Free usb resources
UsbDevice.Exit();
}
}
public void Dispose()
{
Registry = null;
IsDisposed = true;
if (Device != null)
{
Writer.Abort();
Writer.Dispose();
Writer = null;
if (Device.IsOpen)
{
// If this is a "whole" usb device (libusb-win32, linux libusb-1.0)
// it exposes an IUsbDevice interface. If not (WinUSB) the
// 'wholeUsbDevice' variable will be null indicating this is
// an interface of a device; it does not require or support
// configuration and interface selection.
IUsbDevice wholeUsbDevice = Device as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
Device.Close();
}
Device = null;
// Free usb resources
UsbDevice.Exit();
}
}
public bool Open()
{
if (IsOpen)
{
return(false);
}
if (!_Device.Open())
{
return(false);
}
IUsbDevice whole = _Device as IUsbDevice;
if (!ReferenceEquals(whole, null))
{
if (!whole.SetConfiguration(ConfigurationID) || !whole.ClaimInterface(InterfaceID))
{
_Device.Close();
throw new PTPException("could not set USB device configuration and interface to " + ConfigurationID + " and " + InterfaceID + ", respectively");
}
}
Writer = _Device.OpenEndpointWriter(WriterEndpointID);
Reader = _Device.OpenEndpointReader(ReaderEndpointID);
return(true);
}
/// <summary>
/// Dynamic predicate find function. Pass this function into any method that has a <see cref="Predicate{UsbDevice}"/> parameter.
/// </summary>
/// <remarks>
/// Override this member when inheriting the <see cref="UsbDeviceFinder"/> class to change/alter the matching behavior.
/// </remarks>
/// <param name="usbDevice">The UsbDevice to check.</param>
/// <returns>True if the <see cref="UsbDevice"/> instance matches the <see cref="UsbDeviceFinder"/> properties.</returns>
public virtual bool Check(IUsbDevice usbDevice)
{
try
{
if (this.Vid != null && usbDevice.Info.VendorId != this.Vid.Value)
{
return(false);
}
if (this.Pid != null && usbDevice.Info.ProductId != this.Pid.Value)
{
return(false);
}
if (this.Revision != null && usbDevice.Info.Usb != this.Revision.Value)
{
return(false);
}
if (this.SerialNumber != null && usbDevice.Info.SerialNumber != this.SerialNumber)
{
return(false);
}
return(true);
}
catch (LibUsb.UsbException ex) when(ex.ErrorCode == Error.NotFound)
{
// The device has probably disconnected while we were inspecting it. Continue.
return(false);
}
}
public MainWindow()
{
InitializeComponent();
ErrorCode ec = ErrorCode.None;
try
{
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
if (MyUsbDevice == null)
{
MessageBox.Show("Device Not Found.");
}
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// This is a "whole" USB device. Before it can be used,
// the desired configuration and interface must be selected.
// Select config #1
wholeUsbDevice.SetConfiguration(1);
// Claim interface #0.
wholeUsbDevice.ClaimInterface(0);
}
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
reader.DataReceived += (OnRxEndPointData);
reader.DataReceivedEnabled = true;
}
catch (Exception)
{
throw;
}
}
private void Form1_FormClosed(object sender, FormClosedEventArgs e)
{
try
{
reader.DataReceivedEnabled = false;
reader.DataReceived -= (OnRxEndPointData);
reader.Dispose();
writer.Dispose();
if (MyUsbDevice != null)
{
if (MyUsbDevice.IsOpen)
{
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
UsbDevice.Exit();
}
}
catch (Exception ex)
{
}
}
public HeliosDevice(IUsbDevice usbDevice)
{
this.usbDevice = usbDevice;
interruptEndpointReader = usbDevice.OpenEndpointReader(ReadEndpointID.Ep03, 32, EndpointType.Interrupt);
interruptEndpointWriter = usbDevice.OpenEndpointWriter(WriteEndpointID.Ep06, EndpointType.Interrupt);
bulkEndpointWriter = usbDevice.OpenEndpointWriter(WriteEndpointID.Ep02, EndpointType.Bulk);
}
/// <summary>
/// Attempts to open a USB registry as a USB DFU device.
/// </summary>
/// <param name="registry">The input USB registry of a connected device</param>
/// <param name="dfuDevice">The opened DFU device in case of success</param>
/// <returns>True if the DFU device is successfully opened</returns>
public static bool TryOpen(UsbRegistry registry, out Device dfuDevice)
{
dfuDevice = null;
UsbDevice dev;
byte cfIndex = 0;
byte ifIndex = 0;
if (!registry.Open(out dev))
{
return(false);
}
var confInfo = dev.Configs[cfIndex];
// This is a "whole" USB device. Before it can be used,
// the desired configuration and interface must be selected.
IUsbDevice usbDevice = dev as IUsbDevice;
if (usbDevice != null)
{
// Select config
usbDevice.SetConfiguration(confInfo.Descriptor.ConfigID);
}
// find DFU interface
for (ifIndex = 0; ifIndex < confInfo.InterfaceInfoList.Count; ifIndex++)
{
var iface = confInfo.InterfaceInfoList[ifIndex];
if (!IsDfuInterface(iface))
{
continue;
}
if (usbDevice != null)
{
// Claim interface
usbDevice.ClaimInterface(iface.Descriptor.InterfaceID);
}
break;
}
try
{
if (ifIndex == confInfo.InterfaceInfoList.Count)
{
throw new ArgumentException("The device doesn't have valid DFU interface");
}
dfuDevice = new Device(dev, cfIndex, ifIndex);
return(true);
}
catch (Exception)
{
var d = dev as IDisposable;
d.Dispose();
return(false);
}
}
public override void OpenDevice()
{
log.Info("QDLUsb trying to find device");
UsbDevice.UsbErrorEvent += new EventHandler <UsbError>(UsbErrorEvent);
UsbRegistry regDev = null;
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
regDev = UsbDevice.AllWinUsbDevices.Find((reg) => reg.Vid == VID && reg.Pid == PID);
}
else
{
regDev = UsbDevice.AllDevices.Find((reg) => reg.Vid == VID && reg.Pid == PID);
}
if (regDev == null)
{
log.Error("No QDLUSB Devices found");
throw new QDLDeviceNotFoundException("Unable to find device");
}
if (!regDev.Open(out device) || device == null)
{
log.Error("No QDLUSB Devices found");
throw new QDLDeviceNotFoundException("Unable to open device");
}
if (UsbDevice.IsLinux)
{
log.Debug("Running on linux, detaching kernel driver");
MonoUsbDevice monodev = device as MonoUsbDevice;
if (!monodev.DetachKernelDriver())
{
log.Error("Failed to detach kernel driver");
throw new Exception("Failed to detach kernel driver");
}
}
IUsbDevice wholeUsbDevice = device as IUsbDevice;
if (wholeUsbDevice != null)
{
wholeUsbDevice.SetConfiguration(1);
wholeUsbDevice.ClaimInterface(0);
}
reader = device.OpenEndpointReader(ReadEndpointID.Ep01);
writer = device.OpenEndpointWriter(WriteEndpointID.Ep01, EndpointType.Bulk);
if (reader == null || writer == null)
{
device.Close();
device = null;
UsbDevice.Exit();
log.Error("Failed to open endpoints");
throw new Exception("Unable to open endpoints");
}
log.Info("Found QDLUSB device");
}
/// <summary>
/// Close and open the device
/// </summary>
/// <param name="device">The device</param>
private static void CloseAndOpen(IUsbDevice device)
{
if (device.IsOpen)
{
device.Close();
}
Initialize((UsbDevice)device);
}
public static void Connect(DeviceNameList dList)
{
try
{
if ((uDevice = UsbDevice.OpenUsbDevice(uDevFinder)) == null)
{
throw new Exception("Device Not Found");
}
IUsbDevice iuDev = uDevice as IUsbDevice;
if (!ReferenceEquals(iuDev, null))
{
iuDev.SetConfiguration(1);
iuDev.ClaimInterface(0);
}
uDevice.Open();
}
catch (Exception e)
{
Console.WriteLine("usbcom Connecting Proces : {0}", e);
throw;
}
(new Thread(() => {
while (uDevice.IsOpen)
{
byte[] buf = new byte[64];
int bytesRead = 0;
using (var Reader = uDevice.OpenEndpointReader(ReadEndpointID.Ep01))
{
ErrorCode ec = ErrorCode.None;
ec = Reader.Read(buf, 2000, out bytesRead);
if (ec == ErrorCode.IoTimedOut)
{
continue;
}
if (ec == ErrorCode.IoCancelled)
{
return;
}
if (ec != 0)
{
throw new Exception("usbcom ReadCtrl Error : ErrorCode==" + ec.ToString() + "\n" + UsbDevice.LastErrorString);
}
}
if (bytesRead > 0)
{
(new Thread(() => DataGot?.Invoke(null, new DataGotEvArgs()
{
Data = buf
}))).Start();
}
}
})).Start();
}
public override void DeviceInitialize(IDevice device)
{
base.DeviceInitialize(device);
volume = device as IVolume;
if (volume == null || !volume.IsMounted || (usb_device = volume.ResolveRootUsbDevice()) == null)
{
throw new InvalidDeviceException();
}
ms_device = DeviceMapper.Map(this);
try {
if (ms_device.ShouldIgnoreDevice() || !ms_device.LoadDeviceConfiguration())
{
ms_device = null;
}
} catch {
ms_device = null;
}
if (!HasMediaCapabilities && ms_device == null)
{
throw new InvalidDeviceException();
}
// Ignore iPods, except ones with .is_audio_player files
if (MediaCapabilities != null && MediaCapabilities.IsType("ipod"))
{
if (ms_device != null && ms_device.HasIsAudioPlayerFile)
{
Log.Information(
"Mass Storage Support Loading iPod",
"The USB mass storage audio player support is loading an iPod because it has an .is_audio_player file. " +
"If you aren't running Rockbox or don't know what you're doing, things might not behave as expected."
);
}
else
{
throw new InvalidDeviceException();
}
}
Name = ms_device == null ? volume.Name : ms_device.Name;
mount_point = volume.MountPoint;
Initialize();
if (ms_device != null)
{
ms_device.SourceInitialize();
}
AddDapProperties();
// TODO differentiate between Audio Players and normal Disks, and include the size, eg "2GB Audio Player"?
//GenericName = Catalog.GetString ("Audio Player");
}
public bool make_idle(bool initial_abort)
{
int retries = 4;
DFU_Status status;
IUsbDevice thisDev = myUSBDevice as IUsbDevice;
if (initial_abort)
{
abort();
}
while (retries > 0)
{
if (!get_status(out status))
{
clear_status();
continue;
}
switch (status.State)
{
case DFUStateVals.STATE_DFU_IDLE:
if( DFUStatusVals.DFU_STATUS_OK == status.Status ) {
return(true);
}
/* We need the device to have the DFU_STATUS_OK status. */
clear_status();
break;
case DFUStateVals.STATE_DFU_DOWNLOAD_SYNC: /* abort -> idle */
case DFUStateVals.STATE_DFU_DOWNLOAD_IDLE: /* abort -> idle */
case DFUStateVals.STATE_DFU_MANIFEST_SYNC: /* abort -> idle */
case DFUStateVals.STATE_DFU_UPLOAD_IDLE: /* abort -> idle */
case DFUStateVals.STATE_DFU_DOWNLOAD_BUSY: /* abort -> error */
case DFUStateVals.STATE_DFU_MANIFEST: /* abort -> error */
abort();
break;
case DFUStateVals.STATE_DFU_ERROR:
clear_status();
break;
case DFUStateVals.STATE_APP_IDLE:
detach( DFU_DETACH_TIMEOUT );
break;
case DFUStateVals.STATE_APP_DETACH:
case DFUStateVals.STATE_DFU_MANIFEST_WAIT_RESET:
//DEBUG( "Resetting the device\n" );
thisDev.ResetDevice();
return(false);
}
retries--;
}
return(false);
}
public void usbConnect() // The name is self-explanatory...
{
// Find and open the usb device.
mUsbDevice = UsbDevice.OpenUsbDevice(mini2440Finder);
if (mUsbDevice == null)
{
mUsbDevice = UsbDevice.OpenUsbDevice(mini6410Finder);
}
// If we fail to find or connect to the device
if (mUsbDevice == null)
{
l_usbFound.Text = "Error";
t_log.AppendText("\r\n" + "## Could not find or open device." + "\r\n"
+ "Please plug the device, I will detect it." + "\r\n");
b_download.Enabled = false;
b_upload.Enabled = false;
}
// If the device is open and ready
else
{
l_usbFound.Text = "Connected";
if (mUsbDevice.UsbRegistryInfo.Pid == pid2440)
{
t_log.AppendText("\r\n" + "## Mini2440 connected." + "\r\n");
}
if (mUsbDevice.UsbRegistryInfo.Pid == pid6410)
{
t_log.AppendText("\r\n" + "## Mini6410 connected." + "\r\n");
}
b_download.Enabled = true;
b_upload.Enabled = true;
mEpReader = mUsbDevice.OpenEndpointReader((ReadEndpointID)(byte.Parse("1") | 0x80)); // = 81
mEpWriter = mUsbDevice.OpenEndpointWriter((WriteEndpointID)byte.Parse("3"));
if (mEpWriter.EndpointInfo == null) // Try opening endpoint 4 if endpoint 3 is unavailable (i.e. after usb reset when downloading firmware)
{
mEpWriter = mUsbDevice.OpenEndpointWriter((WriteEndpointID)byte.Parse("4"));
}
//mEpReader.Flush();
mEpWriter.Flush();
IUsbDevice wholeUsbDevice = mUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// This is a "whole" USB device. Before it can be used,
// the desired configuration and interface must be selected.
// Select config #1
wholeUsbDevice.SetConfiguration(1);
// Claim interface #0.
wholeUsbDevice.ClaimInterface(0);
}
}
}
public static Task ClearStatusAsync(this IUsbDevice usbDevice)
=> usbDevice.PerformControlTransferAsync(new SetupPacket
(
requestType: new UsbDeviceRequestType(
RequestDirection.In,
RequestType.Class,
RequestRecipient.Interface),
request: DFU_CLEARSTATUS,
length: 0
));
public static Task <TransferResult> GetStatusAsync(this IUsbDevice usbDevice)
=> usbDevice.PerformControlTransferAsync(new SetupPacket
(
requestType: new UsbDeviceRequestType(
RequestDirection.In,
RequestType.Class,
RequestRecipient.Interface),
request: DFU_GETSTATUS,
length: GetStatusPacketLength
));
public static int GetProductId(IUsbDevice device)
{
var raw = device as IRawDevice;
int num = 0;
if (raw != null && Int32.TryParse(raw.Device.UdevMetadata.GetPropertyString(UdevProductId), NumberStyles.HexNumber, null, out num))
{
return(num);
}
return(0);
}
public static int GetDeviceNumber(IUsbDevice device)
{
var raw = device as IRawDevice;
int num = 0;
if (raw != null && Int32.TryParse(raw.Device.UdevMetadata.GetPropertyString(UdevUsbDeviceNumber), out num))
{
return(num);
}
return(0);
}
public bool Connect()
{
_usbRegistry.Open(out _usbDevice);
if (_usbDevice == null)
{
return(false);
}
// If this is a "whole" usb device (libusb-win32, linux libusb)
// it will have an IUsbDevice interface. If not (WinUSB) the
// variable will be null indicating this is an interface of a
// device.
IUsbDevice wholeUsbDevice = _usbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// This is a "whole" USB device. Before it can be used,
// the desired configuration and interface must be selected.
// Select config #1
wholeUsbDevice.SetConfiguration(1);
// Claim interface #0.
if (!wholeUsbDevice.ClaimInterface(0))
{
wholeUsbDevice.ReleaseInterface(0);
_usbDevice.Close();
return(false);
}
}
if (_resolverInfo.V45Endpoints == true)
{
// Open EP1 for writing, used to send BCP commands/packets to the unit.
_endpointWriter = _usbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
// Open EP2 for reading, used to send BCP replies to the USB host.
_endpointReader = _usbDevice.OpenEndpointReader(ReadEndpointID.Ep02);
// Open EP5 for reading, used to send “real time capture data” to the host.
_realTimeEndpointReader = _usbDevice.OpenEndpointReader(ReadEndpointID.Ep05);
}
else
{
// Open EP2 for writing, used to send BCP commands/packets to the unit.
_endpointWriter = _usbDevice.OpenEndpointWriter(WriteEndpointID.Ep02);
// Open EP6 for reading, used to send BCP replies to the USB host.
_endpointReader = _usbDevice.OpenEndpointReader(ReadEndpointID.Ep06);
// Open EP8 for reading, used to send “real time capture data” to the host.
_realTimeEndpointReader = _usbDevice.OpenEndpointReader(ReadEndpointID.Ep08);
}
return(true);
}
private void InitUSB(int VendorID, int ProductID)
{
dev = (IUsbDevice)UsbDevice.OpenUsbDevice(x => x.Vid == VendorID && x.Pid == ProductID);
if (dev == null)
{
throw new NullReferenceException("Cannot find USB device for JZ4780. Check Vendor/Product IDs and that LibUSB-Win32 \".inf\" installed.");
}
dev.SetConfiguration(1);
}
private void btnPrint_Click(object sender, EventArgs e)
{
_printer = UsbDevice.OpenUsbDevice(_printerFinder);
_printerUsbDevice = _printer as IUsbDevice;
if (_printerUsbDevice != null)
{
// This is a "whole" USB device. Before it can be used,
// the desired configuration and interface must be selected.
// Select config #1
_printerUsbDevice.SetConfiguration(1);
// Claim interface #0.
_printerUsbDevice.ClaimInterface(0);
}
// open write endpoint 1.
UsbEndpointWriter writer = _printer.OpenEndpointWriter(WriteEndpointID.Ep02);
List <byte> writeBytesList = new List <byte>();
writeBytesList.AddRange(Encoding.ASCII.GetBytes(txtTextToPrint.Text));
writeBytesList.Add(0x0A);
byte[] writeBuffer = writeBytesList.ToArray();
int bytesWritten;
ErrorCode writeErrorCode = writer.Write(writeBuffer, 10000, out bytesWritten);
// open read endpoint 1.
//UsbEndpointReader reader = printer.OpenEndpointReader(ReadEndpointID.Ep01);
//ErrorCode readErrorCode = ErrorCode.None;
//byte[] readBuffer = new byte[1024];
//while (readErrorCode == ErrorCode.None)
//{
// int bytesRead;
// // If the device hasn't sent data in the last 100 milliseconds,
// // a timeout error (ec = IoTimedOut) will occur.
// readErrorCode = reader.Read(readBuffer, 10000, out bytesRead);
// if (bytesRead == 0)
// {
// break;
// }
// // Write that output to the console.
// MessageBox.Show(Encoding.ASCII.GetString(readBuffer, 0, bytesRead));
//}
}
public UsbDevStream(IUsbDevice dev, WriteEndpointID writePipe, ReadEndpointID readPipe)
{
device = dev;
WritePipe = writePipe;
ReadPipe = readPipe;
writer = device.OpenEndpointWriter(writePipe);
reader = device.OpenEndpointReader(readPipe);
Flush();
}
public static Task <TransferResult> SendDownloadRequestAsync(this IUsbDevice usbDevice)
// buffer: set address pointer command (0x21), address pointer (0x08000000)
=> usbDevice.PerformControlTransferAsync(new SetupPacket
(
requestType: new UsbDeviceRequestType(
RequestDirection.Out,
RequestType.Class,
RequestRecipient.Interface),
request: DFU_DNLOAD,
length: (ushort)DownloadRequestBuffer.Length
), DownloadRequestBuffer);
private void buttonRead_Click(object sender, EventArgs e)
{
dev = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(0x1915, 0x7B));
// bool success = reg.Open(out dev);
IUsbDevice wholeUsbDevice = dev as IUsbDevice;
wholeUsbDevice.SetConfiguration(1);
wholeUsbDevice.ClaimInterface(0);
rdr = wholeUsbDevice.OpenEndpointReader((ReadEndpointID)0x81);
rdr.Flush();
Read();
}
void Reset()
{
if (UsbDev == null)
{
/* USB device not initilized, nothing to reset */
return;
}
Log.WriteLine("Resetting M4ATX device");
UsbDev.ResetDevice();
UsbDev = null;
}
public static void open()
{
ErrorCode ec = ErrorCode.None;
try
{
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
if (MyUsbDevice == null)
{
throw new Exception("Device Not Found.");
}
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
wholeUsbDevice.SetConfiguration(1);
wholeUsbDevice.ClaimInterface(0);
}
UsbEndpointWriter writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
byte[] bytesToSend = { 0x1b, 0x70, 0x00, 0x19, 0xff };
int bytesWritten;
ec = writer.Write(bytesToSend, 2000, out bytesWritten);
if (ec != ErrorCode.None)
{
throw new Exception(UsbDevice.LastErrorString);
}
}
catch (Exception ex)
{
Console.WriteLine();
Console.WriteLine((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message);
}
finally
{
if (MyUsbDevice != null)
{
if (MyUsbDevice.IsOpen)
{
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
UsbDevice.Exit();
}
}
}
/// <summary>
/// Cleans up a device, releasing interfaces and closing connection
/// </summary>
/// <param name="device">The device to close</param>
private void Destroy(IUsbDevice device)
{
try
{
// Attempt to clean up device
device.ReleaseInterface(device.Configs[0].Interfaces[0].Number);
device.Close();
}
catch (Exception e)
{
_logger.LogWarning(e, "Attempted to clean up device, but failed.");
}
}
public void Connect()
{
Context = new UsbContext();
Device = Context.Find(d => VID.Any(vid => d.VendorId == vid) &&
PID.Any(pid => d.ProductId == pid)).Clone();
if (Device is null)
{
throw new Exception("Device isn't connected!");
}
Device.Open();
}
public override void DeviceInitialize (IDevice device)
{
base.DeviceInitialize (device);
volume = device as IVolume;
if (volume == null || (usb_device = volume.ResolveRootUsbDevice ()) == null) {
throw new InvalidDeviceException ();
}
ms_device = DeviceMapper.Map (this);
try {
if (ms_device.ShouldIgnoreDevice () || !ms_device.LoadDeviceConfiguration ()) {
ms_device = null;
}
} catch {
ms_device = null;
}
if (!HasMediaCapabilities && ms_device == null) {
throw new InvalidDeviceException ();
}
// Ignore iPods, except ones with .is_audio_player files
if (MediaCapabilities != null && MediaCapabilities.IsType ("ipod")) {
if (ms_device != null && ms_device.HasIsAudioPlayerFile) {
Log.Information (
"Mass Storage Support Loading iPod",
"The USB mass storage audio player support is loading an iPod because it has an .is_audio_player file. " +
"If you aren't running Rockbox or don't know what you're doing, things might not behave as expected."
);
} else {
throw new InvalidDeviceException ();
}
}
Name = ms_device == null ? volume.Name : ms_device.Name;
mount_point = volume.MountPoint;
Initialize ();
if (ms_device != null) {
ms_device.SourceInitialize ();
}
AddDapProperties ();
// TODO differentiate between Audio Players and normal Disks, and include the size, eg "2GB Audio Player"?
//GenericName = Catalog.GetString ("Audio Player");
}
public Form1()
{
InitializeComponent();
// Hook the device notifier event
UsbDeviceNotifier.OnDeviceNotify += OnDeviceNotifyEvent;
usb_command = new byte[64];
try
{
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
if (MyUsbDevice == null)
{
//throw new Exception("Device Not Found.");
connected = false;
}
else
{
Device_l.Text = "Device: Connected";
connected = true;
Scan_b.Enabled = true;
wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// This is a "whole" USB device. Before it can be used,
// the desired configuration and interface must be selected.
// Select config #1
wholeUsbDevice.SetConfiguration(1);
// Claim interface #0.
wholeUsbDevice.ClaimInterface(0);
}
//MessageBox.Show(ReadEndpointID.Ep04.ToString());
reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
mode = 4;
backgroundWorker1.RunWorkerAsync();
}
}
catch (Exception ex)
{
MessageBox.Show((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message);
}
}
public static int GetProductId(IUsbDevice device)
{
var raw = device as IRawDevice;
int num = 0;
if (raw != null && Int32.TryParse (raw.Device.UdevMetadata.GetPropertyString (UdevProductId), NumberStyles.HexNumber, null, out num)) {
return num;
}
return 0;
}
public void Dispose()
{
try
{
if (_refreshSlotsThread != null)
{
_refreshSlotsThread.Abort();
_refreshSlotsThread = null;
}
if (_slots != null)
{
foreach (var slot in _slots.Values)
{
if (slot != null)
{
slot.DataReader.DataReceivedEnabled = false;
slot.DataReader.DataReceived -= DataReader_DataReceived;
slot.DataReader.Abort();
slot.DataReader.Dispose();
slot.HeadsetReader.DataReceivedEnabled = false;
slot.HeadsetReader.DataReceived -= HeadsetReader_DataReceived;
slot.HeadsetReader.Abort();
slot.HeadsetReader.Dispose();
}
}
}
_slots = new Dictionary<int, ReceiverSlot>();
if (_device != null)
{
if (_device.IsOpen)
_device.Close();
_device = null;
}
}
catch
{
//Don't care...
}
}
public void killReceiver()
{
// Loop through each Controller to clean it up
for (int i = 0; i < 4; i++)
{
// Turns off the Xbox controllers
if (receiverAttached)
{
if (xboxControllers[i].controllerAttached)
{
// Clean up the controller's keep-alive threads
xboxControllers[i].killKeepAlive();
// Clean up the controller's mouse mode threads
xboxControllers[i].killMouseMode();
// Clean up the controller's button combo threads
xboxControllers[i].killButtonCombo();
// Clean up the controller
xboxControllers[i].killController();
}
}
// Cleans up the Wireless Receiver Data
if (epWriters[i] != null)
{
epWriters[i].Abort();
epWriters[i].Dispose();
}
if (epReaders[i] != null)
{
epReaders[i].Abort();
epReaders[i].Dispose();
}
}
// Clean up the Receiver
if (wirelessReceiver != null)
{
if (receiverAttached)
wirelessReceiver.Close();
wirelessReceiver = null;
}
}
public void OnDeviceNotifyEvent(object sender, DeviceNotifyEventArgs e)
{
// A Device system-level event has occured
//Console.SetCursorPosition(0, Console.CursorTop);
//MessageBox.Show(e.Device.IdVendor.ToString());
if (e.EventType == EventType.DeviceArrival && e.Device.IdVendor == 0x16C0 && e.Device.IdProduct == 0x05DD)
{
try
{
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
if (MyUsbDevice == null)
{
//throw new Exception("Device Not Found.");
connected = false;
}
else
{
Device_l.Text = "Device: Connected";
connected = true;
Scan_b.Enabled = true;
wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// This is a "whole" USB device. Before it can be used,
// the desired configuration and interface must be selected.
// Select config #1
wholeUsbDevice.SetConfiguration(1);
// Claim interface #0.
wholeUsbDevice.ClaimInterface(0);
}
//MessageBox.Show(ReadEndpointID.Ep04.ToString());
reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
mode = 4;
backgroundWorker1.RunWorkerAsync();
}
}
catch (Exception ex)
{
MessageBox.Show((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message);
}
}
if (e.EventType == EventType.DeviceRemoveComplete && e.Device.IdVendor == 0x16C0 && e.Device.IdProduct == 0x05DD)
{
timer1.Enabled = false;
connected = false;
if (MyUsbDevice != null)
{
if (MyUsbDevice.IsOpen)
{
// If this is a "whole" usb device (libusb-win32, linux libusb-1.0)
// it exposes an IUsbDevice interface. If not (WinUSB) the
// 'wholeUsbDevice' variable will be null indicating this is
// an interface of a device; it does not require or support
// configuration and interface selection.
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
// Free usb resources
UsbDevice.Exit();
Device_l.Text = "Device: Not Connected";
Scan_b.Enabled = false;
DumpRAM_b.Enabled = false;
DumpROM_b.Enabled = false;
WriteRAM_b.Enabled = false;
Banks_l.Text = "Banks: ";
MBC_l.Text = "MBC: ";
RAM_l.Text = "RAM Size: ";
Size_l.Text = "Size:";
Title_l.Text = "Title:";
}
}
// Console.WriteLine(e.ToString()); // Dump the event info to output.
//Console.WriteLine();
//Console.Write("[Press any key to exit]");
}
public static int GetVendorId (IUsbDevice device)
{
var raw = device as IRawDevice;
return raw == null ? 0 : int.Parse (raw.Device.UdevMetadata.GetPropertyString (UdevVendorId), NumberStyles.HexNumber);
}
// USB connection and adapter management
public override void Open()
{
this.Close();
try
{
caLibUsbAdapter.write_lock.WaitOne();
usb_finder = new UsbDeviceFinder(this.vid, this.pid);
Debug.Assert(this.usb_finder != null);
// open device
usb_device = UsbDevice.OpenUsbDevice(usb_finder);
if (usb_device == null)
{
throw new Exception("No compatible adapters found");
}
wholeUsbDevice = usb_device as IUsbDevice;
if (!ReferenceEquals (wholeUsbDevice, null)) {
wholeUsbDevice.SetConfiguration(1);
wholeUsbDevice.ClaimInterface(1);
} else {
throw new Exception("Failed to claim interface");
}
// open endpoints
ep_reader = usb_device.OpenEndpointReader(this.read_ep_id);
ep_writer = usb_device.OpenEndpointWriter(this.write_ep_id);
if(ep_reader == null || ep_writer == null)
{
throw new Exception("Failed to open endpoints");
}
// clear garbage from input
this.ep_reader.ReadFlush();
// attach read event
ep_reader.DataReceived += (read_usb);
ep_reader.DataReceivedEnabled = true;
} catch (Exception e) {
this.Close();
throw e;
} finally {
caLibUsbAdapter.write_lock.ReleaseMutex();
}
}
public void Stop()
{
lock (_lock)
{
IsOpen = false;
EndPointId = ReadEndpointID.Ep01;
CommunicationOk = false;
if (_reader != null)
{
_thread.Abort();
_thread.Join();
//_reader.DataReceivedEnabled = false;
//_reader.DataReceived -= OnReaderDataReceived;
_reader.ReadFlush();
_reader.Abort();
_reader = null;
}
if (_device != null)
{
_device.ReleaseInterface(0);
_device.Close();
_device = null;
UsbDevice.Exit();
}
}
}
public bool Reset()
{
bool ret = true;
Close();
//Start message thread
_messageThread = new Thread(new ThreadStart(_SendMessages));
_messageThread.IsBackground = true;
_messageThread.Start();
//Find device
_device = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(_VENDOR_ID, _PRODUCT_ID)) as IUsbDevice;
if (_device != null)
{
//Set up the incoming and outgoing endpoints
_reader = _device.OpenEndpointReader(LibUsbDotNet.Main.ReadEndpointID.Ep03);
_reader.DataReceived += _reader_DataReceived;
_reader.DataReceivedEnabled = true;
lock (_writerLock)
{
_writer = _device.OpenEndpointWriter(LibUsbDotNet.Main.WriteEndpointID.Ep02);
}
}
else
ret = false;
return ret;
}
public static int GetDeviceNumber(IUsbDevice device)
{
var raw = device as IRawDevice;
int num = 0;
if (raw != null && Int32.TryParse (raw.Device.UdevMetadata.GetPropertyString (UdevUsbDeviceNumber), out num)) {
return num;
}
return 0;
}
private void InitUSB(int VendorID, int ProductID)
{
dev = (IUsbDevice)UsbDevice.OpenUsbDevice(x => x.Vid == VendorID && x.Pid == ProductID);
if (dev == null)
{
throw new NullReferenceException("Cannot find USB device for JZ4780. Check Vendor/Product IDs and that LibUSB-Win32 \".inf\" installed.");
}
dev.SetConfiguration(1);
}
public void Cleanup()
{
dev.ReleaseInterface(0);
dev.Close();
dev = null;
}
public static int GetDeviceNumber (IUsbDevice device)
{
var raw = device as IRawDevice;
return raw == null ? 0 : int.Parse (raw.Device.UdevMetadata.GetPropertyString (UdevUsbDeviceNumber));
}
public static int GetSpeed (IUsbDevice device)
{
throw new NotImplementedException ();
}
public void Start()
{
lock (_lock)
{
UsbRegDeviceList allLibUsbDevices = UsbDevice.AllLibUsbDevices;
if (allLibUsbDevices.Count > 0)
{
UsbDevice dev;
IsOpen = ((LibUsbRegistry)allLibUsbDevices.First()).Open(out dev);
_device = dev as IUsbDevice;
// Select config
bool configuration = _device.SetConfiguration(1);
// Claim interface
bool claimInterface = _device.ClaimInterface(0);
/*bool found = false;
byte readerId = (byte) ReadEndpointID.Ep01;
while (!found && (byte)readerId <= (byte)ReadEndpointID.Ep15)
{
_reader = _device.OpenEndpointReader((ReadEndpointID)readerId);
byte[] buffer = new byte[1024];
int length;
ErrorCode ret = _reader.Read(buffer, 100, out length);
found = (ret != ErrorCode.Win32Error);
readerId++;
}*/
EndPointId = GetEndpoint();
_reader = _device.OpenEndpointReader(EndPointId);
_thread.Start();
//_reader.DataReceivedEnabled = true;
//_reader.ReadBufferSize = 8;
//_reader.DataReceived += OnReaderDataReceived;
}
}
}
/// <summary>
/// Инициализирует новый экземпляр класса <see cref="T:System.Object"/>.
/// </summary>
public S5Pc100UsbConnection(IUsbDevice Device)
{
this.Device = Device;
}
private void _Init(int vendorId, int productId, int interfaceNumber)
{
_readers = new Dictionary<int, UsbEndpointReader>();
_writers = new Dictionary<int, UsbEndpointWriter>();
_forwardee = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(vendorId, productId)) as IUsbDevice;
if (_forwardee == null) throw new InvalidOperationException("Device not found");
_forwardee.ClaimInterface(interfaceNumber);
_forwardee.SetConfiguration(1);
}
private void button2_Click(object sender, EventArgs e)
{
try
{
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
if (MyUsbDevice == null)
{
throw new Exception("Device Not Found.");
//connected = false;
}
else
{
Device_l.Text = "Device: Connected";
//connected = true;
Scan_b.Enabled = true;
wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// This is a "whole" USB device. Before it can be used,
// the desired configuration and interface must be selected.
// Select config #1
wholeUsbDevice.SetConfiguration(1);
// Claim interface #0.
wholeUsbDevice.ClaimInterface(0);
}
reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep03);
writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep04);
}
}
catch (Exception ex)
{
MessageBox.Show((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message);
}
}
private void _Init(bool throwErrors)
{
Dispose();
_device = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(_VENDOR_ID, _PRODUCT_ID1)) as IUsbDevice;
if (_device == null) _device = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(_VENDOR_ID, _PRODUCT_ID2)) as IUsbDevice;
if (_device == null) _device = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(_VENDOR_ID, _PRODUCT_ID3)) as IUsbDevice;
if (_device == null)
{
if (throwErrors)
throw new InvalidOperationException("Wireless receiver not found");
}
else
{
_device.ClaimInterface(1);
_device.SetConfiguration(1);
_responses = new Dictionary<int, List<byte[]>>();
var now = DateTime.Now;
for (int i = 0; i < _NUMBER_OF_SLOTS; i++)
{
var slot = new ReceiverSlot();
slot.DataWriter = _device.OpenEndpointWriter(_GetWriteEndpoint((i * 2) + 1));
slot.DataReader = _device.OpenEndpointReader(_GetReadEndpoint((i * 2) + 1));
slot.DataReader.DataReceived += DataReader_DataReceived;
slot.DataReader.DataReceivedEnabled = true;
slot.HeadsetWriter = _device.OpenEndpointWriter(_GetWriteEndpoint((i * 2) + 2));
slot.HeadsetReader = _device.OpenEndpointReader(_GetReadEndpoint((i * 2) + 2));
slot.HeadsetReader.DataReceived += HeadsetReader_DataReceived;
slot.HeadsetReader.DataReceivedEnabled = true;
_slots.Add(i + 1, slot);
_RefreshSlot(i + 1);
}
_refreshSlotsThread = new Thread(new ThreadStart(_RefreshSlots));
_refreshSlotsThread.IsBackground = true;
_refreshSlotsThread.Start();
}
}
public void connectReceiver()
{
// Connect to the Xbox Wireless Receiver and register the endpoint
// readers/writers as necessary.
try
{
// Open the Xbox Wireless Receiver as a USB device
// VendorID 0x045e, ProductID 0x0719
wirelessReceiver = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(0x045E, 0x0719)) as IUsbDevice;
// If primary IDs not found attempt secondary IDs
// VendorID 0x045e, Product ID 0x0291
if (wirelessReceiver == null)
wirelessReceiver = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(0x045E, 0x0291)) as IUsbDevice;
// If secondary IDs not found report the error
if (wirelessReceiver == null)
parentWindow.Invoke(new logCallback(parentWindow.logMessage),
"ERROR: Wireless Receiver Not Found.");
else
{
// Set the Configuration, Claim the Interface
wirelessReceiver.ClaimInterface(1);
wirelessReceiver.SetConfiguration(1);
// Log if the Wireless Receiver was connected to successfully
if (wirelessReceiver.IsOpen)
{
receiverAttached = true;
parentWindow.Invoke(new logCallback(parentWindow.logMessage),
"Xbox 360 Wireless Receiver Connected.");
// Connect Bulk Endpoint Readers/Writers and register the receiving event handler
// Controller 1
epReaders[0] = wirelessReceiver.OpenEndpointReader(ReadEndpointID.Ep01);
epWriters[0] = wirelessReceiver.OpenEndpointWriter(WriteEndpointID.Ep01);
epReaders[0].DataReceived += new EventHandler<EndpointDataEventArgs>(xboxControllers[0].processDataPacket);
epReaders[0].DataReceivedEnabled = true;
xboxControllers[0].registerEndpointWriter(epWriters[0]);
// Controller 2
epReaders[1] = wirelessReceiver.OpenEndpointReader(ReadEndpointID.Ep03);
epWriters[1] = wirelessReceiver.OpenEndpointWriter(WriteEndpointID.Ep03);
epReaders[1].DataReceived += new EventHandler<EndpointDataEventArgs>(xboxControllers[1].processDataPacket);
epReaders[1].DataReceivedEnabled = true;
xboxControllers[1].registerEndpointWriter(epWriters[1]);
// Controller 3
epReaders[2] = wirelessReceiver.OpenEndpointReader(ReadEndpointID.Ep05);
epWriters[2] = wirelessReceiver.OpenEndpointWriter(WriteEndpointID.Ep05);
epReaders[2].DataReceived += new EventHandler<EndpointDataEventArgs>(xboxControllers[2].processDataPacket);
epReaders[2].DataReceivedEnabled = true;
xboxControllers[2].registerEndpointWriter(epWriters[2]);
// Controller 4
epReaders[3] = wirelessReceiver.OpenEndpointReader(ReadEndpointID.Ep07);
epWriters[3] = wirelessReceiver.OpenEndpointWriter(WriteEndpointID.Ep07);
epReaders[3].DataReceived += new EventHandler<EndpointDataEventArgs>(xboxControllers[3].processDataPacket);
epReaders[3].DataReceivedEnabled = true;
xboxControllers[3].registerEndpointWriter(epWriters[3]);
parentWindow.Invoke(new logCallback(parentWindow.logMessage),
"Searching for Controllers...Press the Guide Button Now.");
}
}
}
catch
{
parentWindow.Invoke(new logCallback(parentWindow.logMessage),
"ERROR: Problem Connecting to Wireless Receiver.");
}
}
public void Open()
{
if (_deviceReg.Open(out _device) == false)
{
throw new InvalidOperationException("Unable to open the dongle, was it removed?");
}
_writer = _device.OpenEndpointWriter(WriteEndpointID.Ep01, EndpointType.Bulk);
_reader = _device.OpenEndpointReader(ReadEndpointID.Ep01, 32, EndpointType.Bulk);
_iDevice = _device as IUsbDevice;
if (_iDevice != null)
{
_iDevice.SetConfiguration(1);
_iDevice.ClaimInterface(0);
}
Setup();
}
