External I2C Programming Routines added

git-svn-id: https://svnsrv.desy.de/desy/MSK_PROJECTS/other/Fuse-Relay-Board/MCU_Firmware/trunk@785 e4d10518-288a-426b-ba36-e453799dee6f

FTDI_I2C/Makefile.win

+# Project: Project1
+# Makefile created by Dev-C++ 4.9.9.2
+
+CPP  = g++.exe -D__DEBUG__
+CC   = gcc.exe -D__DEBUG__
+WINDRES = windres.exe
+RES  = 
+OBJ  = main.o $(RES)
+LINKOBJ  = main.o $(RES)
+LIBS =  -L"C:/Dev-Cpp/lib" libMPSSE.a libMPSSE.a  -g3 -fmessage-length=0 
+INCS =  -I"C:/Dev-Cpp/include" 
+CXXINCS =  -I"C:/Dev-Cpp/lib/gcc/mingw32/3.4.2/include"  -I"C:/Dev-Cpp/include/c++/3.4.2/backward"  -I"C:/Dev-Cpp/include/c++/3.4.2/mingw32"  -I"C:/Dev-Cpp/include/c++/3.4.2"  -I"C:/Dev-Cpp/include" 
+BIN  = proghyt.exe
+CXXFLAGS = $(CXXINCS)   -traditional-cpp -fno-access-control -g3 -fmessage-length=0
+CFLAGS = $(INCS)   -traditional-cpp -fno-access-control -g3 -fmessage-length=0
+RM = rm -f
+
+.PHONY: all all-before all-after clean clean-custom
+
+all: all-before proghyt.exe all-after
+
+
+clean: clean-custom
+	${RM} $(OBJ) $(BIN)
+
+$(BIN): $(OBJ)
+	$(CPP) $(LINKOBJ) -o "proghyt.exe" $(LIBS)
+
+main.o: main.c
+	$(CPP) -c main.c -o main.o $(CXXFLAGS)

FTDI_I2C/main.c

