ReLibreHardwareMonitor/Hardware/TBalancer/FTD2XX.cs

/*
 
  This Source Code Form is subject to the terms of the Mozilla Public
  License, v. 2.0. If a copy of the MPL was not distributed with this
  file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
  Copyright (C) 2009-2012 Michael Möller <mmoeller@openhardwaremonitor.org>
	
*/

using System;
using System.Runtime.InteropServices;

namespace OpenHardwareMonitor.Hardware.TBalancer {

  internal enum FT_DEVICE : uint {
    FT_DEVICE_232BM,
    FT_DEVICE_232AM,
    FT_DEVICE_100AX,
    FT_DEVICE_UNKNOWN,
    FT_DEVICE_2232C,
    FT_DEVICE_232R,
    FT_DEVICE_2232H,
    FT_DEVICE_4232H
  }

  internal enum FT_STATUS {
    FT_OK,
    FT_INVALID_HANDLE,
    FT_DEVICE_NOT_FOUND,
    FT_DEVICE_NOT_OPENED,
    FT_IO_ERROR,
    FT_INSUFFICIENT_RESOURCES,
    FT_INVALID_PARAMETER,
    FT_INVALID_BAUD_RATE,
    FT_DEVICE_NOT_OPENED_FOR_ERASE,
    FT_DEVICE_NOT_OPENED_FOR_WRITE,
    FT_FAILED_TO_WRITE_DEVICE,
    FT_EEPROM_READ_FAILED,
    FT_EEPROM_WRITE_FAILED,
    FT_EEPROM_ERASE_FAILED,
    FT_EEPROM_NOT_PRESENT,
    FT_EEPROM_NOT_PROGRAMMED,
    FT_INVALID_ARGS,
    FT_OTHER_ERROR
  }

  internal enum FT_FLOW_CONTROL : ushort {
    FT_FLOW_DTR_DSR = 512,
    FT_FLOW_NONE = 0,
    FT_FLOW_RTS_CTS = 256,
    FT_FLOW_XON_XOFF = 1024,
  }

  internal enum FT_PURGE : uint {
    FT_PURGE_RX = 1,
    FT_PURGE_TX = 2,
    FT_PURGE_ALL = 3,
  }

  [StructLayout(LayoutKind.Sequential)]
  internal struct FT_HANDLE {
    private readonly uint handle;
  }

  [StructLayout(LayoutKind.Sequential)]
  internal struct FT_DEVICE_INFO_NODE {    
    public uint Flags;
    public FT_DEVICE Type; 
    public uint ID; 
    public uint LocId; 
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
    public string SerialNumber; 
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
    public string Description;
    public FT_HANDLE Handle;
  }

  internal class FTD2XX {

    public delegate FT_STATUS FT_CreateDeviceInfoListDelegate(
      out uint numDevices);
    public delegate FT_STATUS FT_GetDeviceInfoListDelegate(
      [Out] FT_DEVICE_INFO_NODE[] deviceInfoNodes, ref uint length);
    public delegate FT_STATUS FT_OpenDelegate(int device, out FT_HANDLE handle);
    public delegate FT_STATUS FT_CloseDelegate(FT_HANDLE handle);
    public delegate FT_STATUS FT_SetBaudRateDelegate(FT_HANDLE handle,
      uint baudRate);
    public delegate FT_STATUS FT_SetDataCharacteristicsDelegate(
      FT_HANDLE handle, byte wordLength, byte stopBits, byte parity);
    public delegate FT_STATUS FT_SetFlowControlDelegate(FT_HANDLE handle,
      FT_FLOW_CONTROL flowControl, byte xon, byte xoff);
    public delegate FT_STATUS FT_SetTimeoutsDelegate(FT_HANDLE handle,
      uint readTimeout, uint writeTimeout);
    public delegate FT_STATUS FT_WriteDelegate(FT_HANDLE handle, byte[] buffer,
      uint bytesToWrite, out uint bytesWritten);
    public delegate FT_STATUS FT_PurgeDelegate(FT_HANDLE handle, FT_PURGE mask);
    public delegate FT_STATUS FT_GetStatusDelegate(FT_HANDLE handle,
      out uint amountInRxQueue, out uint amountInTxQueue, out uint eventStatus);
    public delegate FT_STATUS FT_ReadDelegate(FT_HANDLE handle, 
      [Out] byte[] buffer, uint bytesToRead, out uint bytesReturned);
    public delegate FT_STATUS FT_ReadByteDelegate(FT_HANDLE handle,
      out byte buffer, uint bytesToRead, out uint bytesReturned);

