avrdude/external/libftdi1/src/libwinftdi.h

432 lines
12 KiB
C++

//
// libwinftdi.h
// Copyright (C) 2019 Marius Greuel. All rights reserved.
//
#pragma once
#define WIN32_LEAN_AND_MEAN
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <cerrno>
#include <memory>
#include <string>
#include <vector>
#include <windows.h>
namespace LibWinFtdi
{
enum
{
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_NOT_SUPPORTED,
FT_OTHER_ERROR,
FT_DEVICE_LIST_NOT_READY,
};
enum
{
FT_DEVICE_BM,
FT_DEVICE_AM,
FT_DEVICE_100AX,
FT_DEVICE_UNKNOWN,
FT_DEVICE_2232C,
FT_DEVICE_232R,
FT_DEVICE_2232H,
FT_DEVICE_4232H,
FT_DEVICE_232H,
};
enum
{
FT_FLAGS_OPENED = 1,
FT_FLAGS_HISPEED = 2,
};
enum
{
FT_OPEN_BY_SERIAL_NUMBER = 1,
FT_OPEN_BY_DESCRIPTION = 2,
FT_OPEN_BY_LOCATION = 4,
};
enum
{
FT_PURGE_RX = 1,
FT_PURGE_TX = 2,
};
enum
{
FT_EVENT_RXCHAR = 1,
FT_EVENT_MODEM_STATUS = 2,
FT_EVENT_LINE_STATUS = 4,
};
typedef PVOID FT_HANDLE;
typedef ULONG FT_STATUS;
struct DeviceInfo
{
ULONG Flags;
ULONG Type;
ULONG ID;
DWORD LocId;
char SerialNumber[16];
char Description[64];
FT_HANDLE ftHandle;
};
class FtdiApi
{
public:
FtdiApi() = default;
FtdiApi(const FtdiApi&) = delete;
FtdiApi& operator=(const FtdiApi&) = delete;
FtdiApi(FtdiApi&&) = delete;
FtdiApi& operator=(FtdiApi&&) = delete;
~FtdiApi()
{
Unload();
}
HRESULT Load()
{
if (m_module != nullptr)
return S_FALSE;
HMODULE module = LoadLibraryExW(L"ftd2xx.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
if (module == nullptr)
{
return HRESULT_FROM_WIN32(GetLastError());
}
HRESULT hr = S_OK;
if (FAILED(hr = LoadImport(module, "FT_CreateDeviceInfoList", &FT_CreateDeviceInfoList)) ||
FAILED(hr = LoadImport(module, "FT_GetDeviceInfoList", &FT_GetDeviceInfoList)) ||
FAILED(hr = LoadImport(module, "FT_OpenEx", &FT_OpenEx)) ||
FAILED(hr = LoadImport(module, "FT_Close", &FT_Close)) ||
FAILED(hr = LoadImport(module, "FT_ResetDevice", &FT_ResetDevice)) ||
FAILED(hr = LoadImport(module, "FT_ResetPort", &FT_ResetPort)) ||
FAILED(hr = LoadImport(module, "FT_CyclePort", &FT_ResetPort)) ||
FAILED(hr = LoadImport(module, "FT_Purge", &FT_Purge)) ||
FAILED(hr = LoadImport(module, "FT_SetTimeouts", &FT_SetTimeouts)) ||
FAILED(hr = LoadImport(module, "FT_SetBaudRate", &FT_SetBaudRate)) ||
FAILED(hr = LoadImport(module, "FT_SetBitMode", &FT_SetBitMode)) ||
FAILED(hr = LoadImport(module, "FT_SetLatencyTimer", &FT_SetLatencyTimer)) ||
FAILED(hr = LoadImport(module, "FT_GetQueueStatus", &FT_GetQueueStatus)) ||
FAILED(hr = LoadImport(module, "FT_SetEventNotification", &FT_SetEventNotification)) ||
FAILED(hr = LoadImport(module, "FT_SetUSBParameters", &FT_SetUSBParameters)) ||
FAILED(hr = LoadImport(module, "FT_Read", &FT_Read)) ||
FAILED(hr = LoadImport(module, "FT_Write", &FT_Write)))
{
FreeLibrary(module);
return hr;
}
m_module = module;
return S_OK;
}
HRESULT Unload()
{
if (m_module == nullptr)
return S_FALSE;
FreeLibrary(m_module);
m_module = nullptr;
return S_OK;
}
private:
template<typename T>
static HRESULT LoadImport(HMODULE module, LPCSTR lpProcName, T** ptr)
{
auto proc = GetProcAddress(module, lpProcName);
if (proc == nullptr)
{
*ptr = nullptr;
return HRESULT_FROM_WIN32(GetLastError());
}
*ptr = reinterpret_cast<T*>(proc);
return S_OK;
}
private:
HMODULE m_module = nullptr;
protected:
FT_STATUS(WINAPI* FT_CreateDeviceInfoList)(LPDWORD lpdwNumDevs) = nullptr;
FT_STATUS(WINAPI* FT_GetDeviceInfoList)(DeviceInfo* pDest, LPDWORD lpdwNumDevs) = nullptr;
FT_STATUS(WINAPI* FT_OpenEx)(PVOID pArg1, DWORD Flags, FT_HANDLE* pHandle) = nullptr;
FT_STATUS(WINAPI* FT_Close)(FT_HANDLE ftHandle) = nullptr;
FT_STATUS(WINAPI* FT_ResetDevice)(FT_HANDLE ftHandle) = nullptr;
FT_STATUS(WINAPI* FT_ResetPort)(FT_HANDLE ftHandle) = nullptr;
FT_STATUS(WINAPI* FT_CyclePort)(FT_HANDLE ftHandle) = nullptr;
FT_STATUS(WINAPI* FT_Purge)(FT_HANDLE ftHandle, DWORD dwMask) = nullptr;
FT_STATUS(WINAPI* FT_SetTimeouts)(FT_HANDLE ftHandle, DWORD dwReadTimeout, DWORD dwWriteTimeout) = nullptr;
FT_STATUS(WINAPI* FT_SetBaudRate)(FT_HANDLE ftHandle, DWORD dwBaudRate) = nullptr;
FT_STATUS(WINAPI* FT_SetBitMode)(FT_HANDLE ftHandle, UCHAR ucMask, UCHAR ucEnable) = nullptr;
FT_STATUS(WINAPI* FT_SetLatencyTimer)(FT_HANDLE ftHandle, UCHAR ucTimer) = nullptr;
FT_STATUS(WINAPI* FT_GetQueueStatus)(FT_HANDLE ftHandle, DWORD* dwRxBytes) = nullptr;
FT_STATUS(WINAPI* FT_SetEventNotification)(FT_HANDLE ftHandle, DWORD Mask, PVOID Param) = nullptr;
FT_STATUS(WINAPI* FT_SetUSBParameters)(FT_HANDLE ftHandle, DWORD dwInTransferSize, DWORD dwOutTransferSize) = nullptr;
FT_STATUS(WINAPI* FT_Read)(FT_HANDLE ftHandle, LPVOID lpBuffer, DWORD dwBytesToRead, LPDWORD lpBytesReturned) = nullptr;
FT_STATUS(WINAPI* FT_Write)(FT_HANDLE ftHandle, LPVOID lpBuffer, DWORD dwBytesToWrite, LPDWORD lpBytesWritten) = nullptr;
};
class FtdiEnumerator : public FtdiApi
{
public:
FtdiEnumerator() = default;
FtdiEnumerator(const FtdiEnumerator&) = delete;
FtdiEnumerator& operator=(const FtdiEnumerator&) = delete;
FtdiEnumerator(FtdiEnumerator&&) = delete;
FtdiEnumerator& operator=(FtdiEnumerator&&) = delete;
public:
FT_STATUS EnumerateDevices()
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
DWORD lpdwNumDevs = 0;
FT_STATUS status = FT_CreateDeviceInfoList(&lpdwNumDevs);
if (status != FT_OK)
return status;
m_devices.resize(lpdwNumDevs);
status = FT_GetDeviceInfoList(m_devices.data(), &lpdwNumDevs);
if (status != FT_OK)
return status;
return FT_OK;
}
const std::vector<DeviceInfo>& GetDevices() const
{
return m_devices;
}
private:
std::vector<DeviceInfo> m_devices;
};
class FtdiDevice : public FtdiApi
{
public:
FtdiDevice() = default;
FtdiDevice(const FtdiDevice&) = delete;
FtdiDevice& operator=(const FtdiDevice&) = delete;
FtdiDevice(FtdiDevice&&) = delete;
FtdiDevice& operator=(FtdiDevice&&) = delete;
~FtdiDevice()
{
if (m_event != nullptr)
{
CloseHandle(m_event);
}
}
HANDLE GetNotificationEvent() const
{
return m_event;
}
public:
FT_STATUS OpenBySerialNumber(const char* serialNumber)
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_OpenEx(const_cast<char*>(serialNumber), FT_OPEN_BY_SERIAL_NUMBER, &m_handle);
}
FT_STATUS OpenByLocation(uint32_t location)
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_OpenEx(&location, FT_OPEN_BY_LOCATION, &m_handle);
}
FT_STATUS Close()
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_Close(m_handle);
}
FT_STATUS ResetDevice()
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_ResetDevice(m_handle);
}
FT_STATUS ResetPort()
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_ResetPort(m_handle);
}
FT_STATUS CyclePort()
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_CyclePort(m_handle);
}
FT_STATUS Purge(DWORD dwMask = FT_PURGE_RX | FT_PURGE_TX)
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_Purge(m_handle, dwMask);
}
FT_STATUS SetTimeouts(DWORD dwReadTimeout, DWORD dwWriteTimeout)
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_SetTimeouts(m_handle, dwReadTimeout, dwWriteTimeout);
}
FT_STATUS SetBaudRate(DWORD dwBaudRate)
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_SetBaudRate(m_handle, dwBaudRate);
}
FT_STATUS SetBitMode(UCHAR ucMask, UCHAR ucEnable)
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_SetBitMode(m_handle, ucMask, ucEnable);
}
FT_STATUS SetLatencyTimer(UCHAR ucTimer)
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_SetLatencyTimer(m_handle, ucTimer);
}
FT_STATUS GetQueueStatus(DWORD* dwRxBytes)
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_GetQueueStatus(m_handle, dwRxBytes);
}
FT_STATUS SetEventNotification(DWORD Mask)
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
if (m_event == nullptr)
{
m_event = CreateEventW(nullptr, FALSE, FALSE, nullptr);
}
return FT_SetEventNotification(m_handle, Mask, m_event);
}
FT_STATUS SetUSBParameters(DWORD dwInTransferSize, DWORD dwOutTransferSize)
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_SetUSBParameters(m_handle, dwInTransferSize, dwOutTransferSize);
}
FT_STATUS Read(LPVOID lpBuffer, DWORD dwBytesToRead, LPDWORD lpBytesReturned)
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_Read(m_handle, lpBuffer, dwBytesToRead, lpBytesReturned);
}
FT_STATUS Write(LPVOID lpBuffer, DWORD dwBytesToWrite, LPDWORD lpBytesWritten)
{
if (FAILED(Load()))
{
return FT_INVALID_HANDLE;
}
return FT_Write(m_handle, lpBuffer, dwBytesToWrite, lpBytesWritten);
}
private:
FT_HANDLE m_handle = nullptr;
HANDLE m_event = nullptr;
};
}