+/*!
+ * \file sample-dynamic.c
+ *
+ * \author FTDI
+ * \date 20110512
+ *
+ * Copyright  2011 Future Technology Devices International Limited
+ * Company Confidential
+ *
+ * Project: libMPSSE
+ * Module: I2C Sample Application - Interfacing 24LC024H I2C EEPROM
+ *
+ * Rivision History:
+ * 0.1 - 20110513 - initial version
+ * 0.2 - 20110801 - Changed LatencyTimer to 255
+ * 				  Attempt to open channel only if available
+ *				  Added & modified macros
+ *                		  Change APIs I2C_GetChannelInfo & OpenChannel to start indexing from 0
+ * 0.3 - 20111212 - Added comments
+ */
+
+/******************************************************************************/
+/* 							 Include files										   */
+/******************************************************************************/
+/* Standard C libraries */
+#include<stdio.h>
+#include<stdlib.h>
+
+/* OS specific libraries */
+#ifdef _WIN32
+#include<windows.h>
+#endif
+
+#ifdef __linux
+#include<dlfcn.h>
+#endif
+
+/* Include D2XX header*/
+#include "ftd2xx.h"
+
+/* Include libMPSSE header */
+#include "libMPSSE_i2c.h"
+
+/******************************************************************************/
+/*								Macro and type defines							   */
+/******************************************************************************/
+/* Helper macros */
+#ifdef _WIN32
+	#define GET_FUN_POINTER	GetProcAddress
+	#define CHECK_ERROR(exp) {if(exp==NULL){printf("%s:%d:%s(): NULL expression\
+		encountered \n",__FILE__, __LINE__, __FUNCTION__);exit(1);}else{;}};
+#endif
+
+#ifdef __linux
+	#define GET_FUN_POINTER	dlsym
+	#define CHECK_ERROR(exp) {if(dlerror() != NULL){printf("line %d: ERROR \
+		dlsym\n",__LINE__);}}
+#endif
+#define APP_CHECK_STATUS(exp) {if(exp!=FT_OK){printf("%s:%d:%s(): status(0x%x) \
+	!= FT_OK\n",__FILE__, __LINE__, __FUNCTION__,exp);exit(1);}else{;}};
+#define CHECK_NULL(exp){if(exp==NULL){printf("%s:%d:%s():  NULL expression \
+	encountered \n",__FILE__, __LINE__, __FUNCTION__);exit(1);}else{;}};
+
+/* Application specific macro definations */
+#define I2C_DEVICE_ADDRESS_EEPROM		0x57
+#define I2C_DEVICE_BUFFER_SIZE		256
+#define I2C_WRITE_COMPLETION_RETRY		10
+#define START_ADDRESS_EEPROM 	0x00 /*read/write start address inside the EEPROM*/
+#define END_ADDRESS_EEPROM		0x10
+#define RETRY_COUNT_EEPROM		10	/* number of retries if read/write fails */
+#define CHANNEL_TO_OPEN			1	/*0 for first available channel, 1 for next... */
+#define DATA_OFFSET				2
+
+
+/* Declaration of function pointers */
+typedef FT_STATUS (*pfunc_I2C_GetNumChannels)(uint32 *numChannels);
+pfunc_I2C_GetNumChannels p_I2C_GetNumChannels;
+typedef FT_STATUS (*pfunc_I2C_GetChannelInfo)(uint32 index, \
+	FT_DEVICE_LIST_INFO_NODE *chanInfo);
+pfunc_I2C_GetChannelInfo p_I2C_GetChannelInfo;
+typedef FT_STATUS (*pfunc_I2C_OpenChannel)(uint32 index, FT_HANDLE *handle);
+pfunc_I2C_OpenChannel p_I2C_OpenChannel;
+typedef FT_STATUS (*pfunc_I2C_CloseChannel)(FT_HANDLE handle);
+pfunc_I2C_CloseChannel p_I2C_CloseChannel;
+typedef FT_STATUS (*pfunc_I2C_InitChannel)(FT_HANDLE handle, ChannelConfig \
+	*config);
+pfunc_I2C_InitChannel p_I2C_InitChannel;
+typedef FT_STATUS (*pfunc_I2C_DeviceRead)(FT_HANDLE handle,uint32 \
+	deviceAddress,uint32 sizeToTransfer, uint8 *buffer, uint32 \
+	*sizeTransfered, uint32 options);
+pfunc_I2C_DeviceRead p_I2C_DeviceRead;
+typedef FT_STATUS (*pfunc_I2C_DeviceWrite)(FT_HANDLE handle, uint32 \
+	deviceAddress,uint32 sizeToTransfer, uint8 *buffer, uint32 \
+	*sizeTransfered, uint32 options);
+pfunc_I2C_DeviceWrite p_I2C_DeviceWrite;
+
+/******************************************************************************/
+/*								Global variables							  	    */
+/******************************************************************************/
+uint32 channels;
+FT_HANDLE ftHandle;
+ChannelConfig channelConf;
+FT_STATUS status;
+uint8 buffer[I2C_DEVICE_BUFFER_SIZE];
+
+/******************************************************************************/
+/*						Public function definitions						  		   */
+/******************************************************************************/
+/*!
+ * \brief Writes to EEPROM
+ *
+ * This function writes a byte to a specified address within the 24LC024H EEPROM
+ *
+ * \param[in] slaveAddress Address of the I2C slave (EEPROM)
+ * \param[in] registerAddress Address of the memory location inside the slave to where the byte
+ *			is to be written
+ * \param[in] data The byte that is to be written
+ * \return Returns status code of type FT_STATUS(see D2XX Programmer's Guide)
+ * \sa Datasheet of 24LC024H http://ww1.microchip.com/downloads/en/devicedoc/22102a.pdf
+ * \note 
+ * \warning
+ */
+FT_STATUS write_byte(uint8 slaveAddress, uint8 registerAddress, uint8 data)
+{
+	FT_STATUS status;
+	uint32 bytesToTransfer = 0;
+	uint32 bytesTransfered;
+	bool writeComplete=0;
+	uint32 retry=0;
+	
+	bytesToTransfer=0;
+	bytesTransfered=0;
+	buffer[bytesToTransfer++]=registerAddress; /* Byte addressed inside EEPROM */
+	buffer[bytesToTransfer++]=data;
+	status = p_I2C_DeviceWrite(ftHandle, slaveAddress, bytesToTransfer, buffer,\
+		&bytesTransfered, \
+		I2C_TRANSFER_OPTIONS_START_BIT|I2C_TRANSFER_OPTIONS_STOP_BIT);
+	APP_CHECK_STATUS(status);
+
+	/* poll to check completition */
+	while((writeComplete==0) && (retry<I2C_WRITE_COMPLETION_RETRY))
+	{
+		bytesToTransfer=0;
+		bytesTransfered=0;
+		buffer[bytesToTransfer++]=registerAddress; /*Byte addressed inside EEPROM*/
+		status = p_I2C_DeviceWrite(ftHandle, slaveAddress, bytesToTransfer, \
+			buffer, &bytesTransfered, \
+			I2C_TRANSFER_OPTIONS_START_BIT|I2C_TRANSFER_OPTIONS_BREAK_ON_NACK);
+		
+		if(bytesToTransfer==bytesTransfered)
+		{
+			writeComplete=1;
+			printf("... Write done\n");
+		}
+		retry++;
+	}
+	return status;
+}
+
+/*!
+ * \brief Reads from EEPROM
+ *
+ * This function reads a byte from a specified address within the 24LC024H EEPROM
+ *
+ * \param[in] slaveAddress Address of the I2C slave (EEPROM)
+ * \param[in] registerAddress Address of the memory location inside the slave from where the 
+ *			byte is to be read
+ * \param[in] *data Address to where the byte is to be read
+ * \return Returns status code of type FT_STATUS(see D2XX Programmer's Guide)
+ * \sa Datasheet of 24LC024H http://ww1.microchip.com/downloads/en/devicedoc/22102a.pdf
+ * \note 
+ * \warning
+ */
+FT_STATUS read_byte(uint8 slaveAddress, uint8 registerAddress, uint8 *data)
+{
+	FT_STATUS status;
+	uint32 bytesToTransfer = 0;
+	uint32 bytesTransfered;
+	
+	bytesToTransfer=0;
+	bytesTransfered=0;
+	buffer[bytesToTransfer++]=registerAddress; /* Byte addressed inside EEPROM */
+	status = p_I2C_DeviceWrite(ftHandle, slaveAddress, bytesToTransfer, buffer,\
+		&bytesTransfered, I2C_TRANSFER_OPTIONS_START_BIT);
+	bytesToTransfer=1;
+	bytesTransfered=0;
+	status |= p_I2C_DeviceRead(ftHandle, slaveAddress, bytesToTransfer, buffer,\
+		&bytesTransfered, I2C_TRANSFER_OPTIONS_START_BIT);
+	*data = buffer[0];
+	return status;
+}
+
+/*!
+ * \brief Main function / Entry point of the sample application
+ *
+ * This function is the entry point to the sample application. It opens the channel, writes to the
+ * EEPROM and reads back.
+ *
+ * \param[in] none
+ * \return Returns 0 for success
+ * \sa
+ * \note 
+ * \warning
+ */
+int main()
+{
+#ifdef _WIN32
+	#ifdef _MSC_VER
+		HMODULE h_libMPSSE;
+	#else
+		HANDLE h_libMPSSE;
+	#endif
+#endif
+
+#ifdef __linux
+	void *h_libMPSSE;
+#endif
+
+	FT_STATUS status;
+	FT_DEVICE_LIST_INFO_NODE devList;
+	uint8 address;
+	uint8 data;
+	int i,j;
+
+	channelConf.ClockRate = I2C_CLOCK_FAST_MODE;/*i.e. 400000 KHz*/
+	channelConf.LatencyTimer= 255;
+	//channelConf.Options = I2C_DISABLE_3PHASE_CLOCKING;
+	//channelConf.Options = I2C_ENABLE_DRIVE_ONLY_ZERO;
+
+	/* load library */
+    #ifdef _WIN32
+    	#ifdef _MSC_VER
+    		h_libMPSSE = LoadLibrary(L"libMPSSE.dll");
+    	#else
+    		h_libMPSSE = LoadLibrary("libMPSSE.dll");
+    	#endif
+    	if(NULL == h_libMPSSE)
+    	{
+    		printf("Failed loading libMPSSE.dll. Please check if the file exists in the working directory\n");
+    	}
+    #endif
+	
+    #ifdef __linux
+    	h_libMPSSE = dlopen("libMPSSE.so",RTLD_LAZY);
+    	if(!h_libMPSSE)
+    	{
+    		printf("Failed loading libMPSSE.so\n");
+    	}
+    #endif
+
+	/* init function pointers */
+	p_I2C_GetNumChannels = (pfunc_I2C_GetNumChannels)GET_FUN_POINTER(h_libMPSSE, "I2C_GetNumChannels");
+	CHECK_ERROR (p_I2C_GetNumChannels);
+	p_I2C_GetChannelInfo = (pfunc_I2C_GetChannelInfo)GET_FUN_POINTER(h_libMPSSE, "I2C_GetChannelInfo");
+	CHECK_ERROR(p_I2C_GetChannelInfo);
+	p_I2C_OpenChannel = (HINSTANCE__*) (pfunc_I2C_OpenChannel)GET_FUN_POINTER(h_libMPSSE, "I2C_OpenChannel");
+	CHECK_ERROR(p_I2C_OpenChannel);
+	p_I2C_CloseChannel = (pfunc_I2C_CloseChannel)GET_FUN_POINTER(h_libMPSSE,"I2C_CloseChannel");
+	CHECK_ERROR(p_I2C_CloseChannel);
+	p_I2C_InitChannel = (pfunc_I2C_InitChannel)GET_FUN_POINTER(h_libMPSSE, "I2C_InitChannel");
+	CHECK_ERROR(p_I2C_InitChannel);
+	p_I2C_DeviceRead = (pfunc_I2C_DeviceRead)GET_FUN_POINTER(h_libMPSSE, "I2C_DeviceRead");
+	CHECK_ERROR(p_I2C_DeviceRead);
+	p_I2C_DeviceWrite = (pfunc_I2C_DeviceWrite)GET_FUN_POINTER(h_libMPSSE, "I2C_DeviceWrite");
+	CHECK_ERROR(p_I2C_DeviceWrite);
+
+	status = p_I2C_GetNumChannels(&channels);
+	APP_CHECK_STATUS(status);
+	printf("Number of available I2C channels = %d\n",channels);
+	if(channels>0)
+	{
+		for(i=0;i<channels;i++)
+		{
+			status = p_I2C_GetChannelInfo(i,&devList);
+			APP_CHECK_STATUS(status);
+			printf("Information on channel number %d:\n",i);
+			/*print the dev info*/
+			printf("		Flags=0x%x\n",devList.Flags); 
+			printf("		Type=0x%x\n",devList.Type); 
+			printf("		ID=0x%x\n",devList.ID); 
+			printf("		LocId=0x%x\n",devList.LocId); 
+			printf("		SerialNumber=%s\n",devList.SerialNumber); 
+			printf("		Description=%s\n",devList.Description); 
+			printf("		ftHandle=0x%x\n",devList.ftHandle);/* 0 if not open*/
+		}
+
+		/* Open the first available channel */
+		status = p_I2C_OpenChannel(CHANNEL_TO_OPEN,&ftHandle);
+		APP_CHECK_STATUS(status);
+		printf("\nhandle=0x%x status=%d\n",ftHandle,status);
+		status = p_I2C_InitChannel(ftHandle,&channelConf);
+		APP_CHECK_STATUS(status);
+			
+		for(address=START_ADDRESS_EEPROM;address<END_ADDRESS_EEPROM;address++)
+		{
+			printf("writing address = %d data = %d",address,address+DATA_OFFSET);
+			write_byte(I2C_DEVICE_ADDRESS_EEPROM,address,address+DATA_OFFSET);
+		}
+
+		for(address=START_ADDRESS_EEPROM;address<END_ADDRESS_EEPROM;address++)
+		{
+			status = read_byte(I2C_DEVICE_ADDRESS_EEPROM,address, &data);
+			for(j=0; ((j<RETRY_COUNT_EEPROM) && (FT_OK !=status)); j++)
+			{
+				printf("read error... retrying \n");
+				status = read_byte(I2C_DEVICE_ADDRESS_EEPROM,address, &data);
+			}
+			if((RETRY_COUNT_EEPROM==j) && (FT_OK != status))
+			{
+				printf("failed reading\n");
+			}
+			printf("reading address %d data read=%d\n", address, data);
+		}
+		status = p_I2C_CloseChannel(ftHandle);
+	}
+	return 0;
+}

FTDI_I2C/proghyt.dev

+[Project]
+FileName=proghyt.dev
+Name=Project1
+UnitCount=1
+Type=1
+Ver=1
+ObjFiles=
+Includes=
+Libs=
+PrivateResource=
+ResourceIncludes=
+MakeIncludes=
+Compiler=
+CppCompiler=
+Linker=libMPSSE.a_@@_libMPSSE.a_@@_
+IsCpp=1
+Icon=
+ExeOutput=
+ObjectOutput=
+OverrideOutput=0
+OverrideOutputName=proghyt.exe
+HostApplication=
+Folders=
+CommandLine=
+UseCustomMakefile=0
+CustomMakefile=
+IncludeVersionInfo=0
+SupportXPThemes=0
+CompilerSet=0
+CompilerSettings=0101000000000001001000
+
+[Unit1]
+FileName=main.c
+CompileCpp=1
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=$(CPP) -c main.c -o main.o $(CXXFLAGS)
+
+[VersionInfo]
+Major=0
+Minor=1
+Release=1
+Build=1
+LanguageID=1033
+CharsetID=1252
+CompanyName=
+FileVersion=
+FileDescription=Developed using the Dev-C++ IDE
+InternalName=
+LegalCopyright=
+LegalTrademarks=
+OriginalFilename=
+ProductName=
+ProductVersion=
+AutoIncBuildNr=0
+
+[Unit3]
+FileName=libMPSSE_i2c.h
+CompileCpp=1
+Folder=Project1
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+