    public static readonly FT_CreateDeviceInfoListDelegate 
      FT_CreateDeviceInfoList = CreateDelegate<
      FT_CreateDeviceInfoListDelegate>("FT_CreateDeviceInfoList");
    public static readonly FT_GetDeviceInfoListDelegate 
      FT_GetDeviceInfoList = CreateDelegate<
      FT_GetDeviceInfoListDelegate>("FT_GetDeviceInfoList");
    public static readonly FT_OpenDelegate 
      FT_Open = CreateDelegate<
      FT_OpenDelegate>("FT_Open");
    public static readonly FT_CloseDelegate 
      FT_Close = CreateDelegate<
      FT_CloseDelegate>("FT_Close");
    public static readonly FT_SetBaudRateDelegate 
      FT_SetBaudRate = CreateDelegate<
      FT_SetBaudRateDelegate>("FT_SetBaudRate");
    public static readonly FT_SetDataCharacteristicsDelegate 
      FT_SetDataCharacteristics = CreateDelegate<
      FT_SetDataCharacteristicsDelegate>("FT_SetDataCharacteristics");
    public static readonly FT_SetFlowControlDelegate 
      FT_SetFlowControl = CreateDelegate<
      FT_SetFlowControlDelegate>("FT_SetFlowControl");
    public static readonly FT_SetTimeoutsDelegate 
      FT_SetTimeouts = CreateDelegate<
      FT_SetTimeoutsDelegate>("FT_SetTimeouts");
    public static readonly FT_WriteDelegate 
      FT_Write = CreateDelegate<
      FT_WriteDelegate>("FT_Write");
    public static readonly FT_PurgeDelegate 
      FT_Purge = CreateDelegate<
      FT_PurgeDelegate>("FT_Purge");
    public static readonly FT_GetStatusDelegate 
      FT_GetStatus = CreateDelegate<
      FT_GetStatusDelegate>("FT_GetStatus");
    public static readonly FT_ReadDelegate 
      FT_Read = CreateDelegate<
      FT_ReadDelegate>("FT_Read");
    public static readonly FT_ReadByteDelegate
      FT_ReadByte = CreateDelegate<
      FT_ReadByteDelegate>("FT_Read");

    private FTD2XX() { }

    public static FT_STATUS Write(FT_HANDLE handle, byte[] buffer) {
      uint bytesWritten;
      FT_STATUS status = FT_Write(handle, buffer, (uint)buffer.Length, 
        out bytesWritten);
      if (bytesWritten != buffer.Length)
        return FT_STATUS.FT_FAILED_TO_WRITE_DEVICE;
      else
        return status;
    }

    public static int BytesToRead(FT_HANDLE handle) {
      uint amountInRxQueue;
      uint amountInTxQueue;
      uint eventStatus;
      if (FT_GetStatus(handle, out amountInRxQueue, out amountInTxQueue,
        out eventStatus) == FT_STATUS.FT_OK) {
        return (int)amountInRxQueue;
      } else {
        return 0;
      }
    }

    public static byte ReadByte(FT_HANDLE handle) {
      byte buffer;
      uint bytesReturned;
      FT_STATUS status = FT_ReadByte(handle, out buffer, 1, out bytesReturned);
      if (status != FT_STATUS.FT_OK || bytesReturned != 1)
        throw new InvalidOperationException();
      return buffer;
    }

    public static void Read(FT_HANDLE handle, byte[] buffer) {
      uint bytesReturned;
      FT_STATUS status = 
        FT_Read(handle, buffer, (uint)buffer.Length, out bytesReturned);
      if (status != FT_STATUS.FT_OK || bytesReturned != buffer.Length)
        throw new InvalidOperationException();
    }

    private static string GetDllName() {
      int p = (int)Environment.OSVersion.Platform;
      if ((p == 4) || (p == 128))
        return "libftd2xx.so";
      else
        return "ftd2xx.dll";
    }

    private static T CreateDelegate<T>(string entryPoint)
      where T : class {
      DllImportAttribute attribute = new DllImportAttribute(GetDllName());
      attribute.CallingConvention = CallingConvention.StdCall;
      attribute.PreserveSig = true;
      attribute.EntryPoint = entryPoint;
      T newDelegate;
      PInvokeDelegateFactory.CreateDelegate(attribute, out newDelegate);
      return newDelegate;
    }
  }
}