public override bool ReadPipe(UsbEndpointBase endPointBase, IntPtr buffer, int bufferLength, out int lengthTransferred, int isoPacketSize, IntPtr pOverlapped) { LibUsbRequest req = new LibUsbRequest(); req.Endpoint.ID = endPointBase.EpNum; req.Endpoint.PacketSize = isoPacketSize; req.Timeout = UsbConstants.DEFAULT_TIMEOUT; int cltCode = endPointBase.Type == EndpointType.Isochronous ? LibUsbIoCtl.ISOCHRONOUS_READ : LibUsbIoCtl.INTERRUPT_OR_BULK_READ; return(Kernel32.DeviceIoControl(endPointBase.Device.Handle, cltCode, req, LibUsbRequest.Size, buffer, bufferLength, out lengthTransferred, pOverlapped)); }
public bool ResetDevice(SafeHandle interfaceHandle) { LibUsbRequest req = new LibUsbRequest(); int ret; req.Timeout = UsbConstants.DEFAULT_TIMEOUT; return LibUsbDriverIO.UsbIOSync(interfaceHandle, LibUsbIoCtl.RESET_DEVICE, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret); }
public bool ResetDevice(SafeHandle interfaceHandle) { LibUsbRequest req = new LibUsbRequest(); int ret; req.Timeout = UsbConstants.DEFAULT_TIMEOUT; return(LibUsbDriverIO.UsbIOSync(interfaceHandle, LibUsbIoCtl.RESET_DEVICE, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret)); }
public override bool AbortPipe(SafeHandle interfaceHandle, byte pipeID) { LibUsbRequest req = new LibUsbRequest(); int ret; req.Endpoint.ID = pipeID; req.Timeout = UsbConstants.DEFAULT_TIMEOUT; return LibUsbDriverIO.UsbIOSync(interfaceHandle, LibUsbIoCtl.ABORT_ENDPOINT, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret); }
public override bool AbortPipe(SafeHandle interfaceHandle, byte pipeID) { LibUsbRequest req = new LibUsbRequest(); int ret; req.Endpoint.ID = pipeID; req.Timeout = UsbConstants.DEFAULT_TIMEOUT; return(LibUsbDriverIO.UsbIOSync(interfaceHandle, LibUsbIoCtl.ABORT_ENDPOINT, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret)); }
internal static bool ControlTransferEx(SafeHandle interfaceHandle, UsbSetupPacket setupPacket, IntPtr buffer, int bufferLength, out int lengthTransferred, int timeout) { lengthTransferred = 0; LibUsbRequest req = new LibUsbRequest(); req.Timeout = timeout; req.Control.RequestType = (byte)setupPacket.RequestType; req.Control.Request = (byte)setupPacket.Request; req.Control.Value = (ushort)setupPacket.Value; req.Control.Index = (ushort)setupPacket.Index; req.Control.Length = (ushort)setupPacket.Length; /* in request? */ Byte[] reqBytes = req.Bytes; Byte[] inBytes = reqBytes; if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0) { inBytes = new byte[LibUsbRequest.Size + bufferLength]; reqBytes.CopyTo(inBytes, 0); if (buffer != IntPtr.Zero) { Marshal.Copy(buffer, inBytes, LibUsbRequest.Size, bufferLength); } buffer = IntPtr.Zero; bufferLength = 0; } if (UsbIOSync(interfaceHandle, LibUsbIoCtl.CONTROL_TRANSFER, inBytes, inBytes.Length, buffer, bufferLength, out lengthTransferred)) { /* in request? */ if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0) { lengthTransferred = (inBytes.Length - reqBytes.Length); } return(true); } return(false); }
public override bool GetDescriptor(SafeHandle interfaceHandle, byte descriptorType, byte index, ushort languageID, IntPtr buffer, int bufferLength, out int lengthTransferred) { LibUsbRequest req = new LibUsbRequest(); req.Descriptor.Index = index; req.Descriptor.LangID = languageID; req.Descriptor.Recipient = (byte) UsbEndpointDirection.EndpointIn & 0x1F; req.Descriptor.Type = descriptorType; return LibUsbDriverIO.UsbIOSync(interfaceHandle, LibUsbIoCtl.GET_DESCRIPTOR, req, LibUsbRequest.Size, buffer, bufferLength, out lengthTransferred); }
public override bool GetDescriptor(SafeHandle interfaceHandle, byte descriptorType, byte index, ushort languageID, IntPtr buffer, int bufferLength, out int lengthTransferred) { LibUsbRequest req = new LibUsbRequest(); req.Descriptor.Index = index; req.Descriptor.LangID = languageID; req.Descriptor.Recipient = (byte)UsbEndpointDirection.EndpointIn & 0x1F; req.Descriptor.Type = descriptorType; return(LibUsbDriverIO.UsbIOSync(interfaceHandle, LibUsbIoCtl.GET_DESCRIPTOR, req, LibUsbRequest.Size, buffer, bufferLength, out lengthTransferred)); }
public static byte[] RegSetStringRequest(string name, string value) { LibUsbRequest req = new LibUsbRequest(); int uOffset = LibUsbRequest.Size; req.DeviceRegKey.KeyType = (int) KeyType.RegSz; byte[] bytesName = Encoding.Unicode.GetBytes(name + "\0"); byte[] bytesValue = Encoding.Unicode.GetBytes(value + "\0"); req.DeviceRegKey.NameOffset = uOffset; uOffset += bytesName.Length; req.DeviceRegKey.ValueOffset = uOffset; req.DeviceRegKey.ValueLength = bytesValue.Length; uOffset += bytesValue.Length; byte[] buffer = new byte[uOffset]; byte[] regBytes = req.Bytes; Array.Copy(regBytes, buffer, regBytes.Length); Array.Copy(bytesName, 0, buffer, req.DeviceRegKey.NameOffset, bytesName.Length); Array.Copy(bytesValue, 0, buffer, req.DeviceRegKey.ValueOffset, bytesValue.Length); return buffer; }
public static byte[] RegGetRequest(string name, int valueBufferSize) { if (valueBufferSize < 1 || name.Trim().Length == 0) throw new UsbException("Global", "Invalid DeviceRegistry het parameter."); LibUsbRequest req = new LibUsbRequest(); int uOffset = LibUsbRequest.Size; req.DeviceRegKey.KeyType = (int) KeyType.RegBinary; byte[] bytesName = Encoding.Unicode.GetBytes(name + "\0"); req.DeviceRegKey.NameOffset = uOffset; uOffset += bytesName.Length; req.DeviceRegKey.ValueOffset = uOffset; req.DeviceRegKey.ValueLength = (valueBufferSize); uOffset += Math.Max(uOffset + 1, valueBufferSize - (LibUsbRequest.Size + bytesName.Length)); byte[] buffer = new byte[uOffset]; byte[] regBytes = req.Bytes; Array.Copy(regBytes, buffer, regBytes.Length); Array.Copy(bytesName, 0, buffer, req.DeviceRegKey.NameOffset, bytesName.Length); return buffer; }
private void GetPropertiesSPDRP(SafeHandle usbHandle) { byte[] propBuffer = new byte[1024]; GCHandle gcPropBuffer = GCHandle.Alloc(propBuffer, GCHandleType.Pinned); LibUsbRequest req = new LibUsbRequest(); Dictionary<string, int> allProps = Helper.GetEnumData(typeof (DevicePropertyType)); foreach (KeyValuePair<string, int> prop in allProps) { object oValue = String.Empty; req.DeviceProperty.ID = prop.Value; int iReturnBytes; bool bSuccess = LibUsbDriverIO.UsbIOSync(usbHandle, LibUsbIoCtl.GET_REG_PROPERTY, req, LibUsbRequest.Size, gcPropBuffer.AddrOfPinnedObject(), propBuffer.Length, out iReturnBytes); if (bSuccess) { switch ((DevicePropertyType) prop.Value) { case DevicePropertyType.PhysicalDeviceObjectName: case DevicePropertyType.LocationInformation: case DevicePropertyType.Class: case DevicePropertyType.Mfg: case DevicePropertyType.DeviceDesc: case DevicePropertyType.Driver: case DevicePropertyType.EnumeratorName: case DevicePropertyType.FriendlyName: case DevicePropertyType.ClassGuid: oValue = GetAsString(propBuffer, iReturnBytes); break; case DevicePropertyType.HardwareId: case DevicePropertyType.CompatibleIds: oValue = GetAsStringArray(propBuffer, iReturnBytes); break; case DevicePropertyType.BusNumber: case DevicePropertyType.InstallState: case DevicePropertyType.LegacyBusType: case DevicePropertyType.RemovalPolicy: case DevicePropertyType.UiNumber: case DevicePropertyType.Address: oValue = GetAsStringInt32(propBuffer, iReturnBytes); break; case DevicePropertyType.BusTypeGuid: oValue = GetAsGuid(propBuffer, iReturnBytes); break; } } else oValue = String.Empty; mDeviceProperties.Add(prop.Key, oValue); } gcPropBuffer.Free(); }
/// <summary> /// Sets an alternate interface for the specified interface. /// </summary> /// <param name="interfaceID">The interface index to specify an alternate setting for.</param> /// <param name="alternateID">The alternate interface setting.</param> /// <returns>True on success.</returns> public bool SetAltInterface(int interfaceID, int alternateID) { if (!mClaimedInterfaces.Contains(interfaceID)) throw new UsbException(this, String.Format("You must claim interface {0} before setting an alternate interface.", interfaceID)); LibUsbRequest req = new LibUsbRequest(); req.Iface.ID = interfaceID; req.Iface.AlternateID = alternateID; req.Timeout = UsbConstants.DEFAULT_TIMEOUT; int ret; if (UsbIoSync(LibUsbIoCtl.SET_INTERFACE, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret)) { UsbAltInterfaceSettings[interfaceID] = (byte) alternateID; return true; } return false; }
/// <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) { LibUsbRequest req = new LibUsbRequest(); req.Iface.ID = interfaceID; if (!mClaimedInterfaces.Remove(interfaceID)) return true; req.Timeout = UsbConstants.DEFAULT_TIMEOUT; int ret; // NOTE: A claimed interface is ALWAYS removed from the internal list. bool bSuccess = UsbIoSync(LibUsbIoCtl.RELEASE_INTERFACE, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret); return bSuccess; }
/// <summary> /// Gets the alternate interface number for the specified interfaceID. /// </summary> /// <param name="interfaceID">The interface number of to get the alternate setting for.</param> /// <param name="alternateID">The currrently selected alternate interface number.</param> /// <returns>True on success.</returns> public bool GetAltInterface(int interfaceID, out int alternateID) { LibUsbRequest req = new LibUsbRequest(); req.Iface.ID = interfaceID; req.Timeout = UsbConstants.DEFAULT_TIMEOUT; int ret; GCHandle gc = GCHandle.Alloc(req, GCHandleType.Pinned); bool success; alternateID = -1; if ((success = UsbIoSync(LibUsbIoCtl.GET_INTERFACE, req, LibUsbRequest.Size, gc.AddrOfPinnedObject(), 1, out ret)) == true) { alternateID = Marshal.ReadByte(gc.AddrOfPinnedObject()); UsbAltInterfaceSettings[interfaceID] = (byte)alternateID; } gc.Free(); return success; }
/// <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) { if (mClaimedInterfaces.Contains(interfaceID)) return true; LibUsbRequest req = new LibUsbRequest(); req.Iface.ID = interfaceID; req.Timeout = UsbConstants.DEFAULT_TIMEOUT; int ret; bool bSuccess = UsbIoSync(LibUsbIoCtl.CLAIM_INTERFACE, req, LibUsbRequest.Size, IntPtr.Zero, 0, out ret); if (bSuccess) mClaimedInterfaces.Add(interfaceID); return bSuccess; }
internal static bool ControlTransfer(SafeHandle interfaceHandle, UsbSetupPacket setupPacket, IntPtr buffer, int bufferLength, out int lengthTransferred, int timeout) { lengthTransferred = 0; LibUsbRequest req = new LibUsbRequest(); int code; req.Timeout = timeout; switch ((UsbRequestType)(setupPacket.RequestType & (0x03 << 5))) { case UsbRequestType.TypeStandard: switch ((UsbStandardRequest)setupPacket.Request) { case UsbStandardRequest.GetStatus: req.Status.Recipient = (int) setupPacket.RequestType & 0x1F; req.Status.Index = setupPacket.Index; code = LibUsbIoCtl.GET_STATUS; break; case UsbStandardRequest.ClearFeature: req.Feature.Recipient = (int) setupPacket.RequestType & 0x1F; req.Feature.ID = setupPacket.Value; req.Feature.Index = setupPacket.Index; code = LibUsbIoCtl.CLEAR_FEATURE; break; case UsbStandardRequest.SetFeature: req.Feature.Recipient = (int) setupPacket.RequestType & 0x1F; req.Feature.ID = setupPacket.Value; req.Feature.Index = setupPacket.Index; code = LibUsbIoCtl.SET_FEATURE; break; case UsbStandardRequest.GetDescriptor: req.Descriptor.Recipient = (int) setupPacket.RequestType & 0x1F; req.Descriptor.Type = (setupPacket.Value >> 8) & 0xFF; req.Descriptor.Index = setupPacket.Value & 0xFF; req.Descriptor.LangID = setupPacket.Index; code = LibUsbIoCtl.GET_DESCRIPTOR; break; case UsbStandardRequest.SetDescriptor: req.Descriptor.Recipient = (int) setupPacket.RequestType & 0x1F; req.Descriptor.Type = (setupPacket.Value >> 8) & 0xFF; req.Descriptor.Index = setupPacket.Value & 0xFF; req.Descriptor.LangID = setupPacket.Index; code = LibUsbIoCtl.SET_DESCRIPTOR; break; case UsbStandardRequest.GetConfiguration: code = LibUsbIoCtl.GET_CONFIGURATION; break; case UsbStandardRequest.SetConfiguration: req.Config.ID = setupPacket.Value; code = LibUsbIoCtl.SET_CONFIGURATION; break; case UsbStandardRequest.GetInterface: req.Iface.ID = setupPacket.Index; code = LibUsbIoCtl.GET_INTERFACE; break; case UsbStandardRequest.SetInterface: req.Iface.ID = setupPacket.Index; req.Iface.AlternateID = setupPacket.Value; code = LibUsbIoCtl.SET_INTERFACE; break; default: UsbError.Error(ErrorCode.IoControlMessage,0, String.Format("Invalid request: 0x{0:X8}", setupPacket.Request), typeof(LibUsbDriverIO)); return false; } break; case UsbRequestType.TypeVendor: case UsbRequestType.TypeClass: req.Vendor.Type = ((byte) setupPacket.RequestType >> 5) & 0x03; req.Vendor.Recipient = (int) setupPacket.RequestType & 0x1F; req.Vendor.Request = (int) setupPacket.Request; req.Vendor.ID = setupPacket.Value; req.Vendor.Index = setupPacket.Index; code = ((byte) setupPacket.RequestType & 0x80) > 0 ? LibUsbIoCtl.VENDOR_READ : LibUsbIoCtl.VENDOR_WRITE; break; case UsbRequestType.TypeReserved: default: UsbError.Error(ErrorCode.IoControlMessage,0, String.Format("invalid or unsupported request type: 0x{0:X8}", setupPacket.RequestType), typeof(LibUsbDriverIO)); return false; } /* in request? */ Byte[] reqBytes = req.Bytes; Byte[] inBytes = reqBytes; if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0) { inBytes = new byte[LibUsbRequest.Size + bufferLength]; reqBytes.CopyTo(inBytes, 0); if (buffer != IntPtr.Zero) Marshal.Copy(buffer, inBytes, LibUsbRequest.Size, bufferLength); buffer = IntPtr.Zero; bufferLength = 0; } if (UsbIOSync(interfaceHandle, code, inBytes, inBytes.Length, buffer, bufferLength, out lengthTransferred)) { /* in request? */ if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0) lengthTransferred = (inBytes.Length - reqBytes.Length); return true; } return false; }
internal static bool ControlTransferEx(SafeHandle interfaceHandle, UsbSetupPacket setupPacket, IntPtr buffer, int bufferLength, out int lengthTransferred, int timeout) { lengthTransferred = 0; LibUsbRequest req = new LibUsbRequest(); req.Timeout = timeout; req.Control.RequestType = (byte) setupPacket.RequestType; req.Control.Request = (byte) setupPacket.Request; req.Control.Value = (ushort) setupPacket.Value; req.Control.Index = (ushort) setupPacket.Index; req.Control.Length = (ushort) setupPacket.Length; /* in request? */ Byte[] reqBytes = req.Bytes; Byte[] inBytes = reqBytes; if ((setupPacket.RequestType & (byte) UsbEndpointDirection.EndpointIn) == 0) { inBytes = new byte[LibUsbRequest.Size + bufferLength]; reqBytes.CopyTo(inBytes, 0); if (buffer != IntPtr.Zero) Marshal.Copy(buffer, inBytes, LibUsbRequest.Size, bufferLength); buffer = IntPtr.Zero; bufferLength = 0; } if (UsbIOSync(interfaceHandle, LibUsbIoCtl.CONTROL_TRANSFER, inBytes, inBytes.Length, buffer, bufferLength, out lengthTransferred)) { /* in request? */ if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0) lengthTransferred = (inBytes.Length - reqBytes.Length); return true; } return false; }
internal static bool ControlTransfer(SafeHandle interfaceHandle, UsbSetupPacket setupPacket, IntPtr buffer, int bufferLength, out int lengthTransferred, int timeout) { lengthTransferred = 0; LibUsbRequest req = new LibUsbRequest(); int code; req.Timeout = timeout; switch ((UsbRequestType)(setupPacket.RequestType & (0x03 << 5))) { case UsbRequestType.TypeStandard: switch ((UsbStandardRequest)setupPacket.Request) { case UsbStandardRequest.GetStatus: req.Status.Recipient = (int)setupPacket.RequestType & 0x1F; req.Status.Index = setupPacket.Index; code = LibUsbIoCtl.GET_STATUS; break; case UsbStandardRequest.ClearFeature: req.Feature.Recipient = (int)setupPacket.RequestType & 0x1F; req.Feature.ID = setupPacket.Value; req.Feature.Index = setupPacket.Index; code = LibUsbIoCtl.CLEAR_FEATURE; break; case UsbStandardRequest.SetFeature: req.Feature.Recipient = (int)setupPacket.RequestType & 0x1F; req.Feature.ID = setupPacket.Value; req.Feature.Index = setupPacket.Index; code = LibUsbIoCtl.SET_FEATURE; break; case UsbStandardRequest.GetDescriptor: req.Descriptor.Recipient = (int)setupPacket.RequestType & 0x1F; req.Descriptor.Type = (setupPacket.Value >> 8) & 0xFF; req.Descriptor.Index = setupPacket.Value & 0xFF; req.Descriptor.LangID = setupPacket.Index; code = LibUsbIoCtl.GET_DESCRIPTOR; break; case UsbStandardRequest.SetDescriptor: req.Descriptor.Recipient = (int)setupPacket.RequestType & 0x1F; req.Descriptor.Type = (setupPacket.Value >> 8) & 0xFF; req.Descriptor.Index = setupPacket.Value & 0xFF; req.Descriptor.LangID = setupPacket.Index; code = LibUsbIoCtl.SET_DESCRIPTOR; break; case UsbStandardRequest.GetConfiguration: code = LibUsbIoCtl.GET_CONFIGURATION; break; case UsbStandardRequest.SetConfiguration: req.Config.ID = setupPacket.Value; code = LibUsbIoCtl.SET_CONFIGURATION; break; case UsbStandardRequest.GetInterface: req.Iface.ID = setupPacket.Index; code = LibUsbIoCtl.GET_INTERFACE; break; case UsbStandardRequest.SetInterface: req.Iface.ID = setupPacket.Index; req.Iface.AlternateID = setupPacket.Value; code = LibUsbIoCtl.SET_INTERFACE; break; default: UsbError.Error(ErrorCode.IoControlMessage, 0, String.Format("Invalid request: 0x{0:X8}", setupPacket.Request), typeof(LibUsbDriverIO)); return(false); } break; case UsbRequestType.TypeVendor: case UsbRequestType.TypeClass: req.Vendor.Type = ((byte)setupPacket.RequestType >> 5) & 0x03; req.Vendor.Recipient = (int)setupPacket.RequestType & 0x1F; req.Vendor.Request = (int)setupPacket.Request; req.Vendor.ID = setupPacket.Value; req.Vendor.Index = setupPacket.Index; code = ((byte)setupPacket.RequestType & 0x80) > 0 ? LibUsbIoCtl.VENDOR_READ : LibUsbIoCtl.VENDOR_WRITE; break; case UsbRequestType.TypeReserved: default: UsbError.Error(ErrorCode.IoControlMessage, 0, String.Format("invalid or unsupported request type: 0x{0:X8}", setupPacket.RequestType), typeof(LibUsbDriverIO)); return(false); } /* in request? */ Byte[] reqBytes = req.Bytes; Byte[] inBytes = reqBytes; if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0) { inBytes = new byte[LibUsbRequest.Size + bufferLength]; reqBytes.CopyTo(inBytes, 0); if (buffer != IntPtr.Zero) { Marshal.Copy(buffer, inBytes, LibUsbRequest.Size, bufferLength); } buffer = IntPtr.Zero; bufferLength = 0; } if (UsbIOSync(interfaceHandle, code, inBytes, inBytes.Length, buffer, bufferLength, out lengthTransferred)) { /* in request? */ if ((setupPacket.RequestType & (byte)UsbEndpointDirection.EndpointIn) == 0) { lengthTransferred = (inBytes.Length - reqBytes.Length); } return(true); } return(false); }
public override bool ReadPipe(UsbEndpointBase endPointBase, IntPtr buffer, int bufferLength, out int lengthTransferred, int isoPacketSize, IntPtr pOverlapped) { LibUsbRequest req = new LibUsbRequest(); req.Endpoint.ID = endPointBase.EpNum; req.Endpoint.PacketSize = isoPacketSize; req.Timeout = UsbConstants.DEFAULT_TIMEOUT; int cltCode = endPointBase.Type == EndpointType.Isochronous ? LibUsbIoCtl.ISOCHRONOUS_READ : LibUsbIoCtl.INTERRUPT_OR_BULK_READ; return Kernel32.DeviceIoControl(endPointBase.Device.Handle, cltCode, req, LibUsbRequest.Size, buffer, bufferLength, out lengthTransferred, pOverlapped); }
private bool GetObjectName(SafeFileHandle usbHandle, int objectNameIndex, out string objectName) { int objNameLength; Byte[] regKeyPathname = new byte[512]; GCHandle gcRegKeyPathname = GCHandle.Alloc(regKeyPathname, GCHandleType.Pinned); #if RESERVED_FOR_FUTURE_USE LibUsbRequest req=new LibUsbRequest(); req.ObjectName.Index = objectNameIndex; Marshal.Copy(req.Bytes, 0, gcRegKeyPathname.AddrOfPinnedObject(),LibUsbRequest.Size); #endif bool bSuccess = LibUsbDriverIO.UsbIOSync(usbHandle, LibUsbIoCtl.GET_OBJECT_NAME, regKeyPathname, regKeyPathname.Length, gcRegKeyPathname.AddrOfPinnedObject(), regKeyPathname.Length, out objNameLength); gcRegKeyPathname.Free(); if (bSuccess && objNameLength > 1) objectName = Encoding.ASCII.GetString(regKeyPathname, 0, objNameLength-1); else objectName = String.Empty; return bSuccess; }