FTDI_I2C/proghyt.layout

+[Editor_1]
+CursorCol=3
+CursorRow=12
+TopLine=107
+LeftChar=1
+[Editors]
+Focused=0
+Order=0,-1
+[Editor_0]
+Open=1
+Top=1
+CursorCol=28
+CursorRow=252
+TopLine=145
+LeftChar=1

FTDI_I2C/proghyt/ftd2xx.h

+/*++
+
+Copyright  2001-2011 Future Technology Devices International Limited
+
+THIS SOFTWARE IS PROVIDED BY FUTURE TECHNOLOGY DEVICES INTERNATIONAL LIMITED "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+FUTURE TECHNOLOGY DEVICES INTERNATIONAL LIMITED BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES LOSS OF USE, DATA, OR PROFITS OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+FTDI DRIVERS MAY BE USED ONLY IN CONJUNCTION WITH PRODUCTS BASED ON FTDI PARTS.
+
+FTDI DRIVERS MAY BE DISTRIBUTED IN ANY FORM AS LONG AS LICENSE INFORMATION IS NOT MODIFIED.
+
+IF A CUSTOM VENDOR ID AND/OR PRODUCT ID OR DESCRIPTION STRING ARE USED, IT IS THE
+RESPONSIBILITY OF THE PRODUCT MANUFACTURER TO MAINTAIN ANY CHANGES AND SUBSEQUENT WHQL
+RE-CERTIFICATION AS A RESULT OF MAKING THESE CHANGES.
+
+
+Module Name:
+
+ftd2xx.h
+
+Abstract:
+
+Native USB device driver for FTDI FT232x, FT245x, FT2232x and FT4232x devices
+FTD2XX library definitions
+
+Environment:
+
+kernel & user mode
+
+
+--*/
+
+
+#ifndef FTD2XX_H
+#define FTD2XX_H
+
+// The following ifdef block is the standard way of creating macros
+// which make exporting from a DLL simpler.  All files within this DLL
+// are compiled with the FTD2XX_EXPORTS symbol defined on the command line.
+// This symbol should not be defined on any project that uses this DLL.
+// This way any other project whose source files include this file see
+// FTD2XX_API functions as being imported from a DLL, whereas this DLL
+// sees symbols defined with this macro as being exported.
+
+#ifdef FTD2XX_EXPORTS
+#define FTD2XX_API __declspec(dllexport)
+#else
+#define FTD2XX_API __declspec(dllimport)
+#endif
+
+
+typedef PVOID	FT_HANDLE;
+typedef ULONG	FT_STATUS;
+
+//
+// Device status
+//
+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,
+};
+
+
+#define FT_SUCCESS(status) ((status) == FT_OK)
+
+//
+// FT_OpenEx Flags
+//
+
+#define FT_OPEN_BY_SERIAL_NUMBER	1
+#define FT_OPEN_BY_DESCRIPTION		2
+#define FT_OPEN_BY_LOCATION			4
+
+//
+// FT_ListDevices Flags (used in conjunction with FT_OpenEx Flags
+//
+
+#define FT_LIST_NUMBER_ONLY			0x80000000
+#define FT_LIST_BY_INDEX			0x40000000
+#define FT_LIST_ALL					0x20000000
+
+#define FT_LIST_MASK (FT_LIST_NUMBER_ONLY|FT_LIST_BY_INDEX|FT_LIST_ALL)
+
+//
+// Baud Rates
+//
+
+#define FT_BAUD_300			300
+#define FT_BAUD_600			600
+#define FT_BAUD_1200		1200
+#define FT_BAUD_2400		2400
+#define FT_BAUD_4800		4800
+#define FT_BAUD_9600		9600
+#define FT_BAUD_14400		14400
+#define FT_BAUD_19200		19200
+#define FT_BAUD_38400		38400
+#define FT_BAUD_57600		57600
+#define FT_BAUD_115200		115200
+#define FT_BAUD_230400		230400
+#define FT_BAUD_460800		460800
+#define FT_BAUD_921600		921600
+
+//
+// Word Lengths
+//
+
+#define FT_BITS_8			(UCHAR) 8
+#define FT_BITS_7			(UCHAR) 7
+
+//
+// Stop Bits
+//
+
+#define FT_STOP_BITS_1		(UCHAR) 0
+#define FT_STOP_BITS_2		(UCHAR) 2
+
+//
+// Parity
+//
+
+#define FT_PARITY_NONE		(UCHAR) 0
+#define FT_PARITY_ODD		(UCHAR) 1
+#define FT_PARITY_EVEN		(UCHAR) 2
+#define FT_PARITY_MARK		(UCHAR) 3
+#define FT_PARITY_SPACE		(UCHAR) 4
+
+//
+// Flow Control
+//
+
+#define FT_FLOW_NONE		0x0000
+#define FT_FLOW_RTS_CTS		0x0100
+#define FT_FLOW_DTR_DSR		0x0200
+#define FT_FLOW_XON_XOFF	0x0400
+
+//
+// Purge rx and tx buffers
+//
+#define FT_PURGE_RX			1
+#define FT_PURGE_TX			2
+
+//
+// Events
+//
+
+typedef void (*PFT_EVENT_HANDLER)(DWORD,DWORD);
+
+#define FT_EVENT_RXCHAR			1
+#define FT_EVENT_MODEM_STATUS	2
+#define FT_EVENT_LINE_STATUS	4
+
+//
+// Timeouts
+//
+
+#define FT_DEFAULT_RX_TIMEOUT	300
+#define FT_DEFAULT_TX_TIMEOUT	300
+
+//
+// Device types
+//
+
+typedef ULONG	FT_DEVICE;
+
+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
+};
+
+//
+// Bit Modes
+//
+
+#define FT_BITMODE_RESET				0x00
+#define FT_BITMODE_ASYNC_BITBANG		0x01
+#define FT_BITMODE_MPSSE				0x02
+#define FT_BITMODE_SYNC_BITBANG			0x04
+#define FT_BITMODE_MCU_HOST				0x08
+#define FT_BITMODE_FAST_SERIAL			0x10
+#define FT_BITMODE_CBUS_BITBANG			0x20
+#define FT_BITMODE_SYNC_FIFO			0x40
+
+//
+// FT232R CBUS Options EEPROM values
+//
+
+#define FT_232R_CBUS_TXDEN				0x00	//	Tx Data Enable
+#define FT_232R_CBUS_PWRON				0x01	//	Power On
+#define FT_232R_CBUS_RXLED				0x02	//	Rx LED
+#define FT_232R_CBUS_TXLED				0x03	//	Tx LED
+#define FT_232R_CBUS_TXRXLED			0x04	//	Tx and Rx LED
+#define FT_232R_CBUS_SLEEP				0x05	//	Sleep
+#define FT_232R_CBUS_CLK48				0x06	//	48MHz clock
+#define FT_232R_CBUS_CLK24				0x07	//	24MHz clock
+#define FT_232R_CBUS_CLK12				0x08	//	12MHz clock
+#define FT_232R_CBUS_CLK6				0x09	//	6MHz clock
+#define FT_232R_CBUS_IOMODE				0x0A	//	IO Mode for CBUS bit-bang
+#define FT_232R_CBUS_BITBANG_WR			0x0B	//	Bit-bang write strobe
+#define FT_232R_CBUS_BITBANG_RD			0x0C	//	Bit-bang read strobe
+
+//
+// FT232H CBUS Options EEPROM values
+//
+
+#define FT_232H_CBUS_TRISTATE			0x00	//	Tristate
+#define FT_232H_CBUS_RXLED				0x01	//	Rx LED
+#define FT_232H_CBUS_TXLED				0x02	//	Tx LED
+#define FT_232H_CBUS_TXRXLED			0x03	//	Tx and Rx LED
+#define FT_232H_CBUS_PWREN				0x04	//	Power Enable
+#define FT_232H_CBUS_SLEEP				0x05	//	Sleep
+#define FT_232H_CBUS_DRIVE_0			0x06	//	Drive pin to logic 0
+#define FT_232H_CBUS_DRIVE_1			0x07	//	Drive pin to logic 1
+#define FT_232H_CBUS_IOMODE				0x08	//	IO Mode for CBUS bit-bang
+#define FT_232H_CBUS_TXDEN				0x09	//	Tx Data Enable
+#define FT_232H_CBUS_CLK30				0x0A	//	30MHz clock
+#define FT_232H_CBUS_CLK15				0x0B	//	15MHz clock
+#define FT_232H_CBUS_CLK7_5				0x0C	//	7.5MHz clock
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_Open(
+		int deviceNumber,
+		FT_HANDLE *pHandle
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_OpenEx(
+		PVOID pArg1,
+		DWORD Flags,
+		FT_HANDLE *pHandle
+		);
+
+	FTD2XX_API 
+		FT_STATUS WINAPI FT_ListDevices(
+		PVOID pArg1,
+		PVOID pArg2,
+		DWORD Flags
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_Close(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_Read(
+		FT_HANDLE ftHandle,
+		LPVOID lpBuffer,
+		DWORD dwBytesToRead,
+		LPDWORD lpBytesReturned
+		);
+
+	FTD2XX_API 
+		FT_STATUS WINAPI FT_Write(
+		FT_HANDLE ftHandle,
+		LPVOID lpBuffer,
+		DWORD dwBytesToWrite,
+		LPDWORD lpBytesWritten
+		);
+
+	FTD2XX_API 
+		FT_STATUS WINAPI FT_IoCtl(
+		FT_HANDLE ftHandle,
+		DWORD dwIoControlCode,
+		LPVOID lpInBuf,
+		DWORD nInBufSize,
+		LPVOID lpOutBuf,
+		DWORD nOutBufSize,
+		LPDWORD lpBytesReturned,
+		LPOVERLAPPED lpOverlapped
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetBaudRate(
+		FT_HANDLE ftHandle,
+		ULONG BaudRate
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetDivisor(
+		FT_HANDLE ftHandle,
+		USHORT Divisor
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetDataCharacteristics(
+		FT_HANDLE ftHandle,
+		UCHAR WordLength,
+		UCHAR StopBits,
+		UCHAR Parity
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetFlowControl(
+		FT_HANDLE ftHandle,
+		USHORT FlowControl,
+		UCHAR XonChar,
+		UCHAR XoffChar
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_ResetDevice(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetDtr(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_ClrDtr(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetRts(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_ClrRts(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetModemStatus(
+		FT_HANDLE ftHandle,
+		ULONG *pModemStatus
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetChars(
+		FT_HANDLE ftHandle,
+		UCHAR EventChar,
+		UCHAR EventCharEnabled,
+		UCHAR ErrorChar,
+		UCHAR ErrorCharEnabled
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_Purge(
+		FT_HANDLE ftHandle,
+		ULONG Mask
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetTimeouts(
+		FT_HANDLE ftHandle,
+		ULONG ReadTimeout,
+		ULONG WriteTimeout
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetQueueStatus(
+		FT_HANDLE ftHandle,
+		DWORD *dwRxBytes
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetEventNotification(
+		FT_HANDLE ftHandle,
+		DWORD Mask,
+		PVOID Param
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetStatus(
+		FT_HANDLE ftHandle,
+		DWORD *dwRxBytes,
+		DWORD *dwTxBytes,
+		DWORD *dwEventDWord
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetBreakOn(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetBreakOff(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetWaitMask(
+		FT_HANDLE ftHandle,
+		DWORD Mask
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_WaitOnMask(
+		FT_HANDLE ftHandle,
+		DWORD *Mask
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetEventStatus(
+		FT_HANDLE ftHandle,
+		DWORD *dwEventDWord
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_ReadEE(
+		FT_HANDLE ftHandle,
+		DWORD dwWordOffset,
+		LPWORD lpwValue
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_WriteEE(
+		FT_HANDLE ftHandle,
+		DWORD dwWordOffset,
+		WORD wValue
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_EraseEE(
+		FT_HANDLE ftHandle
+		);
+
+	//
+	// structure to hold program data for FT_Program function
+	//
+	typedef struct ft_program_data {
+
+		DWORD Signature1;			// Header - must be 0x00000000 
+		DWORD Signature2;			// Header - must be 0xffffffff
+		DWORD Version;				// Header - FT_PROGRAM_DATA version
+		//			0 = original
+		//			1 = FT2232C extensions
+		//			2 = FT232R extensions
+		//			3 = FT2232H extensions
+		//			4 = FT4232H extensions
+		//			5 = FT232H extensions
+
+		WORD VendorId;				// 0x0403
+		WORD ProductId;				// 0x6001
+		char *Manufacturer;			// "FTDI"
+		char *ManufacturerId;		// "FT"
+		char *Description;			// "USB HS Serial Converter"
+		char *SerialNumber;			// "FT000001" if fixed, or NULL
+		WORD MaxPower;				// 0 < MaxPower <= 500
+		WORD PnP;					// 0 = disabled, 1 = enabled
+		WORD SelfPowered;			// 0 = bus powered, 1 = self powered
+		WORD RemoteWakeup;			// 0 = not capable, 1 = capable
+		//
+		// Rev4 (FT232B) extensions
+		//
+		UCHAR Rev4;					// non-zero if Rev4 chip, zero otherwise
+		UCHAR IsoIn;				// non-zero if in endpoint is isochronous
+		UCHAR IsoOut;				// non-zero if out endpoint is isochronous
+		UCHAR PullDownEnable;		// non-zero if pull down enabled
+		UCHAR SerNumEnable;			// non-zero if serial number to be used
+		UCHAR USBVersionEnable;		// non-zero if chip uses USBVersion
+		WORD USBVersion;			// BCD (0x0200 => USB2)
+		//
+		// Rev 5 (FT2232) extensions
+		//
+		UCHAR Rev5;					// non-zero if Rev5 chip, zero otherwise
+		UCHAR IsoInA;				// non-zero if in endpoint is isochronous
+		UCHAR IsoInB;				// non-zero if in endpoint is isochronous
+		UCHAR IsoOutA;				// non-zero if out endpoint is isochronous
+		UCHAR IsoOutB;				// non-zero if out endpoint is isochronous
+		UCHAR PullDownEnable5;		// non-zero if pull down enabled
+		UCHAR SerNumEnable5;		// non-zero if serial number to be used
+		UCHAR USBVersionEnable5;	// non-zero if chip uses USBVersion
+		WORD USBVersion5;			// BCD (0x0200 => USB2)
+		UCHAR AIsHighCurrent;		// non-zero if interface is high current
+		UCHAR BIsHighCurrent;		// non-zero if interface is high current
+		UCHAR IFAIsFifo;			// non-zero if interface is 245 FIFO
+		UCHAR IFAIsFifoTar;			// non-zero if interface is 245 FIFO CPU target
+		UCHAR IFAIsFastSer;			// non-zero if interface is Fast serial
+		UCHAR AIsVCP;				// non-zero if interface is to use VCP drivers
+		UCHAR IFBIsFifo;			// non-zero if interface is 245 FIFO
+		UCHAR IFBIsFifoTar;			// non-zero if interface is 245 FIFO CPU target
+		UCHAR IFBIsFastSer;			// non-zero if interface is Fast serial
+		UCHAR BIsVCP;				// non-zero if interface is to use VCP drivers
+		//
+		// Rev 6 (FT232R) extensions
+		//
+		UCHAR UseExtOsc;			// Use External Oscillator
+		UCHAR HighDriveIOs;			// High Drive I/Os
+		UCHAR EndpointSize;			// Endpoint size
+		UCHAR PullDownEnableR;		// non-zero if pull down enabled
+		UCHAR SerNumEnableR;		// non-zero if serial number to be used
+		UCHAR InvertTXD;			// non-zero if invert TXD
+		UCHAR InvertRXD;			// non-zero if invert RXD
+		UCHAR InvertRTS;			// non-zero if invert RTS
+		UCHAR InvertCTS;			// non-zero if invert CTS
+		UCHAR InvertDTR;			// non-zero if invert DTR
+		UCHAR InvertDSR;			// non-zero if invert DSR
+		UCHAR InvertDCD;			// non-zero if invert DCD
+		UCHAR InvertRI;				// non-zero if invert RI
+		UCHAR Cbus0;				// Cbus Mux control
+		UCHAR Cbus1;				// Cbus Mux control
+		UCHAR Cbus2;				// Cbus Mux control
+		UCHAR Cbus3;				// Cbus Mux control
+		UCHAR Cbus4;				// Cbus Mux control
+		UCHAR RIsD2XX;				// non-zero if using D2XX driver
+		//
+		// Rev 7 (FT2232H) Extensions
+		//
+		UCHAR PullDownEnable7;		// non-zero if pull down enabled
+		UCHAR SerNumEnable7;		// non-zero if serial number to be used
+		UCHAR ALSlowSlew;			// non-zero if AL pins have slow slew
+		UCHAR ALSchmittInput;		// non-zero if AL pins are Schmitt input
+		UCHAR ALDriveCurrent;		// valid values are 4mA, 8mA, 12mA, 16mA
+		UCHAR AHSlowSlew;			// non-zero if AH pins have slow slew
+		UCHAR AHSchmittInput;		// non-zero if AH pins are Schmitt input
+		UCHAR AHDriveCurrent;		// valid values are 4mA, 8mA, 12mA, 16mA
+		UCHAR BLSlowSlew;			// non-zero if BL pins have slow slew
+		UCHAR BLSchmittInput;		// non-zero if BL pins are Schmitt input
+		UCHAR BLDriveCurrent;		// valid values are 4mA, 8mA, 12mA, 16mA
+		UCHAR BHSlowSlew;			// non-zero if BH pins have slow slew
+		UCHAR BHSchmittInput;		// non-zero if BH pins are Schmitt input
+		UCHAR BHDriveCurrent;		// valid values are 4mA, 8mA, 12mA, 16mA
+		UCHAR IFAIsFifo7;			// non-zero if interface is 245 FIFO
+		UCHAR IFAIsFifoTar7;		// non-zero if interface is 245 FIFO CPU target
+		UCHAR IFAIsFastSer7;		// non-zero if interface is Fast serial
+		UCHAR AIsVCP7;				// non-zero if interface is to use VCP drivers
+		UCHAR IFBIsFifo7;			// non-zero if interface is 245 FIFO
+		UCHAR IFBIsFifoTar7;		// non-zero if interface is 245 FIFO CPU target
+		UCHAR IFBIsFastSer7;		// non-zero if interface is Fast serial
+		UCHAR BIsVCP7;				// non-zero if interface is to use VCP drivers
+		UCHAR PowerSaveEnable;		// non-zero if using BCBUS7 to save power for self-powered designs
+		//
+		// Rev 8 (FT4232H) Extensions
+		//
+		UCHAR PullDownEnable8;		// non-zero if pull down enabled
+		UCHAR SerNumEnable8;		// non-zero if serial number to be used
+		UCHAR ASlowSlew;			// non-zero if AL pins have slow slew
+		UCHAR ASchmittInput;		// non-zero if AL pins are Schmitt input
+		UCHAR ADriveCurrent;		// valid values are 4mA, 8mA, 12mA, 16mA
+		UCHAR BSlowSlew;			// non-zero if AH pins have slow slew
+		UCHAR BSchmittInput;		// non-zero if AH pins are Schmitt input
+		UCHAR BDriveCurrent;		// valid values are 4mA, 8mA, 12mA, 16mA
+		UCHAR CSlowSlew;			// non-zero if BL pins have slow slew
+		UCHAR CSchmittInput;		// non-zero if BL pins are Schmitt input
+		UCHAR CDriveCurrent;		// valid values are 4mA, 8mA, 12mA, 16mA
+		UCHAR DSlowSlew;			// non-zero if BH pins have slow slew
+		UCHAR DSchmittInput;		// non-zero if BH pins are Schmitt input
+		UCHAR DDriveCurrent;		// valid values are 4mA, 8mA, 12mA, 16mA
+		UCHAR ARIIsTXDEN;			// non-zero if port A uses RI as RS485 TXDEN
+		UCHAR BRIIsTXDEN;			// non-zero if port B uses RI as RS485 TXDEN
+		UCHAR CRIIsTXDEN;			// non-zero if port C uses RI as RS485 TXDEN
+		UCHAR DRIIsTXDEN;			// non-zero if port D uses RI as RS485 TXDEN
+		UCHAR AIsVCP8;				// non-zero if interface is to use VCP drivers
+		UCHAR BIsVCP8;				// non-zero if interface is to use VCP drivers
+		UCHAR CIsVCP8;				// non-zero if interface is to use VCP drivers
+		UCHAR DIsVCP8;				// non-zero if interface is to use VCP drivers
+		//
+		// Rev 9 (FT232H) Extensions
+		//
+		UCHAR PullDownEnableH;		// non-zero if pull down enabled
+		UCHAR SerNumEnableH;		// non-zero if serial number to be used
+		UCHAR ACSlowSlewH;			// non-zero if AC pins have slow slew
+		UCHAR ACSchmittInputH;		// non-zero if AC pins are Schmitt input
+		UCHAR ACDriveCurrentH;		// valid values are 4mA, 8mA, 12mA, 16mA
+		UCHAR ADSlowSlewH;			// non-zero if AD pins have slow slew
+		UCHAR ADSchmittInputH;		// non-zero if AD pins are Schmitt input
+		UCHAR ADDriveCurrentH;		// valid values are 4mA, 8mA, 12mA, 16mA
+		UCHAR Cbus0H;				// Cbus Mux control
+		UCHAR Cbus1H;				// Cbus Mux control
+		UCHAR Cbus2H;				// Cbus Mux control
+		UCHAR Cbus3H;				// Cbus Mux control
+		UCHAR Cbus4H;				// Cbus Mux control
+		UCHAR Cbus5H;				// Cbus Mux control
+		UCHAR Cbus6H;				// Cbus Mux control
+		UCHAR Cbus7H;				// Cbus Mux control
+		UCHAR Cbus8H;				// Cbus Mux control
+		UCHAR Cbus9H;				// Cbus Mux control
+		UCHAR IsFifoH;				// non-zero if interface is 245 FIFO
+		UCHAR IsFifoTarH;			// non-zero if interface is 245 FIFO CPU target
+		UCHAR IsFastSerH;			// non-zero if interface is Fast serial
+		UCHAR IsFT1248H;			// non-zero if interface is FT1248
+		UCHAR FT1248CpolH;			// FT1248 clock polarity - clock idle high (1) or clock idle low (0)
+		UCHAR FT1248LsbH;			// FT1248 data is LSB (1) or MSB (0)
+		UCHAR FT1248FlowControlH;	// FT1248 flow control enable
+		UCHAR IsVCPH;				// non-zero if interface is to use VCP drivers
+		UCHAR PowerSaveEnableH;		// non-zero if using ACBUS7 to save power for self-powered designs
+		
+	} FT_PROGRAM_DATA, *PFT_PROGRAM_DATA;
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_EE_Program(
+		FT_HANDLE ftHandle,
+		PFT_PROGRAM_DATA pData
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_EE_ProgramEx(
+		FT_HANDLE ftHandle,
+		PFT_PROGRAM_DATA pData,
+		char *Manufacturer,
+		char *ManufacturerId,
+		char *Description,
+		char *SerialNumber
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_EE_Read(
+		FT_HANDLE ftHandle,
+		PFT_PROGRAM_DATA pData
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_EE_ReadEx(
+		FT_HANDLE ftHandle,
+		PFT_PROGRAM_DATA pData,
+		char *Manufacturer,
+		char *ManufacturerId,
+		char *Description,
+		char *SerialNumber
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_EE_UASize(
+		FT_HANDLE ftHandle,
+		LPDWORD lpdwSize
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_EE_UAWrite(
+		FT_HANDLE ftHandle,
+		PUCHAR pucData,
+		DWORD dwDataLen
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_EE_UARead(
+		FT_HANDLE ftHandle,
+		PUCHAR pucData,
+		DWORD dwDataLen,
+		LPDWORD lpdwBytesRead
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetLatencyTimer(
+		FT_HANDLE ftHandle,
+		UCHAR ucLatency
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetLatencyTimer(
+		FT_HANDLE ftHandle,
+		PUCHAR pucLatency
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetBitMode(
+		FT_HANDLE ftHandle,
+		UCHAR ucMask,
+		UCHAR ucEnable
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetBitMode(
+		FT_HANDLE ftHandle,
+		PUCHAR pucMode
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetUSBParameters(
+		FT_HANDLE ftHandle,
+		ULONG ulInTransferSize,
+		ULONG ulOutTransferSize
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetDeadmanTimeout(
+		FT_HANDLE ftHandle,
+		ULONG ulDeadmanTimeout
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetDeviceInfo(
+		FT_HANDLE ftHandle,
+		FT_DEVICE *lpftDevice,
+		LPDWORD lpdwID,
+		PCHAR SerialNumber,
+		PCHAR Description,
+		LPVOID Dummy
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_StopInTask(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_RestartInTask(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_SetResetPipeRetryCount(
+		FT_HANDLE ftHandle,
+		DWORD dwCount
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_ResetPort(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_CyclePort(
+		FT_HANDLE ftHandle
+		);
+
+
+	//
+	// Win32-type functions
+	//
+
+	FTD2XX_API
+		FT_HANDLE WINAPI FT_W32_CreateFile(
+		LPCTSTR					lpszName,
+		DWORD					dwAccess,
+		DWORD					dwShareMode,
+		LPSECURITY_ATTRIBUTES	lpSecurityAttributes,
+		DWORD					dwCreate,
+		DWORD					dwAttrsAndFlags,
+		HANDLE					hTemplate
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_CloseHandle(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_ReadFile(
+		FT_HANDLE ftHandle,
+		LPVOID lpBuffer,
+		DWORD nBufferSize,
+		LPDWORD lpBytesReturned,
+		LPOVERLAPPED lpOverlapped
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_WriteFile(
+		FT_HANDLE ftHandle,
+		LPVOID lpBuffer,
+		DWORD nBufferSize,
+		LPDWORD lpBytesWritten,
+		LPOVERLAPPED lpOverlapped
+		);
+
+	FTD2XX_API
+		DWORD WINAPI FT_W32_GetLastError(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_GetOverlappedResult(
+		FT_HANDLE ftHandle,
+		LPOVERLAPPED lpOverlapped,
+		LPDWORD lpdwBytesTransferred,
+		BOOL bWait
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_CancelIo(
+		FT_HANDLE ftHandle
+		);
+
+
+	//
+	// Win32 COMM API type functions
+	//
+	typedef struct _FTCOMSTAT {
+		DWORD fCtsHold : 1;
+		DWORD fDsrHold : 1;
+		DWORD fRlsdHold : 1;
+		DWORD fXoffHold : 1;
+		DWORD fXoffSent : 1;
+		DWORD fEof : 1;
+		DWORD fTxim : 1;
+		DWORD fReserved : 25;
+		DWORD cbInQue;
+		DWORD cbOutQue;
+	} FTCOMSTAT, *LPFTCOMSTAT;
+
+	typedef struct _FTDCB {
+		DWORD DCBlength;			/* sizeof(FTDCB)						*/
+		DWORD BaudRate;				/* Baudrate at which running			*/
+		DWORD fBinary: 1;			/* Binary Mode (skip EOF check)			*/
+		DWORD fParity: 1;			/* Enable parity checking				*/
+		DWORD fOutxCtsFlow:1;		/* CTS handshaking on output			*/
+		DWORD fOutxDsrFlow:1;		/* DSR handshaking on output			*/
+		DWORD fDtrControl:2;		/* DTR Flow control						*/
+		DWORD fDsrSensitivity:1;	/* DSR Sensitivity						*/
+		DWORD fTXContinueOnXoff: 1;	/* Continue TX when Xoff sent			*/
+		DWORD fOutX: 1;				/* Enable output X-ON/X-OFF				*/
+		DWORD fInX: 1;				/* Enable input X-ON/X-OFF				*/
+		DWORD fErrorChar: 1;		/* Enable Err Replacement				*/
+		DWORD fNull: 1;				/* Enable Null stripping				*/
+		DWORD fRtsControl:2;		/* Rts Flow control						*/
+		DWORD fAbortOnError:1;		/* Abort all reads and writes on Error	*/
+		DWORD fDummy2:17;			/* Reserved								*/
+		WORD wReserved;				/* Not currently used					*/
+		WORD XonLim;				/* Transmit X-ON threshold				*/
+		WORD XoffLim;				/* Transmit X-OFF threshold				*/
+		BYTE ByteSize;				/* Number of bits/byte, 4-8				*/
+		BYTE Parity;				/* 0-4=None,Odd,Even,Mark,Space			*/
+		BYTE StopBits;				/* 0,1,2 = 1, 1.5, 2					*/
+		char XonChar;				/* Tx and Rx X-ON character				*/
+		char XoffChar;				/* Tx and Rx X-OFF character			*/
+		char ErrorChar;				/* Error replacement char				*/
+		char EofChar;				/* End of Input character				*/
+		char EvtChar;				/* Received Event character				*/
+		WORD wReserved1;			/* Fill for now.						*/
+	} FTDCB, *LPFTDCB;
+
+	typedef struct _FTTIMEOUTS {
+		DWORD ReadIntervalTimeout;			/* Maximum time between read chars.	*/
+		DWORD ReadTotalTimeoutMultiplier;	/* Multiplier of characters.		*/
+		DWORD ReadTotalTimeoutConstant;		/* Constant in milliseconds.		*/
+		DWORD WriteTotalTimeoutMultiplier;	/* Multiplier of characters.		*/
+		DWORD WriteTotalTimeoutConstant;	/* Constant in milliseconds.		*/
+	} FTTIMEOUTS,*LPFTTIMEOUTS;
+
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_ClearCommBreak(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_ClearCommError(
+		FT_HANDLE ftHandle,
+		LPDWORD lpdwErrors,
+		LPFTCOMSTAT lpftComstat
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_EscapeCommFunction(
+		FT_HANDLE ftHandle,
+		DWORD dwFunc
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_GetCommModemStatus(
+		FT_HANDLE ftHandle,
+		LPDWORD lpdwModemStatus
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_GetCommState(
+		FT_HANDLE ftHandle,
+		LPFTDCB lpftDcb
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_GetCommTimeouts(
+		FT_HANDLE ftHandle,
+		FTTIMEOUTS *pTimeouts
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_PurgeComm(
+		FT_HANDLE ftHandle,
+		DWORD dwMask
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_SetCommBreak(
+		FT_HANDLE ftHandle
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_SetCommMask(
+		FT_HANDLE ftHandle,
+		ULONG ulEventMask
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_GetCommMask(
+		FT_HANDLE ftHandle,
+		LPDWORD lpdwEventMask
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_SetCommState(
+		FT_HANDLE ftHandle,
+		LPFTDCB lpftDcb
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_SetCommTimeouts(
+		FT_HANDLE ftHandle,
+		FTTIMEOUTS *pTimeouts
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_SetupComm(
+		FT_HANDLE ftHandle,
+		DWORD dwReadBufferSize,
+		DWORD dwWriteBufferSize
+		);
+
+	FTD2XX_API
+		BOOL WINAPI FT_W32_WaitCommEvent(
+		FT_HANDLE ftHandle,
+		PULONG pulEvent,
+		LPOVERLAPPED lpOverlapped
+		);
+
+
+	//
+	// Device information
+	//
+
+	typedef struct _ft_device_list_info_node {
+		ULONG Flags;
+		ULONG Type;
+		ULONG ID;
+		DWORD LocId;
+		char SerialNumber[16];
+		char Description[64];
+		FT_HANDLE ftHandle;
+	} FT_DEVICE_LIST_INFO_NODE;
+
+	// Device information flags
+	enum {
+		FT_FLAGS_OPENED = 1,
+		FT_FLAGS_HISPEED = 2
+	};
+
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_CreateDeviceInfoList(
+		LPDWORD lpdwNumDevs
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetDeviceInfoList(
+		FT_DEVICE_LIST_INFO_NODE *pDest,
+		LPDWORD lpdwNumDevs
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetDeviceInfoDetail(
+		DWORD dwIndex,
+		LPDWORD lpdwFlags,
+		LPDWORD lpdwType,
+		LPDWORD lpdwID,
+		LPDWORD lpdwLocId,
+		LPVOID lpSerialNumber,
+		LPVOID lpDescription,
+		FT_HANDLE *pftHandle
+		);
+
+
+	//
+	// Version information
+	//
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetDriverVersion(
+		FT_HANDLE ftHandle,
+		LPDWORD lpdwVersion
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetLibraryVersion(
+		LPDWORD lpdwVersion
+		);
+
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_Rescan(
+		void
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_Reload(
+		WORD wVid,
+		WORD wPid
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetComPortNumber(
+		FT_HANDLE ftHandle,
+		LPLONG	lpdwComPortNumber
+		);
+
+
+	//
+	// FT232H additional EEPROM functions
+	//
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_EE_ReadConfig(
+		FT_HANDLE ftHandle,
+		UCHAR ucAddress,
+		PUCHAR pucValue
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_EE_WriteConfig(
+		FT_HANDLE ftHandle,
+		UCHAR ucAddress,
+		UCHAR ucValue
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_EE_ReadECC(
+		FT_HANDLE ftHandle,
+		UCHAR ucOption,
+		LPWORD lpwValue
+		);
+
+	FTD2XX_API
+		FT_STATUS WINAPI FT_GetQueueStatusEx(
+		FT_HANDLE ftHandle,
+		DWORD *dwRxBytes
+		);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif	/* FTD2XX_H */
+

FTDI_I2C/proghyt/libMPSSE_i2c.h

+/*!
+ * \file libMPSSE_i2c.h
+ *
+ * \author FTDI
+ * \date 20110505
+ *
+ * Copyright  2011 Future Technology Devices International Limited
+ * Company Confidential
+ *
+ * Project: libMPSSE
+ * Module: I2C
+ *
+ * Rivision History:
+ * 0.1 - initial version
+ * 0.2 - 20110708 - added FT_ReadGPIO, FT_WriteGPIO & 3-phase clocking
+ * 0.3 - 20111025 - modified for supporting 64bit linux
+ *				  added I2C_TRANSFER_OPTIONS_NACK_LAST_BYTE
+ */
+
+#ifndef LIBMPSSE_I2C_H
+#define LIBMPSSE_I2C_H
+
+#include "ftd2xx.h"
+
+
+/******************************************************************************/
+/*								Macro defines								  */
+/******************************************************************************/
+
+#ifdef _MSC_VER
+#define FTDI_API extern "C"
+#else
+#define FTDI_API
+#endif
+
+/* Options to I2C_DeviceWrite & I2C_DeviceRead */
+/*Generate start condition before transmitting */
+#define	I2C_TRANSFER_OPTIONS_START_BIT		0x00000001
+
+/*Generate stop condition before transmitting */
+#define I2C_TRANSFER_OPTIONS_STOP_BIT		0x00000002
+
+/*Continue transmitting data in bulk without caring about Ack or nAck from device if this bit is 
+not set. If this bit is set then stop transitting the data in the buffer when the device nAcks*/
+#define I2C_TRANSFER_OPTIONS_BREAK_ON_NACK	0x00000004
+
+/* libMPSSE-I2C generates an ACKs for every byte read. Some I2C slaves require the I2C 
+master to generate a nACK for the last data byte read. Setting this bit enables working with such 
+I2C slaves */
+#define I2C_TRANSFER_OPTIONS_NACK_LAST_BYTE	0x00000008
+
+/* no address phase, no USB interframe delays */
+#define I2C_TRANSFER_OPTIONS_FAST_TRANSFER_BYTES	0x00000010
+#define I2C_TRANSFER_OPTIONS_FAST_TRANSFER_BITS	0x00000020
+#define I2C_TRANSFER_OPTIONS_FAST_TRANSFER		0x00000030
+
+/* if I2C_TRANSFER_OPTION_FAST_TRANSFER is set then setting this bit would mean that the 
+address field should be ignored. The address is either a part of the data or this is a special I2C
+frame that doesn't require an address*/
+#define I2C_TRANSFER_OPTIONS_NO_ADDRESS		0x00000040
+
+#define I2C_CMD_GETDEVICEID_RD	0xF9
+#define I2C_CMD_GETDEVICEID_WR	0xF8
+
+#define I2C_GIVE_ACK	1
+#define I2C_GIVE_NACK	0
+
+/* 3-phase clocking is enabled by default. Setting this bit in ConfigOptions will disable it */
+#define I2C_DISABLE_3PHASE_CLOCKING	0x0001
+
+/* The I2C master should actually drive the SDA line only when the output is LOW. It should be
+tristate the SDA line when the output should be high. This tristating the SDA line during output 
+HIGH is supported only in FT232H chip. This feature is called DriveOnlyZero feature and is 
+enabled when the following bit is set in the options parameter in function I2C_Init */
+#define I2C_ENABLE_DRIVE_ONLY_ZERO	0x0002
+
+
+
+/******************************************************************************/
+/*								Type defines								  */
+/******************************************************************************/
+
+typedef unsigned char   uint8;
+typedef unsigned short  uint16;
+typedef unsigned long long uint64;
+
+typedef signed char   int8;
+typedef signed short  int16;
+typedef signed long long int64;
+
+#ifndef _MSC_VER
+//typedef unsigned char	bool;
+#endif
+
+#ifdef __x86_64__  
+	typedef unsigned int   uint32;
+	typedef signed int   int32;
+#else
+	typedef unsigned long   uint32;
+	typedef signed long   int32;
+#endif
+
+typedef enum I2C_ClockRate_t{
+	I2C_CLOCK_STANDARD_MODE = 100000,						/* 100kb/sec */
+	I2C_CLOCK_FAST_MODE = 400000,							/* 400kb/sec */
+	I2C_CLOCK_FAST_MODE_PLUS = 1000000, 					/* 1000kb/sec */
+	I2C_CLOCK_HIGH_SPEED_MODE = 3400000 					/* 3.4Mb/sec */
+}I2C_CLOCKRATE;
+
+
+/* Channel configuration information */
+typedef struct ChannelConfig_t
+{
+	I2C_CLOCKRATE	ClockRate; 
+	uint8			LatencyTimer;
+	uint32			Options;
+}ChannelConfig;
+
+
+/******************************************************************************/
+/*								External variables							  */
+/******************************************************************************/
+
+
+
+
+
+/******************************************************************************/
+/*								Function declarations						  */
+/******************************************************************************/
+FTDI_API FT_STATUS I2C_GetNumChannels(uint32 *numChannels);
+FTDI_API FT_STATUS I2C_GetChannelInfo(uint32 index, 
+	FT_DEVICE_LIST_INFO_NODE *chanInfo);
+FTDI_API FT_STATUS I2C_OpenChannel(uint32 index, FT_HANDLE *handle);
+FTDI_API FT_STATUS I2C_InitChannel(FT_HANDLE handle, ChannelConfig *config);
+FTDI_API FT_STATUS I2C_CloseChannel(FT_HANDLE handle);
+FTDI_API FT_STATUS I2C_DeviceRead(FT_HANDLE handle, uint32 deviceAddress, 
+uint32 sizeToTransfer, uint8 *buffer, uint32 *sizeTransfered, uint32 options);
+FTDI_API FT_STATUS I2C_DeviceWrite(FT_HANDLE handle, uint32 deviceAddress, 
+uint32 sizeToTransfer, uint8 *buffer, uint32 *sizeTransfered, uint32 options);
+FTDI_API void Init_libMPSSE(void);
+FTDI_API void Cleanup_libMPSSE(void);
+FTDI_API FT_STATUS FT_WriteGPIO(FT_HANDLE handle, uint8 dir, uint8 value);
+FTDI_API FT_STATUS FT_ReadGPIO(FT_HANDLE handle,uint8 *value);
+
+
+
+
+/******************************************************************************/
+
+
+#endif	/*LIBMPSSE_I2C_H*/
+

FTDI_I2C/proghyt/main.cpp

+/*!
+ * \file sample-static.c
+ *
+ * \author FTDI
+ * \date 20110512
+ *
+ * Copyright  2011 Future Technology Devices International Limited
+ * Company Confidential
+ *
+ * Project: libMPSSE
+ * Module: I2C Sample Application - Interfacing 24LC024H I2C EEPROM
+ *
+ * Rivision History:
+ * 0.1 - 20110513 - initial version
+ * 0.2 - 20110801 - Changed LatencyTimer to 255
+ * 				  Attempt to open channel only if available
+ *				  Added & modified macros
+ *                		  Change I2C_GetChannelInfo & OpenChannel to start indexing from 0
+ * 0.3 - 20111212 - Added comments
+ */
+
+/******************************************************************************/
+/* 							 Include files										   */
+/******************************************************************************/
+/* Standard C libraries */
+#include<stdio.h>
+#include<stdlib.h>
+/* OS specific libraries */
+#ifdef _WIN32
+#include<windows.h>
+#endif
+
+/* Include D2XX header*/
+#include "ftd2xx.h"
+
+/* Include libMPSSE header */
+#include "libMPSSE_i2c.h"
+
+/******************************************************************************/
+/*								Macro and type defines							   */
+/******************************************************************************/
+/* Helper macros */
+
+#define APP_CHECK_STATUS(exp) {if(exp!=FT_OK){printf("%s:%d:%s(): status(0x%x) \
+!= FT_OK\n",__FILE__, __LINE__, __FUNCTION__,exp);exit(1);}else{;}};
+#define CHECK_NULL(exp){if(exp==NULL){printf("%s:%d:%s():  NULL expression \
+encountered \n",__FILE__, __LINE__, __FUNCTION__);exit(1);}else{;}};
+
+/* Application specific macro definations */
+#define I2C_DEVICE_ADDRESS_EEPROM		0x57
+#define I2C_DEVICE_BUFFER_SIZE		256
+#define I2C_WRITE_COMPLETION_RETRY		10
+#define START_ADDRESS_EEPROM 	0x00 /*read/write start address inside the EEPROM*/
+#define END_ADDRESS_EEPROM		0x10
+
+
+#define RETRY_COUNT_EEPROM		10	/* number of retries if read/write fails */
+#define CHANNEL_TO_OPEN			1	/*0 for first available channel, 1 for next... */
+#define DATA_OFFSET				1
+
+
+
+/******************************************************************************/
+/*								Global variables							  	    */
+/******************************************************************************/
+uint32 channels;
+FT_HANDLE ftHandle;
+ChannelConfig channelConf;
+FT_STATUS status;
+uint8 buffer[I2C_DEVICE_BUFFER_SIZE];
+
+/******************************************************************************/
+/*						Public function definitions						  		   */
+/******************************************************************************/
+/*!
+ * \brief Writes to EEPROM
+ *
+ * This function writes a byte to a specified address within the 24LC024H EEPROM
+ *
+ * \param[in] slaveAddress Address of the I2C slave (EEPROM)
+ * \param[in] registerAddress Address of the memory location inside the slave to where the byte
+ *			is to be written
+ * \param[in] data The byte that is to be written
+ * \return Returns status code of type FT_STATUS(see D2XX Programmer's Guide)
+ * \sa Datasheet of 24LC024H http://ww1.microchip.com/downloads/en/devicedoc/22102a.pdf
+ * \note
+ * \warning
+ */
+FT_STATUS write_byte(uint8 slaveAddress, uint8 registerAddress, uint8 data)
+{
+	uint32 bytesToTransfer = 0;
+	uint32 bytesTransfered;
+	bool writeComplete=0;
+	uint32 retry=0;
+
+	bytesToTransfer=0;
+	bytesTransfered=0;
+	buffer[bytesToTransfer++]=registerAddress; /* Byte addressed inside EEPROM */
+	buffer[bytesToTransfer++]=data;
+	status = I2C_DeviceWrite(ftHandle, slaveAddress, bytesToTransfer, buffer, \
+&bytesTransfered, I2C_TRANSFER_OPTIONS_START_BIT|I2C_TRANSFER_OPTIONS_STOP_BIT);
+
+	/* poll to check completition */
+	while((writeComplete==0) && (retry<I2C_WRITE_COMPLETION_RETRY))
+	{
+		bytesToTransfer=0;
+		bytesTransfered=0;
+		buffer[bytesToTransfer++]=registerAddress; /* Addressed inside EEPROM  */
+		status = I2C_DeviceWrite(ftHandle, slaveAddress, bytesToTransfer,\
+			buffer, &bytesTransfered, \
+			I2C_TRANSFER_OPTIONS_START_BIT|I2C_TRANSFER_OPTIONS_BREAK_ON_NACK);
+		if((FT_OK == status) && (bytesToTransfer == bytesTransfered))
+		{
+			writeComplete=1;
+			printf("  ... Write done\n");
+		}
+		retry++;
+	}
+	return status;
+}
+
+/*!
+ * \brief Reads from EEPROM
+ *
+ * This function reads a byte from a specified address within the 24LC024H EEPROM
+ *
+ * \param[in] slaveAddress Address of the I2C slave (EEPROM)
+ * \param[in] registerAddress Address of the memory location inside the slave from where the
+ *			byte is to be read
+ * \param[in] *data Address to where the byte is to be read
+ * \return Returns status code of type FT_STATUS(see D2XX Programmer's Guide)
+ * \sa Datasheet of 24LC024H http://ww1.microchip.com/downloads/en/devicedoc/22102a.pdf
+ * \note
+ * \warning
+ */
+FT_STATUS read_byte(uint8 slaveAddress, uint8 registerAddress, uint8 *data)
+{
+	FT_STATUS status;
+	uint32 bytesToTransfer = 0;
+	uint32 bytesTransfered;
+
+	bytesToTransfer=0;
+	bytesTransfered=0;
+	buffer[bytesToTransfer++]=registerAddress; /*Byte addressed inside EEPROM */
+	status = I2C_DeviceWrite(ftHandle, slaveAddress, bytesToTransfer, buffer, \
+		&bytesTransfered, I2C_TRANSFER_OPTIONS_START_BIT);
+	APP_CHECK_STATUS(status);
+	bytesToTransfer=1;
+	bytesTransfered=0;
+	status |= I2C_DeviceRead(ftHandle, slaveAddress, bytesToTransfer, buffer, \
+		&bytesTransfered, I2C_TRANSFER_OPTIONS_START_BIT);
+	APP_CHECK_STATUS(status);
+	*data = buffer[0];
+	return status;
+}
+
+/*!
+ * \brief Main function / Entry point to the sample application
+ *
+ * This function is the entry point to the sample application. It opens the channel, writes to the
+ * EEPROM and reads back.
+ *
+ * \param[in] none
+ * \return Returns 0 for success
+ * \sa
+ * \note
+ * \warning
+ */
+int main()
+{
+	FT_STATUS status;
+	FT_DEVICE_LIST_INFO_NODE devList;
+	uint8 address;
+	uint8 data;
+	int i,j;
+
+#ifdef _MSC_VER
+	Init_libMPSSE();
+#endif
+	channelConf.ClockRate = I2C_CLOCK_FAST_MODE;/*i.e. 400000 KHz*/
+	channelConf.LatencyTimer= 255;
+	//channelConf.Options = I2C_DISABLE_3PHASE_CLOCKING;
+	//channelConf.Options = I2C_ENABLE_DRIVE_ONLY_ZERO;
+
+	status = I2C_GetNumChannels(&channels);
+	APP_CHECK_STATUS(status);
+	printf("Number of available I2C channels = %d\n",channels);
+
+	if(channels>0)
+	{
+		for(i=0;i<channels;i++)
+		{
+			status = I2C_GetChannelInfo(i,&devList);
+			APP_CHECK_STATUS(status);
+			printf("Information on channel number %d:\n",i);
+			/*print the dev info*/
+			printf("		Flags=0x%x\n",devList.Flags);
+			printf("		Type=0x%x\n",devList.Type);
+			printf("		ID=0x%x\n",devList.ID);
+			printf("		LocId=0x%x\n",devList.LocId);
+			printf("		SerialNumber=%s\n",devList.SerialNumber);
+			printf("		Description=%s\n",devList.Description);
+			printf("		ftHandle=0x%x\n",devList.ftHandle);/*is 0 unless open*/
+		}
+
+		/* Open the first available channel */
+		status = I2C_OpenChannel(CHANNEL_TO_OPEN,&ftHandle);
+		APP_CHECK_STATUS(status);
+		printf("\nhandle=0x%x status=%d\n",ftHandle,status);
+		status = I2C_InitChannel(ftHandle,&channelConf);
+		APP_CHECK_STATUS(status);
+
+		for(address=START_ADDRESS_EEPROM;address<END_ADDRESS_EEPROM;address++)
+		{
+			printf("writing address = %d data = %d", address, \
+				address+DATA_OFFSET);
+			status = write_byte(I2C_DEVICE_ADDRESS_EEPROM, address, \
+				address+DATA_OFFSET);
+			for(j=0; ((j<RETRY_COUNT_EEPROM) && (FT_OK !=status)); j++)
+			{
+				printf("---- writing again to address = %d, data =%d\n", \
+					address, address+DATA_OFFSET);
+				status = write_byte(I2C_DEVICE_ADDRESS_EEPROM, address, \
+					address+DATA_OFFSET);
+			}
+			APP_CHECK_STATUS(status);
+		}
+		printf("\n");
+		for(address=START_ADDRESS_EEPROM; address<END_ADDRESS_EEPROM; address++)
+		{
+			status = read_byte(I2C_DEVICE_ADDRESS_EEPROM,address, &data);
+			for(j=0; ((j<RETRY_COUNT_EEPROM) && (FT_OK !=status)); j++)
+			{
+				printf("read error... retrying \n");
+				status = read_byte(I2C_DEVICE_ADDRESS_EEPROM,address, &data);
+			}
+			printf("reading address %d data read=%d\n",address,data);
+		}
+		status = I2C_CloseChannel(ftHandle);
+	}
+
+#ifdef _MSC_VER
+	Cleanup_libMPSSE();
+#endif
+
+	return 0;
+}

FTDI_I2C/proghyt/proghyt.cbp

+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="proghyt" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/proghyt" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Debug/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-g" />
+				</Compiler>
+			</Target>
+			<Target title="Release">
+				<Option output="bin/Release/proghyt" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Release/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-O2" />
+				</Compiler>
+				<Linker>
+					<Add option="-s" />
+				</Linker>
+			</Target>
+		</Build>
+		<Compiler>
+			<Add option="-Wall" />
+			<Add option="-fexceptions" />
+		</Compiler>
+		<Unit filename="main.cpp" />
+		<Extensions>
+			<code_completion />
+			<envvars />
+			<debugger />
+			<lib_finder disable_auto="1" />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

FTDI_I2C/proghyt/proghyt.depend

+# depslib dependency file v1.0
+1434625867 source:d:\hw_designs\fuse-relay-board\mcu_firmware\trunk\ftdi_i2c\proghyt\main.cpp
+	<stdio.h>
+	<stdlib.h>
+	<windows.h>
+	"ftd2xx.h"
+	"libMPSSE_i2c.h"
+
+1320115055 d:\hw_designs\fuse-relay-board\mcu_firmware\trunk\ftdi_i2c\proghyt\ftd2xx.h
+
+1434622805 d:\hw_designs\fuse-relay-board\mcu_firmware\trunk\ftdi_i2c\proghyt\libmpsse_i2c.h
+	"ftd2xx.h"
+