Mercurial > hg > ucis.core
annotate USBLib/Communication/USBIO/USBIODevice.cs @ 67:2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
| author | Ivo Smits <Ivo@UCIS.nl> |
|---|---|
| date | Wed, 16 Oct 2013 01:11:49 +0200 |
| parents | abe0d55a2201 |
| children | e811297f5aa4 |
| rev | line source |
|---|---|
| 35 | 1 using System; |
| 2 using System.Collections.Generic; | |
| 3 using System.ComponentModel; | |
| 4 using System.IO; | |
| 5 using System.Runtime.InteropServices; | |
| 6 using Microsoft.Win32.SafeHandles; | |
| 7 using UCIS.USBLib.Internal.Windows; | |
| 8 | |
| 9 namespace UCIS.USBLib.Communication.USBIO { | |
| 10 public class USBIODevice : UsbInterface, IUsbDevice { | |
| 11 public string DeviceFilename { get; private set; } | |
| 12 public IUsbDeviceRegistry Registry { get; private set; } | |
| 13 private SafeFileHandle DeviceHandle; | |
| 14 private SafeFileHandle[] PipeHandlesIn = null; | |
| 15 private SafeFileHandle[] PipeHandlesOut = null; | |
| 16 | |
| 17 static int CTL_CODE(int DeviceType, int Function, int Method, int Access) { return ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method); } | |
| 18 static int _USBIO_IOCTL_CODE(int FnCode, int Method) { return CTL_CODE(0x8094, 0x800 + FnCode, Method, 0); } | |
| 19 const int METHOD_BUFFERED = 0; | |
| 20 const int METHOD_IN_DIRECT = 1; | |
| 21 const int METHOD_OUT_DIRECT = 2; | |
| 22 static readonly int IOCTL_USBIO_GET_DESCRIPTOR = _USBIO_IOCTL_CODE(1, METHOD_OUT_DIRECT); | |
| 23 static readonly int IOCTL_USBIO_GET_CONFIGURATION = _USBIO_IOCTL_CODE(6, METHOD_BUFFERED); | |
| 24 static readonly int IOCTL_USBIO_SET_CONFIGURATION = _USBIO_IOCTL_CODE(9, METHOD_BUFFERED); | |
|
38
a9c4fed19e99
USBLib: fixes in USBIO driver and LibUsbDotNet compatibility code
Ivo Smits <Ivo@UCIS.nl>
parents:
37
diff
changeset
|
25 static readonly int IOCTL_USBIO_UNCONFIGURE_DEVICE = _USBIO_IOCTL_CODE(10, METHOD_BUFFERED); |
| 35 | 26 static readonly int IOCTL_USBIO_CLASS_OR_VENDOR_IN_REQUEST = _USBIO_IOCTL_CODE(12, METHOD_OUT_DIRECT); |
| 27 static readonly int IOCTL_USBIO_CLASS_OR_VENDOR_OUT_REQUEST = _USBIO_IOCTL_CODE(13, METHOD_IN_DIRECT); | |
| 28 static readonly int IOCTL_USBIO_RESET_DEVICE = _USBIO_IOCTL_CODE(21, METHOD_BUFFERED); | |
| 29 static readonly int IOCTL_USBIO_BIND_PIPE = _USBIO_IOCTL_CODE(30, METHOD_BUFFERED); | |
|
46
053cc617af54
USBLib: added functions to clear USB endpoint halt state
Ivo Smits <Ivo@UCIS.nl>
parents:
44
diff
changeset
|
30 static readonly int IOCTL_USBIO_RESET_PIPE = _USBIO_IOCTL_CODE(32, METHOD_BUFFERED); |
|
67
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
31 static readonly int IOCTL_USBIO_ABORT_PIPE = _USBIO_IOCTL_CODE(33, METHOD_BUFFERED); |
| 35 | 32 |
| 33 [DllImport("kernel32.dll", SetLastError = true)] | |
| 34 static unsafe extern bool ReadFile(SafeFileHandle hFile, byte* lpBuffer, uint nNumberOfBytesToRead, out uint lpNumberOfBytesRead, IntPtr lpOverlapped); | |
| 35 [DllImport("kernel32.dll", SetLastError = true)] | |
| 36 static unsafe extern bool WriteFile(SafeFileHandle hFile, byte* lpBuffer, uint nNumberOfBytesToWrite, out uint lpNumberOfBytesWritten, IntPtr lpOverlapped); | |
| 37 | |
| 38 enum USBIO_REQUEST_RECIPIENT : uint { | |
| 39 Device = 0, | |
| 40 Interface, | |
| 41 Endpoint, | |
| 42 Other, | |
| 43 } | |
| 44 enum USBIO_REQUEST_TYPE : uint { | |
| 45 Class = 1, | |
| 46 Vendor, | |
| 47 } | |
| 48 | |
| 49 const UInt32 USBIO_SHORT_TRANSFER_OK = 0x00010000; | |
| 50 | |
| 51 [StructLayout(LayoutKind.Sequential, Pack = 1)] | |
| 52 struct USBIO_DESCRIPTOR_REQUEST { | |
| 53 public USBIO_REQUEST_RECIPIENT Recipient; | |
| 54 public Byte DescriptorType; | |
| 55 public Byte DescriptorIndex; | |
| 56 public Int16 LanguageId; | |
| 57 } | |
| 58 [StructLayout(LayoutKind.Sequential, Pack = 1)] | |
| 59 struct USBIO_BIND_PIPE { | |
| 60 public Byte EndpointAddress; | |
| 61 } | |
| 62 [StructLayout(LayoutKind.Sequential, Pack = 1, Size = 2 + 2 + 4)] | |
| 63 struct USBIO_INTERFACE_SETTING { | |
| 64 public UInt16 InterfaceIndex; | |
| 65 public UInt16 AlternateSettingIndex; | |
| 66 public UInt32 MaximumTransferSize; | |
| 67 } | |
| 68 [StructLayout(LayoutKind.Sequential, Pack = 1)] | |
| 69 unsafe struct USBIO_SET_CONFIGURATION{ | |
| 70 public UInt16 ConfigurationIndex; | |
| 71 public UInt16 NbOfInterfaces; | |
| 72 public fixed byte InterfaceList[32 * (2 + 2 + 4)]; | |
| 73 } | |
| 74 [StructLayout(LayoutKind.Sequential, Pack = 1)] | |
| 75 struct USBIO_CLASS_OR_VENDOR_REQUEST { | |
| 76 public UInt32 Flags; | |
| 77 public USBIO_REQUEST_TYPE Type; | |
| 78 public USBIO_REQUEST_RECIPIENT Recipient; | |
| 79 public Byte RequestTypeReservedBits; | |
| 80 public Byte Request; | |
| 81 public Int16 Value; | |
| 82 public Int16 Index; | |
| 83 } | |
| 84 | |
| 85 public USBIODevice(String path, USBIORegistry registry) { | |
| 86 DeviceFilename = path; | |
| 87 this.Registry = registry; | |
| 88 DeviceHandle = OpenHandle(); | |
| 89 } | |
| 90 private SafeFileHandle OpenHandle() { | |
| 91 SafeFileHandle handle = Kernel32.CreateFile(DeviceFilename, | |
| 92 NativeFileAccess.FILE_GENERIC_READ | NativeFileAccess.FILE_GENERIC_WRITE, | |
| 93 NativeFileShare.FILE_SHARE_WRITE | NativeFileShare.FILE_SHARE_READ, | |
| 94 IntPtr.Zero, | |
| 95 NativeFileMode.OPEN_EXISTING, | |
| 96 NativeFileFlag.FILE_ATTRIBUTE_NORMAL, | |
| 97 IntPtr.Zero); | |
| 98 if (handle.IsInvalid || handle.IsClosed) throw new Win32Exception(Marshal.GetLastWin32Error(), "Could not open device"); | |
| 99 return handle; | |
| 100 } | |
| 101 public override void Close() { | |
| 102 if (PipeHandlesIn != null) for (int i = 0; i < PipeHandlesIn.Length; i++) if (PipeHandlesIn[i] != null) PipeHandlesIn[i].Close(); | |
| 103 if (PipeHandlesOut != null) for (int i = 0; i < PipeHandlesOut.Length; i++) if (PipeHandlesOut[i] != null) PipeHandlesOut[i].Close(); | |
| 104 if (DeviceHandle != null) DeviceHandle.Close(); | |
| 105 } | |
| 106 | |
| 107 public override Byte Configuration { | |
| 108 get { return base.Configuration; } | |
| 109 set { | |
| 110 IList<LibUsbDotNet.Info.UsbConfigInfo> configs = (new LibUsbDotNet.UsbDevice(this)).Configs; | |
| 111 for (int i = 0; i < configs.Count; i++) { | |
| 112 LibUsbDotNet.Info.UsbConfigInfo config = configs[i]; | |
|
65
abe0d55a2201
Removed some redundant USB communication code
Ivo Smits <Ivo@UCIS.nl>
parents:
46
diff
changeset
|
113 if (config.Descriptor.ConfigurationValue == value) { |
| 35 | 114 unsafe { |
| 115 USBIO_SET_CONFIGURATION req = new USBIO_SET_CONFIGURATION(); | |
| 116 req.ConfigurationIndex = (ushort)i; | |
|
65
abe0d55a2201
Removed some redundant USB communication code
Ivo Smits <Ivo@UCIS.nl>
parents:
46
diff
changeset
|
117 req.NbOfInterfaces = Math.Min((ushort)32, config.Descriptor.NumInterfaces); |
| 35 | 118 for (int j = 0; j < req.NbOfInterfaces; j++) { |
|
38
a9c4fed19e99
USBLib: fixes in USBIO driver and LibUsbDotNet compatibility code
Ivo Smits <Ivo@UCIS.nl>
parents:
37
diff
changeset
|
119 LibUsbDotNet.Info.UsbInterfaceInfo intf = config.InterfaceInfoList[j]; |
|
a9c4fed19e99
USBLib: fixes in USBIO driver and LibUsbDotNet compatibility code
Ivo Smits <Ivo@UCIS.nl>
parents:
37
diff
changeset
|
120 *((USBIO_INTERFACE_SETTING*)(req.InterfaceList + sizeof(USBIO_INTERFACE_SETTING) * j)) = |
|
65
abe0d55a2201
Removed some redundant USB communication code
Ivo Smits <Ivo@UCIS.nl>
parents:
46
diff
changeset
|
121 new USBIO_INTERFACE_SETTING() { InterfaceIndex = intf.Descriptor.InterfaceNumber, AlternateSettingIndex = 0, MaximumTransferSize = UInt16.MaxValue }; |
| 35 | 122 } |
|
44
5a2b51b0d71b
USBLib: Fixed initialization of multi-interface USBIO devices
Ivo Smits <Ivo@UCIS.nl>
parents:
38
diff
changeset
|
123 try { |
|
5a2b51b0d71b
USBLib: Fixed initialization of multi-interface USBIO devices
Ivo Smits <Ivo@UCIS.nl>
parents:
38
diff
changeset
|
124 DeviceIoControl(DeviceHandle, IOCTL_USBIO_SET_CONFIGURATION, (IntPtr)(&req), sizeof(USBIO_SET_CONFIGURATION), IntPtr.Zero, 0); |
|
5a2b51b0d71b
USBLib: Fixed initialization of multi-interface USBIO devices
Ivo Smits <Ivo@UCIS.nl>
parents:
38
diff
changeset
|
125 } catch (Win32Exception ex) { |
|
5a2b51b0d71b
USBLib: Fixed initialization of multi-interface USBIO devices
Ivo Smits <Ivo@UCIS.nl>
parents:
38
diff
changeset
|
126 if (ex.NativeErrorCode == unchecked((int)0xE0001005L)) return; |
|
5a2b51b0d71b
USBLib: Fixed initialization of multi-interface USBIO devices
Ivo Smits <Ivo@UCIS.nl>
parents:
38
diff
changeset
|
127 throw; |
|
5a2b51b0d71b
USBLib: Fixed initialization of multi-interface USBIO devices
Ivo Smits <Ivo@UCIS.nl>
parents:
38
diff
changeset
|
128 } |
| 35 | 129 } |
| 130 return; | |
| 131 } | |
| 132 } | |
| 133 throw new InvalidOperationException("Requested configuration ID not found"); | |
| 134 } | |
| 135 } | |
| 136 | |
| 137 public void ClaimInterface(int interfaceID) { | |
| 138 } | |
| 139 public void ReleaseInterface(int interfaceID) { | |
| 140 } | |
| 141 public void SetAltInterface(int interfaceID, int alternateID) { | |
| 142 throw new NotImplementedException(); | |
| 143 } | |
| 144 public void ResetDevice() { | |
| 145 DeviceIoControl(DeviceHandle, IOCTL_USBIO_RESET_DEVICE, IntPtr.Zero, 0, IntPtr.Zero, 0); | |
| 146 } | |
| 147 public unsafe override int GetDescriptor(byte descriptorType, byte index, short langId, byte[] buffer, int offset, int length) { | |
| 148 if (offset < 0 || length < 0 || offset + length > buffer.Length) throw new ArgumentOutOfRangeException("length", "The specified offset and length exceed the buffer length"); | |
| 149 USBIO_DESCRIPTOR_REQUEST req = new USBIO_DESCRIPTOR_REQUEST() { DescriptorType = descriptorType, DescriptorIndex = index, LanguageId = langId, Recipient = USBIO_REQUEST_RECIPIENT.Device }; | |
| 150 fixed (Byte* b = buffer) { | |
| 151 return DeviceIoControl(DeviceHandle, IOCTL_USBIO_GET_DESCRIPTOR, (IntPtr)(&req), sizeof(USBIO_DESCRIPTOR_REQUEST), (IntPtr)(b + offset), length); | |
| 152 } | |
| 153 } | |
|
67
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
154 public override unsafe int ControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, byte[] buffer, int offset, int length) { |
| 35 | 155 if (buffer == null) { |
| 156 if (offset != 0 || length != 0) throw new ArgumentOutOfRangeException("length", "The specified offset and length exceed the buffer length"); | |
| 157 } else { | |
| 158 if (offset < 0 || length < 0 || offset + length > buffer.Length) throw new ArgumentOutOfRangeException("length", "The specified offset and length exceed the buffer length"); | |
| 159 } | |
| 160 switch (requestType & UsbControlRequestType.TypeMask) { | |
| 161 case UsbControlRequestType.TypeStandard: | |
| 162 switch ((UsbStandardRequest)request) { | |
| 163 case UsbStandardRequest.GetDescriptor: | |
| 164 return GetDescriptor((Byte)(value >> 8), (Byte)value, index, buffer, offset, length); | |
| 165 case UsbStandardRequest.GetConfiguration: | |
| 166 fixed (Byte* b = buffer) return DeviceIoControl(DeviceHandle, IOCTL_USBIO_GET_CONFIGURATION, IntPtr.Zero, 0, (IntPtr)(b + offset), length); | |
| 167 case UsbStandardRequest.SetConfiguration: | |
| 168 Configuration = (Byte)value; | |
| 169 return 0; | |
| 170 default: | |
| 171 throw new ArgumentException(String.Format("Invalid request: 0x{0:X8}", request)); | |
| 172 } | |
| 173 case UsbControlRequestType.TypeVendor: | |
| 174 case UsbControlRequestType.TypeClass: | |
| 175 USBIO_CLASS_OR_VENDOR_REQUEST req = new USBIO_CLASS_OR_VENDOR_REQUEST() { | |
| 176 Flags = USBIO_SHORT_TRANSFER_OK, | |
| 177 Type = (USBIO_REQUEST_TYPE)((int)(requestType & UsbControlRequestType.TypeMask) >> 5), | |
| 178 Recipient = (USBIO_REQUEST_RECIPIENT)((int)(requestType & UsbControlRequestType.RecipMask) >> 0), | |
| 179 RequestTypeReservedBits = 0, | |
| 180 Request = request, | |
| 181 Value = value, | |
| 182 Index = index, | |
| 183 }; | |
| 184 fixed (Byte* b = buffer) { | |
| 185 if ((requestType & UsbControlRequestType.EndpointMask) == UsbControlRequestType.EndpointIn) { | |
| 186 return DeviceIoControl(DeviceHandle, IOCTL_USBIO_CLASS_OR_VENDOR_IN_REQUEST, (IntPtr)(&req), sizeof(USBIO_CLASS_OR_VENDOR_REQUEST), (IntPtr)(b + offset), length); | |
| 187 } else { | |
| 188 return DeviceIoControl(DeviceHandle, IOCTL_USBIO_CLASS_OR_VENDOR_OUT_REQUEST, (IntPtr)(&req), sizeof(USBIO_CLASS_OR_VENDOR_REQUEST), (IntPtr)(b + offset), length); | |
| 189 } | |
| 190 } | |
| 191 case UsbControlRequestType.TypeReserved: | |
| 192 default: | |
| 193 throw new ArgumentException(String.Format("Invalid or unsupported request type: 0x{0:X8}", requestType)); | |
| 194 } | |
| 195 } | |
| 196 private unsafe SafeFileHandle OpenHandleForPipe(Byte epID) { | |
| 197 SafeFileHandle handle = OpenHandle(); | |
| 198 USBIO_BIND_PIPE req = new USBIO_BIND_PIPE() { EndpointAddress = epID }; | |
| 199 try { | |
| 200 DeviceIoControl(handle, IOCTL_USBIO_BIND_PIPE, (IntPtr)(&req), sizeof(USBIO_BIND_PIPE), IntPtr.Zero, 0); | |
| 201 } catch (Exception) { | |
| 202 handle.Close(); | |
| 203 throw; | |
| 204 } | |
| 205 return handle; | |
| 206 } | |
| 207 private SafeFileHandle GetHandleForPipe(Byte epID) { | |
| 208 int epidx = epID & 0x7F; | |
| 209 if ((epID & 0x80) != 0) { | |
| 210 if (PipeHandlesIn != null && PipeHandlesIn.Length >= epidx && PipeHandlesIn[epidx] != null) return PipeHandlesIn[epidx]; | |
| 211 SafeFileHandle handle = OpenHandleForPipe(epID); | |
| 212 if (PipeHandlesIn == null) PipeHandlesIn = new SafeFileHandle[epidx + 1]; | |
| 213 else Array.Resize(ref PipeHandlesIn, epidx + 1); | |
| 214 PipeHandlesIn[epidx] = handle; | |
| 215 return handle; | |
| 216 } else { | |
| 217 if (PipeHandlesOut != null && PipeHandlesOut.Length >= epidx && PipeHandlesOut[epidx] != null) return PipeHandlesOut[epidx]; | |
| 218 SafeFileHandle handle = OpenHandleForPipe(epID); | |
| 219 if (PipeHandlesOut == null) PipeHandlesOut = new SafeFileHandle[epidx + 1]; | |
| 220 else Array.Resize(ref PipeHandlesOut, epidx + 1); | |
| 221 PipeHandlesOut[epidx] = handle; | |
| 222 return handle; | |
| 223 } | |
| 224 } | |
|
67
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
225 public unsafe override int PipeTransfer(Byte epnum, Byte[] buffer, int offset, int length) { |
| 35 | 226 if (offset < 0 || length < 0 || offset + length > buffer.Length) throw new ArgumentOutOfRangeException("length", "The specified offset and length exceed the buffer length"); |
| 227 SafeFileHandle handle = GetHandleForPipe(epnum); | |
| 228 uint ret; | |
| 229 fixed (Byte* b = buffer) { | |
|
67
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
230 Boolean success; |
|
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
231 if ((epnum & (Byte)UsbControlRequestType.EndpointMask) == (Byte)UsbControlRequestType.EndpointIn) |
|
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
232 success = ReadFile(handle, b + offset, (uint)length, out ret, IntPtr.Zero); |
|
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
233 else |
|
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
234 success = WriteFile(handle, b + offset, (uint)length, out ret, IntPtr.Zero); |
|
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
235 if (!success) throw new Win32Exception(Marshal.GetLastWin32Error()); |
| 35 | 236 } |
| 237 return (int)ret; | |
| 238 } | |
|
67
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
239 public override void PipeReset(byte pipeID) { |
|
46
053cc617af54
USBLib: added functions to clear USB endpoint halt state
Ivo Smits <Ivo@UCIS.nl>
parents:
44
diff
changeset
|
240 SafeFileHandle handle = GetHandleForPipe(pipeID); |
|
053cc617af54
USBLib: added functions to clear USB endpoint halt state
Ivo Smits <Ivo@UCIS.nl>
parents:
44
diff
changeset
|
241 DeviceIoControl(handle, IOCTL_USBIO_RESET_PIPE, IntPtr.Zero, 0, IntPtr.Zero, 0); |
| 35 | 242 } |
|
67
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
243 public override void PipeAbort(byte pipeID) { |
|
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
244 SafeFileHandle handle = GetHandleForPipe(pipeID); |
|
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
245 DeviceIoControl(handle, IOCTL_USBIO_ABORT_PIPE, IntPtr.Zero, 0, IntPtr.Zero, 0); |
|
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
246 } |
| 35 | 247 |
| 248 private unsafe int DeviceIoControl(SafeHandle hDevice, int IoControlCode, IntPtr InBuffer, int nInBufferSize, IntPtr OutBuffer, int nOutBufferSize) { | |
| 249 int pBytesReturned; | |
| 250 if (Kernel32.DeviceIoControl(hDevice, IoControlCode, InBuffer, nInBufferSize, OutBuffer, nOutBufferSize, out pBytesReturned, null)) | |
| 251 return pBytesReturned; | |
| 252 throw new Win32Exception(Marshal.GetLastWin32Error()); | |
| 253 } | |
| 254 | |
|
67
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
255 public override UsbPipeStream GetPipeStream(byte endpoint) { |
|
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
256 return new PipeStream(this, endpoint, GetHandleForPipe(endpoint)); |
| 35 | 257 } |
| 258 | |
| 259 class PipeStream : UsbPipeStream { | |
| 260 private SafeFileHandle Handle; | |
|
67
2d16447eff12
Simplified USB communication code, added functions to abort pipe transfers
Ivo Smits <Ivo@UCIS.nl>
parents:
65
diff
changeset
|
261 public PipeStream(IUsbInterface device, Byte endpoint, SafeFileHandle handle) : base(device, endpoint) { |
| 35 | 262 this.Handle = handle; |
| 263 } | |
| 264 | |
| 265 public unsafe override void Write(byte[] buffer, int offset, int length) { | |
| 266 if (offset < 0 || length < 0 || offset + length > buffer.Length) throw new ArgumentOutOfRangeException("length", "The specified offset and length exceed the buffer length"); | |
| 267 uint ret; | |
| 268 fixed (Byte* b = buffer) { | |
| 269 if (!WriteFile(Handle, b + offset, (uint)length, out ret, IntPtr.Zero)) throw new Win32Exception(Marshal.GetLastWin32Error()); | |
| 270 } | |
| 271 if (ret <= 0) throw new EndOfStreamException("Could not write all data"); | |
| 272 } | |
| 273 | |
| 274 public unsafe override int Read(byte[] buffer, int offset, int length) { | |
| 275 if (offset < 0 || length < 0 || offset + length > buffer.Length) throw new ArgumentOutOfRangeException("length", "The specified offset and length exceed the buffer length"); | |
| 276 uint ret; | |
| 277 fixed (Byte* b = buffer) { | |
| 278 if (!WriteFile(Handle, b + offset, (uint)length, out ret, IntPtr.Zero)) throw new Win32Exception(Marshal.GetLastWin32Error()); | |
| 279 } | |
| 280 return (int)ret; | |
| 281 } | |
| 282 } | |
| 283 } | |
| 284 } |